Question

我正在从基于MPI的系统迁移到Apache Spark。我需要在Spark中执行以下操作。

假设我有n个顶点。我想从这些n顶点创建边列表。边是两个整数（u，v）的元组，不需要任何属性。

但是，我想在每个执行器中独立并行创建它们。因此，我想为P Spark Executors独立创建P边数组。每个数组可能具有不同的大小并且取决于顶点，因此，我还需要从0到n-1的执行者ID。接下来，我想要一个全局RDD数组边。

在MPI中，我会使用处理器等级在每个处理器中创建一个数组。我如何在Spark中执行此操作，尤其是使用GraphX库？

因此，我的主要目标是在每个执行器中创建一个边数组，并将它们组合成一个RDD。

我首先尝试了鄂尔多斯 - 仁义模型的一个修改版本。作为参数，我只有节点数n和概率p。

假设，执行者i必须处理从101到200的节点。对于任何节点，例如节点101，它将以概率p创建从101到102 -- n的边。在每个执行程序创建分配的边之后，我将实例化GraphX EdgeRDD和VertexRDD。因此，我的计划是在每个执行器中独立创建边缘列表，并将它们合并到RDD。

Answer 1

让我们从下游处理所需的一些导入和变量开始：

import org.apache.spark._
import org.apache.spark.graphx._
import org.apache.spark.rdd.RDD
import scala.util.Random
import org.apache.spark.HashPartitioner

val nPartitions: Integer = ???
val n: Long = ??? 
val p: Double = ???

接下来，我们需要一个种子ID的RDD，可以用来生成边缘。处理这种情况的天真方式就是这样：

sc.parallelize(0L to n)

由于生成的边数取决于节点id，因此这种方法会产生高度偏斜的负载。我们可以通过重新分区来做得更好：

sc.parallelize(0L to n)
  .map((_, None))
  .partitionBy(new HashPartitioner(nPartitions))
  .keys

但更好的方法是从空RDD开始并生成id。我们需要一个小帮手：

def genNodeIds(nPartitions: Int, n: Long)(i: Int) = {
  (0L until n).filter(_ % nPartitions == i).toIterator
}

可以按如下方式使用：

val empty = sc.parallelize(Seq.empty[Int], nPartitions)
val ids = empty.mapPartitionsWithIndex((i, _) => genNodeIds(nPartitions, n)(i))

只需快速检查一下（这是非常昂贵的，所以不要在生产中使用它）：

require(ids.distinct.count == n)

我们可以使用另一个帮助器生成实际边缘：

def genEdgesForId(p: Double, n: Long, random: Random)(i: Long) = {
  (i + 1 until n).filter(_ => random.nextDouble < p).map(j => Edge(i, j, ()))
}

def genEdgesForPartition(iter: Iterator[Long]) = {
  // It could be an overkill but better safe than sorry
  // Depending on your requirement it could worth to
  // consider using commons-math
  // https://commons.apache.org/proper/commons-math/userguide/random.html
  val random = new Random(new java.security.SecureRandom())
  iter.flatMap(genEdgesForId(p, n, random))
}

val edges = ids.mapPartitions(genEdgesForPartition)

最后我们可以创建一个图表：

val graph = Graph.fromEdges(edges, ())

在Spark中为每个Executor创建数组并组合成RDD

1 个答案: