flink源码阅读之JobGraph的生成过程

最新推荐文章于 2024-06-29 13:32:12 发布
最新推荐文章于 2024-06-29 13:32:12 发布
阅读量956 收藏 1
点赞数
分类专栏： BigData 文章标签： flink
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jerseywwwwei/article/details/108230760
版权

flink源码阅读之JobGraph的生成过程

本文flink版本为flink1.11

flink job在最初会生成一个StreamGraph，然而StreamGraph只是程序初步得到的一个数据链路，根据算子的并行度等因素还能优化成为JobGraph。JobGraph的存在主要是为了兼容batch process，Streaming process最初产生的是StreamGraph，而batch process产生的则是OptimizedPlan，他们最后都会转化为JobGraph。

生成JobGraph的整体流程

从StreamGraph到JobGraph的转化步骤

  1. 设置调度模式，Eager 所有节点立即启动。

  2. 广度优先遍历 StreamGraph，为每个 streamNode 生成 byte 数组类型的 hash 值。

  3. 从 source 节点开始递归寻找嵌到一起的 operator，不能嵌到一起的节点单独生成 jobVertex，能够嵌到一起的开始节点生成 jobVertex，其他节点以序列化的形式写入到 StreamConfig，然后 merge 到 CHAINED_TASK_CONFIG，再通过 JobEdge 链接上下游 JobVertex。

  4. 将每个 JobVertex 的入边(StreamEdge)序列化到该 StreamConfig。

  5. 根据 group name 为每个 JobVertext 指定 SlotSharingGroup。

  6. 配置 checkpoint。

  7. 将缓存文件存文件的配置添加到 configuration 中。

  8. 设置 ExecutionConfig。

如果以local model执行flink任务，源码层面的方法调用流程如下所示

StreamGraph转化为JobGraph的重点步骤主要在StreamingJobGraphGenerator文件中，这一部分的方法调用流程如下

看一下源码

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));
		}
		// 方法将可以 Chain 到一起的 StreamNode Chain 在一起，这里会生成相应的 JobVertex 、JobEdge 、 IntermediateDataSet 对象，JobGraph 的 Graph 在这一步就已经完全构建出来了；
		setChaining(hashes, legacyHashes);
		// 方法会将每个 JobVertex 的入边集合也序列化到该 JobVertex 的 StreamConfig 中 (出边集合已经在 setChaining 的时候写入了)；
		setPhysicalEdges();
		// 方法主要是 JobVertex 的 SlotSharingGroup 和 CoLocationGroup 设置；
		setSlotSharingAndCoLocation();
		//
		setManagedMemoryFraction(
			Collections.unmodifiableMap(jobVertices),
			Collections.unmodifiableMap(vertexConfigs),
			Collections.unmodifiableMap(chainedConfigs),
			id -> streamGraph.getStreamNode(id).getMinResources(),
			id -> streamGraph.getStreamNode(id).getManagedMemoryWeight());
		// 方法主要是 checkpoint 相关的设置。
		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;
	}

为每个operator生成hash值

在createJobGraph()方法中，traverseStreamGraphAndGenerateHashes()方法为每个operator生成hash

Map<Integer, byte[]> hashes = defaultStreamGraphHasher.traverseStreamGraphAndGenerateHashes(streamGraph);

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

为每个operator生成hash的原因

Flink 任务失败的时候，各个 operator 是能够从 checkpoint 中恢复到失败之前的状态的，恢复的时候是依据 JobVertexID（hash 值)进行状态恢复的。相同的任务在恢复的时候要求 operator 的 hash 值不变，因此能够获取对应的状态。

setChaining() —判断算子能否chain在一起

setChaining()方法用来将StreamNode chain一起，该方法最终会调用createChain()方法，先分析源码，再解析具体步骤

private void setChaining(Map<Integer, byte[]> hashes, List<Map<Integer, byte[]>> legacyHashes) {
		for (Integer sourceNodeId : streamGraph.getSourceIDs()) {
			createChain(	// 处理每个source StreamNode
					sourceNodeId,
					0,
					new OperatorChainInfo(sourceNodeId, hashes, legacyHashes, streamGraph));
		}
	}

