Flink Graph演变

独影月下酌酒2024-04-22 12:14

1.概述

Flink 集群中运行的 Job，最终归根到底：还是构建一个高效能分布式并行执行的DAG执行图。一个 Flink 流式作业从 Client 提交到 Flink 集群到最后执行，总共经历 4 种状态，总体来说：Flink中的执行图可分成四层：StreamGraph ==> JobGraph ==> ExecutionGraph ==> 物理执行图 。

  • StreamGraph： 根据用户通过Stream API 编写的代码生成最初的图，用来表示程序的拓扑结构。

  • JobGraph： StreamGraph 经过优化之后生成了 JobGraph，提交给 JobManager 的数据结构。主要的优化为：将多个符合条件的节点 chain 在一起作为一个节点，这样可以减少数据在节点之间流动所需的序列化与反序列化传输消耗。

  • ExecutionGraph： JobManager 根据 JobGraph 生成 ExecutionGraph。ExecutionGraph 是 JobGraph 的并行化版本，是调度层最核心的数据结构。

  • 物理执行图： JobManager 根据 ExecutionGraph 对 Job 进行调度后，在各个TaskManager上部署Task后形成的图，并不是一个具体的数据结构。

2.StreamGraph构建和提交源码解析

**StreamGraph：根据用户编写 Stream API 编写的代码生成的最初的图。**Flink 将每一个算子 transform 成一个对流的转换，并且注册到执行环境中，用于生成StreamGraph。它包含的主要抽象概念有：

  • StreamNode： 用来代表 operator 的类，并具有所有相关的属性，如并发度、入边和出边等。
  • StreamEdge： 表示链接两个StreamNode的边。

源码核心入口：

java 复制代码 
StreamExecutionEnvironment.execute(getStreamGraph(jobName));

StreamGraph 先生成一个 StreamGraphGenerator，随后调用 generate() 方法生成一个StreamGraph，StreamExecutionEnvironment.execute() 用于执行一个StreamGraph。

StreamGraph生成过程中，StreamNode的代码入口：

java 复制代码 
// 注释：添加一个 Operator（streamGraph 端会添加一个 StreamNode）
		streamGraph.addOperator(transform.getId(),
				slotSharingGroup,
				transform.getCoLocationGroupKey(),
				transform.getOperatorFactory(),
				transform.getInputType(),
				transform.getOutputType(),
				transform.getName());

StreamGraph生成过程中，StreamEdge的代码入口：

java 复制代码 
for (Integer inputId: inputIds) {
//注释：根据输入的 id，给这个 node 在 graph 中设置相应的 graph
	streamGraph.addEdge(inputId, transform.getId(), 0);
}

3.JobGraph 构建和提交源码解析

JobGraph ：StreamGraph 经过优化之后生成了 JobGraph，提交给 JobManager 的数据结构。

它包含的主要抽象概念有：

  • JobVertex： 经过优化后符合条件的多个 StreamNode 可能会 chain 在一起生成一个 JobVertex，即一个 JobVertex 包含一个或者多个 operator，JobVertex 的输入是 JobEdge，输出是IntermediateDataSet。
  • IntermediateDataSet： 表示 JobVertex 的输出，即经过 operator 处理产生的数据集。producer 是 JobVertex，consumer 是 JobEdge。
  • JobEdge： 表示 job graph 中的一条数据的传输通道。输入 IntermediateDataSet，输出是 JobVertex。即数据是通过 JobEdge 由 IntermediateDataSet 传递给目标 JobVertex。

源码核心代码入口：

java 复制代码 
final JobGraph jobGraph = PipelineExecutorUtils.getJobGraph(pipeline, configuration);
java 复制代码 
	private JobGraph createJobGraph() {
		preValidate();
		// make sure that all vertices start immediately
		jobGraph.setScheduleMode(streamGraph.getScheduleMode());
		// Generate deterministic hashes for the nodes in order to identify them across
		// submission iff they didn't change.
		Map<Integer, byte[]> hashes = defaultStreamGraphHasher.traverseStreamGraphAndGenerateHashes(streamGraph);
		// Generate legacy version hashes for backwards compatibility
		List<Map<Integer, byte[]>> legacyHashes = new ArrayList<>(legacyStreamGraphHashers.size());
		for (StreamGraphHasher hasher : legacyStreamGraphHashers) {
		legacyHashes.add(hasher.traverseStreamGraphAndGenerateHashes(streamGraph));
		}

		setChaining(hashes, legacyHashes);
		setPhysicalEdges();
		setSlotSharingAndCoLocation();
		setManagedMemoryFraction(
			Collections.unmodifiableMap(jobVertices),
			Collections.unmodifiableMap(vertexConfigs),
			Collections.unmodifiableMap(chainedConfigs),
			id -> streamGraph.getStreamNode(id).getMinResources(),
			id -> streamGraph.getStreamNode(id).getManagedMemoryWeight());
		configureCheckpointing();
	jobGraph.setSavepointRestoreSettings(streamGraph.getSavepointRestoreSettings());
		JobGraphUtils.addUserArtifactEntries(streamGraph.getUserArtifacts(), jobGraph);
		// set the ExecutionConfig last when it has been finalized
		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");
		}
		return jobGraph;
	}

