Question

我在Youtube上看过一些有关Spark架构的视频。

即使Lazy评估，出现故障时数据创建的弹性，良好的函数式编程概念是Resilenace分布式数据集成功的原因，一个令人担忧的因素是由于多个transformations导致内存开销导致数据导致的内存开销不变性。

如果我理解正确的概念，每次转换都会创建新的数据集，因此内存需求将会多次消失。如果我在代码中使用10个转换，将创建10组数据集，并且我的内存消耗将增加10倍。

e.g。

val textFile = sc.textFile("hdfs://...")
val counts = textFile.flatMap(line => line.split(" "))
                 .map(word => (word, 1))
                 .reduceByKey(_ + _)
counts.saveAsTextFile("hdfs://...")

上面的示例有三个转换： flatMap, map and reduceByKey 。这是否意味着对于X大小的数据我需要3X数据内存？

我的理解是否正确？缓存RDD只是解决此问题的解决方案吗？

一旦我开始缓存，由于磁盘IO操作会导致大尺寸和性能受到影响，它可能会溢出到磁盘。在这种情况下，Hadoop和Spark的性能是否相当？

编辑：

从答案和评论中，我已经了解了懒惰的初始化和管道流程。我假设3 X内存，其中X是初始RDD大小不准确。

但是可以在内存中缓存1 X RDD并通过pipleline更新吗？ cache（）如何工作？

Answer 1

首先，延迟执行意味着可以发生功能组合：

scala> val rdd = sc.makeRDD(List("This is a test", "This is another test", 
                                 "And yet another test"), 1)
rdd: org.apache.spark.rdd.RDD[String] = ParallelCollectionRDD[70] at makeRDD at <console>:27

scala> val counts = rdd.flatMap(line => {println(line);line.split(" ")}).
     | map(word => {println(word);(word,1)}).
     | reduceByKey((x,y) => {println(s"$x+$y");x+y}).
     | collect
This is a test
This
is
a
test
This is another test
This
1+1
is
1+1
another
test
1+1
And yet another test
And
yet
another
1+1
test
2+1
counts: Array[(String, Int)] = Array((And,1), (is,2), (another,2), (a,1), (This,2), (yet,1), (test,3))

首先请注意，我将并行性降低到1，以便我们可以看到这对单个工作者的影响。然后我为每个转换添加println，以便我们可以看到工作流程如何移动。您看到它处理该行，然后它处理该行的输出，然后进行缩减。因此，如您所建议的那样，每次转换都没有存储单独的状态。相反，每个数据都在整个转换过程中循环，直到需要随机播放为止，这可以从UI的DAG可视化中看出：

这是懒惰的胜利。至于Spark v Hadoop，已经有很多东西（只是谷歌），但要点是Spark倾向于利用开箱即用的网络带宽，在那里给它一个提升。然后，通过懒惰获得了许多性能改进，特别是如果已知模式并且您可以使用DataFrames API。

总的来说，Spark在几乎所有方面都击败了MR。

Answer 2

如果Spark作业中有10个转换，Spark的内存要求不会超过10次。当您在作业中指定转换步骤时，Spark会构建一个DAG，以允许它执行作业中的所有步骤。之后，它将工作分成几个阶段。阶段是一系列转换，Spark可以在数据集上执行而不需要改组。

当在RDD上触发操作时，Spark会评估DAG。它只是将一个阶段中的所有变换一起应用到阶段结束，因此内存压力不可能是10倍，除非每次变换导致混乱（在这种情况下，它可能是一个写得不好的工作）

我建议您观看this talk并浏览slides。

Spark + Scala转换，不变性和＆amp;内存消耗开销

2 个答案: