精华内容
下载资源
问答
  • 宽依赖和窄依赖深度剖析.pngRDD依赖关系与stage划分Spark中RDD的高效与DAG图有着莫大的关系,在DAG调度中需要对计算过程划分stage,而划分依据就是RDD之间的依赖关系。1. 窄依赖与宽依赖针对不同的转换函数,RDD之间...

    宽依赖和窄依赖深度剖析.png

    RDD依赖关系与stage划分

    Spark中RDD的高效与DAG图有着莫大的关系,在DAG调度中需要对计算过程划分stage,而划分依据就是RDD之间的依赖关系。

    1. 窄依赖与宽依赖

    针对不同的转换函数,RDD之间的依赖关系分为窄依赖(narrow dependency)和宽依赖(wide dependency,也成shuffle dependency)。

    1.1 窄依赖

    窄依赖是指1个父RDD分区对应1个子RDD的分区。换句话说,一个父RDD的分区对应于一个子RDD的分区,或者多个父RDD的分区对应于一个子RDD的分区。所以窄依赖又可以分为两种情况:

    1个子RDD的分区对应于1个父RDD的分区,比如map,filter,union等算子

    1个子RDD的分区对应于N个父RDD的分区,比如co-partioned join

    1.2 宽依赖

    宽依赖是指1个父RDD分区对应多个子RDD分区。宽依赖有分为两种情况

    1个父RDD对应非全部多个子RDD分区,比如groupByKey,reduceByKey,sortByKey

    1个父RDD对应所有子RDD分区,比如未经协同划分的join

    窄依赖与宽依赖.png

    总结:如果父RDD分区对应1个子RDD的分区就是窄依赖,否则就是宽依赖。

    2. 为什么Spark将依赖分为窄依赖和宽依赖

    2.1 窄依赖(narrow dependency)

    可以支持在同一个集群Executor上,以pipeline管道形式顺序执行多条命令,例如在执行了map后,紧接着执行filter。分区内的计算收敛,不需要依赖所有分区的数据,可以并行地在不同节点进行计算。所以它的失败回复也更有效,因为它只需要重新计算丢失的parent partition即可

    2.2 宽依赖(shuffle dependency)

    则需要所有的父分区都是可用的,必须等RDD的parent partition数据全部ready之后才能开始计算,可能还需要调用类似MapReduce之类的操作进行跨节点传递。从失败恢复的角度看,shuffle dependency牵涉RDD各级的多个parent partition。

    3. DAG

    RDD之间的依赖关系就形成了DAG(有向无环图)

    在Spark作业调度系统中,调度的前提是判断多个作业任务的依赖关系,这些作业任务之间可能存在因果的依赖关系,也就是说有些任务必须先获得执行,然后相关的依赖人物才能执行,但是任务之间显然不应出现任何直接或间接的循环依赖关系,所以本质上这种关系适合用DAG表示

    4. stage划分

    由于shuffle依赖必须等RDD的父RDD分区数据全部可读之后才能开始计算,因此Spark的设计是让父RDD将结果写在本地,完全写完之后,通知后面的RDD。后面的RDD则首先去读之前RDD的本地数据作为输入,然后进行运算。

    由于上述特性,讲shuffle依赖就必须分为两个阶段(stage)去做:

    (1)第1个阶段(stage)需要把结果shuffle到本地,例如reduceByKey,首先要聚合某个key的所有记录,才能进行下一步的reduce计算,这个汇聚的过程就是shuffle。

    (2) 第二个阶段(stage)则读入数据进行处理。

    为什么要写在本地?

    后面的RDD多个分区都要去读这个信息,如果放到内存,假如出现数据丢失,后面所有的步骤全部不能进行,违背了之前所说的需要父RDD分区数据全部ready的原则。

    同一个stage里面的task是可以并发执行的,下一个stage要等前一个stage ready(和map reduce的reduce需要等map过程ready一脉相承)。

    Spark 将任务以 shuffle 依赖(宽依赖)为边界打散,划分多个 Stage. 最后的结果阶段叫做 ResultStage, 其它阶段叫 ShuffleMapStage, 从后往前推导,依将计算。

    RDD的划分.png

    1.从后往前推理,遇到宽依赖就断开,遇到窄依赖就把当前RDD加入到该Stage

    2.每个Stage里面Task的数量是由该Stage中最后一个RDD的Partition的数量所决定的。

    3.最后一个Stage里面的任务类型是ResultTask,前面其他所有的Stage的任务类型是ShuffleMapTask。

    4.代表当前Stage的算子一定是该Stage的最后一个计算步骤

    表面上看是数据在流动,实质上是算子在流动。

    (1)数据不动代码动

    (2)在一个Stage内部算子为何会流动(Pipeline)?首先是算子合并,也就是所谓的函数式编程的执行的时候最终进行函数的展开从而把一个Stage内部的多个算子合并成为一个大算子(其内部包含了当前Stage中所有算子对数据的计算逻辑);其次,是由于Transformation操作的Lazy特性!在具体算子交给集群的Executor计算之前首先会通过Spark Framework(DAGScheduler)进行算子的优化(基于数据本地性的Pipeline)。

    5. Spark计算引擎原理

    通过RDD,创建DAG(逻辑计划)

    为DAG生成物理查询计划

    调度并执行Task

    分布式执行Task

    计算引擎.png

    展开全文
  • 1RDD的依赖关系及容错1.1RDD的依赖关系RDD的依赖关系分为两种:窄依赖(Narrow Dependencies)与宽依赖(Wide Dependencies,源码中称为ShuffleDependencies)依赖有2个作用,其一用来解决数据容错的高效性;其二用来...

    1RDD的依赖关系及容错

    1.1RDD的依赖关系

    RDD的依赖关系分为两种:窄依赖(Narrow Dependencies)与宽依赖(Wide Dependencies,源码中称为ShuffleDependencies)

    依赖有2个作用,其一用来解决数据容错的高效性;其二用来划分stage。

    窄依赖:每个父RDD的一个Partition最多被子RDD的一个Partition所使用(1:1 或n:1)。例如map、filter、union等操作都会产生窄依赖;

    子RDD分区通常对应常数个父RDD分区(O(1),与数据规模无关。

    宽依赖:一个父RDD的Partition会被多个子RDD的Partition所使用,例如groupByKey、reduceByKey、sortByKey等操作都会产生宽依赖;(1:m 或n:m)

    (子RDD分区通常对应所有的父RDD分区(O(n),与数据规模有关)

    相比于宽依赖,窄依赖对优化很有利,主要基于以下两点:

    1、宽依赖往往对应着shuffle操作,需要在运行过程中将同一个父RDD的分区传入到不同的子RDD分区中,中间可能涉及多个节点之间的数据传输;而窄依赖的每个父RDD的分区只会传入到一个子RDD分区中,通常可以在一个节点内完成转换。

    2、当RDD分区丢失时(某个节点故障),spark会对数据进行重算。

    Ø对于窄依赖,由于父RDD的一个分区只对应一个子RDD分区,这样只需要重算和子RDD分区对应的父RDD分区即可,所以这个重算对数据的利用率是100%的;

    Ø对于宽依赖,重算的父RDD分区对应多个子RDD分区,这样实际上父RDD中只有一部分的数据是被用于恢复这个丢失的子RDD分区的,另一部分对应子RDD的其它未丢失分区,这就造成了多余的计算;更一般的,宽依赖中子RDD分区通常来自多个父RDD分区,极端情况下,所有的父RDD分区都要进行重新计算。

    Ø如下图所示,b1分区丢失,则需要重新计算a1,a2和a3,这就产生了冗余计算(a1,a2,a3中对应b2的数据)。

    区分这两种依赖很有用。首先,窄依赖允许在一个集群节点上以流水线的方式(pipeline)计算所有父分区。例如,逐个元素地执行map、然后filter操作;而宽依赖则需要首先计算好所有父分区数据,然后在节点之间进行Shuffle,这与MapReduce类似。第二,窄依赖能够更有效地进行失效节点的恢复,即只需重新计算丢失RDD分区的父分区,而且不同节点之间可以并行计算;而对于一个宽依赖关系的Lineage图,单个节点失效可能导致这个RDD的所有祖先丢失部分分区,因而需要整体重新计算。

    【误解】之前一直理解错了,以为窄依赖中每个子RDD可能对应多个父RDD,当子RDD丢失时会导致多个父RDD进行重新计算,所以窄依赖不如宽依赖有优势。而实际上应该深入到分区级别去看待这个问题,而且重算的效用也不在于算的多少,而在于有多少是冗余的计算。窄依赖中需要重算的都是必须的,所以重算不冗余。

    窄依赖的函数有:map、filter、union、join(父RDD是hash-partitioned )、mapPartitions、mapValues

    宽依赖的函数有:groupByKey、join(父RDD不是hash-partitioned )、partitionBy

    1.2依赖样例

    依赖的继承关系:

    val rdd1 = sc.parallelize(1 to 10, 1)

    val rdd2 = sc.parallelize(11 to 20, 1)

    val rdd3 = rdd1.union(rdd2)

    rdd3.dependencies.size

    // 长度为2,值为rdd1、rdd2,意为rdd3依赖rdd1、rdd2

    rdd3.dependencies

    // 结果:

    rdd3.dependencies(0).rdd.collect

    // 打印rdd1的数据

    rdd3.dependencies(1).rdd.collect

    // 打印rdd2的数据

    rdd3.dependencies(3).rdd.collect

    // 数组越界,报错

    哪些RDD Actions对应shuffleDependency?下面的join(r5)好像就没有shuffleDependency

    val r1 = sc.parallelize(List("dog", "salmon", "salmon", "rat", "elephant"))

    val r2 = r1.keyBy(_.length)

    val r3 = sc.parallelize(List("dog","cat","gnu","salmon","rabbit","turkey","wolf","bear","bee"))

    val r4 = r3.keyBy(_.length)

    val r5 = r2.join(r4)

    回答:join不一定会有shuffleDependency,上面的操作中就没有。

    redueceByKey会产生shuffleDependency。

    注意上面操作中的keyBy,和我的想象不太一样。要注意一下。

    keyBy:与map操作较为类似,给每个元素增加了一个key

    以下这个例子有点意思:

    val r1 = sc.textFile("hdfs:///user/hadoop/data/block_test1.csv")

    r1

    val r2 = r1.dependencies(0).rdd

    r2.partitions.size

    r2.preferredLocations(r2.partitions(0))

    r2.preferredLocations(r2.partitions(3))

    有意思的地方在于(查找依赖、优先位置):

    1、r1的类型为MapPartitionsRDD

    2、r1依赖于r2,如果没有这个赋值语句是看不出来的。r2的类型为:HadoopRDD

    3、可以检索r2各个分区的位置,该hdfs文件系统的副本数设置为2

    1.3RDD的容错(lineage、checkpoint)

    一般来说,分布式数据集的容错性有两种方式:数据检查点和记录数据的更新(CheckPoint Data,和Logging The Updates)。

    面向大规模数据分析,数据检查点操作成本很高,需要通过数据中心的网络连接在机器之间复制庞大的数据集,而网络带宽往往比内存带宽低得多,同时还需要消耗更多的存储资源。

    因此,Spark选择记录更新的方式。但是,如果更新粒度太细太多,那么记录更新成本也不低。因此,RDD只支持粗粒度转换,即只记录单个块上执行的单个操作(记录如何从其他RDD转换而来,即lineage),然后将创建RDD的一系列变换序列(每个RDD都包含了他是如何由其他RDD变换过来的以及如何重建某一块数据的信息。因此RDD的容错机制又称“血统(Lineage)”容错)记录下来,以便恢复丢失的分区。

    Lineage本质上很类似于数据库中的重做日志(Redo Log),只不过这个重做日志粒度很大,是对全局数据做同样的重做进而恢复数据。

    Lineage容错原理:在容错机制中,如果一个节点死机了,而且运算窄依赖,则只要把丢失的父RDD分区重算即可,不依赖于其他节点。而宽依赖需要父RDD的所有分区都存在,重算就很昂贵了。可以这样理解开销的经济与否:在窄依赖中,在子RDD的分区丢失、重算父RDD分区时,父RDD相应分区的所有数据都是子RDD分区的数据,并不存在冗余计算。在宽依赖情况下,丢失一个子RDD分区重算的每个父RDD的每个分区的所有数据并不是都给丢失的子RDD分区用的,会有一部分数据相当于对应的是未丢失的子RDD分区中需要的数据,这样就会产生冗余计算开销,这也是宽依赖开销更大的原因。因此如果使用Checkpoint算子来做检查点,不仅要考虑Lineage是否足够长,也要考虑是否有宽依赖,对宽依赖加Checkpoint是最物有所值的。

    Checkpoint机制。在以下2种情况下,RDD需要加检查点:

    ØDAG中的Lineage过长,如果重算,则开销太大(如在多次迭代中)

    Ø在宽依赖上做Checkpoint获得的收益更大

    由于RDD是只读的,所以Spark的RDD计算中一致性不是主要关心的内容,内存相对容易管理,这也是设计者很有远见的地方,这样减少了框架的复杂性,提升了性能和可扩展性,为以后上层框架的丰富奠定了强有力的基础。

    在RDD计算中,通过检查点机制进行容错,传统做检查点有两种方式:通过冗余数据和日志记录更新操作。在RDD中的doCheckPoint方法相当于通过冗余数据来缓存数据,而之前介绍的血统就是通过相当粗粒度的记录更新操作来实现容错的。

    检查点(本质是通过将RDD写入Disk做检查点)是为了通过lineage做容错的辅助,Lineage过长会造成容错成本过高,这样就不如在中间阶段做检查点容错,如果之后有节点出现问题而丢失分区,从做检查点的RDD开始重做Lineage,就会减少开销。

    1.4checkpoint与cache的关系

    1、从本质上说:checkpoint是容错机制;cache是优化机制

    2、checkpoint将数据写到共享存储中(hdfs);cache通常是内存中

    3、运算时间很长或运算量太大才能得到的RDD,computing chain过长或依赖其他RDD很多的RDD,需要做checkpoint。会被重复使用的(但不能太大)RDD,做cache。

    实际上,将ShuffleMapTask 的输出结果存放到本地磁盘也算是checkpoint,只不过这个checkpoint的主要目的是去partition输出数据。

    4、RDD的checkpoint操作完成后会斩断lineage,cache操作对lineage没有影响。

    checkpoint 在Spark Streaming中特别重要,spark streaming 中对于一些有状态的操作,这在某些stateful转换中是需要的,在这种转换中,生成RDD需要依赖前面的batches,会导致依赖链随着时间而变长。为了避免这种没有尽头的变长,要定期将中间生成的RDDs保存到可靠存储来切断依赖链,必须隔一段时间进行一次checkpoint。

    cache 和checkpoint是有显著区别的,缓存把 RDD 计算出来然后放在内存中, 但是RDD的依赖链(相当于数据库中的redo日志),也不能丢掉,当某个点某个executor宕了,上面cache的RDD就会丢掉,需要通过依赖链重放计算出来,不同的是,checkpoint是把RDD保存在HDFS中,是多副本可靠存储,所以依赖链就可以丢掉了,即斩断了依赖链,是通过复制实现的高容错。

    注意:checkpoint需要把job重新从头算一遍,最好先cache一下,checkpoint就可以直接保存缓存中的RDD了,就不需要重头计算一遍了,对性能有极大的提升。

    1.5checkpoint的使用与流程

    checkpoint 的正确使用姿势

    val data = sc.textFile("/tmp/spark/1.data").cache()// 注意要cache

    sc.setCheckpointDir("/tmp/spark/checkpoint")

    data.checkpoint

    data.count

    //问题:cache和checkpoint有没有先后的问题;有了cache可以避免第二次计算,我在代码中可以看见相关的说明!!!

    使用很简单,就是设置一下 checkpoint 目录,然后再rdd上调用checkpoint方法,action的时候就对数据进行了checkpoint

    checkpoint 写流程

    RDD checkpoint 过程中会经过以下几个状态,

    [ Initialized –> marked for checkpointing –> checkpointing in progress –> checkpointed ]

    展开全文
  • 1、宽依赖和窄依赖说明由于RDD是粗粒度的操作数据集,每个Transformation操作都会生成一个新的RDD,所以RDD之间就会形成类似流水线的前后依赖关系;RDD和它依赖的父RDD(s)的关系有两种不同的类型,即窄依赖(narrow ...

    1、宽依赖和窄依赖说明

    由于RDD是粗粒度的操作数据集,每个Transformation操作都会生成一个新的RDD,所以RDD之间就会形成类似流水线的前后依赖关系;RDD和它依赖的父RDD(s)的关系有两种不同的类型,即窄依赖(narrow dependency)和宽依赖(wide dependency)。如图所示显示了RDD之间的依赖关系。

    从图中可知:

    窄依赖:是指每个父RDD的一个Partition最多被子RDD的一个Partition所使用,例如map、filter、union等操作都会产生窄依赖;(独生子女)

    宽依赖:是指一个父RDD的Partition会被多个子RDD的Partition所使用,例如groupByKey、reduceByKey、sortByKey等操作都会产生宽依赖;(超生)

    需要特别说明的是对join操作有两种情况:

    (1)图中左半部分join:如果两个RDD在进行join操作时,一个RDD的partition仅仅和另一个RDD中已知个数的Partition进行join,那么这种类型的join操作就是窄依赖,例如图1中左半部分的join操作(join with inputs co-partitioned);

    (2)图中右半部分join:其它情况的join操作就是宽依赖,例如图1中右半部分的join操作(join with inputs not co-partitioned),由于是需要父RDD的所有partition进行join的转换,这就涉及到了shuffle,因此这种类型的join操作也是宽依赖。

    2、 依赖关系下的数据流视图

    在spark中,会根据RDD之间的依赖关系将DAG图(有向无环图)划分为不同的阶段,对于窄依赖,由于partition依赖关系的确定性,partition的转换处理就可以在同一个线程里完成,窄依赖就被spark划分到同一个stage中,而对于宽依赖,只能等父RDD shuffle处理完成后,下一个stage才能开始接下来的计算。

    因此spark划分stage的整体思路是:从后往前推,遇到宽依赖就断开,划分为一个stage;遇到窄依赖就将这个RDD加入该stage中。因此在图2中RDD C,RDD D,RDD E,RDDF被构建在一个stage中,RDD A被构建在一个单独的Stage中,而RDD B和RDD G又被构建在同一个stage中。

    在spark中,Task的类型分为2种:ShuffleMapTask和ResultTask;

    简单来说,DAG的最后一个阶段会为每个结果的partition生成一个ResultTask,即每个Stage里面的Task的数量是由该Stage中最后一个RDD的Partition的数量所决定的!而其余所有阶段都会生成ShuffleMapTask;之所以称之为ShuffleMapTask是因为它需要将自己的计算结果通过shuffle到下一个stage中;也就是说上图中的stage1和stage2相当于mapreduce中的Mapper,而ResultTask所代表的stage3就相当于mapreduce中的reducer。

    在之前动手操作了一个wordcount程序,因此可知,Hadoop中MapReduce操作中的Mapper和Reducer在spark中的基本等量算子是map和reduceByKey;不过区别在于:Hadoop中的MapReduce天生就是排序的;而reduceByKey只是根据Key进行reduce,但spark除了这两个算子还有其他的算子;因此从这个意义上来说,Spark比Hadoop的计算算子更为丰富。

    codeobj , 版权所有丨如未注明 , 均为原创丨本网站采用BY-NC-SA协议进行授权

    转载请注明原文链接:Spark RDD的宽依赖和窄依赖

    展开全文
  • 针对不同的转换函数,RDD之间的依赖关系分类窄依赖(narrow dependency)和宽依赖(wide dependency, 也称 shuffle dependency).宽依赖与窄依赖窄依赖是指父RDD的每个分区只被子RDD的一个分区所使用,子RDD分区通常对应...

    Spark中RDD的高效与DAG图有着莫大的关系,在DAG调度中需要对计算过程划分stage,而划分依据就是RDD之间的依赖关系。针对不同的转换函数,RDD之间的依赖关系分类窄依赖(narrow dependency)和宽依赖(wide dependency, 也称 shuffle dependency).

    宽依赖与窄依赖

    窄依赖是指父RDD的每个分区只被子RDD的一个分区所使用,子RDD分区通常对应常数个父RDD分区(O(1),与数据规模无关)

    相应的,宽依赖是指父RDD的每个分区都可能被多个子RDD分区所使用,子RDD分区通常对应所有的父RDD分区(O(n),与数据规模有关)

    宽依赖和窄依赖如下图所示:

    e486d65548edbaa0a291376746edaec0.png

    相比于宽依赖,窄依赖对优化很有利 ,主要基于以下两点:

    宽依赖往往对应着shuffle操作,需要在运行过程中将同一个父RDD的分区传入到不同的子RDD分区中,中间可能涉及多个节点之间的数据传输;而窄依赖的每个父RDD的分区只会传入到一个子RDD分区中,通常可以在一个节点内完成转换。

    当RDD分区丢失时(某个节点故障),spark会对数据进行重算。

    对于窄依赖,由于父RDD的一个分区只对应一个子RDD分区,这样只需要重算和子RDD分区对应的父RDD分区即可,所以这个重算对数据的利用率是100%的;

    对于宽依赖,重算的父RDD分区对应多个子RDD分区,这样实际上父RDD 中只有一部分的数据是被用于恢复这个丢失的子RDD分区的,另一部分对应子RDD的其它未丢失分区,这就造成了多余的计算;更一般的,宽依赖中子RDD分区通常来自多个父RDD分区,极端情况下,所有的父RDD分区都要进行重新计算。

    如下图所示,b1分区丢失,则需要重新计算a1,a2和a3,这就产生了冗余计算(a1,a2,a3中对应b2的数据)。

    0e2828f651eef1fcec69a158049139fd.png

    以下是文章 RDD:基于内存的集群计算容错抽象 中对宽依赖和窄依赖的对比。

    区分这两种依赖很有用。首先,窄依赖允许在一个集群节点上以流水线的方式(pipeline)计算所有父分区。例如,逐个元素地执行map、然后filter操作;而宽依赖则需要首先计算好所有父分区数据,然后在节点之间进行Shuffle,这与MapReduce类似。第二,窄依赖能够更有效地进行失效节点的恢复,即只需重新计算丢失RDD分区的父分区,而且不同节点之间可以并行计算;而对于一个宽依赖关系的Lineage图,单个节点失效可能导致这个RDD的所有祖先丢失部分分区,因而需要整体重新计算。

    【误解】之前一直理解错了,以为窄依赖中每个子RDD可能对应多个父RDD,当子RDD丢失时会导致多个父RDD进行重新计算,所以窄依赖不如宽依赖有优势。而实际上应该深入到分区级别去看待这个问题,而且重算的效用也不在于算的多少,而在于有多少是冗余的计算。窄依赖中需要重算的都是必须的,所以重算不冗余。

    窄依赖的函数有:map, filter, union, join(父RDD是hash-partitioned ), mapPartitions, mapValues

    宽依赖的函数有:groupByKey, join(父RDD不是hash-partitioned ), partitionBy

    参考:

    RDD:基于内存的集群计算容错抽象

    Spark技术内幕:Stage划分及提交源码分析

    Spark分布式计算和RDD模型研究

    SPARK 阔依赖 和窄依赖 transfer action lazy策略之间的关系

    展开全文
  • 宽依赖和窄依赖

    2019-03-19 15:43:49
    宽依赖与窄依赖 窄依赖是指父RDD的每个分区只被子RDD的一个分区所使用,子RDD分区通常对应常数个父RDD分区(O(1),与数据规模无关) 相应的,宽依赖是指父RDD的每个分区都可能被多个子RDD分区所使用,子RDD分区通常...
  • Spark宽依赖和窄依赖

    2020-03-26 16:48:45
    Spark宽依赖和窄依赖
  • spark宽依赖以及窄依赖
  • 窄依赖和宽依赖

    2019-01-08 09:21:34
    RDD之间有一系列的依赖关系,依赖关系又分为窄依赖和宽依赖。 窄依赖 父RDD和子RDD partition之间的关系是一对一的。或者父RDD一个partition只对应一个子RDD的partition情况下的父RDD和子RDD partition关系是多对一...
  • Spark RDD 宽依赖&窄依赖1.窄依赖2.宽依赖:3.阶段的划分4.宽依赖和窄依赖的作用: 1.窄依赖 每一个父RDD的Partition最多被子RDD的一个Partition使用 (一对一的关系) 常见算子:map flatmap filter union sample...
  • RDD和它依赖的父RDD(s)的关系有两种不同的类型,即窄依赖(narrow dependency)和宽依赖(wide dependency)。 窄依赖: 窄依赖指的是每一个父RDD的Partition最多被子RDD的一个Partition使用 总结:窄依赖我们...
  • RDD和它依赖的父RDD(s)的关系有两种不同的类型,即窄依赖(narrow dependency)和宽依赖(wide dependency)。如图所示显示了RDD之间的依赖关系???? 窄依赖:是指每个父RDD的每个Partition都只被子RDD的一个...
  • 宽依赖和窄依赖 什么是依赖关系 当前的RDD和它的上级的RDD之间的一个描述. 一个应用下面有job,job下面有阶段,阶段怎么划分的,就是通过依赖关系划分的. 窄依赖 窄依赖表示每一个父RDD的Partition最多被子RDD的一个...
  • RDD算子操作会使得RDD分区之间产生不同依赖,主要有两种依赖:宽依赖和窄依赖。 宽依赖:是指一个父RDD的各个分区被一个子RDD的各个分区多次依赖, 窄依赖:是指一个父RDD的各个分区被一个子RDD的各个分区一次依赖,...
  • RDD 宽依赖与窄依赖

    2019-08-14 18:39:02
    RDD依赖关系与stage划分 ...针对不同的转换函数,RDD之间的依赖关系分为窄依赖(narrow dependency)和宽依赖(wide dependency,也成shuffle dependency)。 1.1 窄依赖 窄依赖是指1个父RDD分区...
  • spark窄依赖和宽依赖

    2018-06-09 18:46:02
    spark窄依赖和宽依赖
  • 宽依赖与窄依赖区别

    2021-02-23 10:22:08
    依赖 窄依赖是指父RDD的每个分区只被子RDD的一个分区所使用。换句话说,一个父RDD的分区对应于一...宽依赖是指父RDD的每个分区都可能被多个子RDD分区所使用,子RDD分区通常对应所有的父RDD分区(O(n),与数据规模有关)
  • RDD的宽依赖和窄依赖

    2019-11-30 15:09:47
    1、RDD的宽依赖和窄依赖的区别 是否有shuffle操作,也叫洗牌操作 窄依赖: 一对一 或者 多对一 宽依赖: 一对多 窄依赖可以进行流水线优化,宽依赖不可以 优化:fork/join 机制 一个作业可以划分成多个阶段 ...
  • Spark中RDD是相互依赖的,依赖关系分宽依赖和窄依赖
  • 宽依赖和窄依赖的区别 参考: https://blog.csdn.net/u013384984/article/details/80963455 总结一下: 窄依赖:父RDD中,每个分区内的数据,都只会被子RDD中特定的分区所消费,为窄依赖: **宽依赖:**父RDD中,...
  • Spark RDD宽依赖 窄依赖

    2019-08-15 20:48:02
    宽依赖宽依赖往往对应着shuffle操作,需要在运行过程中将同一个父RDD的分区传入到不同的子RDD分区中,中间可能涉及多个节点之间的数据传输。 窄依赖: 而窄依赖的每个父RDD的分区只会传入到一个子RDD分区中...
  • Spark宽依赖与窄依赖

    2020-12-01 00:30:16
    RDD之间的依赖关系分为两种,宽依赖(wide dependency/shuffle dependency)和窄依赖(narrow dependency) 1.窄依赖 窄依赖就是指父RDD的每个分区只被一个子RDD分区使用,子RDD分区通常只对应常数个父RDD分区,如下...
  • 宽依赖与窄依赖

    2018-06-09 21:18:09
    1、宽依赖英文全名:ShuffleDependency。本质如其名,就是Shuffle。每一个父RDD的partition中的数据,都可能会传输一部分,到下一个RDD的partition中,此时会出现,父RDD和子RDD的partition之间,具有交错复杂的关系...
  • 宽依赖:父RDD的分区被子RDD的多个分区使用 例如 groupByKey、reduceByKey、sortByKey等操作会产生宽依赖,会产生shuffle 窄依赖:父RDD的每个分区都只被子RDD的一个分区使用 例如map、filter、union等操作会产生...
  • spark的宽依赖和窄依赖 spark 划分stage取决于rdd之间的依赖,rdd之间的依赖分为宽依赖和窄依赖 窄依赖是指 父rdd的一个分区指被子rdd的一个分区使用,参考下图,父rdd只会被一个子rdd使用 宽依赖父rdd的每一个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,390
精华内容 556
关键字:

宽依赖