在 StreamGraph 构建 JobGraph 的过程中，最重要的事情就是是否能构建 OperatorChain？

  • 1.上下游的入度为1(即为下游节点没有来自其他节点的输入)

    downStreamVertex.getInEdges().size() == 1

  • 2.上下游节点在同一个 slot group 中

    upStreamVertex.isSameSlotSharingGroup(downStreamVertex)

  • 3.前后算子不为空

    ！(downStreamOperator == null || upStreamOperator == null)

  • 4.上游节点的 chain 策略为 ALWAYS 或者 HEAD(只能与下游连接，不能与上游连接，source默认为HEAD)

    upStreamOperator.getChainingStrategy() ！= ChainingStrategy.NEVER

  • 5.下游节点的 chain 策略为 ALWAYS(可以与上游连接，map、flatmap、filter等默认是ALWAYS)

    downStreamOperator.getChainingStrategy() == ChainingStrategy.ALWAYS

  • 6.两个节点之间物理分区的逻辑是 ForwardPatitioner(数据从上游直接下游)

    edge.getPartitioner() instanceof ForwardPartitioner

  • 7.两个算子之间的shuffle方式不等于批处理模式

    edge.getShuffleMode() != ShuffleMode.BATCH

  • 8.上下游的并行度一致

    upStreamVertex.getParallelism() == downStreamVertex.getParallelism()

  • 9.用户没有禁用 chain

    streamGraph.isChainingEnabled()

4.ExecutionGraph 构建和提交源码解析

ExecutionGraph：JobManager(JobMaster) 根据 JobGraph 生成 ExecutionGraph。ExecutionGraph 是 JobGraph 的并行化版本，是调度底层最核心的数据结构。

它包含的抽象概念：

  • ExecutionJobVertex: 与 JobGraph 中的 JobVertex 一一对应。每一个 ExecutionJobVertex 都有和并发度一样的 ExecutionVertex。

  • ExecutionVertex: 表示 ExecutionJobVertex 的其中一个并发子任务，输入是 Executiondge，输出是 IntermediateResultPartition。

  • IntermediateResult: 和 JobGraph 中的 IntermediateDataSet 一一对应。一个

    IntermediateResult包含多个IntermediateResultPartition，其个数等于该operator的并发度。

  • IntermediateResultPartition: 表示ExecutionVertex的一个输出分区，输入是

    ExecutionVertex，输出是若干个ExecutionEdge。

  • ExecutionEdge: 表示ExecutionVertex的输入，source是IntermediateResultPartition，

    target是ExecutionVertex。source和target都只能是一个。

源码核心代码入口：

java 复制代码 
ExecutionGraph executioinGraph = SchedulerBase.createAndRestoreExecutionGraph()

在 SchedulerBase 这个类的内部，有两个成员变量：一个是 JobGraph，一个是 ExecutioinGraph 在创建 SchedulerBase 的子类：DefaultScheduler 的实例对象的时候，会在 SchedulerBase 的构造 方法中去生成 ExecutionGraph。

SchedulerBase 类的源码如下：