private List<StreamEdge> createChain(Integer currentNodeId, int chainIndex, OperatorChainInfo chainInfo) {
		Integer startNodeId = chainInfo.getStartNodeId();
		if (!builtVertices.contains(startNodeId)) {
			// 当前operator chain的最终的输出边，不包括内部的边
			List<StreamEdge> transitiveOutEdges = new ArrayList<StreamEdge>();
			// 以Edge为粒度，计算上下游能chain在一起的Edge
			List<StreamEdge> chainableOutputs = new ArrayList<StreamEdge>();
			List<StreamEdge> nonChainableOutputs = new ArrayList<StreamEdge>();
			// 获得当前要处理的StreamNode
			StreamNode currentNode = streamGraph.getStreamNode(currentNodeId);
			// 遍历当前StreamNode的输出节点，判断哪些输出节点能chain
			for (StreamEdge outEdge : currentNode.getOutEdges()) {
				if (isChainable(outEdge, streamGraph)) {
					chainableOutputs.add(outEdge);
				} else {
					nonChainableOutputs.add(outEdge);
				}
			}
			// 对于chainable的输出边，递归调用，找到最终的输出边并加入到输出列表中
			for (StreamEdge chainable : chainableOutputs) {
				transitiveOutEdges.addAll( // 递归调用，能chain在一起的话，chainIndex会+1
						createChain(chainable.getTargetId(), chainIndex + 1, chainInfo));
			}

			for (StreamEdge nonChainable : nonChainableOutputs) {
				transitiveOutEdges.add(nonChainable); // 这个边不管能不能连接，都应该添加到输出列表中
				createChain(nonChainable.getTargetId(), 0, chainInfo.newChain(nonChainable.getTargetId()));
			}

			chainedNames.put(currentNodeId, createChainedName(currentNodeId, chainableOutputs)); // 记录chainedName
			chainedMinResources.put(currentNodeId, createChainedMinResources(currentNodeId, chainableOutputs)); // 计算Chain之后node的minResources
			chainedPreferredResources.put(currentNodeId, createChainedPreferredResources(currentNodeId, chainableOutputs)); // 计算Chain之后node的资源上限
			// addNodeToChain 用于保存一个operator chain中所有operator的hash信息
			OperatorID currentOperatorId = chainInfo.addNodeToChain(currentNodeId, chainedNames.get(currentNodeId));

			if (currentNode.getInputFormat() != null) {
				getOrCreateFormatContainer(startNodeId).addInputFormat(currentOperatorId, currentNode.getInputFormat());
			}

			if (currentNode.getOutputFormat() != null) {
				getOrCreateFormatContainer(startNodeId).addOutputFormat(currentOperatorId, currentNode.getOutputFormat());
			}
			// 如果当前节点为起始节点，直接创建JobVertex，如果不是，则先创建一个Stream Config
			StreamConfig config = currentNodeId.equals(startNodeId)
					? createJobVertex(startNodeId, chainInfo)
					: new StreamConfig(new Configuration());
			// 设置 JobVertex 的 StreamConfig, 基本上是将 StreamNode 中的配置设置到 StreamConfig 中
			setVertexConfig(currentNodeId, config, chainableOutputs, nonChainableOutputs);
			// 走到这里，说明chain已经完成
			if (currentNodeId.equals(startNodeId)) {

				config.setChainStart();
				config.setChainIndex(0);
				config.setOperatorName(streamGraph.getStreamNode(currentNodeId).getOperatorName());
				config.setOutEdgesInOrder(transitiveOutEdges);
				config.setOutEdges(streamGraph.getStreamNode(currentNodeId).getOutEdges());

				for (StreamEdge edge : transitiveOutEdges) {
					connect(startNodeId, edge);
				}
				// 将chain中所有子节点的StreamConfig写入的headOfChain节点的CHAINED_TASK_CONFIG 配置中
				config.setTransitiveChainedTaskConfigs(chainedConfigs.get(startNodeId));

			} else {
				chainedConfigs.computeIfAbsent(startNodeId, k -> new HashMap<Integer, StreamConfig>()); // 如果是chain中子节点

				config.setChainIndex(chainIndex);
				StreamNode node = streamGraph.getStreamNode(currentNodeId);
				config.setOperatorName(node.getOperatorName());
				chainedConfigs.get(startNodeId).put(currentNodeId, config); // 将当前 StreamNode 的 config 记录到该 chain 的 config 集合中
			}

			config.setOperatorID(currentOperatorId);

			if (chainableOutputs.isEmpty()) {
				config.setChainEnd();
			}
			return transitiveOutEdges;

		} else {
			return new ArrayList<>();
		}
	}

