Flink源码系列——获取JobGraph的过程

接《Flink源码系列——获取StreamGraph的过程》获取到StreamGraph后，继续分析，如果通过获取到的StreamGraph来转化为JobGraph。转化逻辑在StreamingJobGraphGenerator这个类中，入口是createJobGraph(StreamGraph)方法。先是初始化了一个StreamingJobGraphGenerator的实例，StreamingJobGraphGenerator构造函数是私有的，只能通过这里进行实例构造，构造函数中就是做了一些基本的初始化的工作，并初始化了一个JobGraph实例，然后调用内部的私有方法createJobGraph()。

public static JobGraph createJobGraph(StreamGraph streamGraph) {
   return new StreamingJobGraphGenerator(streamGraph).createJobGraph();
}

createJobGraph()方法就是jobGraph进行配置的主要逻辑，如下：

private JobGraph createJobGraph() {
   /** 设置调度模式，采用的EAGER模式，既所有节点都是立即启动的 */
   jobGraph.setScheduleMode(ScheduleMode.EAGER);
   /** 第一步 */
   /** 
    * 1.1
    * 广度优先遍历StreamGraph，并且为每个SteamNode生成散列值, 这里的散列值产生算法，可以保证如果提交的拓扑没有改变，则每次生成的散列值都是一样的。
    * 一个StreamNode的ID对应一个散列值。
    */
   Mapbyte[]> hashes = defaultStreamGraphHasher.traverseStreamGraphAndGenerateHashes(streamGraph);
   /**
    * 1.2
    * 为向后兼容性生成遗留版本散列
    * 目前好像就是根据用户对每个StreamNode设置的hash值,生产StreamNode对应的hash值
    */
   Listbyte[]>> legacyHashes = new ArrayList<>(legacyStreamGraphHashers.size());
   for (StreamGraphHasher hasher : legacyStreamGraphHashers) {
      legacyHashes.add(hasher.traverseStreamGraphAndGenerateHashes(streamGraph));
   }
   /** 相连接的操作符的散列值对 */
   Mapbyte[], byte[]>>> chainedOperatorHashes = new HashMap<>();
   /** 
    * 第二步
    * 最重要的函数，生成JobVertex，JobEdge等，并尽可能地将多个节点chain在一起 
    */
   setChaining(hashes, legacyHashes, chainedOperatorHashes);
   /**
    * 第三步
    * 将每个JobVertex的入边集合也序列化到该JobVertex的StreamConfig中
    * (出边集合已经在setChaining的时候写入了)
    */
   setPhysicalEdges();
   /**
    * 第四步
    * 据group name，为每个 JobVertex 指定所属的 SlotSharingGroup,
    * 以及针对 Iteration的头尾设置  CoLocationGroup
    */
   setSlotSharing();
   /** 
    * 第五步
    * 配置checkpoint 
    */
   configureCheckpointing();
   /** 将缓存文件的配置添加到configuration中 */
   for (Tuple2 e : streamGraph.getEnvironment().getCachedFiles()) {
      DistributedCache.writeFileInfoToConfig(e.f0, e.f1, jobGraph.getJobConfiguration());
   }
   /** 设置ExecutionConfig */
   try {
      jobGraph.setExecutionConfig(streamGraph.getExecutionConfig());
   }
   catch (IOException e) {
      throw new IllegalConfigurationException("Could not serialize the ExecutionConfig." +
            "This indicates that non-serializable types (like custom serializers) were registered");
   }
   /** 返回转化好的jobGraph */
   return jobGraph;
}

jobGraph的整个产生过程就如上所示，接下来针对其中的主要步骤进行简单分析。

---

第一步、为每个节点产生散列值

这里就是根据StreamGraph的配置，给StreamGraph中的每个StreamNode产生一个长度为16的字节数组的散列值，这个散列值是用来后续生成JobGraph中对应的JobVertex的ID。在Flink中，任务存在从checkpoint中进行状态恢复的场景，而在恢复时，是以JobVertexID为依据的，所有就需要任务在重启的过程中，对于相同的任务，其各JobVertexID能够保持不变，而StreamGraph中各个StreamNode的ID，就是其包含的StreamTransformation的ID，而StreamTransformation的ID是在对数据流中的数据进行转换的过程中，通过一个静态的累加器生成的，比如有多个数据源时，每个数据源添加的顺序不一致，则有可能导致相同数据处理逻辑的任务，就会对应于不同的ID，所以为了得到确定的ID，在进行JobVertexID的产生时，需要以一种确定的方式来确定其值，要么是通过用户为每个ID直接指定对应的一个散列值，要么参考StreamGraph中的一些特征，为每个JobVertex产生一个确定的ID。

