@Test public void degreeCounting() throws Exception { int numV = 200; int numE = generateRandomGraph(numV); clopen(); final TitanGraphComputer computer = graph.compute(); computer.resultMode(TitanGraphComputer.ResultMode.NONE); computer.workers(4); computer.program(new DegreeCounter()); computer.mapReduce(new DegreeMapper()); ComputerResult result = computer.submit().get(); System.out.println("Execution time (ms) ["+numV+"|"+numE+"]: " + result.memory().getRuntime()); assertTrue(result.memory().exists(DegreeMapper.DEGREE_RESULT)); Map<Long,Integer> degrees = result.memory().get(DegreeMapper.DEGREE_RESULT); assertNotNull(degrees); assertEquals(numV,degrees.size()); int totalCount = 0; for (Map.Entry<Long,Integer> entry : degrees.entrySet()) { int degree = entry.getValue(); TitanVertex v = getV(tx, entry.getKey().longValue()); int count = v.value("uid"); assertEquals(count,degree); totalCount+= degree; } assertEquals(numV*(numV+1)/2,totalCount); assertEquals(1,result.memory().getIteration()); }
@Override public void execute(Vertex vertex, Messenger<Integer> messenger, Memory memory) { if (memory.isInitialIteration()) { messenger.sendMessage(DEG_MSG, 1); } else { int degree = IteratorUtils.stream(messenger.receiveMessages()).reduce(0, (a, b) -> a + b); vertex.property(VertexProperty.Cardinality.single, DEGREE, degree); if (memory.getIteration()<length) messenger.sendMessage(DEG_MSG, degree); } }
@Override public boolean terminate(Memory memory) { assertEquals(Long.valueOf(6 * (memory.getIteration() + 1)), memory.get("a")); assertEquals(Long.valueOf(6), memory.get("b")); assertFalse(memory.get("c")); assertTrue(memory.get("d")); assertFalse(memory.get("e")); assertEquals(memory.getIteration() + 1, memory.<Integer>get("f").intValue()); memory.set("b", 0l); memory.set("e", true); try { memory.add("a", 0l); fail("Should only allow Memory.set() during VertexProgram.terminate()"); } catch (final Exception e) { validateException(Memory.Exceptions.memoryAddOnlyDuringVertexProgramExecute("a"), e); } return memory.getIteration() > 1; }
@Test @LoadGraphWith(MODERN) public void shouldAndOrIncrCorrectlyThroughSubStages() throws Exception { ComputerResult results = graphProvider.getGraphComputer(graph).program(new VertexProgramG()).submit().get(); assertEquals(2, results.memory().getIteration()); assertEquals(6, results.memory().asMap().size()); assertEquals(6, results.memory().keys().size()); assertTrue(results.memory().keys().contains("a")); assertTrue(results.memory().keys().contains("b")); assertTrue(results.memory().keys().contains("c")); assertTrue(results.memory().keys().contains("d")); assertTrue(results.memory().keys().contains("e")); assertTrue(results.memory().keys().contains("f")); assertEquals(Long.valueOf(18), results.memory().get("a")); assertEquals(Long.valueOf(0), results.memory().get("b")); assertFalse(results.memory().get("c")); assertTrue(results.memory().get("d")); assertTrue(results.memory().get("e")); assertEquals(3, results.memory().<Integer>get("f").intValue()); }
@Override public void execute(final Vertex vertex, final Messenger messenger, final Memory memory) { if (memory.isInitialIteration()) { assertFalse(memory.exists("m1")); assertTrue(memory.exists("m2")); assertTrue(memory.get("m2")); assertFalse(memory.exists("m3")); assertTrue(memory.exists("m4")); assertEquals(0, memory.<Integer>get("m4").intValue()); memory.add("m1", false); memory.add("m2", true); memory.add("m3", 1l); memory.add("m4", -1); } else { assertFalse(memory.exists("m1")); // no broadcast assertTrue(memory.exists("m2")); assertFalse(memory.exists("m3")); // no broadcast assertTrue(memory.exists("m4")); try { assertFalse(memory.get("m1")); fail(); } catch (final Exception e) { validateException(Memory.Exceptions.memoryDoesNotExist("m1"), e); assertTrue(memory.get("m2")); try { assertEquals(6l, memory.<Long>get("m3").longValue()); fail(); } catch (final Exception e) { validateException(Memory.Exceptions.memoryDoesNotExist("m3"), e);
@Override public boolean terminate(final Memory memory) { final boolean voteToHalt = memory.<Boolean>get(VOTE_TO_HALT) || memory.getIteration() >= (this.distributeVote ? this.maxIterations + 1 : this.maxIterations); if (voteToHalt) { return true; } else { memory.set(VOTE_TO_HALT, true); return false; } }
public MapMemory(final Memory otherMemory) { otherMemory.keys().forEach(key -> this.memoryMap.put(key, otherMemory.get(key))); this.iteration = otherMemory.getIteration(); }
@Override public boolean terminate(final Memory memory) { final TraverserGenerator generator = this.traversal.get().getTraverserGenerator(); MemoryTraversalSideEffects.setMemorySideEffects(this.traversal.get(), memory, ProgramPhase.TERMINATE); checkSideEffects(); if (memory.isInitialIteration()) { assertFalse(memory.exists(TraversalVertexProgram.HALTED_TRAVERSERS)); return false; } else { /// assertTrue(memory.exists(TraversalVertexProgram.HALTED_TRAVERSERS)); final TraverserSet<String> haltedTraversers = memory.get(TraversalVertexProgram.HALTED_TRAVERSERS); haltedTraversers.add(generator.generate("hello", this.programStep, 1l)); haltedTraversers.add(generator.generate("gremlin", this.programStep, 1l)); memory.set(TraversalVertexProgram.HALTED_TRAVERSERS, haltedTraversers); return true; } }
@Override public void execute(Vertex vertex, Messenger messenger, Memory memory) { assertEquals(memory.getIteration() * 6, memory.<Integer>get("test").intValue()); memory.add("test", 1); }
@Test @LoadGraphWith(MODERN) public void shouldSupportBroadcastKeys() throws Exception { final ComputerResult result = graphProvider.getGraphComputer(graph).program(new VertexProgramP()).submit().get(); assertTrue(result.memory().exists("m1")); assertFalse(result.memory().exists("m2")); assertFalse(result.memory().exists("m3")); assertTrue(result.memory().exists("m4")); assertTrue(result.memory().get("m1")); assertEquals(-18, result.memory().<Integer>get("m4").intValue()); assertEquals(2, result.memory().keys().size()); }
@Override public boolean terminate(final Memory memory) { if (memory.isInitialIteration() && this.haltedTraversersIndex != null) { this.haltedTraversersIndex.clear(); } final boolean voteToHalt = memory.<Boolean>get(VOTE_TO_HALT); if (voteToHalt) { return true; } else { // it is basically always assumed that the program will want to halt, but if message passing occurs, the // program will want to continue, thus reset false values to true for future iterations memory.set(VOTE_TO_HALT, true); return false; } }
@Override public boolean terminate(Memory memory) { return memory.getIteration() > 1; }
@Override public boolean terminate(final Memory memory) { assertTrue(memory.exists("m1")); assertTrue(memory.exists("m2")); assertTrue(memory.exists("m3")); if (memory.isInitialIteration()) { assertFalse(memory.get("m1")); assertTrue(memory.get("m2")); assertEquals(12l, memory.<Long>get("m3").longValue()); return false; } else { assertTrue(memory.get("m1")); assertTrue(memory.get("m2")); assertEquals(24l, memory.<Long>get("m3").longValue()); return true; } }
@Override public void setup(final Memory memory) { memory.set("a", 0l); memory.set("b", 0l); memory.set("c", true); memory.set("d", false); memory.set("e", true); memory.set("f", memory.getIteration()); try { memory.add("a", 0l); fail("Should only allow Memory.set() during VertexProgram.setup()"); } catch (final Exception e) { validateException(Memory.Exceptions.memoryAddOnlyDuringVertexProgramExecute("a"), e); } }
/** * A helper method that generates a {@link Map} of the memory key/values. * * @return the map representation of the memory key/values */ public default Map<String, Object> asMap() { final Map<String, Object> map = keys().stream() .map(key -> Pair.with(key, get(key))) .collect(Collectors.toMap(Pair::getValue0, Pair::getValue1)); return Collections.unmodifiableMap(map); }
@Override public void execute(final Vertex vertex, Messenger<Pair<Serializable, Double>> messenger, final Memory memory) { if (memory.isInitialIteration()) { if (this.distributeVote) { messenger.sendMessage(this.countScope, Pair.with('c', 1.0d)); vertex.property(VertexProperty.Cardinality.single, VOTE_STRENGTH, voteStrength); messenger.sendMessage(this.voteScope, new Pair<>((Serializable) vertex.id(), voteStrength)); memory.add(VOTE_TO_HALT, false); } else if (1 == memory.getIteration() && this.distributeVote) { double voteStrength = (null == this.initialVoteStrengthTraversal ? 1.0d : vertex.property(VertexProperty.Cardinality.single, VOTE_STRENGTH, voteStrength); messenger.sendMessage(this.voteScope, new Pair<>((Serializable) vertex.id(), voteStrength)); memory.add(VOTE_TO_HALT, false); } else { final Map<Serializable, Double> votes = new HashMap<>(); Serializable cluster = PeerPressureVertexProgram.largestCount(votes); if (null == cluster) cluster = (Serializable) vertex.id(); memory.add(VOTE_TO_HALT, vertex.value(this.property).equals(cluster)); vertex.property(VertexProperty.Cardinality.single, this.property, cluster); messenger.sendMessage(this.voteScope, new Pair<>(cluster, vertex.<Double>value(VOTE_STRENGTH)));
@Override public void execute(final Vertex vertex, Messenger<Long> messenger, final Memory memory) { if (memory.isInitialIteration()) { if (vertex.id().equals(Long.valueOf(seed).longValue())) { // The seed sends a single message to start the computation log.debug("Sent initial message from {}", vertex.id()); // The seed's distance to itself is zero vertex.property(VertexProperty.Cardinality.single, DISTANCE, 0L); messenger.sendMessage(incidentMessageScope, 0L); } } else { Iterator<Long> distances = messenger.receiveMessages(); // Find minimum distance among all incoming messages, or null if no messages came in Long shortestDistanceSeenOnThisIteration = IteratorUtils.stream(distances).reduce((a, b) -> Math.min(a, b)).orElse(null); if (null == shortestDistanceSeenOnThisIteration) return; // no messages to process or forward on this superstep VertexProperty<Long> currentShortestVP = vertex.property(DISTANCE); if (!currentShortestVP.isPresent() || currentShortestVP.value() > shortestDistanceSeenOnThisIteration) { // First/shortest distance seen by this vertex: store it and forward to neighbors vertex.property(VertexProperty.Cardinality.single, DISTANCE, shortestDistanceSeenOnThisIteration); messenger.sendMessage(incidentMessageScope, shortestDistanceSeenOnThisIteration); } // else: no new winner, ergo no reason to send message to neighbors } }
computer.program(new DegreeCounter(2)); ComputerResult result = computer.submit().get(); System.out.println("Execution time (ms) ["+numV+"|"+numE+"]: " + result.memory().getRuntime()); assertEquals(2,result.memory().getIteration());