À l'aide de bougies de soumettre, qu'est-ce que le comportement de l' --total-exécuteur des noyaux option?

Je suis en cours d'exécution d'une étincelle de cluster sur le code C++ enveloppé dans python.
Je suis actuellement en train de tester différentes configurations de multi-threading options (en Python niveau d'Étincelle ou de niveau).

Je suis en utilisant étincelle avec autonome binaires, sur une HDFS 2.5.4 cluster. Le cluster est actuellement composé de 10 esclaves, avec 4 cœurs de chacun.

De ce que je peux voir, par défaut, une Étincelle lance 4 esclaves par nœud (j'ai 4 python travail sur un nœud esclave à un moment).

Comment puis-je limiter ce nombre ? Je peux voir que j'ai un --total-exécuteur des noyaux option pour "étincelle soumettre", mais il existe peu de documentation sur la façon dont il influe sur la distribution des interprètes sur le cluster !

Je vais faire des tests pour se faire une idée claire, mais si quelqu'un qui connait a une idée de ce que cette option n', cela pourrait aider.

Mise à jour :

Je suis passé par l'étincelle de la documentation de nouveau, ici, est ce que je comprends :

  • Par défaut, j'ai un exécuteur testamentaire par travailleur nœud (ici 10 travailleurs nœud, donc 10 exécuteurs)
  • Cependant, chaque travailleur peut exécuter plusieurs tâches en parallèle. En mode autonome, le comportement par défaut est d'utiliser tous les cœurs disponibles, ce qui explique pourquoi je peux observer 4 python.
  • De limiter le nombre de cœurs utilisés par travailleur, et de limiter le nombre de tâches en parallèle, j'ai au moins 3 options :
    • utilisation --total-executor-cores avec spark-submit (moins satisfaisante, car il n'y a aucun indice sur la façon dont le groupe de cœurs est traitée)
    • utilisation SPARK_WORKER_CORES dans le fichier de configuration
    • utilisation -c options avec le départ des scripts

Les lignes suivantes de cette documentation http://spark.apache.org/docs/latest/spark-standalone.html m'a aidé à comprendre ce qui se passe sur :

SPARK_WORKER_INSTANCES

Nombre de travailleurs instances à exécuter sur chaque machine (par défaut: 1).
Vous pouvez faire de ce plus 1 si vous avez de très grandes machines et voudrais plusieurs Étincelle processus de travail.
Si vous ne définissez cette, assurez-vous de définir également SPARK_WORKER_CORES explicitement à limiter les cœurs par travailleur, ou bien chaque travailleur va essayer d'utiliser tous les cœurs.

Ce n'est toujours pas clair pour moi, c'est pourquoi il est préférable dans mon cas, de limiter le nombre de tâches en parallèle par travailleur nœud 1 et compter sur mon C++ code hérité de multithreading. Je mettrai à jour ce post avec les résultats de l'expérience, lorsque je vais terminer mon étude.

À partir de votre mise à jour, ce qu'il ne semble pas clair pour moi, c'est comment vous avez atteint la conclusion qu'il est préférable de limiter le nombre de tâches en parallèle et comptons sur votre code C++ de multithreading.
Eh bien, je suis effectivement en cours d'exécution d'un ensemble d'expériences spécifiques, pour vérifier si il est plus intéressant de s'appuyer sur d'habitude héritée de multithreading ou de l'utilisation de l'Étincelle approche. Je suis en cours d'exécution sur le cloud google, et dans mon certains traitement de l'image les cas, le meilleur compromis est le suivant : pour un travailleur à N noyaux, ont N/2 emplois parallèles à l'aide de l'étincelle, chaque travail multithread sur 2 à l'aide de threads openMP. Par exemple : 8 travailleurs nœud avec 16 coeurs, le meilleur compromis est de 64 emplois parallèles, et chacun d'eux multithread sur 2 cœurs. Le contraire (16 emplois parallèles, chacun d'entre eux sur le mont de plus de 8 cœurs est deux fois plus lent).
Merci pour le acclaration.

OriginalL'auteur MathiasOrtner | 2015-05-04