在执行createChain方法时，它首先从会遍历这个 StreamGraph 的 source 节点，然后选择从 source 节点开始执行 createChain() 方法，在具体的实现里，主要逻辑如下：

  1. createChain() 当前要处理的节点是 currentNodeId，先从 StreamGraph 中拿到这个 StreamNode 的 outEdge（currentNode.getOutEdges()），然后判断这个 outEdge 连接的两个 StreamNode 是否可以 Chain 在一起，判断方法是 isChainable()；
  2. 紧接着会有一个递归调用：
    • 对于可以 Chain 在一起的 StreamEdge（这个 Edge 连接两个 StreamNode 是可以 Chain 在一起），会再次调用 createChain() 方法，并且 createChain() 中的 startNodeId 还是最开始的 startNodeId（这个标识了这个 ChainNode 的开始 NodeId），而 chainIndex 会自增加 1；
    • 而对于不能 Chain 在一起的 StreamEdge，createChain() 中的 startNodeId 变成了这个 StreamEdge 的 target StreamNode（相当于如果 Chain 在一起，ChainNode 中的 startNodeId 会赋值为下一个节点的 NodeId，然后再依次类推），chainIndex 又从 0 开始计；
    • 也就是说：createChain() 中的 startNodeId 表示了当前可以 Chain 之后 Node 的 startId，这里，会一直递归调用，直到达到 Sink 节点。
  3. 然后在生成 StreamConfig 对象时，判断当前的 currentNodeId 与 startNodeId 是否相等，如果相等的话，证明当前 Node 就是这个 ChainNode 的 StartNode，这里会调用 createJobVertex() 方法给这个 ChainNode 创建一个 JobVertex 对象，最后会返回一个 StreamConfig 对象，如果前面的 id 不相等的话，这里会直接返回一个 StreamConfig 对象（这个对象主要是记录当前 StreamNode 的一些配置，它会同步 StreamGraph 中相关的配置）；
  4. 最后还会分两种情况判断：
    • 如果 id 相等，相当于这个 ChainNode 已经完成，先做一些相关的配置（比如：标识当前 StreamNode 为这个 JobVertex 的起始 node），最后再通过 connect() 方法创建 JobEdge 和 IntermediateDataSet 对象，把这个 Graph 连接起来；
    • 如果 id 不相等，那么证明当前 StreamNode 只是这个 Chain的一部分，这里只是同步一下信息，并记录到缓存。
判断两个StreamNode能否chain

判断两个StreamNode能够chain，需要符合以下几个条件

  1. 对应下游Vertex的入读只有1。
  2. 上游Vertex和下游Vertex在一个共享的slot中。
  3. edge 的分区函数是 ForwardPartitioner 的实例。ForwardPartitioner分区器要求上下游算子并行度一样。上下游Operator同属一个SubTasks。关于flink的8大分区，可以参考
  4. 任务不是流式任务
  5. 上下游算子并行度相同
  6. StreamGraph是否允许连接
