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后形成的图，并不是一个具体的数据结构。
相关推荐
Elastic 中国社区官方博客1 小时前
使用 Vertex AI Gemini 模型和 Elasticsearch Playground 快速创建 RAG 应用程序
大数据·人工智能·elasticsearch·搜索引擎·全文检索
CHICX12292 小时前
【Hadoop】改一下core-site.xml和hdfs-site.xml配置就可以访问Web UI
xml·大数据·hadoop
权^3 小时前
MySQL--聚合查询、联合查询、子查询、合并查询（上万字超详解！！！）
大数据·数据库·学习·mysql
bin91537 小时前
【EXCEL数据处理】000010 案列 EXCEL文本型和常规型转换。使用的软件是微软的Excel操作的。处理数据的目的是让数据更直观的显示出来，方便查看。
大数据·数据库·信息可视化·数据挖掘·数据分析·excel·数据可视化
极客先躯10 小时前
Hadoop krb5.conf 配置详解
大数据·hadoop·分布式·kerberos·krb5.conf·认证系统
2301_7869643612 小时前
3、练习常用的HBase Shell命令+HBase 常用的Java API 及应用实例
java·大数据·数据库·分布式·hbase
matlabgoodboy13 小时前
“图像识别技术：重塑生活与工作的未来”
大数据·人工智能·生活
happycao12313 小时前
Flink 03 | 数据流基本操作
大数据·flink
Neituijunsir14 小时前
2024.09.22 校招 实习 内推 面经
大数据·人工智能·算法·面试·自动驾驶·汽车·求职招聘
Data 31716 小时前
Hive数仓操作（十一）
大数据·数据库·数据仓库·hive·hadoop
热门推荐
01组基轨迹建模 GBTM的介绍与实现（Stata 或 R）02【经验分享】Ubuntu22.04安装微信(linux官方版)032024年高教社杯数学建模国赛C题超详细解题思路分析04分享几个惊艳的 Three.js 个人站点05安卓系列机型永久去除data分区加密 详细步骤解析06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07springer 在线投稿编译踩坑08Ubuntu24.04安装中文输入法09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10CTF网络安全大赛简单的web抓包题目：HEADache