À 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
avecspark-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
- utilisation
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.
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
Vous devez vous connecter pour publier un commentaire.
La documentation ne semble pas claire.
De mon expérience, la pratique la plus courante d'allouer des ressources est, en indiquant le nombre d'exécutants et le nombre de cœurs par un exécuteur testamentaire, par exemple (pris à partir de ici):
Cependant, cette approche est limitée à FIL, et n'est pas applicable autonome et mesos en fonction Étincelle, selon cette.
Au lieu de cela, le paramètre
--total-executor-cores
peut être utilisé, ce qui représente le montant total de cœurs de tous les interprètes - affecté à la Étincelle travail. Dans votre cas, avoir un total de 40 cœurs, la définition de l'attribut--total-executor-cores 40
d'utiliser toutes les ressources disponibles.Malheureusement, je ne suis pas au courant de la façon dont Étincelle distribue la charge de travail lorsque moins de ressources que le montant total disponible, sont fournis. Si vous travaillez avec deux ou plus de deux simultanée des emplois, cependant, il devrait être transparent pour l'utilisateur, dans ce Étincelle (ou quel que soit le gestionnaire de ressources) serait de gérer la façon dont les ressources sont gérées en fonction des paramètres de l'utilisateur.
C'est ce que j'ai pensé qu'il le ferait. Cependant, il est un fait intéressant, qui a maintenant été prouvé.
OriginalL'auteur Mikel Urkia
À assurez-vous combien de travailleurs ont commencé sur chaque esclave, ouvrez le navigateur web, tapez http://master-ip:8080, et de voir le
workers
la section à propos de la façon dont beaucoup de travailleurs a été commencé exactement, et aussi qui travailleur à qui l'esclave. (Je mentionne ci-dessus, parce que je ne suis pas sûr qu'entendez-vous en disant: "4 esclaves par le nœud")Par défaut, allumage serait de commencer exacte 1 travailleur sur chaque esclave, sauf si vous spécifiez
SPARK_WORKER_INSTANCES=n
dans conf/spark-env.sh où n est le nombre de travailleurs de l'instance que vous souhaitez démarrer sur chaque esclave.Lorsque vous soumettez une étincelle d'emploi par le biais de l'étincelle-soumettre, allumage serait de commencer une demande de pilote et les exécuteurs testamentaires pour votre travail.
--total-executor-cores
vous avez spécifié serait de limiter le total des cœurs qui est disponible pour cette application.Je suis à l'aide d'Étincelle sur les EMR et je n'ai rien à 8080?
OriginalL'auteur Yijie Shen