defaultStreamGraphHasher是在StreamingJobGraphGenerator构造函数中初始化的，其对应StreamGraphHasherV2的实例，这个类就是负责给StreamGraph中的每个StreamNode产生一个确定的散列值，其具体的实现这里不做介绍，感兴趣的可以看下它的源码，逻辑还是很清晰的，这里主要介绍下其在产生一个StreamNode时，主要考虑的因素。(最好是结合着具体的代码看这段逻辑，会更清晰)

如果用户对节点指定了一个散列值，则基于用户指定的值，产生一个长度为16的字节数组；
如果用户没有指定，则根据当前节点所处的位置，产生一个散列值，考虑的因素有：

a、在当前StreamNode之前已经处理过的节点的个数，作为当前StreamNode的id，添加到hasher中；
b、遍历当前StreamNode输出的每个StreamEdge，并判断当前StreamNode与这个StreamEdge的目标StreamNode是否可以进行链接，如果可以，则将目标StreamNode的id也放入hasher中，且这个目标StreamNode的id与当前StreamNode的id取相同的值；
c、将上述步骤后产生的字节数据，与当前StreamNode的所有输入StreamNode对应的字节数据，进行相应的位操作，最终得到的字节数据，就是当前StreamNode对应的长度为16的字节数组。

另外在StreamingJobGraphGenerator的构造函数中，legacyStreamGraphHashers这个数组中，默认添加一个StreamGraphHasher的子类实现StreamGraphUserHashHasher。所以在上述的代码中，1.2步骤就是执行StreamGraphUserHashHasher这个类的逻辑。这个类的逻辑很简单，就是判断用户是否设置了散列值，如果设置了，就为对应的StreamNode产生一个散列值数组。

这里涉及到两个用户设置的散列值，StreamingJobGraphGenerator中使用的是StreamTransformation的uid属性，StreamGraphUserHashHasher使用的是StreamTransformation的userProvidedNodeHash属性。这两个属性解析如下：

uid —— 这个字段是用户设置的，用来在任务重启时，保障JobVertexID一致，一般是从之前的任务日志中，找出对应的值而设置的；
userProvidedNodeHash —— 这个字段也是用户设置的，设置的用户自己产生的散列值。

---

第二步、设置执行链

执行链的设置，就是从数据源StreamNode，依次遍历，如下：

private void setChaining(Mapbyte[]> hashes, Listbyte[]>> legacyHashes, Mapbyte[], byte[]>>> chainedOperatorHashes) {
   /** 从源StreamNode进行遍历 */
   for (Integer sourceNodeId : streamGraph.getSourceIDs()) {
      createChain(sourceNodeId, sourceNodeId, hashes, legacyHashes, 0, chainedOperatorHashes);
   }
}

三个入参：

hashes和legacyHashes就是上面产生的每个StreamNode的ID对应的散列字节数组。
chainedOperatorHashes是一个map:

其key是顺序链接在一起的StreamNode的起始那个StreamNode的ID，比如source->flatMap这个两个对应的StreamNode，在这个例子中，key的值就是source对应的id，为1；
value是一个列表，包含了这个链上的所有操作符的散列值；

这个列表中的每个元素是一个二元组，这个列表的值就是{[source的主hash，source的备用hash_1]，[source的主hash，source的备用hash_2]，[flatMap的主hash，flatMap的备用hash_1]，…}，对于这里的例子，列表中只有二个元素，为{[source的主hash，null]，[flatMap的主hash，null]}

在进行分析createChain方法之前，先看一下两个StreamNode是否可以链接到一起执行的判断逻辑，如下：