public static boolean isChainable(StreamEdge edge, StreamGraph streamGraph) {
		StreamNode upStreamVertex = streamGraph.getSourceVertex(edge);
		StreamNode downStreamVertex = streamGraph.getTargetVertex(edge);
		return downStreamVertex.getInEdges().size() == 1
				&& upStreamVertex.isSameSlotSharingGroup(downStreamVertex)
				&& areOperatorsChainable(upStreamVertex, downStreamVertex, streamGraph)
				&& (edge.getPartitioner() instanceof ForwardPartitioner)
				&& edge.getShuffleMode() != ShuffleMode.BATCH
				&& upStreamVertex.getParallelism() == downStreamVertex.getParallelism()
				&& streamGraph.isChainingEnabled();
	}
createJobVertex()创建JobVertex

源码如下，根据chainInfo与StreamNode创建JobVertex

private StreamConfig createJobVertex(
			Integer streamNodeId,
			OperatorChainInfo chainInfo) {

		JobVertex jobVertex;
		StreamNode streamNode = streamGraph.getStreamNode(streamNodeId);

		byte[] hash = chainInfo.getHash(streamNodeId);

		if (hash == null) {
			throw new IllegalStateException("Cannot find node hash. " +
					"Did you generate them before calling this method?");
		}

		JobVertexID jobVertexId = new JobVertexID(hash);

		List<Tuple2<byte[], byte[]>> chainedOperators = chainInfo.getChainedOperatorHashes(streamNodeId);
		List<OperatorIDPair> operatorIDPairs = new ArrayList<>();
		if (chainedOperators != null) {
			for (Tuple2<byte[], byte[]> chainedOperator : chainedOperators) {
				OperatorID userDefinedOperatorID = chainedOperator.f1 == null ? null : new OperatorID(chainedOperator.f1);
				operatorIDPairs.add(OperatorIDPair.of(new OperatorID(chainedOperator.f0), userDefinedOperatorID));
			}
		}

		if (chainedInputOutputFormats.containsKey(streamNodeId)) {
			jobVertex = new InputOutputFormatVertex(
					chainedNames.get(streamNodeId),
					jobVertexId,
					operatorIDPairs);

			chainedInputOutputFormats
				.get(streamNodeId)
				.write(new TaskConfig(jobVertex.getConfiguration()));
		} else {
			jobVertex = new JobVertex(
					chainedNames.get(streamNodeId),
					jobVertexId,
					operatorIDPairs);
		}

		for (OperatorCoordinator.Provider coordinatorProvider : chainInfo.getCoordinatorProviders()) {
			try {
				jobVertex.addOperatorCoordinator(new SerializedValue<>(coordinatorProvider));
			} catch (IOException e) {
				throw new FlinkRuntimeException(String.format(
						"Coordinator Provider for node %s is not serializable.", chainedNames.get(streamNodeId)));
			}
		}

		jobVertex.setResources(chainedMinResources.get(streamNodeId), chainedPreferredResources.get(streamNodeId));

		jobVertex.setInvokableClass(streamNode.getJobVertexClass());

		int parallelism = streamNode.getParallelism();

		if (parallelism > 0) {
			jobVertex.setParallelism(parallelism);
		} else {
			parallelism = jobVertex.getParallelism();
		}

		jobVertex.setMaxParallelism(streamNode.getMaxParallelism());

		if (LOG.isDebugEnabled()) {
			LOG.debug("Parallelism set: {} for {}", parallelism, streamNodeId);
		}

		// TODO: inherit InputDependencyConstraint from the head operator
		jobVertex.setInputDependencyConstraint(streamGraph.getExecutionConfig().getDefaultInputDependencyConstraint());

		jobVertices.put(streamNodeId, jobVertex);
		builtVertices.add(streamNodeId);
		jobGraph.addVertex(jobVertex);

		return new StreamConfig(jobVertex.getConfiguration());
	}
connect()-将JobVertex与JobEdge连接在一起

  • JobVertex：经过优化后符合条件的多个StreamNode可能会chain在一起生成一个JobVertex，即一个JobVertex包含一个或多个operator，JobVertex的输入是JobEdge，输出是IntermediateDataSet。

  • IntermediateDataSet：表示JobVertex的输出，即经过operator处理产生的数据集。producer是JobVertex，consumer是JobEdge。

  • JobEdge：代表了job graph中的一条数据传输通道。source 是 IntermediateDataSet，target 是 JobVertex。即数据通过JobEdge由IntermediateDataSet传递给目标JobVertex。

