public FixBreakpoint breakBefore(Collection<ExecutionStage> stages) { for (ExecutionStage stage : stages) { if (this.stagesToSuspend.add(stage)) { this.breakBefore(stage.getSuccessors()); } } return this; }
/** * Collects all {@link ExecutionStage}s in this instance. * * @return the {@link ExecutionStage}s */ public Set<ExecutionStage> getStages() { Set<ExecutionStage> seenStages = new HashSet<>(); Queue<ExecutionStage> openStages = new LinkedList<>(this.getStartingStages()); while (!openStages.isEmpty()) { final ExecutionStage stage = openStages.poll(); if (seenStages.add(stage)) { openStages.addAll(stage.getSuccessors()); } } return seenStages; }
public FixBreakpoint breakAfter(ExecutionStage stage) { return this.breakBefore(stage.getSuccessors()); }
private void logStages(ExecutionPlan executionPlan) { if (this.logger.isInfoEnabled()) { StringBuilder sb = new StringBuilder(); Set<ExecutionStage> seenStages = new HashSet<>(); Queue<ExecutionStage> stagedStages = new LinkedList<>(executionPlan.getStartingStages()); ExecutionStage nextStage; while ((nextStage = stagedStages.poll()) != null) { sb.append(nextStage).append(":\n"); nextStage.getPlanAsString(sb, "* "); nextStage.getSuccessors().stream() .filter(seenStages::add) .forEach(stagedStages::add); } this.logger.info("Current execution plan:\n{}", executionPlan.toExtensiveString()); } }
public List<Map> toJsonList() { Counter<ExecutionStage> stageActivationCounter = new Counter<>(); Queue<ExecutionStage> activatedStages = new LinkedList<>(this.startingStages); Set<ExecutionStage> seenStages = new HashSet<>(); ArrayList<Map> allStages = new ArrayList<>(); while (!activatedStages.isEmpty()) { final ExecutionStage stage = activatedStages.poll(); if (!seenStages.add(stage)) continue; Map stageMap = stage.toJsonMap(); // Better way to put sequence number ? stageMap.put("sequence_number", allStages.size()); allStages.add(stageMap); for (ExecutionStage successor : stage.getSuccessors()) { final int count = stageActivationCounter.add(successor, 1); if (count == successor.getPredecessors().size() || successor.isLoopHead()) { activatedStages.add(successor); } } } return allStages; }
/** * Creates a {@link String} representation of this instance. * * @param isStriclyOrdering whether {@link ExecutionStage}s should be listed only after <i>all</i> their predecessors * @return the {@link String} representation */ public String toExtensiveString(boolean isStriclyOrdering) { StringBuilder sb = new StringBuilder(); Counter<ExecutionStage> stageActivationCounter = new Counter<>(); Queue<ExecutionStage> activatedStages = new LinkedList<>(this.startingStages); Set<ExecutionStage> seenStages = new HashSet<>(); while (!activatedStages.isEmpty()) { while (!activatedStages.isEmpty()) { final ExecutionStage stage = activatedStages.poll(); if (!seenStages.add(stage)) continue; sb.append(">>> ").append(stage).append(":\n"); stage.getPlanAsString(sb, "> "); sb.append("\n"); for (ExecutionStage successor : stage.getSuccessors()) { final int count = stageActivationCounter.add(successor, 1); if (!isStriclyOrdering || count == successor.getPredecessors().size() || successor.isLoopHead()) { activatedStages.add(successor); } } } } return sb.toString(); }
&& !executionStage.getSuccessors().contains(successorExecutionStage)) { executionStage.addSuccessor(successorExecutionStage);
/** * Sets up a {@link Breakpoint} for an {@link ExecutionPlan}. * * @param executionPlan for that the {@link Breakpoint} should be set * @param round {@link TimeMeasurement} to be extended for any interesting time measurements */ private void setUpBreakpoint(ExecutionPlan executionPlan, TimeMeasurement round) { // Set up appropriate Breakpoints. final TimeMeasurement breakpointRound = round.start("Configure Breakpoint"); FixBreakpoint immediateBreakpoint = new FixBreakpoint(); final Set<ExecutionStage> completedStages = this.crossPlatformExecutor.getCompletedStages(); if (completedStages.isEmpty()) { executionPlan.getStartingStages().forEach(immediateBreakpoint::breakAfter); } else { completedStages.stream() .flatMap(stage -> stage.getSuccessors().stream()) .filter(stage -> !completedStages.contains(stage)) .forEach(immediateBreakpoint::breakAfter); } this.crossPlatformExecutor.setBreakpoint(new ConjunctiveBreakpoint( immediateBreakpoint, this.cardinalityBreakpoint, new NoIterationBreakpoint() // Avoid re-optimization inside of loops. )); breakpointRound.stop(); }