java 复制代码 
public SchedulerBase(final Logger log, final JobGraph jobGraph, final BackPressureStatsTracker backPressureStatsTracker,
		final Executor ioExecutor, final Configuration jobMasterConfiguration, final SlotProvider slotProvider,
		final ScheduledExecutorService futureExecutor, final ClassLoader userCodeLoader, final CheckpointRecoveryFactory checkpointRecoveryFactory,
		final Time rpcTimeout, final RestartStrategyFactory restartStrategyFactory, final BlobWriter blobWriter,
		final JobManagerJobMetricGroup jobManagerJobMetricGroup, final Time slotRequestTimeout, final ShuffleMaster<?> shuffleMaster,
		final JobMasterPartitionTracker partitionTracker, final ExecutionVertexVersioner executionVertexVersioner,
		final boolean legacyScheduling) throws Exception {
		this.log = checkNotNull(log);
    	// jobGraph
		this.jobGraph = checkNotNull(jobGraph);
		this.backPressureStatsTracker = checkNotNull(backPressureStatsTracker);
		this.ioExecutor = checkNotNull(ioExecutor);
		this.jobMasterConfiguration = checkNotNull(jobMasterConfiguration);
		this.slotProvider = checkNotNull(slotProvider);
		this.futureExecutor = checkNotNull(futureExecutor);
		this.userCodeLoader = checkNotNull(userCodeLoader);
		this.checkpointRecoveryFactory = checkNotNull(checkpointRecoveryFactory);
		this.rpcTimeout = checkNotNull(rpcTimeout);
		final RestartStrategies.RestartStrategyConfiguration restartStrategyConfiguration = jobGraph.getSerializedExecutionConfig()
			.deserializeValue(userCodeLoader).getRestartStrategy();
		this.restartStrategy = RestartStrategyResolving
			.resolve(restartStrategyConfiguration, restartStrategyFactory, jobGraph.isCheckpointingEnabled());
		if(legacyScheduling) {
			log.info("Using restart strategy {} for {} ({}).", this.restartStrategy, jobGraph.getName(), jobGraph.getJobID());
		}
		this.blobWriter = checkNotNull(blobWriter);
		this.jobManagerJobMetricGroup = checkNotNull(jobManagerJobMetricGroup);
		this.slotRequestTimeout = checkNotNull(slotRequestTimeout);
		this.executionVertexVersioner = checkNotNull(executionVertexVersioner);
		this.legacyScheduling = legacyScheduling;
         // executionGraph
		this.executionGraph = createAndRestoreExecutionGraph(jobManagerJobMetricGroup, checkNotNull(shuffleMaster), checkNotNull(partitionTracker));
		this.schedulingTopology = executionGraph.getSchedulingTopology();
		this.inputsLocationsRetriever = new ExecutionGraphToInputsLocationsRetrieverAdapter(executionGraph);
		this.coordinatorMap = createCoordinatorMap();
	}

ExecutionGraph构建源码

java 复制代码 
/**
 *this.executionGraph = createAndRestoreExecutionGraph(xx);
 * --> ExecutionGraph newExecutionGraph = createExecutionGraph(xxx)
 * --> ExecutionGraphBuilder.buildGraph(xx)
 */
public static ExecutionGraph buildGraph(xxxx){
    //1.创建 ExecutionGraph 对象
    executionGraph = (prior != null) ? prior : new ExecutionGraph(...);
    //2.生成 JobGraph 的 JSON 表达形式
    executionGraph.setJsonPlan(JsonPlanGenerator.generatePlan(jobGraph));
    //3.从 JobGraph 构建 ExecutionGraph
    executionGraph.attachJobGraph(sortedTopology);
    //4.返回 ExecutionGraph
    return executionGraph;
}
===============================attachJobGraph========================================
public void attachJobGraph(List<JobVertex> topologiallySorted) throws JobException {
    //1.遍历 JobVertex 执行并行化生成 ExecutioinVertex
    for (JobVertex jobVertex : topologiallySorted) {
			if (jobVertex.isInputVertex() && !jobVertex.isStoppable()) {
				this.isStoppable = false;
			}
			// 每一个 JobVertex 对应到一个 ExecutionJobVertex
			ExecutionJobVertex ejv = new ExecutionJobVertex(
					this,
					jobVertex,
					1,
					maxPriorAttemptsHistoryLength,
					rpcTimeout,
					globalModVersion,
					createTimestamp);
            // 刚方法内部设置并行度
			ejv.connectToPredecessors(this.intermediateResults);
			ExecutionJobVertex previousTask = this.tasks.putIfAbsent(jobVertex.getID(), ejv);
			if (previousTask != null) {
				throw new JobException(String.format("Encountered two job vertices with ID %s : previous=[%s] / new=[%s]",
					jobVertex.getID(), ejv, previousTask));
			}
			// 设置 IntermediateResult 对象
			for (IntermediateResult res : ejv.getProducedDataSets()) {
				IntermediateResult previousDataSet = this.intermediateResults.putIfAbsent(res.getId(), res);
				if (previousDataSet != null) {
					throw new JobException(String.format("Encountered two intermediate data set with ID %s : previous=[%s] / new=[%s]",
						res.getId(), res, previousDataSet));
				}
			}
			this.verticesInCreationOrder.add(ejv);
			this.numVerticesTotal += ejv.getParallelism();
			newExecJobVertices.add(ejv);
		}
    
}
===================================ejv.connectToPredecessors=========================
    	public void connectToPredecessors(Map<IntermediateDataSetID, IntermediateResult> intermediateDataSets) throws JobException {
		List<JobEdge> inputs = jobVertex.getInputs();
		if (LOG.isDebugEnabled()) {
			LOG.debug(String.format("Connecting ExecutionJobVertex %s (%s) to %d predecessors.", jobVertex.getID(), jobVertex.getName(), inputs.size()));
		}

		for (int num = 0; num < inputs.size(); num++) {
			JobEdge edge = inputs.get(num);
			if (LOG.isDebugEnabled()) {
				if (edge.getSource() == null) {
					LOG.debug(String.format("Connecting input %d of vertex %s (%s) to intermediate result referenced via ID %s.",
							num, jobVertex.getID(), jobVertex.getName(), edge.getSourceId()));
				} else {
					LOG.debug(String.format("Connecting input %d of vertex %s (%s) to intermediate result referenced via predecessor %s (%s).",
							num, jobVertex.getID(), jobVertex.getName(), edge.getSource().getProducer().getID(), edge.getSource().getProducer().getName()));
				}
			}

			// fetch the intermediate result via ID. if it does not exist, then it either has not been created, or the order
			// in which this method is called for the job vertices is not a topological order
			IntermediateResult ires = intermediateDataSets.get(edge.getSourceId());
			if (ires == null) {
				throw new JobException("Cannot connect this job graph to the previous graph. No previous intermediate result found for ID "
						+ edge.getSourceId());
			}

			this.inputs.add(ires);
			int consumerIndex = ires.registerConsumer();
			for (int i = 0; i < parallelism; i++) {
				ExecutionVertex ev = taskVertices[i];
				ev.connectSource(num, ires, edge, consumerIndex);
			}
		}
	}