public static boolean isChainable(StreamEdge edge, StreamGraph streamGraph) {
   /** 获取StreamEdge的源和目标StreamNode */
   StreamNode upStreamVertex = edge.getSourceVertex();
   StreamNode downStreamVertex = edge.getTargetVertex();
   /** 获取源和目标StreamNode中的StreamOperator */
   StreamOperator headOperator = upStreamVertex.getOperator();
   StreamOperator outOperator = downStreamVertex.getOperator();
   /**
    * 1、下游节点只有一个输入
    * 2、下游节点的操作符不为null
    * 3、上游节点的操作符不为null
    * 4、上下游节点在一个槽位共享组内
    * 5、下游节点的连接策略是 ALWAYS
    * 6、上游节点的连接策略是 HEAD 或者 ALWAYS
    * 7、edge 的分区函数是 ForwardPartitioner 的实例
    * 8、上下游节点的并行度相等
    * 9、可以进行节点连接操作
    */
   return downStreamVertex.getInEdges().size() == 1
         && outOperator != null
         && headOperator != null
         && upStreamVertex.isSameSlotSharingGroup(downStreamVertex)
         && outOperator.getChainingStrategy() == ChainingStrategy.ALWAYS
         && (headOperator.getChainingStrategy() == ChainingStrategy.HEAD ||
            headOperator.getChainingStrategy() == ChainingStrategy.ALWAYS)
         && (edge.getPartitioner() instanceof ForwardPartitioner)
         && upStreamVertex.getParallelism() == downStreamVertex.getParallelism()
         && streamGraph.isChainingEnabled();
}

只有上述的9个条件都同时满足时，才能说明两个StreamEdge的源和目标StreamNode是可以链接在一起执行的。

createChain方法的处理逻辑就是依次遍历StreamGraph中的所有数据源的ID，对于这里案例来说，只有一个数据源，其ID为1。createChain的入参解释如下：

startNodeId —— StreamNode的链的起始node的id，由于从source开始，这里就是1；
currentNodeId —— 当前处理的node的id，这里也是1；
hashes和legacyHashes —— 这两个就是前面产生的每个StreamNode对应的散列值；
chainIndex —— 表示当前节点在链中的位置，每个链都是从0开始编号，当前才处理source，所以为0；
chainedOperatorHashes —— 用来保存每个链中所有操作符的散列值，含义前面已经解释过，初始值是一个空map。

以上面给定的入参值，来继续分析构建过程。

