@Override
public Vertex<LongWritable, LongWritable, LongWritable> getCurrentVertex()
throws IOException, InterruptedException {
Vertex<LongWritable, LongWritable, LongWritable> vertex = conf.createVertex();
String tokens[] = saperator.split(getRecordReader().getCurrentValue().toString());
List<Edge<LongWritable, LongWritable>> edges =
Lists.newArrayListWithCapacity(tokens.length - 1);
long weight = ((long) 1.0) / (tokens.length - 1);
LongWritable VertexId = new LongWritable(Long.parseLong(tokens[0]));
LongWritable VertexValue = new LongWritable(Long.parseLong(tokens[1]));
System.out.println(VertexValue);
String edgeId[] = tokens[2].split(",");
/*
for(int n=2;n<tokens.length-1;n++)
{
edges.add(EdgeFactory.create(new LongWritable(Long.parseLong(tokens[n])),new LongWritable(weight)));
}
*/
for (String edge : edgeId) {
edges.add(
EdgeFactory.create(new LongWritable(Long.parseLong(edge)), new LongWritable(weight)));
}
// vertex.initialize(VertexId, (LongWritable) edges);
vertex.initialize(VertexId, VertexValue, edges);
return vertex;
}
@Override
public void compute(
Vertex<IntWritable, IntWritable, NullWritable> vertex, Iterable<IntWritable> messages)
throws IOException {
if (0 == getSuperstep()) {
vertex.setValue(new IntWritable(Integer.MAX_VALUE));
}
Integer minDist = isSource(vertex) ? 0 : Integer.MAX_VALUE;
for (IntWritable msg : messages) {
if (msg.get() < minDist) {
minDist = msg.get();
}
}
if (minDist < vertex.getValue().get()) {
vertex.setValue(new IntWritable(minDist));
for (Edge<IntWritable, NullWritable> edge : vertex.getEdges()) {
final IntWritable neighbor = edge.getTargetVertexId();
final Integer distance = minDist + 1;
sendMessage(neighbor, new IntWritable(distance));
}
}
vertex.voteToHalt();
}
@Override
public boolean shouldDebugVertex(
Vertex<LongWritable, IntWritable, NullWritable> vertex, long superstepNo) {
return (vertex.getId().get() == 74780L)
|| (vertex.getId().get() == 75686)
|| (vertex.getId().get() == 75685);
}
/**
* Append some vertices to an out-of-core partition.
*
* @param partitionId Id of the destination partition
* @param vertices Vertices to be added
* @throws IOException
*/
private void appendVertices(Integer partitionId, Collection<Vertex<I, V, E, M>> vertices)
throws IOException {
File file = new File(getPartitionPath(partitionId));
DataOutputStream outputStream =
new DataOutputStream(new BufferedOutputStream(new FileOutputStream(file, true)));
for (Vertex<I, V, E, M> vertex : vertices) {
vertex.write(outputStream);
}
outputStream.close();
}
/**
* Write a partition to disk.
*
* @param partition The partition object to write
* @throws java.io.IOException
*/
private void writePartition(Partition<I, V, E, M> partition) throws IOException {
File file = new File(getPartitionPath(partition.getId()));
file.getParentFile().mkdirs();
file.createNewFile();
DataOutputStream outputStream =
new DataOutputStream(new BufferedOutputStream(new FileOutputStream(file)));
for (Vertex<I, V, E, M> vertex : partition.getVertices()) {
vertex.write(outputStream);
}
outputStream.close();
}
@Override
public void compute(
Vertex<IntWritable, IntWritable, NullWritable> vertex, Iterable<IntWritable> messages)
throws IOException {
int currentLength = vertex.getValue().get();
// First superstep is special, because we can simply look at the neighbors
if (getSuperstep() == 0) {
if (isSource(vertex)) {
vertex.setValue(new IntWritable(0));
sendMessageToAllEdges(vertex, vertex.getValue());
} else {
vertex.setValue(new IntWritable(Integer.MAX_VALUE));
}
vertex.voteToHalt();
return;
}
boolean changed = false;
// did we get a smaller length ?
for (IntWritable message : messages) {
int candidateLength = message.get() + 1;
if (candidateLength < currentLength) {
currentLength = candidateLength;
changed = true;
}
}
// propagate new length to the neighbors
if (changed) {
vertex.setValue(new IntWritable(currentLength));
sendMessageToAllEdges(vertex, vertex.getValue());
}
vertex.voteToHalt();
}
/**
* Read a partition from disk.
*
* @param partitionId Id of the partition to read
* @return The partition object
* @throws IOException
*/
private Partition<I, V, E, M> readPartition(Integer partitionId) throws IOException {
Partition<I, V, E, M> partition = new Partition<I, V, E, M>(conf, partitionId);
File file = new File(getPartitionPath(partitionId));
DataInputStream inputStream =
new DataInputStream(new BufferedInputStream(new FileInputStream(file)));
int numVertices = onDiskPartitions.get(partitionId);
for (int i = 0; i < numVertices; ++i) {
Vertex<I, V, E, M> vertex = conf.createVertex();
vertex.readFields(inputStream);
partition.putVertex(vertex);
}
inputStream.close();
file.delete();
return partition;
}
@Override
public void compute(
Vertex<LongWritable, DoubleWritable, FloatWritable> vertex, Iterable<LongWritable> messages)
throws IOException {
Assert.assertNotNull(vertex);
vertex.voteToHalt();
}
/**
* Propagates the smallest vertex id to all neighbors. Will always choose to halt and only
* reactivate if a smaller id has been sent to it.
*
* @param messages Iterator of messages from the previous superstep.
* @throws java.io.IOException
*/
@Override
public void compute(
Vertex<LongWritable, LongWritable, NullWritable> vertex, Iterable<LongWritable> messages)
throws IOException {
long currentComponent = vertex.getValue().get();
// First superstep is special, because we can simply look at the neighbors
if (getSuperstep() == 0) {
for (Edge<LongWritable, NullWritable> edge : vertex.getEdges()) {
long neighbor = edge.getTargetVertexId().get();
if (neighbor < currentComponent) {
currentComponent = neighbor;
}
}
// Only need to send value if it is not the own id
if (currentComponent != vertex.getValue().get()) {
vertex.setValue(new LongWritable(currentComponent));
for (Edge<LongWritable, NullWritable> edge : vertex.getEdges()) {
LongWritable neighbor = edge.getTargetVertexId();
if (neighbor.get() > currentComponent) {
sendMessage(neighbor, vertex.getValue());
}
}
}
vertex.voteToHalt();
return;
}
boolean changed = false;
// did we get a smaller id ?
for (LongWritable message : messages) {
long candidateComponent = message.get();
if (candidateComponent < currentComponent) {
currentComponent = candidateComponent;
changed = true;
}
}
// propagate new component id to the neighbors
if (changed) {
vertex.setValue(new LongWritable(currentComponent));
sendMessageToAllEdges(vertex, vertex.getValue());
}
vertex.voteToHalt();
}
@Override
public void compute(
Vertex<IntWritable, IntWritable, NullWritable> vertex, Iterable<IntWritable> messages)
throws IOException {
if (getSuperstep() == 0) {
// send list of this vertex's neighbors to all neighbors
for (Edge<IntWritable, NullWritable> edge : vertex.getEdges()) {
sendMessageToAllEdges(vertex, edge.getTargetVertexId());
}
} else {
for (IntWritable message : messages) {
// INTENTIONAL BUG: the original algorithm has these two lines, which
// avoids the
// NullPointerException, which the current code throws.
// final int current = (closeMap.get(message) == null) ?
// 0 : closeMap.get(message) + 1;
final int current = closeMap.get(message);
closeMap.put(message, current);
}
// make sure the result values are sorted and
// packaged in an IntArrayListWritable for output
Set<Pair> sortedResults = Sets.<Pair>newTreeSet();
for (Map.Entry<IntWritable, Integer> entry : closeMap.entrySet()) {
sortedResults.add(new Pair(entry.getKey(), entry.getValue()));
}
IntArrayListWritable outputList = new IntArrayListWritable();
for (Pair pair : sortedResults) {
if (pair.value > 0) {
outputList.add(pair.key);
} else {
break;
}
}
if (outputList.isEmpty()) {
vertex.setValue(new IntWritable(-1));
} else {
vertex.setValue(outputList.get(0));
}
}
vertex.voteToHalt();
}
@Override
public Vertex<LongWritable, DoubleWritable, FloatWritable> getCurrentVertex()
throws IOException, InterruptedException {
Vertex<LongWritable, DoubleWritable, FloatWritable> vertex = conf.createVertex();
String[] tokens = neighborSeparator.split(getRecordReader().getCurrentValue().toString());
List<Edge<LongWritable, FloatWritable>> edges =
Lists.newArrayListWithCapacity(tokens.length - 1);
for (int n = 1; n < tokens.length; n++) {
String[] parts = weightSeparator.split(tokens[n]);
edges.add(
EdgeFactory.create(
new LongWritable(Long.parseLong(parts[0])),
new FloatWritable(Float.parseFloat(parts[1]))));
}
LongWritable vertexId = new LongWritable(Long.parseLong(tokens[0]));
vertex.initialize(vertexId, new DoubleWritable(), edges);
return vertex;
}
@Override
public Vertex<LongWritable, VertexDataStructure, FloatWritable> getCurrentVertex()
throws IOException, InterruptedException {
Text line = getRecordReader().getCurrentValue();
Vertex<LongWritable, VertexDataStructure, FloatWritable> vertex = getConf().createVertex();
try {
JSONArray jsonVertex = new JSONArray(line.toString());
vertex.initialize(
new LongWritable(jsonVertex.getLong(0)),
new VertexDataStructure(jsonVertex.getLong(1), new HashSet<Long>()));
JSONArray jsonEdgeArray = jsonVertex.getJSONArray(2);
for (int i = 0; i < jsonEdgeArray.length(); ++i) {
JSONArray jsonEdge = jsonEdgeArray.getJSONArray(i);
Edge<LongWritable, FloatWritable> edge =
EdgeFactory.create(
new LongWritable(jsonEdge.getLong(0)),
new FloatWritable((float) jsonEdge.getDouble(1)));
vertex.addEdge(edge);
}
} catch (JSONException e) {
throw new IllegalArgumentException("next: Couldn't get vertex from line " + line, e);
}
return vertex;
}
public IncidentAndAdjacentIterator(Vertex<IntWritable, DoubleWritable, Directions> vertex) {
this(vertex.getEdges().iterator());
}
/**
* Is this vertex the source id?
*
* @param vertex Vertex
* @return True if the source id
*/
private boolean isSource(Vertex<IntWritable, ?, ?> vertex) {
return vertex.getId().get() == SOURCE_ID.get(getConf());
}
// public static double level=0;
@Override
public void compute(
Vertex<LongWritable, DoubleWritable, FloatWritable> v, Iterable<DoubleWritable> msg)
throws IOException {
if (getSuperstep() == 0) {
if (isSource(v) == true) {
v.setValue(new DoubleWritable(0));
// level++;
sendMessageToAllEdges(v, new DoubleWritable(v.getId().get()));
} else v.setValue(new DoubleWritable(-1));
} else {
for (DoubleWritable messages : msg) {
if (v.getValue().get() == -1) {
v.setValue(messages);
for (Edge<LongWritable, FloatWritable> edge : v.getEdges()) {
if (edge.getTargetVertexId().get() != v.getValue().get()) {
sendMessage(edge.getTargetVertexId(), new DoubleWritable(v.getId().get()));
}
}
} else {
if (v.getValue().get() != messages.get()) {
removeEdgesRequest(v.getId(), new LongWritable((long) messages.get()));
removeEdgesRequest(new LongWritable((long) messages.get()), v.getId());
}
}
/*
if(v.getValue().get() > messages.get())
{
v.setValue(new DoubleWritable(getSuperstep()));
// changed=true;
}*/
}
if (v.getValue().get() == -1) {
for (Edge<LongWritable, FloatWritable> edge : v.getEdges()) {
if (edge.getTargetVertexId().get() != v.getValue().get())
sendMessage(edge.getTargetVertexId(), new DoubleWritable(v.getId().get()));
}
}
/* if(changed)
{
level++;
sendMessageToAllEdges(v,new DoubleWritable(level));
changed=false;
}*/
}
v.voteToHalt();
}
private boolean isSource(Vertex<LongWritable, DoubleWritable, FloatWritable> v) {
return v.getId().get() == SOURCE_ID.get(getConf());
}