/** * Try to match the given operator pattern.. * * @param operator the operator that should be matched with the operator pattern */ private void attemptMatchFrom(Operator operator, InputSlot<?> fromInputSlot, OutputSlot<?> fromOutputSlot) { Validate.isTrue(fromInputSlot == null, "Cannot handle downstream traversals."); // Try to make a match starting from the currently visited operator. final SubplanMatch subplanMatch = new SubplanMatch(SubplanPattern.this); this.match(SubplanPattern.this.outputPattern, operator, fromOutputSlot, subplanMatch); }
protected void checkSanity(SubplanMatch subplanMatch, Operator replacementSubplan) { if (replacementSubplan.getNumInputs() != subplanMatch.getInputMatch().getOperator().getNumInputs()) { throw new IllegalStateException("Incorrect number of inputs in the replacement subplan."); } if (replacementSubplan.getNumOutputs() != subplanMatch.getOutputMatch().getOperator().getNumOutputs()) { throw new IllegalStateException("Incorrect number of outputs in the replacement subplan."); } }
protected void copyNames(SubplanMatch subplanMatch, Operator replacementSubplan) { if (subplanMatch.getOperatorMatches().size() == 1) { final OperatorMatch operatorMatch = subplanMatch.getOperatorMatches().values().stream().findAny().get(); final Operator operator = operatorMatch.getOperator(); String operatorName; if ((operatorName = operator.getName()) != null) { this.setNameTo(operatorName, replacementSubplan); } } }
@Override @SuppressWarnings("unchecked") protected Operator translate(SubplanMatch subplanMatch, int epoch) { final GroupByOperator groupBy = (GroupByOperator) subplanMatch.getMatch("groupBy").getOperator(); final ReduceOperator reduce = (ReduceOperator) subplanMatch.getMatch("reduce").getOperator(); return new ReduceByOperator<>( groupBy.getKeyDescriptor(), reduce.getReduceDescriptor(), groupBy.getInputType() ).at(epoch); } }
subplanMatch.addOperatorMatch(operatorMatch); if (subplanMatch.getMaximumEpoch() >= this.minEpoch) { this.matches.add(subplanMatch);
/** * Check if this instances does not violate any of the {@link Operator#getTargetPlatforms()} restrictions. */ private boolean meetsPlatformRestrictions(SubplanMatch match) { // Short-cut: This transformation is not introducing some platform dependency. if (this.getTargetPlatforms().isEmpty()) { return true; } // Short-cut: The matched operators do not require specific platforms. if (!match.getTargetPlatforms().isPresent()) { return true; } // Otherwise check if return match.getTargetPlatforms().get().containsAll(this.getTargetPlatforms()); }
@Override @SuppressWarnings("unchecked") protected Operator translate(SubplanMatch subplanMatch, int epoch) { final ReduceOperator reduce = (ReduceOperator) subplanMatch.getMatch("reduce").getOperator(); return new GlobalReduceOperator<>( reduce.getReduceDescriptor(), reduce.getInputType() ).at(epoch); } }
@Override protected Operator translate(SubplanMatch subplanMatch, int epoch) { final GroupByOperator groupBy = (GroupByOperator) subplanMatch.getMatch("groupBy").getOperator(); return new MaterializedGroupByOperator<>( groupBy.getKeyDescriptor(), groupBy.getInputType(), groupBy.getOutputType() ).at(epoch); } }
if (match.getInputMatch() == match.getOutputMatch()) { this.logger.debug("Replacing {} with {} in epoch {}.", match.getOutputMatch().getOperator(), replacement, epoch); } else { this.logger.debug("Replacing {}..{} with {} in epoch {}.", match.getInputMatch().getOperator(), match.getOutputMatch().getOperator(), replacement, epoch);
@Override protected Operator translate(SubplanMatch subplanMatch, int epoch) { // Extract the single matched Operator. final Map<String, OperatorMatch> operatorMatches = subplanMatch.getOperatorMatches(); Validate.isTrue(operatorMatches.size() == 1); final OperatorMatch operatorMatch = operatorMatches.values().stream().findFirst().get(); final Operator matchedOperator = operatorMatch.getOperator(); // Create a replacement Operator and align the InputSlots. final Operator replacementOperator = this.replacementFactory.apply((MatchedOperator) matchedOperator, epoch); for (int inputIndex = matchedOperator.getNumRegularInputs(); inputIndex < matchedOperator.getNumInputs(); inputIndex++) { final InputSlot<?> broadcastInput = matchedOperator.getInput(inputIndex); Validate.isTrue(broadcastInput.isBroadcast()); replacementOperator.addBroadcastInput(broadcastInput.copyFor(replacementOperator)); } return replacementOperator; } }
@Override protected Operator translate(SubplanMatch subplanMatch, int epoch) { final IESelfJoinOperator<?, ?, ?> originalOperator = (IESelfJoinOperator<?, ?, ?>) subplanMatch.getMatch("ieselfjoin").getOperator(); return new SparkIESelfJoinOperator(originalOperator.getInputType(), originalOperator.getGet0Pivot(), originalOperator.getCond0(), originalOperator.getGet0Ref(), originalOperator.getCond1()).at(epoch); } }
private void introduceAlternative(RheemPlan plan, SubplanMatch match, Operator replacement) { // Wrap the match in an OperatorAlternative. final Operator originalOutputOperator = match.getOutputMatch().getOperator(); boolean wasTopLevel = originalOutputOperator.getParent() == null; OperatorAlternative operatorAlternative = OperatorAlternative.wrap(match.getInputMatch().getOperator(), originalOutputOperator); // Update the plan sinks if necessary. if (wasTopLevel && originalOutputOperator.isSink()) { plan.replaceSink(originalOutputOperator, operatorAlternative); } // Add a new alternative to the operatorAlternative. operatorAlternative.addAlternative(replacement); }
@Override protected Operator translate(SubplanMatch subplanMatch, int epoch) { final IEJoinOperator<?, ?, ?> originalOperator = (IEJoinOperator<?, ?, ?>) subplanMatch.getMatch("iejoin").getOperator(); return new SparkIEJoinOperator(originalOperator.getInputType0(), originalOperator.getInputType1(), originalOperator.getGet0Pivot(), originalOperator.getGet1Pivot(), originalOperator.getCond0(), originalOperator.getGet0Ref(), originalOperator.getGet1Ref(), originalOperator.getCond1()).at(epoch); } }
final Operator originalInputOperator = match.getInputMatch().getOperator(); for (int inputIndex = 0; inputIndex < originalInputOperator.getNumInputs(); inputIndex++) { final InputSlot originalInputSlot = originalInputOperator.getInput(inputIndex); final Operator originalOutputOperator = match.getOutputMatch().getOperator(); for (int outputIndex = 0; outputIndex < originalOutputOperator.getNumOutputs(); outputIndex++) { final OutputSlot originalOutputSlot = originalOutputOperator.getOutput(outputIndex);