Question

我们有一个火花流应用程序（火花2.1在Hortonworks 2.6上运行）并使用DataSet.repartition（在从Kafka读取的DataSet<Row>上）以便根据DataSet<Row>'s分区重新分区到给定列（称为 block_id ）。

我们从包含50个分区的DataSet<Row>开始，最后（在调用DataSet.repartition之后）分区数相当于唯一 block_id的的数量。

问题是DataSet.repartition表现不像我们预期的那样 - 当我们查看运行repartition的spark作业的事件时间轴时，我们看到有几个任务处理1 block_id 和处理2 block_id的甚至3或4 block_id的的任务更少。

似乎DataSet.repartition确保具有相同 block_id 的所有Rows都在单个分区内，但并不是每个创建分区的任务都只会处理一个block_id。

结果是重新分区作业（在流应用程序内部运行）花费的时间与其最长任务（处理最多 block_id的）的任务相同。

我们尝试使用流媒体应用程序提供的Vcores数量 - 从10到25到50（我们在原始RDD中有50个分区，从Kafka读取）但结果是相同的 - 总是有一个或多个任务处理多个 block_id 。

我们甚至尝试增加批处理时间，这再次无法帮助我们实现处理一个 block_id 的任务的目标。

举个例子 - 这里是事件时间表和描述repartition火花作业运行的任务表：

事件时间表 - 红色的两个任务是处理两个 block_id 的任务：

任务表 - 红色的两个任务与上面的两个相同 - 注意每个任务的持续时间是所有其他任务的持续时间的两倍（只处理一个 block_id ）

这对我们来说是一个问题，因为流媒体应用程序由于这些长任务而延迟，我们需要一个解决方案，使我们能够在DataSet上执行repartition，同时让每个任务只处理一个 block_id 。

如果那是不可能的，那么可能在JavaRDD?上就可以了。因为在我们的案例中，我们运行DataSet<Row>的{{1}}是从repartition创建的。

Answer 1

您需要考虑的两个问题：

有一个自定义分区程序，可确保数据的均匀分布，1 block_id / partition
调整集群大小，以便有足够的执行程序同时运行所有任务（block_ids）

正如您所看到的，对DataFrame进行简单的重新分区并不能确保您获得统一的分发。当您通过block_id重新分区时，它将使用HashPartitioner，其公式为：

Utils.nonNegativeMod(key.hashCode, numPartitions)

请参阅：https://github.com/apache/spark/blob/branch-2.2/core/src/main/scala/org/apache/spark/Partitioner.scala#L80-L88

很可能将2+个密钥分配给同一个partition_id，因为partition_id是密钥的hashCode模数numPartitions。

通过将RDD与自定义分区程序一起使用，可以实现所需的功能。最简单的方法是在重新分区之前提取不同的block_id列表。

这是一个简单的例子。假设您可以有5个块（2,3,6,8,9）并且您的群集有8个执行器（可以同时运行多达8个任务），我们由3个执行器过度配置：

scala> spark.conf.get("spark.sql.shuffle.partitions")
res0: String = 8

scala> spark.conf.get("spark.default.parallelism")
res1: String = 8

// Basic class to store dummy records
scala> case class MyRec(block_id: Int, other: String)
defined class MyRec

// Sample DS
scala> val ds = List((2,"A"), (3,"X"), (3, "B"), (9, "Y"), (6, "C"), (9, "M"), (6, "Q"), (2, "K"), (2, "O"), (6, "W"), (2, "T"), (8, "T")).toDF("block_id", "other").as[MyRec]
ds: org.apache.spark.sql.Dataset[MyRec] = [block_id: int, other: string]

scala> ds.show
+--------+-----+
|block_id|other|
+--------+-----+
|       2|    A|
|       3|    X|
|       3|    B|
|       9|    Y|
|       6|    C|
|       9|    M|
|       6|    Q|
|       2|    K|
|       2|    O|
|       6|    W|
|       2|    T|
|       8|    T|
+--------+-----+

// Default partitioning gets data distributed as uniformly as possible (record count)
scala> ds.rdd.getNumPartitions
res3: Int = 8

// Print records distribution by partition
scala> ds.rdd.mapPartitionsWithIndex((idx, it) => Iterator((idx, it.toList))).toDF("partition_id", "block_ids").show
+------------+--------------+
|partition_id|     block_ids|
+------------+--------------+
|           0|       [[2,A]]|
|           1|[[3,X], [3,B]]|
|           2|       [[9,Y]]|
|           3|[[6,C], [9,M]]|
|           4|       [[6,Q]]|
|           5|[[2,K], [2,O]]|
|           6|       [[6,W]]|
|           7|[[2,T], [8,T]]|
+------------+--------------+

// repartitioning by block_id leaves 4 partitions empty and assigns 2 block_ids (6,9) to same partition (1)
scala> ds.repartition('block_id).rdd.mapPartitionsWithIndex((idx, it) => Iterator((idx, it.toList))).toDF("partition_id", "block_ids").where(size('block_ids) > 0).show(false)
+------------+-----------------------------------+
|partition_id|block_ids                          |
+------------+-----------------------------------+
|1           |[[9,Y], [6,C], [9,M], [6,Q], [6,W]]|
|3           |[[3,X], [3,B]]                     |
|6           |[[2,A], [2,K], [2,O], [2,T]]       |
|7           |[[8,T]]                            |
+------------+-----------------------------------+

// Create a simple mapping for block_id to partition_id to be used by our custom partitioner (logic may be more elaborate or static if the list of block_ids is static):
scala> val mappings = ds.map(_.block_id).dropDuplicates.collect.zipWithIndex.toMap
mappings: scala.collection.immutable.Map[Int,Int] = Map(6 -> 1, 9 -> 0, 2 -> 3, 3 -> 2, 8 -> 4)

//custom partitioner assigns partition_id according to the mapping arg
scala> class CustomPartitioner(mappings: Map[Int,Int]) extends org.apache.spark.Partitioner {
     |   override def numPartitions: Int = mappings.size
     |   override def getPartition(rec: Any): Int = { mappings.getOrElse(rec.asInstanceOf[Int], 0) }
     | }
defined class CustomPartitioner

// Repartition DS using new partitioner
scala> val newDS = ds.rdd.map(r => (r.block_id, r)).partitionBy(new CustomPartitioner(mappings)).toDS
newDS: org.apache.spark.sql.Dataset[(Int, MyRec)] = [_1: int, _2: struct<block_id: int, other: string>]

// Display evenly distributed block_ids
scala> newDS.rdd.mapPartitionsWithIndex((idx, it) => Iterator((idx, it.toList))).toDF("partition_id", "block_ids").where(size('block_ids) > 0).show(false)
+------------+--------------------------------------------+
|partition_id|block_ids                                   |
+------------+--------------------------------------------+
|0           |[[9,[9,Y]], [9,[9,M]]]                      |
|1           |[[6,[6,C]], [6,[6,Q]], [6,[6,W]]]           |
|2           |[[3,[3,X]], [3,[3,B]]]                      |
|3           |[[2,[2,A]], [2,[2,K]], [2,[2,O]], [2,[2,T]]]|
|4           |[[8,[8,T]]]                                 |
+------------+--------------------------------------------+

在Spark 2中使用DataSet.repartition - 多个任务处理多个分区

1 个答案: