Comment distribuer efficacement et utiliser des partitions dans l'étincelle?

Question

Ceci est mon exemple.

val arr = Array((1,2), (1,3), (1,4), (2,3), (4,5)) 
val data = sc.parallelize(arr, 5) 

data.glom.map(_length).collect 
Array[Int] = Array(1, 1, 1, 1, 1) 

val agg = data.reduceByKey(_+_) 
agg.glom.map(_.length).collect 
Array[Int] = Array(0, 1, 1, 0, 1) 

val fil = agg.filter(_._2 < 4) 
fil.glom.map(_.length).collect 
Array[Int] = Array(0, 0, 1, 0, 0) 

val sub = data.map{case(x,y) => (x, (x,y))}.subtractByKey(fil).map(_._2) 
Array[(Int, Int)] = Array((1,4), (1,3), (1,2), (4,5)) 

sub.glom.map(_.length).collect 
Array[Int] = Array(0, 3, 0, 0, 1) 

Ce que je me demande, c'est de répartir également les partitions.

La variable data se compose de cinq partitions, toutes les données étant partitionnées de manière égale.

ex)par1: (1,2) 
    par2: (1,3) 
    par3: (1,4) 
    par4: (2,3) 
    par5: (4,5) 

Après plusieurs transformation operation, attribués à la variable sub Seulement deux des cinq partitions sont utilisées.

La variable sub se compose de cinq partitions, mais toutes les données ne sont pas partitionnées de manière égale.

ex)par1: empty 
    par2: (1,2),(1,3),(1,4) 
    par3: empty 
    par4: empty 
    par5: (4,5) 

Si j'ajoute une autre transformation operation à la variable sub, il y aura 5 partitions disponibles, mais seulement deux partitions seront utilisées pour l'opération.

ex)sub.map{case(x,y) => (x, x, (x,y))} 

Donc, je veux utiliser toutes les partitions disponibles lorsque les données sont exploitées. J'ai utilisé la méthode repartition, mais ce n'est pas moins cher. Donc, je cherche un moyen judicieux d'utiliser autant de partitions que possible.

Y a-t-il un bon moyen?

Answer 1

Alors repartition est certainement la voie à suivre :)

Votre exemple est un peu trop simple à démontrer quoi que ce que Spark est construit pour gérer des milliards de lignes - pas 5 lignes. repartition ne mettra pas exactement le même nombre de lignes dans chaque partition, mais il distribuera les données uniformément. Essayez de refaire votre exemple avec 1.000.000 lignes à la place et vous verrez que les données sont effectivement réparties uniformément après un repartition.

L'asymétrie de données est souvent un gros problème lorsque l'on travaille avec des transformations de grandes quantités de données, et le repartitionnement de vos données s'accompagne du coût de temps supplémentaire car il faut mélanger des données. Parfois, cela vaut la peine de prendre la pénalité, car les étapes de transformation suivantes seront plus rapides.