Examples of org.apache.flink.compiler.plan.Channel

org.apache.flink.compiler.plan.Channel

        
        /* Test on the union output connections
         * It must be under the GroupOperator and the strategy should be forward
         */
        if (visitable instanceof SingleInputPlanNode && visitable.getPactContract() instanceof GroupReduceOperatorBase){
          final Channel inConn = ((SingleInputPlanNode) visitable).getInput();
          Assert.assertTrue("Union should just forward the Partitioning",
              inConn.getShipStrategy() == ShipStrategyType.FORWARD ); 
          Assert.assertTrue("Union Node should be under Group operator",
              inConn.getSource() instanceof NAryUnionPlanNode );
        }
        
        /* Test on the union input connections
         * Must be NUM_INPUTS input connections, all FlatMapOperators with a own partitioning strategy(propably hash)
         */
        if (visitable instanceof NAryUnionPlanNode) {
          int numberInputs = 0;
          for (Iterator<Channel> inputs = visitable.getInputs().iterator(); inputs.hasNext(); numberInputs++) {
            final Channel inConn = inputs.next();
            PlanNode inNode = inConn.getSource();
            Assert.assertTrue("Input of Union should be FlatMapOperators",
                inNode.getPactContract() instanceof FlatMapOperatorBase);
            Assert.assertTrue("Shipment strategy under union should partition the data",
                inConn.getShipStrategy() == ShipStrategyType.PARTITION_HASH); 
          }
          
          Assert.assertTrue("NAryUnion should have " + NUM_INPUTS + " inputs", numberInputs == NUM_INPUTS);
          return false;
        }

View Full Code Here

        if (visitable instanceof WorksetIterationPlanNode) {
          PlanNode deltaNode = ((WorksetIterationPlanNode) visitable).getSolutionSetDeltaPlanNode();


          //get the CoGroup
          DualInputPlanNode dpn = (DualInputPlanNode) deltaNode.getInputs().iterator().next().getSource();
          Channel in1 = dpn.getInput1();
          Channel in2 = dpn.getInput2();


          Assert.assertTrue(in1.getLocalProperties().getOrdering() == null);
          Assert.assertTrue(in2.getLocalProperties().getOrdering() != null);
          Assert.assertTrue(in2.getLocalProperties().getOrdering().getInvolvedIndexes().contains(0));
          Assert.assertTrue(in1.getShipStrategy() == ShipStrategyType.FORWARD);
          Assert.assertTrue(in2.getShipStrategy() == ShipStrategyType.PARTITION_HASH);
          return false;
        }
        return true;
      }

