Apache Spark : remplir une chaîne de manière distribuée

Bonjour à tous,

Je dispose de N machines, et d’une chaîne de caractères initialement vides sur mon driver Spark. Je dispose également, sur mon driver, d’une fonction qui concatène une chaîne de caractères avec celle précédemment évoquée.

Soit :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

  def main(args : Array[String]) : Unit = {

    val conf = new SparkConf().setAppName("Simple states graph")
    val spark_context : SparkContext = new SparkContext(conf)

    var graph : String = "" // La variable vide qu'il faut remplir

    graph += StatesGraphCompiler.addState(graph, "Etat 1") // Appel 1 à la fonction de concaténation/remplissage
    graph += StatesGraphCompiler.addState(graph, "Etat 2") // Appel 2

    printf(graph) // Affichage final

  }

Je souhaiterais :

1. Faire exécuter le premier addState sur un worker

2. Faire exécuter le second sur un AUTRE worker (i.e. : distribuer le remplissage).

3. Que le driver affiche la chaîne finale.

Comment faire cela avec Spark ? Je pense à des union des RDDs issus d’une conversion de chaque String en RDD. Mais je ne suis pas sûr et certain que ce soit la façon la plus élégante de faire cela.

J’ai l’impression que Spark est surtout adapté pour faire usage de données, mais pas pour en générer…

Tes états sont tes données. Utilise Spark pour transformer ces données. Attention au fait que distribuer un truc qui doit être fait dans un ordre précis n’a pas d’intérêt.

Justement, je ne peux pas transformer mes états, je cherche à les créer. C’est bien leur création que je souhaite distribuer.

Les créer à partir de quoi ? Aléatoirement ?

Alors effectivement, au bout du compte je les créerai à partir d’un fichier.

Mais là actuellement je veux les créer à la main (donc en faisant ces appels), sans utiliser de fichier ("external dataset"), c’est pas possible c’est ça ?

Donc tu as une liste d’états [e1, e2, e3, …], une fonction f(e) à appliquer à chaque état, c’est ça ?

Oui, mais cette liste n’existe que dans ma tête, comme tu peux le voir dans mon code. M’enfin au pire je l’écrirai dans un fichier/une collection Scala et puis voilà effectivement !

Je ne comprends pas. Si cette liste n’existe que dans ta tête, comment veux-tu que ton programme s’en serve ?

Bah parce que je donne un élément de cette liste à chaque appel, comme tu peux le voir dans mon code. Mais au final ça sert à rien, je vais directement faire une collection, la paralléliser, et faire un foreach pour appliquer ma fonction dessus, ça devrait être bon nan ?

Non non aide-moi à comprendre. Comment comptes-tu faire tourner un programme qui prendre en entrée une liste qui est uniquement dans ta tête, sans que tu la donnes au programme ?

Peux-tu me donner un exemple de programme qui fait ceci ?

En fait la liste est une chaîne de caractères vide au début (variable graph).

Je voulais remplir caractèreS par caractèreS cette liste (ie. : la remplir en faisant des concaténations de strings). La fonction addState permet justement cela.

L’idée étant donc de remplir graph avec des appels successifs à addState, et de décider des valeurs servant au remplissage dans ces appels (e.g. : Etat 1, Etat 2).

De sorte qu’il n’y avait pas de liste d’états de programmée, puisque ces derniers étaient indiqués en tant que paramètres uns-à-uns.