JobVertex与JobEdge的联系如下图所示

再看一下connect的源码

private void connect(Integer headOfChain, StreamEdge edge) {
		// 记录StreamEdge
		physicalEdgesInOrder.add(edge);

		Integer downStreamVertexID = edge.getTargetId();
		// 这里 headVertex 指的是 headOfChain 对应的 JobVertex（也是当前 node 对应的 vertex）
		JobVertex headVertex = jobVertices.get(headOfChain);
		JobVertex downStreamVertex = jobVertices.get(downStreamVertexID);

		StreamConfig downStreamConfig = new StreamConfig(downStreamVertex.getConfiguration());
		// 这个节点的输入数增加1
		downStreamConfig.setNumberOfInputs(downStreamConfig.getNumberOfInputs() + 1);

		StreamPartitioner<?> partitioner = edge.getPartitioner();

		ResultPartitionType resultPartitionType;
		switch (edge.getShuffleMode()) {
			case PIPELINED:
				resultPartitionType = ResultPartitionType.PIPELINED_BOUNDED;
				break;
			case BATCH:
				resultPartitionType = ResultPartitionType.BLOCKING;
				break;
			case UNDEFINED:
				resultPartitionType = determineResultPartitionType(partitioner);
				break;
			default:
				throw new UnsupportedOperationException("Data exchange mode " +
					edge.getShuffleMode() + " is not supported yet.");
		}
		// 开始创建jobEdge
		JobEdge jobEdge;
		if (isPointwisePartitioner(partitioner)) {
			jobEdge = downStreamVertex.connectNewDataSetAsInput( // 这个方法会创建 IntermediateDataSet 对象
				headVertex,
				DistributionPattern.POINTWISE, // 上游与下游的消费模式，（每个生产任务的 sub-task 会连接到消费任务的一个或多个 sub-task）
				resultPartitionType);
		} else {
			jobEdge = downStreamVertex.connectNewDataSetAsInput(
					headVertex,
					DistributionPattern.ALL_TO_ALL, // 每个生产任务的 sub-task 都会连接到每个消费任务的 sub-task
					resultPartitionType);
		}
		// set strategy name so that web interface can show it.
		jobEdge.setShipStrategyName(partitioner.toString());

		if (LOG.isDebugEnabled()) {
			LOG.debug("CONNECTED: {} - {} -> {}", partitioner.getClass().getSimpleName(),
					headOfChain, downStreamVertexID);
		}
	}

执行完connect()方法之后，JobGraph基本已经创建完成。

reference

