@Override public void execute(final Vertex vertex, final Messenger messenger, final Memory memory) { try { Thread.sleep(1); } catch (Exception e) { throw new IllegalStateException(e.getMessage(), e); } if (!this.announced) { memory.add("workerCount", 1l); this.announced = true; } }
@Override public void execute(Vertex vertex, Messenger messenger, Memory memory) { assertEquals(memory.getIteration() * 6, memory.<Integer>get("test").intValue()); memory.add("test", 1); }
@Override public void workerIterationStart(final Memory memory) { assertEquals(memory.getIteration() * 6, memory.<Integer>get("test").intValue()); try { memory.add("test", memory.getIteration()); fail("Should throw an immutable memory exception"); } catch (IllegalStateException e) { assertEquals(Memory.Exceptions.memoryIsCurrentlyImmutable().getMessage(), e.getMessage()); } }
@Override public void execute(final Vertex vertex, final Messenger<Object> messenger, final Memory memory) { try { vertex.property(VertexProperty.Cardinality.single, "blah", "blah"); fail("Should throw an IllegalArgumentException"); } catch (final IllegalArgumentException e) { assertEquals(GraphComputer.Exceptions.providedKeyIsNotAnElementComputeKey("blah").getMessage(), e.getMessage()); } catch (final Exception e) { fail("Should throw an IllegalArgumentException: " + e); } memory.add("a", 1); if (memory.isInitialIteration()) { vertex.property(VertexProperty.Cardinality.single, "nameLengthCounter", vertex.<String>value("name").length()); memory.add("b", vertex.<String>value("name").length()); } else { vertex.property(VertexProperty.Cardinality.single, "nameLengthCounter", vertex.<String>value("name").length() + vertex.<Integer>value("nameLengthCounter")); } }
if (memory.isInitialIteration()) { messenger.sendMessage(this.countMessageScope, 1.0d); memory.add(VERTEX_COUNT, 1.0d); } else { final double vertexCount = memory.<Double>get(VERTEX_COUNT); final double localTerminalEnergy = teleporationEnergy / vertexCount; pageRank = pageRank + localTerminalEnergy; memory.add(TELEPORTATION_ENERGY, -localTerminalEnergy); memory.add(CONVERGENCE_ERROR, Math.abs(pageRank - previousPageRank)); vertex.property(VertexProperty.Cardinality.single, this.property, pageRank); memory.add(TELEPORTATION_ENERGY, (1.0d - this.alpha) * pageRank); pageRank = this.alpha * pageRank; if (edgeCount > 0.0d) messenger.sendMessage(this.incidentMessageScope, pageRank / edgeCount); else memory.add(TELEPORTATION_ENERGY, pageRank);
@Override public void add(final String key, final Object value) { if (this.phase.workerState()) this.memory.add(key, value); else this.memory.set(key, this.sideEffects.getReducer(key).apply(this.memory.get(key), value)); }
/** * Move any valid path into the VP's memory. * @param vertex The current vertex. * @param memory The VertexProgram's memory. */ private void collectShortestPaths(final Vertex vertex, final Memory memory) { final VertexProperty<Map<Vertex, Pair<Number, Set<Path>>>> pathProperty = vertex.property(PATHS); if (pathProperty.isPresent()) { final Map<Vertex, Pair<Number, Set<Path>>> paths = pathProperty.value(); final List<Path> result = new ArrayList<>(); for (final Pair<Number, Set<Path>> pair : paths.values()) { for (final Path path : pair.getValue1()) { if (isEndVertex(vertex)) { if (this.distanceEqualsNumberOfHops || this.maxDistance == null || NumberHelper.compare(pair.getValue0(), this.maxDistance) <= 0) { result.add(path); } } } } pathProperty.remove(); memory.add(SHORTEST_PATHS, result); } }
@Override public void execute(final Vertex vertex, final Messenger messenger, final Memory memory) { if (memory.isInitialIteration()) { final Property<TraverserSet> haltedTraversers = vertex.property(TraversalVertexProgram.HALTED_TRAVERSERS); if (!haltedTraversers.isPresent()) return; final Iterator iterator = haltedTraversers.value().iterator(); if (iterator.hasNext()) { while (iterator.hasNext()) { final Traverser t = (Traverser) iterator.next(); if (!(t.path() instanceof EmptyPath)) { final int pathLength = t.path().size(); final List<Pair<Vertex, Integer>> memoryValue = new LinkedList<>(); memoryValue.add(Pair.with(vertex, pathLength)); memory.add(LENGTHS_KEY, memoryValue); } } } } else { if (memory.exists(LENGTHS_KEY)) { final List<Pair<Vertex, Integer>> lengths = memory.get(LENGTHS_KEY); for (final Pair<Vertex, Integer> pair : lengths) { if (pair.getValue0().equals(vertex)) { vertex.property(VertexProperty.Cardinality.list, propertyKey, pair.getValue1()); } } } } }
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 memory.add("m1", true); memory.add("m2", true); memory.add("m3", 2l); memory.add("m4", -2);
@Test @LoadGraphWith(MODERN) public void shouldHaveImmutableComputeResultMemory() throws Exception { final ComputerResult results = graphProvider.getGraphComputer(graph).program(new VertexProgramB()).submit().get(); try { results.memory().set("set", "test"); } catch (Exception ex) { validateException(Memory.Exceptions.memoryIsCurrentlyImmutable(), ex); } try { results.memory().add("incr", 1); } catch (Exception ex) { validateException(Memory.Exceptions.memoryIsCurrentlyImmutable(), ex); } try { results.memory().add("and", true); } catch (Exception ex) { validateException(Memory.Exceptions.memoryIsCurrentlyImmutable(), ex); } try { results.memory().add("or", false); } catch (Exception ex) { validateException(Memory.Exceptions.memoryIsCurrentlyImmutable(), ex); } }
@Override public void execute(final Vertex vertex, final Messenger messenger, final Memory memory) { try { memory.get("a"); fail("The memory key does not exist and should fail"); } catch (Exception e) { validateException(Memory.Exceptions.memoryDoesNotExist("a"), e); } try { memory.add("a", true); fail("Setting a memory key that wasn't declared should fail"); } catch (Exception e) { validateException(GraphComputer.Exceptions.providedKeyIsNotAMemoryComputeKey("a"), e); } }
Host.getHostingVertex(traverser.get()).equals(vertex))) { if (returnHaltedTraversers) memory.add(TraversalVertexProgram.HALTED_TRAVERSERS, new TraverserSet<>(haltedTraverserStrategy.halt(traverser))); else haltedTraversers.add(traverser.detach()); }); memory.add(TraversalVertexProgram.MUTATED_MEMORY_KEYS, new HashSet<>(Collections.singleton(step.getId()))); } else { final Barrier barrier = (Barrier) step; while (barrier.hasNextBarrier()) { memory.add(step.getId(), barrier.nextBarrier()); memory.add(TraversalVertexProgram.MUTATED_MEMORY_KEYS, new HashSet<>(Collections.singleton(step.getId()))); Host.getHostingVertex(traverser.get()).equals(vertex))) { if (returnHaltedTraversers) memory.add(TraversalVertexProgram.HALTED_TRAVERSERS, new TraverserSet<>(haltedTraverserStrategy.halt(traverser))); else haltedTraversers.add(traverser.detach());
@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; }
vertex.property(VertexProperty.Cardinality.single, VOTE_STRENGTH, voteStrength); messenger.sendMessage(this.voteScope, new Pair<>((Serializable) vertex.id(), voteStrength)); memory.add(VOTE_TO_HALT, false); 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 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); } }
@Override public void execute(final Vertex vertex, final Messenger messenger, final Memory memory) { assertFalse(memory.exists(TraversalVertexProgram.HALTED_TRAVERSERS)); final TraverserGenerator generator = this.traversal.get().getTraverserGenerator(); MemoryTraversalSideEffects.setMemorySideEffects(this.traversal.get(), memory, ProgramPhase.EXECUTE); this.checkSideEffects(); final TraverserSet<Vertex> activeTraversers = memory.get(TraversalVertexProgram.ACTIVE_TRAVERSERS); if (vertex.label().equals("software")) { assertEquals(1, activeTraversers.stream().filter(v -> v.get().equals(vertex)).count()); if (memory.isInitialIteration()) { assertFalse(vertex.property(TraversalVertexProgram.HALTED_TRAVERSERS).isPresent()); vertex.property( TraversalVertexProgram.HALTED_TRAVERSERS, new TraverserSet<>(generator.generate(vertex.value("name"), this.programStep, 1l))); } else { assertTrue(vertex.property(TraversalVertexProgram.HALTED_TRAVERSERS).isPresent()); } } else { assertFalse(vertex.property(TraversalVertexProgram.HALTED_TRAVERSERS).isPresent()); assertEquals(0, activeTraversers.stream().filter(v -> v.get().equals(vertex)).count()); if (!memory.isInitialIteration()) { if (vertex.value("name").equals("marko")) memory.add(TraversalVertexProgram.HALTED_TRAVERSERS, new TraverserSet<>(generator.generate("marko-is-my-name", this.programStep, 1l))); else if (vertex.value("name").equals("vadas")) this.traversal.get().getSideEffects().add(TraversalVertexProgram.HALTED_TRAVERSERS, new TraverserSet<>(generator.generate("the-v-o-double-g", this.programStep, 1l))); } } }
if (traverser.isHalted()) { if (this.returnHaltedTraversers) memory.add(HALTED_TRAVERSERS, new TraverserSet<>(this.haltedTraverserStrategy.halt(traverser))); else haltedTraversers.add((Traverser.Admin) traverser.detach()); }); memory.add(VOTE_TO_HALT, activeTraversers.isEmpty() || WorkerExecutor.execute(vertex, new SingleMessenger<>(messenger, activeTraversers), this.traversalMatrix, memory, this.returnHaltedTraversers, haltedTraversers, this.haltedTraverserStrategy)); } else // ITERATION 1+ memory.add(VOTE_TO_HALT, WorkerExecutor.execute(vertex, messenger, this.traversalMatrix, memory, this.returnHaltedTraversers, haltedTraversers, this.haltedTraverserStrategy));