5.物理执行图

物理执行图：JobManager 根据 ExecutionGraph 对 Job 进行调度后，在各个TaskManager 上部署Task 后形成的"图"，并不是一个具体的数据结构。

它包含的主要抽象概念有：

  • 1、Task：Execution被调度后在分配的 TaskManager 中启动对应的 Task。Task 包裹了具有用户执行 逻辑的 operator。

  • 2、ResultPartition：代表由一个Task的生成的数据，和ExecutionGraph中的 IntermediateResultPartition一一对应。

  • 3、ResultSubpartition：是ResultPartition的一个子分区。每个ResultPartition包含多个 ResultSubpartition，其数目要由下游消费 Task 数和 DistributionPattern 来决定。

  • 4、InputGate：代表Task的输入封装，和JobGraph中JobEdge一一对应。每个InputGate消费了一个或 多个的ResultPartition。

  • 5、InputChannel：每个InputGate会包含一个以上的InputChannel，和ExecutionGraph中的 ExecutionEdge一一对应，也和ResultSubpartition一对一地相连，即一个InputChannel接收一个 ResultSubpartition的输出。

6.总结

  • Flink Graph的演变：StreamGraph ==> JobGraph ==> ExecutionGraph ==> 物理执行图。
  • StreamGraph： 根据用户通过Stream API 编写的代码生成最初的图，用来表示程序的拓扑结构。
  • JobGraph(优化)： StreamGraph 经过优化之后生成了 JobGraph，提交给 JobManager 的数据结构。主要的优化为：将多个符合条件的节点 chain 在一起作为一个节点，这样可以减少数据在节点之间流动所需的序列化与反序列化传输消耗。
  • ExecutionGraph(并行化)： JobManager 根据 JobGraph 生成 ExecutionGraph。ExecutionGraph 是 JobGraph 的并行化版本，是调度层最核心的数据结构。
  • 物理执行图： JobManager 根据 ExecutionGraph 对 Job 进行调度后，在各个TaskManager上部署Task后形成的图，并不是一个具体的数据结构。
相关推荐
W Y31 分钟前
【架构-37】Spark和Flink
架构·flink·spark
ycsdn1034 分钟前
Caused by: org.apache.flink.api.common.io.ParseException: Row too short:
大数据·flink
冷眼Σ(-᷅_-᷄๑)2 小时前
WPF缩放动画和平移动画叠加后会发生什么?
wpf·动画
DolphinScheduler社区2 小时前
Apache DolphinScheduler + OceanBase，搭建分布式大数据调度平台的实践
大数据
时差9533 小时前
MapReduce 的 Shuffle 过程
大数据·mapreduce
kakwooi4 小时前
Hadoop---MapReduce(3)
大数据·hadoop·mapreduce
数新网络4 小时前
《深入浅出Apache Spark》系列②：Spark SQL原理精髓全解析
大数据·sql·spark
△曉風殘月〆4 小时前
WPF MVVM入门系列教程（二、依赖属性）
c#·wpf·mvvm
昨天今天明天好多天9 小时前
【数据仓库】
大数据
油头少年_w10 小时前
大数据导论及分布式存储HadoopHDFS入门
大数据·hadoop·hdfs
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10红米手机使用google play