private List createChain(
      Integer startNodeId,
      Integer currentNodeId,
      Mapbyte[]> hashes,
      Listbyte[]>> legacyHashes,
      int chainIndex,
      Mapbyte[], byte[]>>> chainedOperatorHashes) {

   /** builtVertices这个集合是用来存放已经构建好的StreamNode的id */
   if (!builtVertices.contains(startNodeId)) {

      /**
       * 过渡用的出边集合, 用来生成最终的 JobEdge,
       * 注意：存在某些StreamNode会连接到一起，比如source->map->flatMap，
       * 如果这几个StreamNode连接到一起，则transitiveOutEdges是不包括 chain 内部的边，既不包含source->map的StreamEdge的 */
      List transitiveOutEdges = new ArrayList();

      /** 可以与当前节点链接的StreamEdge */
      List chainableOutputs = new ArrayList();
      /** 不可以与当前节点链接的StreamEdge */
      List nonChainableOutputs = new ArrayList();

      /** 将当前节点的出边分成 chainable 和 nonChainable 两类 */
      for (StreamEdge outEdge : streamGraph.getStreamNode(currentNodeId).getOutEdges()) {
         if (isChainable(outEdge, streamGraph)) {
            chainableOutputs.add(outEdge);
         } else {
            nonChainableOutputs.add(outEdge);
         }
      }

      /** 对于每个可连接的StreamEdge，递归调用其目标StreamNode，startNodeId保持不变，但是chainIndex会加1 */
      for (StreamEdge chainable : chainableOutputs) {
         transitiveOutEdges.addAll(
               createChain(startNodeId, chainable.getTargetId(), hashes, legacyHashes, chainIndex + 1, chainedOperatorHashes));
      }

      /**
       * 对于每个不可连接的StreamEdge，则将对于的StreamEdge就是当前链的一个输出StreamEdge，所以会添加到transitiveOutEdges这个集合中
       * 然后递归调用其目标节点，注意，startNodeID变成了nonChainable这个StreamEdge的输出节点id，chainIndex也赋值为0，说明重新开始一条链的建立
       */
      for (StreamEdge nonChainable : nonChainableOutputs) {
         transitiveOutEdges.add(nonChainable);
         createChain(nonChainable.getTargetId(), nonChainable.getTargetId(), hashes, legacyHashes, 0, chainedOperatorHashes);
      }

      /** 获取链起始节点对应的操作符散列值列表，如果没有，则是空列表 */
      Listbyte[], byte[]>> operatorHashes = chainedOperatorHashes.computeIfAbsent(startNodeId, k -> new ArrayList<>());

      /** 当前 StreamNode 对应的主散列值 */
      byte[] primaryHashBytes = hashes.get(currentNodeId);

      /** 遍历每个备用散列值，并与主散列值，组成一个二元组，添加到列表中 */
      for (Mapbyte[]> legacyHash : legacyHashes) {
         operatorHashes.add(new Tuple2<>(primaryHashBytes, legacyHash.get(currentNodeId)));
      }

      /** 生成当前节点的显示名，如："Keyed Aggregation -> Sink: Unnamed" */
      chainedNames.put(currentNodeId, createChainedName(currentNodeId, chainableOutputs));
      chainedMinResources.put(currentNodeId, createChainedMinResources(currentNodeId, chainableOutputs));
      chainedPreferredResources.put(currentNodeId, createChainedPreferredResources(currentNodeId, chainableOutputs));

      /**
       * 1、如果当前节点是起始节点, 则直接创建 JobVertex 并返回 StreamConfig,
       * 2、否则先创建一个空的 StreamConfig
       *
       * createJobVertex 函数就是根据 StreamNode 创建对应的 JobVertex, 并返回了空的 StreamConfig
       */
      StreamConfig config = currentNodeId.equals(startNodeId)
            ? createJobVertex(startNodeId, hashes, legacyHashes, chainedOperatorHashes)
            : new StreamConfig(new Configuration());

      /**
       * {@link StreamConfig}就是对{@link Configuration}的封装，
       * 所以通过{@code StreamConfig}设置的配置，最终都是保存在{@code Configuration}中的。
       */

      /**
       * 设置 JobVertex 的 StreamConfig, 基本上是序列化 StreamNode 中的配置到 StreamConfig 中.
       * 其中包括 序列化器, StreamOperator, Checkpoint 等相关配置
       * 经过这一步操作后，StreamNode的相关配置会通过对{@code StreamNode}的设置接口，将配置保存在{@code Configuration}中，
       * 而{@code Configuration}是是{@link JobVertex}的属性，也就是说经过这步操作，相关配置已经被保存到了{@code JobVertex}中。
       */
      setVertexConfig(currentNodeId, config, chainableOutputs, nonChainableOutputs);

      if (currentNodeId.equals(startNodeId)) {

         /** 如果是chain的起始节点。（不是chain的中间节点，会被标记成 chain start）*/
         config.setChainStart();
         config.setChainIndex(0);
         config.setOperatorName(streamGraph.getStreamNode(currentNodeId).getOperatorName());
         /** 我们也会把物理出边写入配置, 部署时会用到 */
         config.setOutEdgesInOrder(transitiveOutEdges);
         config.setOutEdges(streamGraph.getStreamNode(currentNodeId).getOutEdges());

         /** 将当前节点(headOfChain)与所有出边相连 */
         for (StreamEdge edge : transitiveOutEdges) {
            /** 通过StreamEdge构建出JobEdge，创建 IntermediateDataSet ，用来将JobVertex和JobEdge相连 */
            connect(startNodeId, edge);
         }

         /** 将chain中所有子节点的StreamConfig写入到 headOfChain 节点的 CHAINED_TASK_CONFIG 配置中 */
         config.setTransitiveChainedTaskConfigs(chainedConfigs.get(startNodeId));

      } else {
         /** 如果是 chain 中的子节点 */

         Map chainedConfs = chainedConfigs.get(startNodeId);

         if (chainedConfs == null) {
            chainedConfigs.put(startNodeId, new HashMap());
         }
         config.setChainIndex(chainIndex);
         StreamNode node = streamGraph.getStreamNode(currentNodeId);
         config.setOperatorName(node.getOperatorName());
         /** 将当前节点的StreamConfig添加到该chain的config集合中 */
         chainedConfigs.get(startNodeId).put(currentNodeId, config);
      }

      config.setOperatorID(new OperatorID(primaryHashBytes));

      /** 如果节点的输出StreamEdge已经为空，则说明是链的结尾 */
      if (chainableOutputs.isEmpty()) {
         config.setChainEnd();
      }
      return transitiveOutEdges;

   } else {
      /** startNodeId 如果已经构建过,则直接返回 */
      return new ArrayList<>();
   }
}

创建过程详解代码中的注解。

如果startNodeId已经被构建完成，则直接返回一个空集合；
如果还没有构建，则开始新的构建；

显示递归构建链的下游节点，在下游节点都递归构建完成后，再构建当前节点；
如果当前节点是一个链的起始节点，则新建一个JobVertex，并将相关配置都通过StreamConfig提供的接口，配置到JobVertex的configuration属性中；
如果是链的中间节点，则将相关配置添加到其对应的StreamConfig对象中。