View Full Code Here

    try {
      SourcePlanNode target = new SourcePlanNode(getSourceNode(), "Source");
      
      SourcePlanNode otherTarget = new SourcePlanNode(getSourceNode(), "Source");
      
      Channel toMap1 = new Channel(target);
      toMap1.setShipStrategy(ShipStrategyType.FORWARD);
      toMap1.setLocalStrategy(LocalStrategy.NONE);
      SingleInputPlanNode map1 = new SingleInputPlanNode(getMapNode(), "Mapper 1", toMap1, DriverStrategy.MAP);
      
      Channel toMap2 = new Channel(map1);
      toMap2.setShipStrategy(ShipStrategyType.FORWARD);
      toMap2.setLocalStrategy(LocalStrategy.NONE);
      SingleInputPlanNode map2 = new SingleInputPlanNode(getMapNode(), "Mapper 2", toMap2, DriverStrategy.MAP);
      
      {
        GlobalProperties gp = new GlobalProperties();
        LocalProperties lp = new LocalProperties();

View Full Code Here

  @Test
  public void testSingleInputOperators() {
    try {
      SourcePlanNode target = new SourcePlanNode(getSourceNode(), "Source");
      
      Channel toMap1 = new Channel(target);
      toMap1.setShipStrategy(ShipStrategyType.FORWARD);
      toMap1.setLocalStrategy(LocalStrategy.NONE);
      SingleInputPlanNode map1 = new SingleInputPlanNode(getMapNode(), "Mapper 1", toMap1, DriverStrategy.MAP);
      
      Channel toMap2 = new Channel(map1);
      toMap2.setShipStrategy(ShipStrategyType.FORWARD);
      toMap2.setLocalStrategy(LocalStrategy.NONE);
      SingleInputPlanNode map2 = new SingleInputPlanNode(getMapNode(), "Mapper 2", toMap2, DriverStrategy.MAP);
      
      // no feedback properties and none are ever required and present
      {
        GlobalProperties gp = new GlobalProperties();
        LocalProperties lp = new LocalProperties();
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertTrue(report != null && report != NO_PARTIAL_SOLUTION && report != NOT_MET);
      }
      
      // some global feedback properties and none are ever required and present
      {
        GlobalProperties gp = new GlobalProperties();
        gp.setHashPartitioned(new FieldList(2, 5));
        LocalProperties lp = new LocalProperties();
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertTrue(report != null && report != NO_PARTIAL_SOLUTION && report != NOT_MET);
      }
      
      // some local feedback properties and none are ever required and present
      {
        GlobalProperties gp = new GlobalProperties();
        LocalProperties lp = LocalProperties.forGrouping(new FieldList(1, 2));
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertTrue(report != null && report != NO_PARTIAL_SOLUTION && report != NOT_MET);
      }
      
      // some global and local feedback properties and none are ever required and present
      {
        GlobalProperties gp = new GlobalProperties();
        gp.setHashPartitioned(new FieldList(2, 5));
        LocalProperties lp = LocalProperties.forGrouping(new FieldList(1, 2));
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertTrue(report != null && report != NO_PARTIAL_SOLUTION && report != NOT_MET);
      }
      
      // --------------------------- requirements on channel 1 -----------------------
      
      // some required global properties, which are matched exactly
      {
        GlobalProperties gp = new GlobalProperties();
        gp.setHashPartitioned(new FieldList(2, 5));
        LocalProperties lp = new LocalProperties();
        
        RequestedGlobalProperties reqGp = new RequestedGlobalProperties();
        reqGp.setHashPartitioned(new FieldList(2, 5));
        
        toMap1.setRequiredGlobalProps(reqGp);
        toMap1.setRequiredLocalProps(null);
        
        toMap2.setRequiredGlobalProps(null);
        toMap2.setRequiredLocalProps(null);
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertTrue(report != null && report != NO_PARTIAL_SOLUTION && report != NOT_MET);
      }
      
      // some required local properties, which are matched exactly
      {
        GlobalProperties gp = new GlobalProperties();
        LocalProperties lp = LocalProperties.forGrouping(new FieldList(1, 2));
        
        RequestedLocalProperties reqLp = new RequestedLocalProperties();
        reqLp.setGroupedFields(new FieldList(1, 2));
        
        toMap1.setRequiredGlobalProps(null);
        toMap1.setRequiredLocalProps(reqLp);
        
        toMap2.setRequiredGlobalProps(null);
        toMap2.setRequiredLocalProps(null);
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertTrue(report != null && report != NO_PARTIAL_SOLUTION && report != NOT_MET);
      }
      
      // some required global and local properties, which are matched exactly
      {
        GlobalProperties gp = new GlobalProperties();
        gp.setHashPartitioned(new FieldList(2, 5));
        LocalProperties lp = LocalProperties.forGrouping(new FieldList(1, 2));
        
        RequestedGlobalProperties reqGp = new RequestedGlobalProperties();
        reqGp.setHashPartitioned(new FieldList(2, 5));
        
        RequestedLocalProperties reqLp = new RequestedLocalProperties();
        reqLp.setGroupedFields(new FieldList(1, 2));
        
        toMap1.setRequiredGlobalProps(reqGp);
        toMap1.setRequiredLocalProps(reqLp);
        
        toMap2.setRequiredGlobalProps(null);
        toMap2.setRequiredLocalProps(null);
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertTrue(report != null && report != NO_PARTIAL_SOLUTION && report != NOT_MET);
      }
      
      // some required global and local properties, which are over-fulfilled
      {
        GlobalProperties gp = new GlobalProperties();
        gp.setHashPartitioned(new FieldList(2));
        LocalProperties lp = LocalProperties.forGrouping(new FieldList(1, 2));
        
        RequestedGlobalProperties reqGp = new RequestedGlobalProperties();
        reqGp.setHashPartitioned(new FieldList(2, 5));
        
        RequestedLocalProperties reqLp = new RequestedLocalProperties();
        reqLp.setGroupedFields(new FieldList(1));
        
        toMap1.setRequiredGlobalProps(reqGp);
        toMap1.setRequiredLocalProps(reqLp);
        
        toMap2.setRequiredGlobalProps(null);
        toMap2.setRequiredLocalProps(null);
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertTrue(report != null && report != NO_PARTIAL_SOLUTION && report != NOT_MET);
      }
      
      // some required global properties that are not met
      {
        GlobalProperties gp = new GlobalProperties();
        gp.setHashPartitioned(new FieldList(2, 1));
        LocalProperties lp = new LocalProperties();
        
        RequestedGlobalProperties reqGp = new RequestedGlobalProperties();
        reqGp.setHashPartitioned(new FieldList(2, 5));
        
        toMap1.setRequiredGlobalProps(reqGp);
        toMap1.setRequiredLocalProps(null);
        
        toMap2.setRequiredGlobalProps(null);
        toMap2.setRequiredLocalProps(null);
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertEquals(NOT_MET, report);
      }
      
      // some required local properties that are not met
      {
        GlobalProperties gp = new GlobalProperties();
        LocalProperties lp = LocalProperties.forGrouping(new FieldList(1));
        
        RequestedLocalProperties reqLp = new RequestedLocalProperties();
        reqLp.setGroupedFields(new FieldList(2, 1));
        
        toMap1.setRequiredGlobalProps(null);
        toMap1.setRequiredLocalProps(reqLp);
        
        toMap2.setRequiredGlobalProps(null);
        toMap2.setRequiredLocalProps(null);
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertEquals(NOT_MET, report);
      }
      
      // some required global and local properties where the global properties are not met
      {
        GlobalProperties gp = new GlobalProperties();
        gp.setHashPartitioned(new FieldList(2, 1));
        LocalProperties lp = LocalProperties.forGrouping(new FieldList(1));
        
        RequestedGlobalProperties reqGp = new RequestedGlobalProperties();
        reqGp.setAnyPartitioning(new FieldList(2, 5));
        
        RequestedLocalProperties reqLp = new RequestedLocalProperties();
        reqLp.setGroupedFields(new FieldList(1));
        
        toMap1.setRequiredGlobalProps(reqGp);
        toMap1.setRequiredLocalProps(reqLp);
        
        toMap2.setRequiredGlobalProps(null);
        toMap2.setRequiredLocalProps(null);
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertEquals(NOT_MET, report);
      }
      
      // some required global and local properties where the local properties are not met
      {
        GlobalProperties gp = new GlobalProperties();
        gp.setHashPartitioned(new FieldList(1));
        LocalProperties lp = LocalProperties.forGrouping(new FieldList(1));
        
        RequestedGlobalProperties reqGp = new RequestedGlobalProperties();
        reqGp.setAnyPartitioning(new FieldList(1));
        
        RequestedLocalProperties reqLp = new RequestedLocalProperties();
        reqLp.setGroupedFields(new FieldList(2));
        
        toMap1.setRequiredGlobalProps(reqGp);
        toMap1.setRequiredLocalProps(reqLp);
        
        toMap2.setRequiredGlobalProps(null);
        toMap2.setRequiredLocalProps(null);
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertEquals(NOT_MET, report);
      }
      
      // --------------------------- requirements on channel 2 -----------------------
      
      // some required global properties, which are matched exactly
      {
        GlobalProperties gp = new GlobalProperties();
        gp.setHashPartitioned(new FieldList(2, 5));
        LocalProperties lp = new LocalProperties();
        
        RequestedGlobalProperties reqGp = new RequestedGlobalProperties();
        reqGp.setHashPartitioned(new FieldList(2, 5));
        
        toMap1.setRequiredGlobalProps(null);
        toMap1.setRequiredLocalProps(null);
        
        toMap2.setRequiredGlobalProps(reqGp);
        toMap2.setRequiredLocalProps(null);
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertTrue(report != null && report != NO_PARTIAL_SOLUTION && report != NOT_MET);
      }
      
      // some required local properties, which are matched exactly
      {
        GlobalProperties gp = new GlobalProperties();
        LocalProperties lp = LocalProperties.forGrouping(new FieldList(1, 2));
        
        RequestedLocalProperties reqLp = new RequestedLocalProperties();
        reqLp.setGroupedFields(new FieldList(1, 2));
        
        toMap1.setRequiredGlobalProps(null);
        toMap1.setRequiredLocalProps(null);
        
        toMap2.setRequiredGlobalProps(null);
        toMap2.setRequiredLocalProps(reqLp);
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertTrue(report != null && report != NO_PARTIAL_SOLUTION && report != NOT_MET);
      }
      
      // some required global and local properties, which are matched exactly
      {
        GlobalProperties gp = new GlobalProperties();
        gp.setHashPartitioned(new FieldList(2, 5));
        LocalProperties lp = LocalProperties.forGrouping(new FieldList(1, 2));
        
        RequestedGlobalProperties reqGp = new RequestedGlobalProperties();
        reqGp.setHashPartitioned(new FieldList(2, 5));
        
        RequestedLocalProperties reqLp = new RequestedLocalProperties();
        reqLp.setGroupedFields(new FieldList(1, 2));
        
        toMap1.setRequiredGlobalProps(null);
        toMap1.setRequiredLocalProps(null);
        
        toMap2.setRequiredGlobalProps(reqGp);
        toMap2.setRequiredLocalProps(reqLp);
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertTrue(report != null && report != NO_PARTIAL_SOLUTION && report != NOT_MET);
      }
      
      // some required global and local properties, which are over-fulfilled
      {
        GlobalProperties gp = new GlobalProperties();
        gp.setHashPartitioned(new FieldList(2));
        LocalProperties lp = LocalProperties.forGrouping(new FieldList(1, 2));
        
        RequestedGlobalProperties reqGp = new RequestedGlobalProperties();
        reqGp.setHashPartitioned(new FieldList(2, 5));
        
        RequestedLocalProperties reqLp = new RequestedLocalProperties();
        reqLp.setGroupedFields(new FieldList(1));
        
        toMap1.setRequiredGlobalProps(null);
        toMap1.setRequiredLocalProps(null);
        
        toMap2.setRequiredGlobalProps(reqGp);
        toMap2.setRequiredLocalProps(reqLp);
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertTrue(report != null && report != NO_PARTIAL_SOLUTION && report != NOT_MET);
      }
      
      // some required global properties that are not met
      {
        GlobalProperties gp = new GlobalProperties();
        gp.setHashPartitioned(new FieldList(2, 1));
        LocalProperties lp = new LocalProperties();
        
        RequestedGlobalProperties reqGp = new RequestedGlobalProperties();
        reqGp.setHashPartitioned(new FieldList(2, 5));
        
        toMap1.setRequiredGlobalProps(null);
        toMap1.setRequiredLocalProps(null);
        
        toMap2.setRequiredGlobalProps(reqGp);
        toMap2.setRequiredLocalProps(null);
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertEquals(NOT_MET, report);
      }
      
      // some required local properties that are not met
      {
        GlobalProperties gp = new GlobalProperties();
        LocalProperties lp = LocalProperties.forGrouping(new FieldList(1));
        
        RequestedLocalProperties reqLp = new RequestedLocalProperties();
        reqLp.setGroupedFields(new FieldList(2, 1));
        
        toMap1.setRequiredGlobalProps(null);
        toMap1.setRequiredLocalProps(null);
        
        toMap2.setRequiredGlobalProps(null);
        toMap2.setRequiredLocalProps(reqLp);
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertEquals(NOT_MET, report);
      }
      
      // some required global and local properties where the global properties are not met
      {
        GlobalProperties gp = new GlobalProperties();
        gp.setHashPartitioned(new FieldList(2, 1));
        LocalProperties lp = LocalProperties.forGrouping(new FieldList(1));
        
        RequestedGlobalProperties reqGp = new RequestedGlobalProperties();
        reqGp.setAnyPartitioning(new FieldList(2, 5));
        
        RequestedLocalProperties reqLp = new RequestedLocalProperties();
        reqLp.setGroupedFields(new FieldList(1));
        
        toMap1.setRequiredGlobalProps(null);
        toMap1.setRequiredLocalProps(null);
        
        toMap2.setRequiredGlobalProps(reqGp);
        toMap2.setRequiredLocalProps(reqLp);
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertEquals(NOT_MET, report);
      }
      
      // some required global and local properties where the local properties are not met
      {
        GlobalProperties gp = new GlobalProperties();
        gp.setHashPartitioned(new FieldList(1));
        LocalProperties lp = LocalProperties.forGrouping(new FieldList(1));
        
        RequestedGlobalProperties reqGp = new RequestedGlobalProperties();
        reqGp.setAnyPartitioning(new FieldList(1));
        
        RequestedLocalProperties reqLp = new RequestedLocalProperties();
        reqLp.setGroupedFields(new FieldList(2));
        
        toMap1.setRequiredGlobalProps(null);
        toMap1.setRequiredLocalProps(null);
        
        toMap2.setRequiredGlobalProps(reqGp);
        toMap2.setRequiredLocalProps(reqLp);
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertEquals(NOT_MET, report);
      }
      
      // ---------------------- requirements mixed on 1 and 2 -----------------------
      
      // some required global properties at step one and some more at step 2
      {
        GlobalProperties gp = new GlobalProperties();
        gp.setHashPartitioned(new FieldList(1, 2));
        LocalProperties lp = LocalProperties.EMPTY;
        
        RequestedGlobalProperties reqGp1 = new RequestedGlobalProperties();
        reqGp1.setAnyPartitioning(new FieldList(1, 2));
        
        RequestedGlobalProperties reqGp2 = new RequestedGlobalProperties();
        reqGp2.setHashPartitioned(new FieldList(1, 2));
        
        toMap1.setRequiredGlobalProps(reqGp1);
        toMap1.setRequiredLocalProps(null);
        
        toMap2.setRequiredGlobalProps(reqGp2);
        toMap2.setRequiredLocalProps(null);
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertTrue(report != null && report != NO_PARTIAL_SOLUTION && report != NOT_MET);
      }
      
      // some required local properties at step one and some more at step 2
      {
        GlobalProperties gp = new GlobalProperties();
        LocalProperties lp = LocalProperties.forOrdering(new Ordering(3, null, Order.ASCENDING).appendOrdering(1, null, Order.DESCENDING));
        
        RequestedLocalProperties reqLp1 = new RequestedLocalProperties();
        reqLp1.setGroupedFields(new FieldList(3, 1));
        
        RequestedLocalProperties reqLp2 = new RequestedLocalProperties();
        reqLp2.setOrdering(new Ordering(3, null, Order.ANY).appendOrdering(1, null, Order.ANY));
        
        toMap1.setRequiredGlobalProps(null);
        toMap1.setRequiredLocalProps(reqLp1);
        
        toMap2.setRequiredGlobalProps(null);
        toMap2.setRequiredLocalProps(reqLp2);
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertTrue(report != null && report != NO_PARTIAL_SOLUTION && report != NOT_MET);
      }
      
      // some required global properties at step one and some local ones at step 2
      {
        GlobalProperties gp = new GlobalProperties();
        gp.setHashPartitioned(new FieldList(1, 2));
        LocalProperties lp = LocalProperties.forGrouping(new FieldList(2, 1));
        
        RequestedGlobalProperties reqGp = new RequestedGlobalProperties();
        reqGp.setAnyPartitioning(new FieldList(1, 2));
        
        RequestedLocalProperties reqLp = new RequestedLocalProperties();
        reqLp.setGroupedFields(new FieldList(2));
        
        toMap1.setRequiredGlobalProps(reqGp);
        toMap1.setRequiredLocalProps(null);
        
        toMap2.setRequiredGlobalProps(null);
        toMap2.setRequiredLocalProps(reqLp);
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertTrue(report != null && report != NO_PARTIAL_SOLUTION && report != NOT_MET);
      }
      
      // some required local properties at step one and some global ones at step 2
      {
        GlobalProperties gp = new GlobalProperties();
        gp.setHashPartitioned(new FieldList(1, 2));
        LocalProperties lp = LocalProperties.forGrouping(new FieldList(2, 1));
        
        RequestedGlobalProperties reqGp = new RequestedGlobalProperties();
        reqGp.setAnyPartitioning(new FieldList(1, 2));
        
        RequestedLocalProperties reqLp = new RequestedLocalProperties();
        reqLp.setGroupedFields(new FieldList(2));
        
        toMap1.setRequiredGlobalProps(null);
        toMap1.setRequiredLocalProps(reqLp);
        
        toMap2.setRequiredGlobalProps(reqGp);
        toMap2.setRequiredLocalProps(null);
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertTrue(report != null && report != NO_PARTIAL_SOLUTION && report != NOT_MET);
      }
      
      // some fulfilled global properties at step one and some non-fulfilled local ones at step 2
      {
        GlobalProperties gp = new GlobalProperties();
        gp.setHashPartitioned(new FieldList(1, 2));
        LocalProperties lp = LocalProperties.forGrouping(new FieldList(2, 1));
        
        RequestedGlobalProperties reqGp = new RequestedGlobalProperties();
        reqGp.setAnyPartitioning(new FieldList(1, 2));
        
        RequestedLocalProperties reqLp = new RequestedLocalProperties();
        reqLp.setGroupedFields(new FieldList(2, 3));
        
        toMap1.setRequiredGlobalProps(reqGp);
        toMap1.setRequiredLocalProps(null);
        
        toMap2.setRequiredGlobalProps(null);
        toMap2.setRequiredLocalProps(reqLp);
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertEquals(NOT_MET, report);
      }
      
      // some fulfilled local properties at step one and some non-fulfilled global ones at step 2
      {
        GlobalProperties gp = new GlobalProperties();
        gp.setHashPartitioned(new FieldList(1, 2));
        LocalProperties lp = LocalProperties.forGrouping(new FieldList(2, 1));
        
        RequestedGlobalProperties reqGp = new RequestedGlobalProperties();
        reqGp.setAnyPartitioning(new FieldList(2, 3));
        
        RequestedLocalProperties reqLp = new RequestedLocalProperties();
        reqLp.setGroupedFields(new FieldList(2, 1));
        
        toMap1.setRequiredGlobalProps(null);
        toMap1.setRequiredLocalProps(reqLp);
        
        toMap2.setRequiredGlobalProps(reqGp);
        toMap2.setRequiredLocalProps(null);
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertEquals(NOT_MET, report);
      }
      
      // some non-fulfilled global properties at step one and some fulfilled local ones at step 2
      {
        GlobalProperties gp = new GlobalProperties();
        gp.setHashPartitioned(new FieldList(1, 2));
        LocalProperties lp = LocalProperties.forGrouping(new FieldList(2, 1));
        
        RequestedGlobalProperties reqGp = new RequestedGlobalProperties();
        reqGp.setAnyPartitioning(new FieldList(2, 3));
        
        RequestedLocalProperties reqLp = new RequestedLocalProperties();
        reqLp.setGroupedFields(new FieldList(2, 1));
        
        toMap1.setRequiredGlobalProps(reqGp);
        toMap1.setRequiredLocalProps(null);
        
        toMap2.setRequiredGlobalProps(null);
        toMap2.setRequiredLocalProps(reqLp);
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertEquals(NOT_MET, report);
      }
      
      // some non-fulfilled local properties at step one and some fulfilled global ones at step 2
      {
        GlobalProperties gp = new GlobalProperties();
        gp.setHashPartitioned(new FieldList(1, 2));
        LocalProperties lp = LocalProperties.forGrouping(new FieldList(2, 1));
        
        RequestedGlobalProperties reqGp = new RequestedGlobalProperties();
        reqGp.setAnyPartitioning(new FieldList(1, 2));
        
        RequestedLocalProperties reqLp = new RequestedLocalProperties();
        reqLp.setGroupedFields(new FieldList(2, 1, 3));
        
        toMap1.setRequiredGlobalProps(null);
        toMap1.setRequiredLocalProps(reqLp);
        
        toMap2.setRequiredGlobalProps(reqGp);
        toMap2.setRequiredLocalProps(null);
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertEquals(NOT_MET, report);
      }
    }

View Full Code Here

  @Test
  public void testSingleInputOperatorsWithReCreation() {
    try {
      SourcePlanNode target = new SourcePlanNode(getSourceNode(), "Source");
      
      Channel toMap1 = new Channel(target);
      SingleInputPlanNode map1 = new SingleInputPlanNode(getMapNode(), "Mapper 1", toMap1, DriverStrategy.MAP);
      
      Channel toMap2 = new Channel(map1);
      SingleInputPlanNode map2 = new SingleInputPlanNode(getMapNode(), "Mapper 2", toMap2, DriverStrategy.MAP);
      
      // set ship strategy in first channel, so later non matching global properties do not matter
      {
        GlobalProperties gp = new GlobalProperties();
        gp.setHashPartitioned(new FieldList(1, 2));
        LocalProperties lp = LocalProperties.EMPTY;
        
        RequestedGlobalProperties reqGp = new RequestedGlobalProperties();
        reqGp.setAnyPartitioning(new FieldSet(2, 5));
        
        toMap1.setShipStrategy(ShipStrategyType.PARTITION_HASH, new FieldList(2, 5));
        toMap1.setLocalStrategy(LocalStrategy.NONE);
        
        toMap2.setShipStrategy(ShipStrategyType.FORWARD);
        toMap2.setLocalStrategy(LocalStrategy.NONE);
        
        
        toMap1.setRequiredGlobalProps(null);
        toMap1.setRequiredLocalProps(null);
        
        toMap2.setRequiredGlobalProps(reqGp);
        toMap2.setRequiredLocalProps(null);
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertEquals(MET, report);
      }
      
      // set ship strategy in second channel, so previous non matching global properties void the match
      {
        GlobalProperties gp = new GlobalProperties();
        gp.setHashPartitioned(new FieldList(1, 2));
        LocalProperties lp = LocalProperties.EMPTY;
        
        RequestedGlobalProperties reqGp = new RequestedGlobalProperties();
        reqGp.setAnyPartitioning(new FieldSet(2, 5));
        
        toMap1.setShipStrategy(ShipStrategyType.FORWARD);
        toMap1.setLocalStrategy(LocalStrategy.NONE);
        
        toMap2.setShipStrategy(ShipStrategyType.PARTITION_HASH, new FieldList(2, 5));
        toMap2.setLocalStrategy(LocalStrategy.NONE);
        
        
        toMap1.setRequiredGlobalProps(reqGp);
        toMap1.setRequiredLocalProps(null);
        
        toMap2.setRequiredGlobalProps(null);
        toMap2.setRequiredLocalProps(null);
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertEquals(NOT_MET, report);
      }
      
      // set local strategy in first channel, so later non matching local properties do not matter
      {
        GlobalProperties gp = new GlobalProperties();
        gp.setHashPartitioned(new FieldList(1, 2));
        LocalProperties lp = LocalProperties.forOrdering(new Ordering(3, null, Order.ASCENDING).appendOrdering(1, null, Order.DESCENDING));
        
        RequestedLocalProperties reqLp = new RequestedLocalProperties();
        reqLp.setGroupedFields(new FieldList(4, 1));
        
        toMap1.setShipStrategy(ShipStrategyType.FORWARD);
        toMap1.setLocalStrategy(LocalStrategy.SORT, new FieldList(5, 7), new boolean[] {false, false});
        
        toMap2.setShipStrategy(ShipStrategyType.FORWARD);
        toMap2.setLocalStrategy(LocalStrategy.NONE);
        
        toMap1.setRequiredGlobalProps(null);
        toMap1.setRequiredLocalProps(null);
        
        toMap2.setRequiredGlobalProps(null);
        toMap2.setRequiredLocalProps(reqLp);
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertTrue(report != null && report != NO_PARTIAL_SOLUTION && report != NOT_MET);
      }
      
      // set local strategy in second channel, so previous non matching local properties void the match
      {
        GlobalProperties gp = new GlobalProperties();
        gp.setHashPartitioned(new FieldList(1, 2));
        LocalProperties lp = LocalProperties.forOrdering(new Ordering(3, null, Order.ASCENDING).appendOrdering(1, null, Order.DESCENDING));
        
        RequestedLocalProperties reqLp = new RequestedLocalProperties();
        reqLp.setGroupedFields(new FieldList(4, 1));
        
        toMap1.setShipStrategy(ShipStrategyType.FORWARD);
        toMap1.setLocalStrategy(LocalStrategy.NONE);
        
        toMap2.setShipStrategy(ShipStrategyType.FORWARD);
        toMap2.setLocalStrategy(LocalStrategy.SORT, new FieldList(5, 7), new boolean[] {false, false});
        
        
        toMap1.setRequiredGlobalProps(null);
        toMap1.setRequiredLocalProps(reqLp);
        
        toMap2.setRequiredGlobalProps(null);
        toMap2.setRequiredLocalProps(null);
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertEquals(NOT_MET, report);
      }
      
      // create the properties on the same node as the requirement
      {
        GlobalProperties gp = new GlobalProperties();
        gp.setHashPartitioned(new FieldList(1, 2));
        LocalProperties lp = LocalProperties.forOrdering(new Ordering(3, null, Order.ASCENDING).appendOrdering(1, null, Order.DESCENDING));
        
        RequestedGlobalProperties reqGp = new RequestedGlobalProperties();
        reqGp.setAnyPartitioning(new FieldSet(5, 7));
        
        RequestedLocalProperties reqLp = new RequestedLocalProperties();
        reqLp.setGroupedFields(new FieldList(5, 7));
        
        toMap1.setShipStrategy(ShipStrategyType.PARTITION_HASH, new FieldList(5, 7));
        toMap1.setLocalStrategy(LocalStrategy.SORT, new FieldList(5, 7), new boolean[] {false, false});
        
        toMap2.setShipStrategy(ShipStrategyType.FORWARD);
        toMap2.setLocalStrategy(LocalStrategy.NONE);
        
        toMap1.setRequiredGlobalProps(reqGp);
        toMap1.setRequiredLocalProps(reqLp);
        
        toMap2.setRequiredGlobalProps(null);
        toMap2.setRequiredLocalProps(null);
        
        FeedbackPropertiesMeetRequirementsReport report = map2.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertEquals(MET, report);
      }
    }

View Full Code Here

  @Test
  public void testSingleInputOperatorsChainOfThree() {
    try {
      SourcePlanNode target = new SourcePlanNode(getSourceNode(), "Source");
      
      Channel toMap1 = new Channel(target);
      SingleInputPlanNode map1 = new SingleInputPlanNode(getMapNode(), "Mapper 1", toMap1, DriverStrategy.MAP);
      
      Channel toMap2 = new Channel(map1);
      SingleInputPlanNode map2 = new SingleInputPlanNode(getMapNode(), "Mapper 2", toMap2, DriverStrategy.MAP);
      
      Channel toMap3 = new Channel(map2);
      SingleInputPlanNode map3 = new SingleInputPlanNode(getMapNode(), "Mapper 3", toMap3, DriverStrategy.MAP);
      
      // set local strategy in first channel, so later non matching local properties do not matter
      {
        GlobalProperties gp = new GlobalProperties();
        LocalProperties lp = LocalProperties.forOrdering(new Ordering(3, null, Order.ASCENDING).appendOrdering(1, null, Order.DESCENDING));
        
        RequestedLocalProperties reqLp = new RequestedLocalProperties();
        reqLp.setGroupedFields(new FieldList(4, 1));
        
        toMap1.setShipStrategy(ShipStrategyType.FORWARD);
        toMap1.setLocalStrategy(LocalStrategy.SORT, new FieldList(5, 7), new boolean[] {false, false});
        
        toMap2.setShipStrategy(ShipStrategyType.FORWARD);
        toMap2.setLocalStrategy(LocalStrategy.NONE);
        
        toMap3.setShipStrategy(ShipStrategyType.FORWARD);
        toMap3.setLocalStrategy(LocalStrategy.NONE);
        
        toMap1.setRequiredGlobalProps(null);
        toMap1.setRequiredLocalProps(null);
        
        toMap2.setRequiredGlobalProps(null);
        toMap2.setRequiredLocalProps(null);
        
        toMap3.setRequiredGlobalProps(null);
        toMap3.setRequiredLocalProps(reqLp);
        
        FeedbackPropertiesMeetRequirementsReport report = map3.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertTrue(report != null && report != NO_PARTIAL_SOLUTION && report != NOT_MET);
      }
      
      // set global strategy in first channel, so later non matching global properties do not matter
      {
        GlobalProperties gp = new GlobalProperties();
        gp.setHashPartitioned(new FieldList(5, 3));
        LocalProperties lp = LocalProperties.EMPTY;
        
        RequestedGlobalProperties reqGp = new RequestedGlobalProperties();
        reqGp.setAnyPartitioning(new FieldSet(2, 3));
        
        toMap1.setShipStrategy(ShipStrategyType.PARTITION_HASH, new FieldList(1, 2));
        toMap1.setLocalStrategy(LocalStrategy.NONE);
        
        toMap2.setShipStrategy(ShipStrategyType.FORWARD);
        toMap2.setLocalStrategy(LocalStrategy.NONE);
        
        toMap3.setShipStrategy(ShipStrategyType.FORWARD);
        toMap3.setLocalStrategy(LocalStrategy.NONE);
        
        toMap1.setRequiredGlobalProps(null);
        toMap1.setRequiredLocalProps(null);
        
        toMap2.setRequiredGlobalProps(null);
        toMap2.setRequiredLocalProps(null);
        
        toMap3.setRequiredGlobalProps(reqGp);
        toMap3.setRequiredLocalProps(null);
        
        FeedbackPropertiesMeetRequirementsReport report = map3.checkPartialSolutionPropertiesMet(target, gp, lp);
        assertTrue(report != null && report != NO_PARTIAL_SOLUTION && report != NOT_MET);
      }
    }

View Full Code Here

          continue;
        }
        
        for (RequestedGlobalProperties igps: this.channelProps) {
          // create a candidate channel for the first input. mark it cached, if the connection says so
          Channel c1 = new Channel(child1, this.input1.getMaterializationMode());
          if (this.input1.getShipStrategy() == null) {
            // free to choose the ship strategy
            igps.parameterizeChannel(c1, dopChange1);
            
            // if the DOP changed, make sure that we cancel out properties, unless the
            // ship strategy preserves/establishes them even under changing DOPs
            if (dopChange1 && !c1.getShipStrategy().isNetworkStrategy()) {
              c1.getGlobalProperties().reset();
            }
          } else {
            // ship strategy fixed by compiler hint
            if (this.keys1 != null) {
              c1.setShipStrategy(this.input1.getShipStrategy(), this.keys1.toFieldList());
            } else {
              c1.setShipStrategy(this.input1.getShipStrategy());
            }
            
            if (dopChange1) {
              c1.adjustGlobalPropertiesForFullParallelismChange();
            }
          }
          
          // create a candidate channel for the first input. mark it cached, if the connection says so
          Channel c2 = new Channel(child2, this.input2.getMaterializationMode());
          if (this.input2.getShipStrategy() == null) {
            // free to choose the ship strategy
            igps.parameterizeChannel(c2, dopChange2);
            
            // if the DOP changed, make sure that we cancel out properties, unless the
            // ship strategy preserves/establishes them even under changing DOPs
            if (dopChange2 && !c2.getShipStrategy().isNetworkStrategy()) {
              c2.getGlobalProperties().reset();
            }
          } else {
            // ship strategy fixed by compiler hint
            if (this.keys2 != null) {
              c2.setShipStrategy(this.input2.getShipStrategy(), this.keys2.toFieldList());
            } else {
              c2.setShipStrategy(this.input2.getShipStrategy());
            }
            
            if (dopChange2) {
              c2.adjustGlobalPropertiesForFullParallelismChange();
            }
          }
          
          // get the global properties and clear unique fields (not preserved anyways during the union)
          GlobalProperties p1 = c1.getGlobalProperties();
          GlobalProperties p2 = c2.getGlobalProperties();
          p1.clearUniqueFieldCombinations();
          p2.clearUniqueFieldCombinations();
          
          // adjust the partitionings, if they exist but are not equal. this may happen when both channels have a
          // partitioning that fulfills the requirements, but both are incompatible. For example may a property requirement
          // be ANY_PARTITIONING on fields (0) and one channel is range partitioned on that field, the other is hash
          // partitioned on that field. 
          if (!igps.isTrivial() && !(p1.equals(p2))) {
            if (c1.getShipStrategy() == ShipStrategyType.FORWARD && c2.getShipStrategy() != ShipStrategyType.FORWARD) {
              // adjust c2 to c1
              c2 = c2.clone();
              p1.parameterizeChannel(c2,dopChange2);
            } else if (c2.getShipStrategy() == ShipStrategyType.FORWARD && c1.getShipStrategy() != ShipStrategyType.FORWARD) {
              // adjust c1 to c2
              c1 = c1.clone();
              p2.parameterizeChannel(c1,dopChange1);
            } else if (c1.getShipStrategy() == ShipStrategyType.FORWARD && c2.getShipStrategy() == ShipStrategyType.FORWARD) {
              boolean adjustC1 = c1.getEstimatedOutputSize() <= 0 || c2.getEstimatedOutputSize() <= 0 ||
                  c1.getEstimatedOutputSize() <= c2.getEstimatedOutputSize();
              if (adjustC1) {
                c2 = c2.clone();
                p1.parameterizeChannel(c2, dopChange2);
              } else {
                c1 = c1.clone();
                p2.parameterizeChannel(c1, dopChange1);
              }

View Full Code Here

        in.setLocalStrategy(LocalStrategy.COMBININGSORT, in.getLocalStrategyKeys(), in.getLocalStrategySortOrder());
      }
      return new SingleInputPlanNode(node, "Reduce("+node.getPactContract().getName()+")", in, DriverStrategy.SORTED_GROUP_REDUCE, this.keyList);
    } else {
      // non forward case. all local properties are killed anyways, so we can safely plug in a combiner
      Channel toCombiner = new Channel(in.getSource());
      toCombiner.setShipStrategy(ShipStrategyType.FORWARD);
      // create an input node for combine with same DOP as input node
      GroupReduceNode combinerNode = ((GroupReduceNode) node).getCombinerUtilityNode();
      combinerNode.setDegreeOfParallelism(in.getSource().getDegreeOfParallelism());


      SingleInputPlanNode combiner = new SingleInputPlanNode(combinerNode, "Combine("+node.getPactContract()
          .getName()+")", toCombiner, DriverStrategy.SORTED_GROUP_COMBINE);
      combiner.setCosts(new Costs(0, 0));
      combiner.initProperties(toCombiner.getGlobalProperties(), toCombiner.getLocalProperties());
      // set sorting comparator key info
      combiner.setDriverKeyInfo(in.getLocalStrategyKeys(), in.getLocalStrategySortOrder(), 0);
      // set grouping comparator key info
      combiner.setDriverKeyInfo(this.keyList, 1);
      
      Channel toReducer = new Channel(combiner);
      toReducer.setShipStrategy(in.getShipStrategy(), in.getShipStrategyKeys(), in.getShipStrategySortOrder());
      toReducer.setLocalStrategy(LocalStrategy.COMBININGSORT, in.getLocalStrategyKeys(), in.getLocalStrategySortOrder());
      return new SingleInputPlanNode(node, "Reduce ("+node.getPactContract().getName()+")", toReducer, DriverStrategy.SORTED_GROUP_REDUCE, this.keyList);
    }
  }

View Full Code Here

    if (in.getShipStrategy() == ShipStrategyType.FORWARD) {
      // locally connected, directly instantiate
      return new SingleInputPlanNode(node, "Reduce ("+node.getPactContract().getName()+")", in, DriverStrategy.ALL_REDUCE);
    } else {
      // non forward case.plug in a combiner
      Channel toCombiner = new Channel(in.getSource());
      toCombiner.setShipStrategy(ShipStrategyType.FORWARD);
      
      // create an input node for combine with same DOP as input node
      ReduceNode combinerNode = ((ReduceNode) node).getCombinerUtilityNode();
      combinerNode.setDegreeOfParallelism(in.getSource().getDegreeOfParallelism());


      SingleInputPlanNode combiner = new SingleInputPlanNode(combinerNode, "Combine ("+node.getPactContract().getName()+")", toCombiner, DriverStrategy.ALL_REDUCE);
      combiner.setCosts(new Costs(0, 0));
      combiner.initProperties(toCombiner.getGlobalProperties(), toCombiner.getLocalProperties());
      
      Channel toReducer = new Channel(combiner);
      toReducer.setShipStrategy(in.getShipStrategy(), in.getShipStrategyKeys(), in.getShipStrategySortOrder());
      toReducer.setLocalStrategy(in.getLocalStrategy(), in.getLocalStrategyKeys(), in.getLocalStrategySortOrder());
      return new SingleInputPlanNode(node, "Reduce("+node.getPactContract().getName()+")", toReducer, DriverStrategy.ALL_REDUCE);
    }
  }

View Full Code Here

          // Chained Task. Sanity check first...
          final Iterator<Channel> inConns = node.getInputs().iterator();
          if (!inConns.hasNext()) {
            throw new CompilerException("Bug: Found chained task with no input.");
          }
          final Channel inConn = inConns.next();
          
          if (inConns.hasNext()) {
            throw new CompilerException("Bug: Found a chained task with more than one input!");
          }
          if (inConn.getLocalStrategy() != null && inConn.getLocalStrategy() != LocalStrategy.NONE) {
            throw new CompilerException("Bug: Found a chained task with an input local strategy.");
          }
          if (inConn.getShipStrategy() != null && inConn.getShipStrategy() != ShipStrategyType.FORWARD) {
            throw new CompilerException("Bug: Found a chained task with an input ship strategy other than FORWARD.");
          }
  
          AbstractJobVertex container = chainedTask.getContainingVertex();
          
          if (container == null) {
            final PlanNode sourceNode = inConn.getSource();
            container = this.vertices.get(sourceNode);
            if (container == null) {
              // predecessor is itself chained
              container = this.chainedTasks.get(sourceNode).getContainingVertex();
              if (container == null) {
                throw new IllegalStateException("Bug: Chained task predecessor has not been assigned its containing vertex.");
              }
            } else {
              // predecessor is a proper task job vertex and this is the first chained task. add a forward connection entry.
              new TaskConfig(container.getConfiguration()).addOutputShipStrategy(ShipStrategyType.FORWARD);
            }
            chainedTask.setContainingVertex(container);
          }
          
          // add info about the input serializer type
          chainedTask.getTaskConfig().setInputSerializer(inConn.getSerializer(), 0);
          
          // update name of container task
          String containerTaskName = container.getName();
          if(containerTaskName.startsWith("CHAIN ")) {
            container.setName(containerTaskName+" -> "+chainedTask.getTaskName());
          } else {
            container.setName("CHAIN "+containerTaskName+" -> "+chainedTask.getTaskName());
          }
          
          this.chainedTasksInSequence.add(chainedTask);
          return;
        }
        else if (node instanceof BulkPartialSolutionPlanNode ||
            node instanceof WorksetPlanNode)
        {
          // merged iteration head task. the task that the head is merged with will take care of it
          return;
        } else {
          throw new CompilerException("Bug: Unrecognized merged task vertex.");
        }
      }
      
      // -------- Here, we translate non-chained tasks -------------
      
      
      if (this.currentIteration != null) {
        AbstractJobVertex head = this.iterations.get(this.currentIteration).getHeadTask();
        // the head may still be null if we descend into the static parts first
        if (head != null) {
          targetVertex.setStrictlyCoLocatedWith(head);
        }
      }
      
      
      // create the config that will contain all the description of the inputs
      final TaskConfig targetVertexConfig = new TaskConfig(targetVertex.getConfiguration());
            
      // get the inputs. if this node is the head of an iteration, we obtain the inputs from the
      // enclosing iteration node, because the inputs are the initial inputs to the iteration.
      final Iterator<Channel> inConns;
      if (node instanceof BulkPartialSolutionPlanNode) {
        inConns = ((BulkPartialSolutionPlanNode) node).getContainingIterationNode().getInputs().iterator();
        // because the partial solution has its own vertex, is has only one (logical) input.
        // note this in the task configuration
        targetVertexConfig.setIterationHeadPartialSolutionOrWorksetInputIndex(0);
      } else if (node instanceof WorksetPlanNode) {
        WorksetPlanNode wspn = (WorksetPlanNode) node;
        // input that is the initial workset
        inConns = Collections.singleton(wspn.getContainingIterationNode().getInput2()).iterator();
        
        // because we have a stand-alone (non-merged) workset iteration head, the initial workset will
        // be input 0 and the solution set will be input 1
        targetVertexConfig.setIterationHeadPartialSolutionOrWorksetInputIndex(0);
        targetVertexConfig.setIterationHeadSolutionSetInputIndex(1);
      } else {
        inConns = node.getInputs().iterator();
      }
      if (!inConns.hasNext()) {
        throw new CompilerException("Bug: Found a non-source task with no input.");
      }
      
      int inputIndex = 0;
      while (inConns.hasNext()) {
        Channel input = inConns.next();
        inputIndex += translateChannel(input, inputIndex, targetVertex, targetVertexConfig, false);
      }
      // broadcast variables
      int broadcastInputIndex = 0;
      for (NamedChannel broadcastInput: node.getBroadcastInputs()) {

View Full Code Here

0 1 2 3

TOP

Related Classes of org.apache.flink.compiler.plan.Channel

org.apache.flink.compiler.AdditionalOperatorsTest

org.apache.flink.compiler.CoGroupSolutionSetFirstTest

org.apache.flink.compiler.costs.CostEstimator

org.apache.flink.compiler.dag.BinaryUnionNode

org.apache.flink.compiler.dag.BulkIterationNode

org.apache.flink.compiler.dag.DataSinkNode

org.apache.flink.compiler.dag.SingleInputNode

org.apache.flink.compiler.dag.TwoInputNode

org.apache.flink.compiler.dag.WorksetIterationNode

org.apache.flink.compiler.dataproperties.LocalProperties

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.