为什么在星火中聚合和折叠两个不同的API？

Question

当使用Scala标准库时，我可以这样做：

scala> val scalaList = List(1,2,3)
scalaList: List[Int] = List(1, 2, 3)

scala> scalaList.foldLeft(0)((acc,n)=>acc+n)
res0: Int = 6

从多家酒馆中获得一家公司。

我可以这样做：

scala> scalaList.foldLeft("")((acc,n)=>acc+n.toString)
res1: String = 123

用多个Ints做一根绳子。

因此，foldLeft可以是同构的，也可以是异构的，无论我们想要什么，它都在一个API中。

在星火中，如果我想在许多Ints中有一个Int，我可以这样做：

scala> val rdd = sc.parallelize(List(1,2,3))
rdd: org.apache.spark.rdd.RDD[Int] = ParallelCollectionRDD[1] at parallelize at <console>:12
scala> rdd.fold(0)((acc,n)=>acc+n)
res1: Int = 6

折叠API类似于foldLeft，但它只是同构的，RDDInt只能用fold生成Int。

火花中也有一个聚合API：

scala> rdd.aggregate("")((acc,n)=>acc+n.toString, (s1,s2)=>s1+s2)
res11: String = 132

它是异构的，RDDInt现在可以生成一个字符串。

那么，为什么折叠和聚合在星火中作为两个不同的API来实现呢？

为什么它们的设计不像foldLeft那样，既可以是同构的，也可以是异构的？

(我对火花很陌生，如果这是个愚蠢的问题，请原谅。)

Answer 1

fold可以更有效地实现，因为它不依赖于固定的评估顺序。因此，每个集群节点都可以并行地fold自己的块，然后在最后生成一个小的总体fold。然而，对于foldLeft，每个元素必须按顺序折叠，任何事情都不能并行处理。

(同时，为了方便起见，使用一个更简单的API也很好。为此，标准库有reduce和foldLeft )

Answer 2

特别是在Spark中，计算是以并行方式进行的，因此不能像标准库中那样实现foldLeft。相反，聚合需要两个函数，一个函数对T类型的每个元素执行类似于T的操作，生成一个U类型的值，另一个函数将每个分区的U组合成最终值：

def aggregate[U: ClassTag](zeroValue: U)(seqOp: (U, T) => U, combOp: (U, U) => U): U

Answer 3

foldLeft, foldRight, reduceLeft, reduceRight, scanLeft和scanRight是累加参数可以与输入参数((A, B) -> B)不同的操作，这些操作只能按顺序执行。

fold是一种操作，其中累积的参数必须是相同类型的输入参数((A, A) -> A)。然后，它可以并行执行。

aggregation是一种操作，其中累积的参数可以是不同类型的输入参数，但随后您必须提供一个额外的函数，该函数定义如何在最终结果中聚合累积参数。此操作允许并行执行。aggregation操作是foldLeft和fold的组合。

要获得更详细的信息，您可以查看“并行编程”课程的coursera视频：

• https://www.coursera.org/learn/parprog1/lecture/efzVT/data-parallel-operations-i
• https://www.coursera.org/learn/parprog1/lecture/shwKn/data-parallel-operations-ii