@Override public LongValue next() { value.setValue(data[pos++]); return value; }
@Override public LongValue next() { if (current <= to) { currentValue.setValue(current++); return currentValue; } else { throw new NoSuchElementException(); } }
@Override public LongValue copy(LongValue from, LongValue reuse) { reuse.setValue(from.getValue()); return reuse; }
@Override public LongValue translate(Long value, LongValue reuse) throws Exception { if (reuse == null) { reuse = new LongValue(); } reuse.setValue(value); return reuse; } }
@SuppressWarnings("unused") public void coGroup(Iterable<Vertex<K, VV>> vertex, Iterable<Edge<K, EV>> outEdges, Collector<Tuple2<K, LongValue>> out) { long count = 0; for (Edge<K, EV> edge : outEdges) { count++; } degree.setValue(count); Iterator<Vertex<K, VV>> vertexIterator = vertex.iterator(); if (vertexIterator.hasNext()) { vertexDegree.f0 = vertexIterator.next().f0; out.collect(vertexDegree); } else { throw new NoSuchElementException("The edge src/trg id could not be found within the vertexIds"); } } }
@Override public Vertex<K, LongValue> reduce(Vertex<K, LongValue> left, Vertex<K, LongValue> right) throws Exception { LongValue count = left.f1; count.setValue(count.getValue() + right.f1.getValue()); return left; } }
@Override public Tuple2<T, LongValue> reduce(Tuple2<T, LongValue> left, Tuple2<T, LongValue> right) throws Exception { left.f1.setValue(left.f1.getValue() + right.f1.getValue()); return left; } }
@Override public Tuple2<T, LongValue> reduce(Tuple2<T, LongValue> left, Tuple2<T, LongValue> right) throws Exception { left.f1.setValue(left.f1.getValue() + right.f1.getValue()); return left; } }
@Override public LongValue reduce(LongValue value1, LongValue value2) throws Exception { value1.setValue(value1.getValue() + value2.getValue()); return value1; } }
@Override public Tuple3<T, LongValue, LongValue> reduce(Tuple3<T, LongValue, LongValue> value1, Tuple3<T, LongValue, LongValue> value2) throws Exception { value1.f2.setValue(value1.f2.getValue() + value2.f2.getValue()); return value1; } }
@Override public Tuple3<T, Degrees, LongValue> reduce(Tuple3<T, Degrees, LongValue> value1, Tuple3<T, Degrees, LongValue> value2) throws Exception { value1.f2.setValue(value1.f2.getValue() + value2.f2.getValue()); return value1; } }
@Override public LongValue translate(LongValue value, LongValue reuse) throws Exception { if (reuse == null) { reuse = new LongValue(); } reuse.setValue(offset + value.getValue()); return reuse; } }
target.setValue(val - increment); out.collect(edge); } else if (dimension.f1) { target.setValue(val + increment * (dimension.f0 - 1)); out.collect(edge); target.setValue(val + increment); out.collect(edge); } else if (dimension.f1) { target.setValue(val - increment * (dimension.f0 - 1)); out.collect(edge);
@Override public Tuple2<FloatValue, LongValue> map(Tuple3<T, LongValue, FloatValue> value) throws Exception { long degree = value.f1.getValue(); long neighborPairs = degree * (degree - 1) / 2; sumOfScores.setValue(value.f2.getValue() * neighborPairs); numberOfNeighborPairs.setValue(neighborPairs); return output; } }
@Override public void reduce(Iterable<Tuple2<T, ByteValue>> values, Collector<Vertex<T, Degrees>> out) throws Exception { long degree = 0; long outDegree = 0; long inDegree = 0; for (Tuple2<T, ByteValue> edge : values) { output.f0 = edge.f0; byte bitmask = edge.f1.getValue(); degree++; if (bitmask == EdgeOrder.FORWARD.getBitmask()) { outDegree++; } else if (bitmask == EdgeOrder.REVERSE.getBitmask()) { inDegree++; } else { outDegree++; inDegree++; } } output.f1.getDegree().setValue(degree); output.f1.getOutDegree().setValue(outDegree); output.f1.getInDegree().setValue(inDegree); out.collect(output); } }
@Override public void flatMap(LongValue source, Collector<Edge<LongValue, NullValue>> out) throws Exception { edge.f0 = source; long sourceID = source.getValue(); for (OffsetRange offsetRange : offsetRanges) { long targetID = sourceID + offsetRange.getOffset(); for (long i = offsetRange.getLength(); i > 0; i--) { // add positive offset target.setValue(targetID++ % vertexCount); out.collect(edge); } } } }
/** * Executes the throughput benchmark with the given number of records. * * @param records to pass through the network stack */ public void executeBenchmark(long records, long timeout) throws Exception { final LongValue value = new LongValue(); value.setValue(0); long lastRecord = records / writerThreads.length; CompletableFuture<?> recordsReceived = receiver.setExpectedRecord(lastRecord); for (LongRecordWriterThread writerThread : writerThreads) { writerThread.setRecordsToSend(lastRecord); } recordsReceived.get(timeout, TimeUnit.MILLISECONDS); }
/** * Executes the latency benchmark with the given number of records. * * @param records * records to pass through the network stack * @param flushAfterLastEmit * whether to flush the {@link RecordWriter} after the last record */ public void executeBenchmark(long records, boolean flushAfterLastEmit) throws Exception { final LongValue value = new LongValue(); value.setValue(0); CompletableFuture<?> recordsReceived = receiver.setExpectedRecord(records); for (int i = 1; i < records; i++) { recordWriter.emit(value); } value.setValue(records); recordWriter.broadcastEmit(value); if (flushAfterLastEmit) { recordWriter.flushAll(); } recordsReceived.get(RECEIVER_TIMEOUT, TimeUnit.MILLISECONDS); }
private void sendRecords(long records) throws IOException, InterruptedException { LongValue value = new LongValue(0); for (int i = 1; i < records; i++) { if (broadcastMode) { recordWriter.broadcastEmit(value); } else { recordWriter.emit(value); } } value.setValue(records); recordWriter.broadcastEmit(value); recordWriter.flushAll(); finishSendingRecords(); } }