/** * Compare the current step with another step. * * @param other the other step * @param compareIds whether to compare step IDs or not * @return true if the steps are equal, otherwise false */ public default boolean equals(final Step other, final boolean compareIds) { return (!compareIds || (other != null && this.getId().equals(other.getId()))) && this.equals(other); } }
public MutableMetricsSupplier(final Step<?, ?> previousStep) { this.stepId = previousStep.getId(); this.stepString = previousStep instanceof RepeatStep.RepeatEndStep || previousStep instanceof ComputerAwareStep.EndStep ? previousStep.toString() + " (profiling ignored)" : previousStep.toString(); }
public default MemoryComputeKey getMemoryComputeKey() { return MemoryComputeKey.of(((Step) this).getId(), Operator.and, false, true); }
private Map<String, Set<String>> getReferencedLabelsMap() { if (null == this.referencedLabelsMap) { this.referencedLabelsMap = new HashMap<>(); for (final Traversal.Admin<?, ?> traversal : this.matchTraversals) { final Set<String> referencedLabels = new HashSet<>(); for (final Step<?, ?> step : traversal.getSteps()) { referencedLabels.addAll(PathUtil.getReferencedLabels(step)); } this.referencedLabelsMap.put(traversal.getStartStep().getId(), referencedLabels); } } return this.referencedLabelsMap; }
public static boolean hasExecutedTraversal(final Traverser.Admin<Object> traverser, final Traversal.Admin<Object, Object> traversal) { return traverser.getTags().contains(traversal.getStartStep().getId()); }
private final Traverser.Admin<E> prepareTraversalForNextStep(final Traverser.Admin<E> traverser) { if (!this.traverserStepIdAndLabelsSetByChild) { traverser.setStepId(this.nextStep.getId()); traverser.addLabels(this.labels); } return traverser; }
@Override public TestProgram clone() { try { final TestProgram clone = (TestProgram) super.clone(); clone.traversal = this.traversal.clone(); clone.programStep = new TraversalMatrix<>(clone.traversal.get()).getStepById(this.programStep.getId()); return clone; } catch (final CloneNotSupportedException e) { throw new IllegalStateException(e.getMessage(), e); } }
private <S> Traverser.Admin<S> retractUnnecessaryLabels(final Traverser.Admin<S> traverser) { if (null == this.parent.getKeepLabels()) return traverser; final Set<String> keepers = new HashSet<>(this.parent.getKeepLabels()); final Set<String> tags = traverser.getTags(); for (final Traversal.Admin<?, ?> matchTraversal : this.parent.matchTraversals) { // get remaining traversal patterns for the traverser final String startStepId = matchTraversal.getStartStep().getId(); if (!tags.contains(startStepId)) { keepers.addAll(this.parent.getReferencedLabelsMap().get(startStepId)); // get the reference labels required for those remaining traversals } } return PathProcessor.processTraverserPathLabels(traverser, keepers); // remove all reference labels that are no longer required }
@Override protected Iterator<Traverser.Admin<E>> computerAlgorithm() { final List<Traverser.Admin<E>> ends = new ArrayList<>(); final Traverser.Admin<S> start = this.starts.next(); final Object choice = PickTokenKey.make(TraversalUtil.apply(start, this.branchTraversal)); final List<Traversal.Admin<S, E>> branch = this.traversalOptions.containsKey(choice) ? this.traversalOptions.get(choice) : this.traversalOptions.get(Pick.none); if (null != branch) { branch.forEach(traversal -> { final Traverser.Admin<E> split = (Traverser.Admin<E>) start.split(); split.setStepId(traversal.getStartStep().getId()); //split.addLabels(this.labels); ends.add(split); }); } if (choice != Pick.any) { final List<Traversal.Admin<S, E>> anyBranch = this.traversalOptions.get(Pick.any); if (null != anyBranch) { anyBranch.forEach(traversal -> { final Traverser.Admin<E> split = (Traverser.Admin<E>) start.split(); split.setStepId(traversal.getStartStep().getId()); //split.addLabels(this.labels); ends.add(split); }); } } return ends.iterator(); }
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 storeState(final Configuration configuration) { VertexProgram.super.storeState(configuration); this.traversal.storeState(configuration, VertexProgramStep.ROOT_TRAVERSAL); TraversalVertexProgram.storeHaltedTraversers(configuration, this.haltedTraversers); configuration.setProperty(ProgramVertexProgramStep.STEP_ID, this.programStep.getId()); }
private static void verifyUniqueStepIds(final Traversal.Admin<?, ?> traversal, final int depth, final Set<String> ids) { for (final Step step : traversal.asAdmin().getSteps()) { /*for (int i = 0; i < depth; i++) System.out.print("\t"); System.out.println(step.getId() + " --> " + step);*/ if (!ids.add(step.getId())) { fail("The following step id already exists: " + step.getId() + "---" + step); } if (step instanceof TraversalParent) { for (final Traversal.Admin<?, ?> globalTraversal : ((TraversalParent) step).getGlobalChildren()) { verifyUniqueStepIds(globalTraversal, depth + 1, ids); } for (final Traversal.Admin<?, ?> localTraversal : ((TraversalParent) step).getLocalChildren()) { verifyUniqueStepIds(localTraversal, depth + 1, ids); } } } } }
private final void harvestSteps(final Traversal.Admin<?, ?> traversal) { for (final Step<?, ?> step : traversal.getSteps()) { this.matrix.put(step.getId(), step); if (step instanceof TraversalParent) { for (final Traversal.Admin<?, ?> globalChild : ((TraversalParent) step).getGlobalChildren()) { this.harvestSteps(globalChild); } for (final Traversal.Admin<?, ?> localChild : ((TraversalParent) step).getLocalChildren()) { this.harvestSteps(localChild); } } } } }
private void initializeIfNeeded() { if (null == this.metrics) { this.onGraphComputer = TraversalHelper.onGraphComputer(this.getTraversal()); this.metrics = new MutableMetrics(this.getPreviousStep().getId(), this.getPreviousStep().toString()); final Step<?, S> previousStep = this.getPreviousStep(); // give metrics to the step being profiled so that it can add additional data to the metrics like // annotations if (previousStep instanceof Profiling) ((Profiling) previousStep).setMetrics(this.metrics); } }
@Override public void processAllStarts() { while (this.starts.hasNext() && (this.maxBarrierSize == Integer.MAX_VALUE || this.barrier.size() < this.maxBarrierSize)) { final Traverser.Admin<S> traverser = this.starts.next(); traverser.setStepId(this.getNextStep().getId()); // when barrier is reloaded, the traversers should be at the next step this.barrier.add(traverser); } }
@Override protected Traverser.Admin<S> processNextStart() throws NoSuchElementException { final Traverser.Admin<S> start = this.starts.next(); if (this.traverserStepIdAndLabelsSetByChild) { final ComputerAwareStep<?, ?> step = (ComputerAwareStep<?, ?>) this.getTraversal().getParent(); start.setStepId(step.getNextStep().getId()); start.addLabels(step.getLabels()); } return start; }
@Override protected Iterator<Traverser.Admin<S>> computerAlgorithm() throws NoSuchElementException { if (null == this.repeatTraversal) throw new IllegalStateException("The repeat()-traversal was not defined: " + this); final Traverser.Admin<S> start = this.starts.next(); if (doUntil(start, true)) { start.setStepId(this.getNextStep().getId()); start.addLabels(this.labels); return IteratorUtils.of(start); } else { start.setStepId(this.repeatTraversal.getStartStep().getId()); start.initialiseLoops(start.getStepId(), this.loopName); if (doEmit(start, true)) { final Traverser.Admin<S> emitSplit = start.split(); emitSplit.resetLoops(); emitSplit.setStepId(this.getNextStep().getId()); return IteratorUtils.of(start, emitSplit); } else { return IteratorUtils.of(start); } } }
@Override public void storeState(final Configuration configuration) { VertexProgram.super.storeState(configuration); this.sourceVertexFilterTraversal.storeState(configuration, SOURCE_VERTEX_FILTER); this.targetVertexFilterTraversal.storeState(configuration, TARGET_VERTEX_FILTER); this.edgeTraversal.storeState(configuration, EDGE_TRAVERSAL); this.distanceTraversal.storeState(configuration, DISTANCE_TRAVERSAL); configuration.setProperty(INCLUDE_EDGES, this.includeEdges); if (this.maxDistance != null) configuration.setProperty(MAX_DISTANCE, maxDistance); if (this.traversal != null) { this.traversal.storeState(configuration, ProgramVertexProgramStep.ROOT_TRAVERSAL); configuration.setProperty(ProgramVertexProgramStep.STEP_ID, this.programStep.getId()); } TraversalVertexProgram.storeHaltedTraversers(configuration, this.haltedTraversers); }
@Override protected Iterator<Traverser.Admin<S>> computerAlgorithm() throws NoSuchElementException { final RepeatStep<S> repeatStep = (RepeatStep<S>) this.getTraversal().getParent(); final Traverser.Admin<S> start = this.starts.next(); start.incrLoops(); if (repeatStep.doUntil(start, false)) { start.resetLoops(); start.setStepId(repeatStep.getNextStep().getId()); start.addLabels(repeatStep.labels); return IteratorUtils.of(start); } else { start.setStepId(repeatStep.getId()); if (repeatStep.doEmit(start, false)) { final Traverser.Admin<S> emitSplit = start.split(); emitSplit.resetLoops(); emitSplit.setStepId(repeatStep.getNextStep().getId()); emitSplit.addLabels(repeatStep.labels); return IteratorUtils.of(start, emitSplit); } return IteratorUtils.of(start); } } }
@Override public void processAllStarts() { if (this.starts.hasNext()) { final BulkSet<Object> bulkSet = new BulkSet<>(); while (this.starts.hasNext()) { final Traverser.Admin<S> traverser = this.starts.next(); bulkSet.add(TraversalUtil.applyNullable(traverser, this.aggregateTraversal), traverser.bulk()); traverser.setStepId(this.getNextStep().getId()); // when barrier is reloaded, the traversers should be at the next step this.barrier.add(traverser); } this.getTraversal().getSideEffects().add(this.sideEffectKey, bulkSet); } }