瓜不田
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode 685：去除有向图的冗余连接
Einskai216的博客
09-17 428
题意 现在有一个N个点，N条边的有向图，每个节点至少与一条边相连，现在要求删掉一条边，使得有向图成为一棵树，从而可以从一个根节点遍历到其他节点（可能出现多个符合条件的答案，要求去除最后一次出现的边） 题解 大方向：并查集 冗余会出现于什么情况？ 情况1：一个节点有两个父亲，比如输入边集：[[1,2], [1,3], [2 3]] 情况2：一条边的加入导致循环，比如输入边集：[[1,2], [2,3], [3,4], [4,1], [1,5]] 如何根据冗余情况找到冗余边？
Flink源码剖析之JobGraph的生成
darkness0604的博客
03-23 1871
背景 其实，以前编写flink代码的时候，模式比较固定，不管你中间过程如何花里胡哨，开头总要有一个获取上下文环境，最后总要有一个：env.execute()，之前只是知道这个方法，会在job提交的时候，用于获取job的计算流程图，但是我一直很好奇，到底是什么时机生成的呢？ 源码剖析 创建JobGraph 我们知道，提交任务的时候，是要有一步获取Job的JobGraph的： /** * Creates a {@link JobGraph} with a specified {@link Job
2、Flink作业转换-JobGraph
江7城子的专栏
07-23 499
Flink客户端在构建出StreamGrap后，会通过优化得到另一个执行计划图 - JobGraph，并将JobGraph提交至JobManager。JobManager根据任务所需资源将其转化成具有并行性质的ExecutionGraph，根据ExecutionGraph进行任务调度。
Flink 原理与实现：如何生成 JobGraph
lx1309244704的博客
12-10 2086
转载来源：http://wuchong.me/blog/2016/05/10/flink-internals-how-to-build-jobgraph/ 继前文Flink 原理与实现：架构和拓扑概览中介绍了Flink的四层执行图模型，本文将主要介绍 Flink 是如何将 StreamGraph 转换成 JobGraph 的。根据用户用Stream API编写的程序，构造出一个代表拓扑结构的St...
Flink源码系列——获取JobGraph的过程
混混的博客
03-10 3164
接《Flink源码系列——获取StreamGraph的过程》获取到StreamGraph后，继续分析，如果通过获取到的StreamGraph来转化为JobGraph。转化逻辑在StreamingJobGraphGenerator这个类中，入口是createJobGraph(StreamGraph)方法。先是初始化了一个StreamingJobGraphGenerator的实例，StreamingJ...
flink源码阅读思维导图xmind
11-20
描述了flink源码框架。使用案例,常用函数，api等等，适合初学者了解和学习，反压,函数定义等等，欢迎下载讨论
flink源码浅析和运行机理梳理
05-17
阅读建议：此资源基于flink的源码追踪并简单分析，学习参考的时候建议下载相应版本的flink源码，并搭建虚拟机安装部署测试flink，在运行过程中结合源码和笔记学习效果更佳。有经验的开发人员可以编译并debug flink的...
Flink源码解析.zip
06-04
9、Flink 源码解析 —— 如何获取 JobGraph？ 10、Flink 源码解析 —— 如何获取 StreamGraph？ 11、Flink 源码解析 —— Flink JobManager 有什么作用？ 12、Flink 源码解析 —— Flink TaskManager 有什么作用...
flink 1.14.4 源码下载
04-03
Apache Flink 是一个开源的流处理和批处理框架，它在大数据领域扮演着重要的...通过阅读和理解Flink 1.14.4的源码，开发者不仅可以学习到流处理和批处理的最佳实践，还能为自己的项目定制优化，甚至贡献代码回馈社区。
Flink示例源码-Flink入门
12-16
总的来说，"Flink示例源码-Flink入门"这个压缩包为初学者提供了一个宝贵的起点，通过阅读和运行其中的代码，我们可以更直观地理解Flink的工作原理和用法。从基本的WordCount到高级的窗口和状态管理，每一个示例都将...
【Flink】详解JobGraph
pcx171的博客
02-12 742
本文从源码出发，详细介绍了flink如何对StreamGraph进行优化进而构建JobGraph对象，并在最后给出了自己的总结。
Flink 深入理解任务执行计划，即Graph生成过程（源码解读）
Direction_Wind的博客
02-21 1575
可以看到上述所有算子都被按执行顺序添加进了transformations 这个 List 中，接下来就是根据算子是否有座shuffle操作来把算子分成两类，分别是StreamNode的非shuffle算子, 以及上下游做shuffle的streamEdge操作，并且将streamEdge操作 与 StreamNode 绑定，来形成一个有前后顺序的DAG图。Flink 会根据节点的并行度以及他们之间的连边方式，把一些计算节点进行链接合并，最终形成 JobGraph，从而降低计算节点间的数据传输开销。
Flink-JobGraph基本概念
jacky_wang_123的专栏
10-20 1300
JobGraph也是在client端生成的，我们看一下StreamGraph->JobGraph的变化： 主要的变化有： StreamNode变成了JobVertex StreamEdge变成了JobEdge 增加了IntermediateDataSet Forward相连的StreamNode合并成一个JobVertex JobGraph的生成 同样，我们进入debug模式，从execute()方法一路点点点，到了StreamingJobGraphGenerator.createJ.
Flink源码解读(二)：JobGraph源码解读
Stray_Lambs的博客
10-07 873
目录 JobGraph源码解读 JobGraph生成过程 入口函数 createJobGraph函数 参考 JobGraph源码解读 上回说到，StreamGraph的源码其中是在客户端生成，并且是生成Node节点和Edge，主要是通过StreamAPI生成，表示拓扑结构，这次给大家讲讲JobGraph的生成(以Yarn集群模式)。 首先，JobGraph是基于StreamGraph进行优化(包括设置Checkpoint、slot分组策略，内存占比等)，最主要是将多个符合条件的StreamN
flink笔记：027 作业图（JobGraph）与执行图（ExecutionGraph）
weixin_43015677的博客
04-02 456
由 Flink 程序直接映射成的数据流图（dataflow graph），也被称为逻辑流图（logical StreamGraph），因为它们表示的是计算逻辑的高级视图。四层：逻辑流图（StreamGraph）→ 作业图（JobGraph）→ 执行图（ExecutionGraph）→ 物理图（Physical Graph）。在这个转换过程中，有几个不同的阶段，会生成不同层级的图，其中最重要的就是作业图（JobGraph）和执行图（ExecutionGraph）。
【Flink】Flink源码分析——批处理模式JobGraph的创建
九师兄
06-25 479
转载：Flink源码分析——批处理模式JobGraph的创建 仅供自己学习。Flink不管是流处理还是批处理都是将我们的程序编译成JobGraph进行提交的，之前我们分析过流处理模式下的JobGraph创建，现在我们来分析一下批处理模式下的JobGraph创建。本文以本地模式为例，分析JobGraph的创建我们仍然以WordCount为例子来分析JobGraph的创建过程，WordCount代码 这个WordCount执行之后生成的DataSet关系图如下所示： 注意这里的Operator并非是指算子层面的
Flink作业执行之 4.JobGraph
最新发布
初阳
06-29 1066
前文了解了由Transformation到StreamGraph的过程，StreamGraph即作业的逻辑拓扑结构。生成逻辑结构后，接下来的操作往往是对逻辑结构的优化。在很多组件中都是这样的处理，如hive、spark等都会执行“逻辑计划->优化计划->物理计划”的处理过程。从StreamGraph到JobGraph的过程中很重要的事情是将节点组成节点链。在方法中调用方法完成JobGraph实例的生成。接口根据提供的配置执行管道。接口内只有一个execute方法。
Flink1.12源码解读——JobGraph执行图构建过程
ws0owws0ow的博客
02-26 553
Apache Flink作为国内最火的大数据计算引擎之一，自身支持高吞吐，低延迟，exactly-once语义，有状态流等特性，阅读源码有助加深对框架的理解和认知。 Flink分为四种执行图，本章主要解析JobGraph的生成计划 本章及后续源码解读环境以生产为主：运行模式：OnYarn，HA模式：ZK，Mode：Streaming，关键逻辑解释我会备注到代码上（灰色字体）勿忽视。 Flink会生成JobGraph去优化StreamGraph,其中包括设置Checkpoint，Slot分组策略，内存占
从WordCount学习Flink源码-JobGraph
bigdatakenan的博客
08-23 231
上节我们看到了transformation是如何转换成streamgraph的,转换成streamgraph后flink client还需做进一步处理将streamgraph转换成jobgraph。下面我们来看一下streamgraph是如何转换成jobgrah的。streamgraph转换成jobgrah需要做以下几步：1.将streamNode转成成JobVertex2.将符合条件的streamNode chain在一起3.将streamEdge转换成jobEdge。
flink的JobGraph源码
06-11
Flink JobGraph的源码位于Flink的flink-core模块中，具体路径为： ``` flink-core/src/main/java/org/apache/flink/runtime/jobgraph/JobGraph.java ``` JobGraph类是Flink程序中Job Graph的主要数据结构，它包含...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值