@Override public void setup(final Memory memory) { memory.set(VOTE_TO_HALT, true); }
@Override public void setup(final Memory memory) { memory.set(VOTE_TO_HALT, false); }
@Override public void setup(final Memory memory) { memory.set("workerCount", 0l); }
@Override public void set(final String key, final Object value) { this.sideEffects.set(key, value); if (null != this.memory) this.memory.set(key, value); }
@Override public void setup(final Memory memory) { memory.set("test", memory.getIteration()); }
@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 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; } }
@Override public void setup(final Memory memory) { assertFalse(memory.exists("m1")); // or assertFalse(memory.exists("m2")); // and assertFalse(memory.exists("m3")); // long assertFalse(memory.exists("m4")); // int memory.set("m1", false); memory.set("m2", true); memory.set("m3", 0l); memory.set("m4", 0); }
@Override public boolean terminate(final Memory memory) { boolean terminate = memory.<Double>get(CONVERGENCE_ERROR) < this.epsilon || memory.getIteration() >= this.maxIterations; memory.set(CONVERGENCE_ERROR, 0.0d); return terminate; }
@Override public void workerIterationEnd(final Memory memory) { assertEquals(memory.getIteration() * 6, memory.<Integer>get("test").intValue()); try { memory.set("test", memory.getIteration()); fail("Should throw an immutable memory exception"); } catch (IllegalStateException e) { assertEquals(Memory.Exceptions.memoryIsCurrentlyImmutable().getMessage(), e.getMessage()); } }
@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 void setup(final Memory memory) { MemoryTraversalSideEffects.setMemorySideEffects(this.traversal.get(), memory, ProgramPhase.SETUP); final Map<Vertex, Long> map = (Map<Vertex, Long>) this.haltedTraversers.iterator().next().get(); assertEquals(2, map.size()); assertTrue(map.values().contains(3l)); assertTrue(map.values().contains(1l)); final IndexedTraverserSet<Object,Vertex> activeTraversers = new IndexedTraverserSet.VertexIndexedTraverserSet(); map.keySet().forEach(vertex -> activeTraversers.add(this.haltedTraversers.peek().split(vertex, EmptyStep.instance()))); this.haltedTraversers.clear(); this.checkSideEffects(); memory.set(TraversalVertexProgram.ACTIVE_TRAVERSERS, activeTraversers); }
protected static void processMemory(final TraversalMatrix<?, ?> traversalMatrix, final Memory memory, final TraverserSet<Object> toProcessTraversers, final Set<String> completedBarriers) { // handle traversers and data that were sent from the workers to the master traversal via memory if (memory.exists(TraversalVertexProgram.MUTATED_MEMORY_KEYS)) { for (final String key : memory.<Set<String>>get(TraversalVertexProgram.MUTATED_MEMORY_KEYS)) { final Step<Object, Object> step = traversalMatrix.getStepById(key); assert step instanceof Barrier; completedBarriers.add(step.getId()); if (!(step instanceof LocalBarrier)) { // local barriers don't do any processing on the master traversal (they just lock on the workers) final Barrier<Object> barrier = (Barrier<Object>) step; barrier.addBarrier(memory.get(key)); step.forEachRemaining(toProcessTraversers::add); // if it was a reducing barrier step, reset the barrier to its seed value if (step instanceof ReducingBarrierStep) memory.set(step.getId(), ((ReducingBarrierStep) step).getSeedSupplier().get()); } } } memory.set(TraversalVertexProgram.MUTATED_MEMORY_KEYS, new HashSet<>()); }
@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)); }
@Override public boolean terminate(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.set("a", true); // fail("Setting a memory key that wasn't declared should fail"); } catch (Exception e) { validateException(GraphComputer.Exceptions.providedKeyIsNotAMemoryComputeKey("a"), e); } return true; }
@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; }
@Override public void setup(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.set("a", true); fail("Setting a memory key that wasn't declared should fail"); } catch (Exception e) { validateException(GraphComputer.Exceptions.providedKeyIsNotAMemoryComputeKey("a"), e); } }
@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; } }