在对head节点设置时，会在head节点与每个输出StreamEdge的目标节点之间建立连接，代码如下：

private void connect(Integer headOfChain, StreamEdge edge) {
   /** 将当前edge记录物理边界顺序集合中 */
   physicalEdgesInOrder.add(edge);

   /** 获取StreamEdge的输出节点的id */
   Integer downStreamvertexID = edge.getTargetId();

   /** 通过节点id获取到要进行连接的上下游JobVertex节点 */
   JobVertex headVertex = jobVertices.get(headOfChain);
   JobVertex downStreamVertex = jobVertices.get(downStreamvertexID);

   /** 获取下游JobVertex的配置属性 */
   StreamConfig downStreamConfig = new StreamConfig(downStreamVertex.getConfiguration());

   /** 下游JobVertex的输入源加1 */
   downStreamConfig.setNumberOfInputs(downStreamConfig.getNumberOfInputs() + 1);

   /** 获取StreamEdge中的分区器 */
   StreamPartitioner partitioner = edge.getPartitioner();
   JobEdge jobEdge;
   /** 根据分区器的不同子类，创建相应的JobEdge */
   if (partitioner instanceof ForwardPartitioner) {
      /** 向前传递分区 */
      jobEdge = downStreamVertex.connectNewDataSetAsInput(
         headVertex,
         DistributionPattern.POINTWISE,
         ResultPartitionType.PIPELINED_BOUNDED);
   } else if (partitioner instanceof RescalePartitioner){
      /** 可扩展分区 */
      jobEdge = downStreamVertex.connectNewDataSetAsInput(
         headVertex,
         DistributionPattern.POINTWISE,
         ResultPartitionType.PIPELINED_BOUNDED);
   } else {
      /** 其他分区 */
      jobEdge = downStreamVertex.connectNewDataSetAsInput(
            headVertex,
            DistributionPattern.ALL_TO_ALL,
            ResultPartitionType.PIPELINED_BOUNDED);
   }
   /** 设置数据传输策略,以便在web上显示 */
   jobEdge.setShipStrategyName(partitioner.toString());

   /** 打印调试日志 */
   if (LOG.isDebugEnabled()) {
      LOG.debug("CONNECTED: {} - {} -> {}", partitioner.getClass().getSimpleName(),
            headOfChain, downStreamvertexID);
   }
}

其中JobEdge是通过下游JobVertex的connectNewDataSetAsInput方法来创建的，在创建JobEdge的前，会先用上游JobVertex创建一个IntermediateDataSet实例，用来作为上游JobVertex的结果输出，然后作为JobEdge的输入，构建JobEdge实例，具体实现如下：

public JobEdge connectNewDataSetAsInput(
      JobVertex input,
      DistributionPattern distPattern,
      ResultPartitionType partitionType) {
   /** 创建输入JobVertex的输出数据集合 */
   IntermediateDataSet dataSet = input.createAndAddResultDataSet(partitionType);
   /** 构建JobEdge实例 */
   JobEdge edge = new JobEdge(dataSet, this, distPattern);
   /** 将JobEdge实例，作为当前JobVertex的输入 */
   this.inputs.add(edge);
   /** 设置中间结果集合dataSet的消费者是上面创建的JobEdge */
   dataSet.addConsumer(edge);
   return edge;
}

通过上述的构建过程，就可以实现上下游JobVertex的连接，上游JobVertex ——> 中间结果集合IntermediateDataSet ——> JobEdge ——> 下游JobVertex。其中IntermediateDataSet和JobEdge是用来建立上下游JobVertex之间连接的配置；一个IntermediateDataSet有一个消息producer，可以有多个消息消费者JobEdge；一个JobEdge则有一个数据源IntermediateDataSet，一个目标JobVertex；一个JobVertex可以产生多个输出IntermediateDataSet，也可以接受来自多个JobEdge的数据。

通过上述的构建过程，对于这里的例子，source -> flatMap 组成一个链，构建成一个JobVertex，reduce -> sink 组成一个链，构建成一个JobVertex。

---

JobGraph是在StreamGraph的基础之上，对StreamNode进行了关联合并的操作，比如对于source -> flatMap -> reduce -> sink 这样一个数据处理链，当source和flatMap满足链接的条件时，可以可以将两个操作符的操作放到一个线程并行执行，这样可以减少网络中的数据传输，由于在source和flatMap之间的传输的数据也不用序列化和反序列化，所以也提高了程序的执行效率。