[size=x-large][b]摘要[/b][/size]
本文提出了分布式内存抽象的概念——[color=red][b]弹性分布式数据集[/b][/color](RDD,Resilient Distributed Datasets),它具备像MapReduce等数据流模型的容错特性,并且允许开发人员在大型集群上执行基于内存的计算。现有的数据流系统对两种应用的处理并不高效:一是迭代式算法,这在图应用和机器学习领域很常见;二是交互式数据挖掘工具。这两种情况下,将数据保存在内存中能够极大地提高性能。[color=blue][b]为了有效地实现容错,RDD提供了一种高度受限的共享内存,即RDD是只读的,并且只能通过其他RDD上的批量操作来创建。[/b][/color]尽管如此,RDD仍然足以表示很多类型的计算,包括MapReduce和专用的迭代编程模型(如Pregel)等。我们实现的RDD在迭代计算方面比Hadoop快20多倍,同时还可以在5-7秒内交互式地查询1TB数据集。
Spark中最核心的概念为RDD(Resilient Distributed DataSets)中文为:弹性分布式数据集,RDD为对分布式内存对象的 抽象它表示一个被分区不可变且能并行操作的数据集;RDD为可序列化的、可缓存到内存对RDD进行操作过后还可以存到内存中,下次操作直接把内存中RDD作为输入,避免了Hadoop MapReduce的大IO操作;
[color=red][b]RDD生成[/b][/color]
Spark所要处理的任何数据都是存储在RDD之中,目前两种方式可以生成一个RDD:
1、从RDD进行转换操作
2、使用外部存储系统创建,如:HDFS;
[color=red][b]RDD操作[/b][/color]
RDD支持两种操作:
转换(transformation operation)
转换操作将一个RDD经过操作后返回一个全新的RDD,转换操是lazy(惰性)的[color=blue][b]这期间不会产生任何数据的计算;[/b][/color]
转换函数有:distinct、filter、map、flatMap、union、groupByKey等;
行动(action operation)
每一个行动操作都会触发Spark Job进行计算并返回最终的结果,行动操作有这么几类:返回标量,count返回元素的个数;返回Scala集合,task(n)返回0到n-1组成的集合;写入外部存储,saveAsHadoopFile(path)存储到HDFS;
行动函数有:count、top、task、saveAsHadoopFile等;
RDD为不可变的数据集,可以使用转换操作“修改”一个RDD,但这操作过后返回的是一个全新的RDD 原本RDD并没有改变;
[color=red][b]Lineage[/b][/color]
Spark RDD只支持粗粒度的操作,对一个RDD的操作都会被作用于该RDD的所有数据;为了保证RDD的高可用性RDD通过使用Lineage(血统)记录了RDD演变流程(从其他RDD到当前RDD所做的操作)[size=medium][color=blue][b] 当RDD分区数据丢失时可以通过Lineage的信息重新计算与恢复分区数据,或进行RDD的重建;[/b][/color][/size]
[color=red][b]RDD的依赖关系(dependencies):[/b][/color]
由于对RDD的操作都是粗粒度的一个转换操作过后都会产生一个新的RDD,RDD之间会形成一个前后依赖关系;Spark中存在两种依赖:窄依赖(Narrow Dependencies)、宽依赖(Wide Dependencies);
[b]窄依赖(Narrow Dependencies):[/b]一个父RDD的分区只能被一个子RDD的一个分区使用;
[b]宽依赖(Wide Dependencies):[/b]多个子RDD的分区依赖于一个父RDD的同一个分区;
窄依赖的节点(RDD)关系如果流水一般,所以当节点失败后只需重新计算父节点的分区即可,宽依赖需要重新计算父节点的多个分区代价是非常昂贵的;
[color=red][size=large][b]1.引言[/b][/size][/color]
无论是工业界还是学术界,都已经广泛使用高级集群编程模型来处理日益增长的数据,如MapReduce和Dryad。[size=medium][color=red][b]这些系统将分布式编程简化为自动提供位置感知性调度、容错以及负载均衡,使得大量用户能够在商用集群上分析超大数据集。[/b][/color][/size]
大多数现有的集群计算系统都是基于非循环的数据流模型。从稳定的物理存储(如分布式文件系统)中加载记录,记录被传入由一组确定性操作构成的DAG,然后写回稳定存储。DAG数据流图能够在运行时自动实现任务调度和故障恢复。
尽管非循环数据流是一种很强大的抽象方法,但仍然有些应用无法使用这种方式描述。我们就是针对这些不太适合非循环模型的应用,[color=red][b]它们的特点是在多个并行操作之间重用工作数据集。[/b][/color]这类应用包括:(1)机器学习和图应用中常用的迭代算法(每一步对数据执行相似的函数);(2)交互式数据挖掘工具(用户反复查询一个数据子集)。基于数据流的框架并不明确支持工作集,所以需要将数据输出到磁盘,然后在每次查询时重新加载,这带来较大的开销。
[size=medium][color=blue][b]我们提出了一种分布式的内存抽象,称为弹性分布式数据集(RDD,Resilient Distributed Datasets)。[/b][/color][/size]它支持基于工作集的应用,同时具有数据流模型的特点:自动容错、位置感知调度和可伸缩性。[size=medium][color=red][b]RDD允许用户在执行多个查询时显式地将工作集缓存在内存中,后续的查询能够重用工作集,这极大地提升了查询速度。[/b][/color][/size]
[color=red][b]RDD提供了一种高度受限的共享内存模型,即RDD是只读的记录分区的集合,只能通过在其他RDD执行确定的转换操作(如map、join和group by)而创建,然而这些限制使得实现容错的开销很低。[/b][/color]与分布式共享内存系统需要付出高昂代价的检查点和回滚机制不同,RDD通过Lineage来重建丢失的分区:[size=medium][color=blue][b]一个RDD中包含了如何从其他RDD衍生所必需的相关信息,从而不需要检查点操作就可以重构丢失的数据分区。[/b][/color][/size]尽管RDD不是一个通用的共享内存抽象,但却具备了良好的描述能力、可伸缩性和可靠性,但却能够广泛适用于数据并行类应用。
第一个指出非循环数据流存在不足的并非是我们,例如,Google的Pregel[21],是一种专门用于迭代式图算法的编程模型;Twister[13]和HaLoop[8],是两种典型的迭代式MapReduce模型。但是,对于一些特定类型的应用,这些系统提供了一个受限的通信模型。相比之下,RDD则为基于工作集的应用提供了更为通用的抽象,用户可以对中间结果进行显式的命名和物化,控制其分区,还能执行用户选择的特定操作(而不是在运行时去循环执行一系列MapReduce步骤)。[color=blue][b]RDD可以用来描述Pregel、迭代式MapReduce,以及这两种模型无法描述的其他应用,如交互式数据挖掘工具(用户将数据集装入内存,然后执行ad-hoc查询)。[/b][/color]
Spark是我们实现的RDD系统,在我们内部能够被用于开发多种并行应用。[size=medium][color=red][b]Spark采用Scala语言[5]实现,提供类似于DryadLINQ的集成语言编程接口[34],使用户可以非常容易地编写并行任务。[/b][/color][/size]此外,随着Scala新版本解释器的完善,Spark还能够用于交互式查询大数据集。我们相信Spark会是第一个能够使用有效、通用编程语言,并在集群上对大数据集进行交互式分析的系统。
我们通过微基准和用户应用程序来评估RDD。实验表明,在处理迭代式应用上Spark比Hadoop快高达20多倍,计算数据分析类报表的性能提高了40多倍,[size=large][color=red][b]同时能够在5-7秒的延时内交互式扫描1TB数据集。[/b][/color][/size]此外,我们还在Spark之上实现了Pregel和HaLoop编程模型(包括其位置优化策略),以库的形式实现(分别使用了100和200行Scala代码)。最后,利用RDD内在的确定性特性,我们还创建了一种Spark调试工具rddbg,允许用户在任务期间利用Lineage重建RDD,然后像传统调试器那样重新执行任务。
本文首先在第2部分介绍了RDD的概念,然后第3部分描述Spark API,第4部分解释如何使用RDD表示几种并行应用(包括Pregel和HaLoop),第5部分讨论Spark中RDD的表示方法以及任务调度器,第6部分描述具体实现和rddbg,第7部分对RDD进行评估,第8部分给出了相关研究工作,最后第9部分总结。
[color=red][size=x-large][b]2.弹性分布式数据集(RDD)[/b][/size][/color]
本部分描述RDD和编程模型。首先讨论设计目标(2.1),然后定义RDD(2.2),讨论Spark的编程模型(2.3),并给出一个示例(2.4),最后对比RDD与分布式共享内存(2.5)。
[size=large][b]2.1 目标和概述[/b][/size]
我们的目标是为基于工作集的应用([color=red][b]即多个并行操作重用中间结果的这类应用[/b][/color])提供抽象,同时保持MapReduce及其相关模型的优势特性:即自动容错、位置感知性调度和可伸缩性。RDD比数据流模型更易于编程,同时基于工作集的计算也具有良好的描述能力。
在这些特性中,最难实现的是容错性。一般来说,分布式数据集的容错性有两种方式:即数据检查点和记录数据的更新。我们面向的是大规模数据分析,数据检查点操作成本很高:需要通过数据中心的网络连接在机器之间复制庞大的数据集,而网络带宽往往比内存带宽低得多,同时还需要消耗更多的存储资源(在内存中复制数据可以减少需要缓存的数据量,而存储到磁盘则会拖慢应用程序)。所以,我们选择记录更新的方式。但是,如果更新太多,那么记录更新成本也不低。[size=medium][color=red][b]因此,RDD只支持粗粒度转换,即在大量记录上执行的单个操作。[/b][/color][/size]将创建RDD的一系列转换记录下来(即Lineage),以便恢复丢失的分区。
虽然只支持粗粒度转换限制了编程模型,但我们发现RDD仍然可以很好地适用于很多应用,特别是支持数据并行的批量分析应用,包括数据挖掘、机器学习、图算法等,[size=medium][color=blue][b]因为这些程序通常都会在很多记录上执行相同的操作。[/b][/color][/size]RDD不太适合那些异步更新共享状态的应用,例如并行web爬行器。因此,我们的目标是为大多数分析型应用提供有效的编程模型,而其他类型的应用交给专门的系统。
[size=large][b]2.2 RDD抽象[/b][/size]
[size=medium][color=red][b]RDD是只读的、分区记录的集合。RDD只能基于在稳定物理存储中的数据集和其他已有的RDD上执行确定性操作来创建。[/b][/color][/size][b]这些确定性操作称之为转换,如map、filter、groupBy、join(转换不是程开发人员在RDD上执行的操作)。[/b]
[b]RDD不需要物化。RDD含有如何从其他RDD衍生(即计算)出本RDD的相关信息(即Lineage),据此可以从物理存储的数据计算出相应的RDD分区。[/b]
[size=large][b]2.3 编程模型[/b][/size]
在Spark中,RDD被表示为对象,通过这些对象上的方法(或函数)调用转换。
定义RDD之后,程序员就可以在动作中使用RDD了。[color=red][b]动作是向应用程序返回值,或向存储系统导出数据的那些操作,例如,count(返回RDD中的元素个数),collect(返回元素本身),save(将RDD输出到存储系统)。[/b][/color]在Spark中,只有在动作第一次使用RDD时,才会计算RDD(即延迟计算)。这样在构建RDD的时候,运行时通过管道的方式传输多个转换。
[color=red][b]程序员还可以从两个方面控制RDD,即缓存和分区。用户可以请求将RDD缓存,这样运行时将已经计算好的RDD分区存储起来,以加速后期的重用。[/b][/color]缓存的RDD一般存储在内存中,但如果内存不够,可以写到磁盘上。
另一方面,RDD还允许用户根据关键字(key)指定分区顺序,这是一个可选的功能。目前支持哈希分区和范围分区。例如,应用程序请求将两个RDD按照同样的哈希分区方式进行分区(将同一机器上具有相同关键字的记录放在一个分区),以加速它们之间的join操作。在Pregel和HaLoop中,多次迭代之间采用一致性的分区置换策略进行优化,我们同样也允许用户指定这种优化。
[size=large][b]2.4 示例:控制台日志挖掘[/b][/size]
本部分我们通过一个具体示例来阐述RDD。假定有一个大型网站出错,操作员想要检查Hadoop文件系统(HDFS)中的日志文件(TB级大小)来找出原因。[color=red][b]通过使用Spark,操作员只需将日志中的错误信息装载到一组节点的内存中,然后执行交互式查询。[/b][/color]首先,需要在Spark解释器中输入如下Scala命令:
第1行从HDFS文件定义了一个RDD(即一个文本行集合),第2行获得一个过滤后的RDD,第3行请求将errors缓存起来。[color=red][b]注意在Scala语法中filter的参数是一个闭包。[/b][/color]
这时集群还没有开始执行任何任务。但是,用户已经可以在这个RDD上执行对应的动作,例如统计错误消息的数目:
用户还可以在RDD上执行更多的转换操作,并使用转换结果,如:
[b]使用errors的第一个action运行以后,[/b][color=red][b]Spark会把errors的分区缓存在内存中,极大地加快了后续计算速度。[/b][/color]注意,最初的RDD lines不会被缓存。[b]因为错误信息可能只占原数据集的很小一部分(小到足以放入内存)。[/b]
最后,为了说明模型的容错性,图1给出了第3个查询的Lineage图。在lines RDD上执行filter操作,得到errors,然后再filter、map后得到新的RDD,在这个RDD上执行collect操作。Spark调度器以流水线的方式执行后两个转换,向拥有errors分区缓存的节点发送一组任务。此外,如果某个errors分区丢失,Spark只在相应的lines分区上执行filter操作来重建该errors分区。
[img]http://dl2.iteye.com/upload/attachment/0124/2904/b922b555-0ea1-382b-b5e7-9b548682c26f.png[/img]
图1 示例中第三个查询的Lineage图。(方框表示RDD,箭头表示转换)
[size=x-large][b]2.5 RDD与分布式共享内存[/b][/size]
[b]为了进一步理解RDD是一种分布式的内存抽象,表1列出了RDD与分布式共享内存(DSM,Distributed Shared Memory)[24]的对比。[/b]在DSM系统中,应用可以向全局地址空间的任意位置进行读写操作。(注意这里的DSM,不仅指传统的共享内存系统,还包括那些通过分布式哈希表或分布式文件系统进行数据共享的系统,比如Piccolo[28])[color=red][b]DSM是一种通用的抽象,但这种通用性同时也使得在商用集群上实现有效的容错性更加困难。[/b][/color]
[b]RDD与DSM主要区别在于,不仅可以通过批量转换创建(即“写”)RDD,还可以对任意内存位置读写。[/b]也就是说,[size=medium][color=blue][b]RDD限制应用执行批量写操作,这样有利于实现有效的容错。[/b][/color][/size]特别地,[b]RDD没有检查点开销,因为可以使用Lineage来恢复RDD。[/b]而且,[size=medium][color=red][b]失效时只需要重新计算丢失的那些RDD分区,可以在不同节点上并行执行,而不需要回滚整个程序。[/b][/color][/size]
[img]http://dl2.iteye.com/upload/attachment/0124/2906/c69250c7-79d5-3b00-b697-f9a009c25e11.png[/img]
注意,通过备份任务的拷贝,RDD还可以处理落后任务(即运行很慢的节点),这点与MapReduce[12]类似。[color=red][b]而DSM则难以实现备份任务,因为任务及其副本都需要读写同一个内存位置。[/b][/color]
与DSM相比,RDD模型有两个好处。
[color=blue][b]第一,对于RDD中的批量操作,运行时将根据数据存放的位置来调度任务,从而提高性能。[/b][/color]
[color=red][b]第二,对于基于扫描的操作,如果内存不足以缓存整个RDD,就进行部分缓存。[/b][/color]把内存放不下的分区存储到磁盘上,此时性能与现有的数据流系统差不多。
最后看一下读操作的粒度。[size=medium][color=blue][b]RDD上的很多动作(如count和collect)都是批量读操作,即扫描整个数据集,可以将任务分配到距离数据最近的节点上。[/b][/color][/size]同时,RDD也支持细粒度操作,即在哈希或范围分区的RDD上执行关键字查找。
[size=x-large][color=red][b]3. Spark编程接口[/b][/color][/size]
Spark用Scala[5]语言实现了RDD的API。[color=blue][b]Scala是一种基于JVM的静态类型、函数式、面向对象的语言。[/b][/color]我们选择Scala是因为它简洁(特别适合交互式使用)、有效(因为是静态类型)。但是,RDD抽象并不局限于函数式语言,也可以使用其他语言来实现RDD,比如像Hadoop[2]那样用类表示用户函数。
[color=red][b]要使用Spark,开发者需要编写一个driver程序,连接到集群以运行Worker,[/b][/color]如图2所示。Driver定义了一个或多个RDD,并调用RDD上的动作。[color=blue][b]Worker是长时间运行的进程,将RDD分区以Java对象的形式缓存在内存中。[/b][/color]
[img]http://dl2.iteye.com/upload/attachment/0124/3151/d11b4b4a-80f3-3511-bade-b665e3add753.png[/img]
图2 Spark的运行时。[size=medium][color=red][b]用户的driver程序启动多个worker,worker从分布式文件系统中读取数据块,并将计算后的RDD分区缓存在内存中。[/b][/color][/size]
再看看2.4中的例子,[color=red][b]用户执行RDD操作时会提供参数,比如map传递一个闭包(closure,函数式编程中的概念)。[/b][/color]Scala将闭包表示为Java对象,如果传递的参数是闭包,则这些对象被序列化,通过网络传输到其他节点上进行装载。[color=blue][b]Scala将闭包内的变量保存为Java对象的字段。例如,var x = 5; rdd.map(_ + x) 这段代码将RDD中的每个元素加5。[/b][/color]总的来说,Spark的语言集成类似于DryadLINQ。
RDD本身是静态类型对象,由参数指定其元素类型。例如,RDD[int]是一个整型RDD。不过,我们举的例子几乎都省略了这个类型参数,因为Scala支持类型推断。
虽然在概念上使用Scala实现RDD很简单,但还是要处理一些Scala闭包对象的反射问题。如何通过Scala解释器来使用Spark还需要更多工作,这点我们将在第6部分讨论。不管怎样,我们都不需要修改Scala编译器。
[color=red][size=large][b]3.1 Spark中的RDD操作[/b][/size][/color]
表2列出了Spark中的RDD转换和动作。[size=large][color=blue][b]每个操作都给出了标识,其中方括号表示类型参数。前面说过转换是延迟操作,用于定义新的RDD;而动作启动计算操作,并向用户程序返回值或向外部存储写数据。[/b][/color][/size]
[img]http://dl2.iteye.com/upload/attachment/0124/3159/5574bea4-8cb0-3467-b36b-08422630bc55.jpg[/img]
[size=medium][color=red][b]注意,有些操作只对键值对可用,比如join。[/b][/color][/size]另外,[color=blue][b]函数名与Scala及其他函数式语言中的API匹配,例如map是一对一的映射,而flatMap是将每个输入映射为一个或多个输出(与MapReduce中的map类似)。[/b][/color]
除了这些操作以外,用户还可以请求将RDD缓存起来。而且,用户还可以通过Partitioner类获取RDD的分区顺序,然后将另一个RDD按照同样的方式分区。有些操作会自动产生一个哈希或范围分区的RDD,像groupByKey,reduceByKey和sort等。
[size=x-large][color=red][b]4. 应用程序示例[/b][/color][/size]
现在我们讲述如何使用RDD表示几种基于数据并行的应用。首先讨论一些迭代式机器学习应用(4.1),然后看看如何使用RDD描述几种已有的集群编程模型,即MapReduce(4.2),Pregel(4.3),和Hadoop(4.4)。最后讨论一下RDD不适合哪些应用(4.5)。
[size=large][b]4.1 迭代式机器学习[/b][/size]
很多机器学习算法都具有迭代特性,运行迭代优化方法来优化某个目标函数,例如梯度下降方法。[color=red][b]如果这些算法的工作集能够放入内存,将极大地加速程序运行。[/b][/color]而且,这些算法通常采用批量操作,例如映射和求和,这样更容易使用RDD来表示。
例如下面的程序是逻辑回归[15]的实现。逻辑回归是一种常见的分类算法,即寻找一个最佳分割两组点(即垃圾邮件和非垃圾邮件)的超平面w。算法采用梯度下降的方法:开始时w为随机值,在每一次迭代的过程中,对w的函数求和,然后朝着优化的方向移动w。
首先定义一个名为points的缓存RDD,这是在文本文件上执行map转换之后得到的,即将每个文本行解析为一个Point对象。然后在points上反复执行map和reduce操作,每次迭代时通过对当前w的函数进行求和来计算梯度。7.1小节我们将看到这种在内存中缓存points的方式,比每次迭代都从磁盘文件装载数据并进行解析要快得多。
已经在Spark中实现的迭代式机器学习算法还有:kmeans(像逻辑回归一样每次迭代时执行一对map和reduce操作),期望最大化算法(EM,两个不同的map/reduce步骤交替执行),交替最小二乘矩阵分解和协同过滤算法。Chu等人提出迭代式MapReduce也可以用来实现常用的学习算法[11]。
[size=large][b]4.2 使用RDD实现MapReduce[/b][/size]
MapReduce模型[12]很容易使用RDD进行描述。假设有一个输入数据集(其元素类型为T),和两个函数myMap: T => List[(Ki, Vi)] 和 myReduce: (Ki; List[Vi]) ) List[R],代码如下:
如果任务包含combiner,则相应的代码为:
[color=red][b]ReduceByKey操作在mapper节点上执行部分聚集,与MapReduce的combiner类似。[/b][/color]
转自:[url]http://shiyanjun.cn/archives/744.html[/url]
本文提出了分布式内存抽象的概念——[color=red][b]弹性分布式数据集[/b][/color](RDD,Resilient Distributed Datasets),它具备像MapReduce等数据流模型的容错特性,并且允许开发人员在大型集群上执行基于内存的计算。现有的数据流系统对两种应用的处理并不高效:一是迭代式算法,这在图应用和机器学习领域很常见;二是交互式数据挖掘工具。这两种情况下,将数据保存在内存中能够极大地提高性能。[color=blue][b]为了有效地实现容错,RDD提供了一种高度受限的共享内存,即RDD是只读的,并且只能通过其他RDD上的批量操作来创建。[/b][/color]尽管如此,RDD仍然足以表示很多类型的计算,包括MapReduce和专用的迭代编程模型(如Pregel)等。我们实现的RDD在迭代计算方面比Hadoop快20多倍,同时还可以在5-7秒内交互式地查询1TB数据集。
Spark中最核心的概念为RDD(Resilient Distributed DataSets)中文为:弹性分布式数据集,RDD为对分布式内存对象的 抽象它表示一个被分区不可变且能并行操作的数据集;RDD为可序列化的、可缓存到内存对RDD进行操作过后还可以存到内存中,下次操作直接把内存中RDD作为输入,避免了Hadoop MapReduce的大IO操作;
[color=red][b]RDD生成[/b][/color]
Spark所要处理的任何数据都是存储在RDD之中,目前两种方式可以生成一个RDD:
1、从RDD进行转换操作
2、使用外部存储系统创建,如:HDFS;
[color=red][b]RDD操作[/b][/color]
RDD支持两种操作:
转换(transformation operation)
转换操作将一个RDD经过操作后返回一个全新的RDD,转换操是lazy(惰性)的[color=blue][b]这期间不会产生任何数据的计算;[/b][/color]
转换函数有:distinct、filter、map、flatMap、union、groupByKey等;
行动(action operation)
每一个行动操作都会触发Spark Job进行计算并返回最终的结果,行动操作有这么几类:返回标量,count返回元素的个数;返回Scala集合,task(n)返回0到n-1组成的集合;写入外部存储,saveAsHadoopFile(path)存储到HDFS;
行动函数有:count、top、task、saveAsHadoopFile等;
RDD为不可变的数据集,可以使用转换操作“修改”一个RDD,但这操作过后返回的是一个全新的RDD 原本RDD并没有改变;
[color=red][b]Lineage[/b][/color]
Spark RDD只支持粗粒度的操作,对一个RDD的操作都会被作用于该RDD的所有数据;为了保证RDD的高可用性RDD通过使用Lineage(血统)记录了RDD演变流程(从其他RDD到当前RDD所做的操作)[size=medium][color=blue][b] 当RDD分区数据丢失时可以通过Lineage的信息重新计算与恢复分区数据,或进行RDD的重建;[/b][/color][/size]
[color=red][b]RDD的依赖关系(dependencies):[/b][/color]
由于对RDD的操作都是粗粒度的一个转换操作过后都会产生一个新的RDD,RDD之间会形成一个前后依赖关系;Spark中存在两种依赖:窄依赖(Narrow Dependencies)、宽依赖(Wide Dependencies);
[b]窄依赖(Narrow Dependencies):[/b]一个父RDD的分区只能被一个子RDD的一个分区使用;
[b]宽依赖(Wide Dependencies):[/b]多个子RDD的分区依赖于一个父RDD的同一个分区;
窄依赖的节点(RDD)关系如果流水一般,所以当节点失败后只需重新计算父节点的分区即可,宽依赖需要重新计算父节点的多个分区代价是非常昂贵的;
[color=red][size=large][b]1.引言[/b][/size][/color]
无论是工业界还是学术界,都已经广泛使用高级集群编程模型来处理日益增长的数据,如MapReduce和Dryad。[size=medium][color=red][b]这些系统将分布式编程简化为自动提供位置感知性调度、容错以及负载均衡,使得大量用户能够在商用集群上分析超大数据集。[/b][/color][/size]
大多数现有的集群计算系统都是基于非循环的数据流模型。从稳定的物理存储(如分布式文件系统)中加载记录,记录被传入由一组确定性操作构成的DAG,然后写回稳定存储。DAG数据流图能够在运行时自动实现任务调度和故障恢复。
尽管非循环数据流是一种很强大的抽象方法,但仍然有些应用无法使用这种方式描述。我们就是针对这些不太适合非循环模型的应用,[color=red][b]它们的特点是在多个并行操作之间重用工作数据集。[/b][/color]这类应用包括:(1)机器学习和图应用中常用的迭代算法(每一步对数据执行相似的函数);(2)交互式数据挖掘工具(用户反复查询一个数据子集)。基于数据流的框架并不明确支持工作集,所以需要将数据输出到磁盘,然后在每次查询时重新加载,这带来较大的开销。
[size=medium][color=blue][b]我们提出了一种分布式的内存抽象,称为弹性分布式数据集(RDD,Resilient Distributed Datasets)。[/b][/color][/size]它支持基于工作集的应用,同时具有数据流模型的特点:自动容错、位置感知调度和可伸缩性。[size=medium][color=red][b]RDD允许用户在执行多个查询时显式地将工作集缓存在内存中,后续的查询能够重用工作集,这极大地提升了查询速度。[/b][/color][/size]
[color=red][b]RDD提供了一种高度受限的共享内存模型,即RDD是只读的记录分区的集合,只能通过在其他RDD执行确定的转换操作(如map、join和group by)而创建,然而这些限制使得实现容错的开销很低。[/b][/color]与分布式共享内存系统需要付出高昂代价的检查点和回滚机制不同,RDD通过Lineage来重建丢失的分区:[size=medium][color=blue][b]一个RDD中包含了如何从其他RDD衍生所必需的相关信息,从而不需要检查点操作就可以重构丢失的数据分区。[/b][/color][/size]尽管RDD不是一个通用的共享内存抽象,但却具备了良好的描述能力、可伸缩性和可靠性,但却能够广泛适用于数据并行类应用。
第一个指出非循环数据流存在不足的并非是我们,例如,Google的Pregel[21],是一种专门用于迭代式图算法的编程模型;Twister[13]和HaLoop[8],是两种典型的迭代式MapReduce模型。但是,对于一些特定类型的应用,这些系统提供了一个受限的通信模型。相比之下,RDD则为基于工作集的应用提供了更为通用的抽象,用户可以对中间结果进行显式的命名和物化,控制其分区,还能执行用户选择的特定操作(而不是在运行时去循环执行一系列MapReduce步骤)。[color=blue][b]RDD可以用来描述Pregel、迭代式MapReduce,以及这两种模型无法描述的其他应用,如交互式数据挖掘工具(用户将数据集装入内存,然后执行ad-hoc查询)。[/b][/color]
Spark是我们实现的RDD系统,在我们内部能够被用于开发多种并行应用。[size=medium][color=red][b]Spark采用Scala语言[5]实现,提供类似于DryadLINQ的集成语言编程接口[34],使用户可以非常容易地编写并行任务。[/b][/color][/size]此外,随着Scala新版本解释器的完善,Spark还能够用于交互式查询大数据集。我们相信Spark会是第一个能够使用有效、通用编程语言,并在集群上对大数据集进行交互式分析的系统。
我们通过微基准和用户应用程序来评估RDD。实验表明,在处理迭代式应用上Spark比Hadoop快高达20多倍,计算数据分析类报表的性能提高了40多倍,[size=large][color=red][b]同时能够在5-7秒的延时内交互式扫描1TB数据集。[/b][/color][/size]此外,我们还在Spark之上实现了Pregel和HaLoop编程模型(包括其位置优化策略),以库的形式实现(分别使用了100和200行Scala代码)。最后,利用RDD内在的确定性特性,我们还创建了一种Spark调试工具rddbg,允许用户在任务期间利用Lineage重建RDD,然后像传统调试器那样重新执行任务。
本文首先在第2部分介绍了RDD的概念,然后第3部分描述Spark API,第4部分解释如何使用RDD表示几种并行应用(包括Pregel和HaLoop),第5部分讨论Spark中RDD的表示方法以及任务调度器,第6部分描述具体实现和rddbg,第7部分对RDD进行评估,第8部分给出了相关研究工作,最后第9部分总结。
[color=red][size=x-large][b]2.弹性分布式数据集(RDD)[/b][/size][/color]
本部分描述RDD和编程模型。首先讨论设计目标(2.1),然后定义RDD(2.2),讨论Spark的编程模型(2.3),并给出一个示例(2.4),最后对比RDD与分布式共享内存(2.5)。
[size=large][b]2.1 目标和概述[/b][/size]
我们的目标是为基于工作集的应用([color=red][b]即多个并行操作重用中间结果的这类应用[/b][/color])提供抽象,同时保持MapReduce及其相关模型的优势特性:即自动容错、位置感知性调度和可伸缩性。RDD比数据流模型更易于编程,同时基于工作集的计算也具有良好的描述能力。
在这些特性中,最难实现的是容错性。一般来说,分布式数据集的容错性有两种方式:即数据检查点和记录数据的更新。我们面向的是大规模数据分析,数据检查点操作成本很高:需要通过数据中心的网络连接在机器之间复制庞大的数据集,而网络带宽往往比内存带宽低得多,同时还需要消耗更多的存储资源(在内存中复制数据可以减少需要缓存的数据量,而存储到磁盘则会拖慢应用程序)。所以,我们选择记录更新的方式。但是,如果更新太多,那么记录更新成本也不低。[size=medium][color=red][b]因此,RDD只支持粗粒度转换,即在大量记录上执行的单个操作。[/b][/color][/size]将创建RDD的一系列转换记录下来(即Lineage),以便恢复丢失的分区。
虽然只支持粗粒度转换限制了编程模型,但我们发现RDD仍然可以很好地适用于很多应用,特别是支持数据并行的批量分析应用,包括数据挖掘、机器学习、图算法等,[size=medium][color=blue][b]因为这些程序通常都会在很多记录上执行相同的操作。[/b][/color][/size]RDD不太适合那些异步更新共享状态的应用,例如并行web爬行器。因此,我们的目标是为大多数分析型应用提供有效的编程模型,而其他类型的应用交给专门的系统。
[size=large][b]2.2 RDD抽象[/b][/size]
[size=medium][color=red][b]RDD是只读的、分区记录的集合。RDD只能基于在稳定物理存储中的数据集和其他已有的RDD上执行确定性操作来创建。[/b][/color][/size][b]这些确定性操作称之为转换,如map、filter、groupBy、join(转换不是程开发人员在RDD上执行的操作)。[/b]
[b]RDD不需要物化。RDD含有如何从其他RDD衍生(即计算)出本RDD的相关信息(即Lineage),据此可以从物理存储的数据计算出相应的RDD分区。[/b]
[size=large][b]2.3 编程模型[/b][/size]
在Spark中,RDD被表示为对象,通过这些对象上的方法(或函数)调用转换。
定义RDD之后,程序员就可以在动作中使用RDD了。[color=red][b]动作是向应用程序返回值,或向存储系统导出数据的那些操作,例如,count(返回RDD中的元素个数),collect(返回元素本身),save(将RDD输出到存储系统)。[/b][/color]在Spark中,只有在动作第一次使用RDD时,才会计算RDD(即延迟计算)。这样在构建RDD的时候,运行时通过管道的方式传输多个转换。
[color=red][b]程序员还可以从两个方面控制RDD,即缓存和分区。用户可以请求将RDD缓存,这样运行时将已经计算好的RDD分区存储起来,以加速后期的重用。[/b][/color]缓存的RDD一般存储在内存中,但如果内存不够,可以写到磁盘上。
另一方面,RDD还允许用户根据关键字(key)指定分区顺序,这是一个可选的功能。目前支持哈希分区和范围分区。例如,应用程序请求将两个RDD按照同样的哈希分区方式进行分区(将同一机器上具有相同关键字的记录放在一个分区),以加速它们之间的join操作。在Pregel和HaLoop中,多次迭代之间采用一致性的分区置换策略进行优化,我们同样也允许用户指定这种优化。
[size=large][b]2.4 示例:控制台日志挖掘[/b][/size]
本部分我们通过一个具体示例来阐述RDD。假定有一个大型网站出错,操作员想要检查Hadoop文件系统(HDFS)中的日志文件(TB级大小)来找出原因。[color=red][b]通过使用Spark,操作员只需将日志中的错误信息装载到一组节点的内存中,然后执行交互式查询。[/b][/color]首先,需要在Spark解释器中输入如下Scala命令:
lines = spark.textFile("hdfs://...")
errors = lines.filter(_.startsWith("ERROR"))
errors.cache()
第1行从HDFS文件定义了一个RDD(即一个文本行集合),第2行获得一个过滤后的RDD,第3行请求将errors缓存起来。[color=red][b]注意在Scala语法中filter的参数是一个闭包。[/b][/color]
这时集群还没有开始执行任何任务。但是,用户已经可以在这个RDD上执行对应的动作,例如统计错误消息的数目:
errors.count()
用户还可以在RDD上执行更多的转换操作,并使用转换结果,如:
// Count errors mentioning MySQL:
errors.filter(_.contains("MySQL")).count()
// Return the time fields of errors mentioning
// HDFS as an array (assuming time is field
// number 3 in a tab-separated format):
errors.filter(_.contains("HDFS"))
.map(_.split('\t')(3))
.collect()
[b]使用errors的第一个action运行以后,[/b][color=red][b]Spark会把errors的分区缓存在内存中,极大地加快了后续计算速度。[/b][/color]注意,最初的RDD lines不会被缓存。[b]因为错误信息可能只占原数据集的很小一部分(小到足以放入内存)。[/b]
最后,为了说明模型的容错性,图1给出了第3个查询的Lineage图。在lines RDD上执行filter操作,得到errors,然后再filter、map后得到新的RDD,在这个RDD上执行collect操作。Spark调度器以流水线的方式执行后两个转换,向拥有errors分区缓存的节点发送一组任务。此外,如果某个errors分区丢失,Spark只在相应的lines分区上执行filter操作来重建该errors分区。
[img]http://dl2.iteye.com/upload/attachment/0124/2904/b922b555-0ea1-382b-b5e7-9b548682c26f.png[/img]
图1 示例中第三个查询的Lineage图。(方框表示RDD,箭头表示转换)
[size=x-large][b]2.5 RDD与分布式共享内存[/b][/size]
[b]为了进一步理解RDD是一种分布式的内存抽象,表1列出了RDD与分布式共享内存(DSM,Distributed Shared Memory)[24]的对比。[/b]在DSM系统中,应用可以向全局地址空间的任意位置进行读写操作。(注意这里的DSM,不仅指传统的共享内存系统,还包括那些通过分布式哈希表或分布式文件系统进行数据共享的系统,比如Piccolo[28])[color=red][b]DSM是一种通用的抽象,但这种通用性同时也使得在商用集群上实现有效的容错性更加困难。[/b][/color]
[b]RDD与DSM主要区别在于,不仅可以通过批量转换创建(即“写”)RDD,还可以对任意内存位置读写。[/b]也就是说,[size=medium][color=blue][b]RDD限制应用执行批量写操作,这样有利于实现有效的容错。[/b][/color][/size]特别地,[b]RDD没有检查点开销,因为可以使用Lineage来恢复RDD。[/b]而且,[size=medium][color=red][b]失效时只需要重新计算丢失的那些RDD分区,可以在不同节点上并行执行,而不需要回滚整个程序。[/b][/color][/size]
[img]http://dl2.iteye.com/upload/attachment/0124/2906/c69250c7-79d5-3b00-b697-f9a009c25e11.png[/img]
注意,通过备份任务的拷贝,RDD还可以处理落后任务(即运行很慢的节点),这点与MapReduce[12]类似。[color=red][b]而DSM则难以实现备份任务,因为任务及其副本都需要读写同一个内存位置。[/b][/color]
与DSM相比,RDD模型有两个好处。
[color=blue][b]第一,对于RDD中的批量操作,运行时将根据数据存放的位置来调度任务,从而提高性能。[/b][/color]
[color=red][b]第二,对于基于扫描的操作,如果内存不足以缓存整个RDD,就进行部分缓存。[/b][/color]把内存放不下的分区存储到磁盘上,此时性能与现有的数据流系统差不多。
最后看一下读操作的粒度。[size=medium][color=blue][b]RDD上的很多动作(如count和collect)都是批量读操作,即扫描整个数据集,可以将任务分配到距离数据最近的节点上。[/b][/color][/size]同时,RDD也支持细粒度操作,即在哈希或范围分区的RDD上执行关键字查找。
[size=x-large][color=red][b]3. Spark编程接口[/b][/color][/size]
Spark用Scala[5]语言实现了RDD的API。[color=blue][b]Scala是一种基于JVM的静态类型、函数式、面向对象的语言。[/b][/color]我们选择Scala是因为它简洁(特别适合交互式使用)、有效(因为是静态类型)。但是,RDD抽象并不局限于函数式语言,也可以使用其他语言来实现RDD,比如像Hadoop[2]那样用类表示用户函数。
[color=red][b]要使用Spark,开发者需要编写一个driver程序,连接到集群以运行Worker,[/b][/color]如图2所示。Driver定义了一个或多个RDD,并调用RDD上的动作。[color=blue][b]Worker是长时间运行的进程,将RDD分区以Java对象的形式缓存在内存中。[/b][/color]
[img]http://dl2.iteye.com/upload/attachment/0124/3151/d11b4b4a-80f3-3511-bade-b665e3add753.png[/img]
图2 Spark的运行时。[size=medium][color=red][b]用户的driver程序启动多个worker,worker从分布式文件系统中读取数据块,并将计算后的RDD分区缓存在内存中。[/b][/color][/size]
再看看2.4中的例子,[color=red][b]用户执行RDD操作时会提供参数,比如map传递一个闭包(closure,函数式编程中的概念)。[/b][/color]Scala将闭包表示为Java对象,如果传递的参数是闭包,则这些对象被序列化,通过网络传输到其他节点上进行装载。[color=blue][b]Scala将闭包内的变量保存为Java对象的字段。例如,var x = 5; rdd.map(_ + x) 这段代码将RDD中的每个元素加5。[/b][/color]总的来说,Spark的语言集成类似于DryadLINQ。
RDD本身是静态类型对象,由参数指定其元素类型。例如,RDD[int]是一个整型RDD。不过,我们举的例子几乎都省略了这个类型参数,因为Scala支持类型推断。
虽然在概念上使用Scala实现RDD很简单,但还是要处理一些Scala闭包对象的反射问题。如何通过Scala解释器来使用Spark还需要更多工作,这点我们将在第6部分讨论。不管怎样,我们都不需要修改Scala编译器。
[color=red][size=large][b]3.1 Spark中的RDD操作[/b][/size][/color]
表2列出了Spark中的RDD转换和动作。[size=large][color=blue][b]每个操作都给出了标识,其中方括号表示类型参数。前面说过转换是延迟操作,用于定义新的RDD;而动作启动计算操作,并向用户程序返回值或向外部存储写数据。[/b][/color][/size]
[img]http://dl2.iteye.com/upload/attachment/0124/3159/5574bea4-8cb0-3467-b36b-08422630bc55.jpg[/img]
[size=medium][color=red][b]注意,有些操作只对键值对可用,比如join。[/b][/color][/size]另外,[color=blue][b]函数名与Scala及其他函数式语言中的API匹配,例如map是一对一的映射,而flatMap是将每个输入映射为一个或多个输出(与MapReduce中的map类似)。[/b][/color]
除了这些操作以外,用户还可以请求将RDD缓存起来。而且,用户还可以通过Partitioner类获取RDD的分区顺序,然后将另一个RDD按照同样的方式分区。有些操作会自动产生一个哈希或范围分区的RDD,像groupByKey,reduceByKey和sort等。
[size=x-large][color=red][b]4. 应用程序示例[/b][/color][/size]
现在我们讲述如何使用RDD表示几种基于数据并行的应用。首先讨论一些迭代式机器学习应用(4.1),然后看看如何使用RDD描述几种已有的集群编程模型,即MapReduce(4.2),Pregel(4.3),和Hadoop(4.4)。最后讨论一下RDD不适合哪些应用(4.5)。
[size=large][b]4.1 迭代式机器学习[/b][/size]
很多机器学习算法都具有迭代特性,运行迭代优化方法来优化某个目标函数,例如梯度下降方法。[color=red][b]如果这些算法的工作集能够放入内存,将极大地加速程序运行。[/b][/color]而且,这些算法通常采用批量操作,例如映射和求和,这样更容易使用RDD来表示。
例如下面的程序是逻辑回归[15]的实现。逻辑回归是一种常见的分类算法,即寻找一个最佳分割两组点(即垃圾邮件和非垃圾邮件)的超平面w。算法采用梯度下降的方法:开始时w为随机值,在每一次迭代的过程中,对w的函数求和,然后朝着优化的方向移动w。
val points = spark.textFile(...)
.map(parsePoint).persist()
var w = // random initial vector
for (i <- 1 to ITERATIONS) {
val gradient = points.map{ p =>
p.x * (1/(1+exp(-p.y*(w dot p.x)))-1)*p.y
}.reduce((a,b) => a+b)
w -= gradient
}
首先定义一个名为points的缓存RDD,这是在文本文件上执行map转换之后得到的,即将每个文本行解析为一个Point对象。然后在points上反复执行map和reduce操作,每次迭代时通过对当前w的函数进行求和来计算梯度。7.1小节我们将看到这种在内存中缓存points的方式,比每次迭代都从磁盘文件装载数据并进行解析要快得多。
已经在Spark中实现的迭代式机器学习算法还有:kmeans(像逻辑回归一样每次迭代时执行一对map和reduce操作),期望最大化算法(EM,两个不同的map/reduce步骤交替执行),交替最小二乘矩阵分解和协同过滤算法。Chu等人提出迭代式MapReduce也可以用来实现常用的学习算法[11]。
[size=large][b]4.2 使用RDD实现MapReduce[/b][/size]
MapReduce模型[12]很容易使用RDD进行描述。假设有一个输入数据集(其元素类型为T),和两个函数myMap: T => List[(Ki, Vi)] 和 myReduce: (Ki; List[Vi]) ) List[R],代码如下:
data.flatMap(myMap)
.groupByKey()
.map((k, vs) => myReduce(k, vs))
如果任务包含combiner,则相应的代码为:
data.flatMap(myMap)
.reduceByKey(myCombiner)
.map((k, v) => myReduce(k, v))
[color=red][b]ReduceByKey操作在mapper节点上执行部分聚集,与MapReduce的combiner类似。[/b][/color]
转自:[url]http://shiyanjun.cn/archives/744.html[/url]