Où voulez-vous commencer à régler le ci-dessus mentionné params. Pouvons-nous commencer avec exécuteur de la mémoire et d'obtenir le nombre d'exécuteurs testamentaires, ou nous commençons avec des carottes et obtenir l'exécuteur nombre. J'ai suivi le lien. Cependant j'ai une grande idée, mais toujours pas comment ni par où commencer et arriver à une conclusion définitive.
Réponses
Trop de publicités?
La réponse suivante couvre les 3 principaux aspects mentionnés dans le titre - nombre d'exécuteurs testamentaires, liquidateurs de la mémoire et le nombre de noyaux. Il y a peut être d'autres paramètres comme le pilote de la mémoire et d'autres dont je n'ai pas l'adresse de cette réponse, mais souhaitez l'ajouter dans un avenir proche.
Cas 1 Matériel - 6 Nœuds, et Chaque nœud de 16 cœurs, 64 GO de RAM
Chaque exécuteur testamentaire est une instance de la JVM. Donc on peut avoir plusieurs exécuteurs testamentaires dans un seul Nœud
Tout d'abord 1 core et 1 GO est nécessaire pour des OS et Hadoop Démons, alors disponibles sont de 15 carottes, 63 GO de RAM pour chaque nœud
Commencer par la façon de choisir le nombre de noyaux:
Number of cores = Concurrent tasks as executor can run
So we might think, more concurrent tasks for each executor will give better performance. But research shows that
any application with more than 5 concurrent tasks, would lead to bad show. So stick this to 5.
This number came from the ability of executor and not from how many cores a system has. So the number 5 stays same
even if you have double(32) cores in the CPU.
Nombre d'exécuteurs:
Coming back to next step, with 5 as cores per executor, and 15 as total available cores in one Node(CPU) - we come to
3 executors per node.
So with 6 nodes, and 3 executors per node - we get 18 executors. Out of 18 we need 1 executor (java process) for AM in YARN we get 17 executors
This 17 is the number we give to spark using --num-executors while running from spark-submit shell command
Mémoire pour chaque exécuteur testamentaire:
From above step, we have 3 executors per node. And available RAM is 63 GB
So memory for each executor is 63/3 = 21GB.
However small overhead memory is also needed to determine the full memory request to YARN for each executor.
Formula for that over head is max(384, .07 * spark.executor.memory)
Calculating that overhead - .07 * 21 (Here 21 is calculated as above 63/3)
= 1.47
Since 1.47 GB > 384 MB, the over head is 1.47.
Take the above from each 21 above => 21 - 1.47 ~ 19 GB
So executor memory - 19 GB
Chiffres définitifs - Interprètes - 17, Carottes 5, Exécuteur testamentaire de la Mémoire - 19 GO
Cas 2 Matériel : Même Nœud 6, 32 Cœurs, 64 GO
5 est de même pour bonne simultanéité
Nombre d'exécutants pour chaque nœud = 32/5 ~ 6
Si le total des exécuteurs = 6 * 6 Nœuds = 36. Ensuite, le nombre final est de 36 - 1 pour AM = 35
Exécuteur de la mémoire : 6 exécuteurs pour chaque nœud. 63/6 ~ 10 . Dessus de la tête est .07 * 10 = 700 MO. Donc arrondi à 1 go comme sur la tête, nous obtenons 10-1 = 9 GO
Chiffres définitifs - Interprètes - 35, les Carottes 5, Exécuteur testamentaire de la Mémoire - 9 GO
Cas 3
Les scénarios ci-dessus commencent à l'acceptation d'un nombre de cœurs comme fixes et mobiles à # des interprètes et la mémoire.
Maintenant, pour le premier cas, si nous pensons que nous n'avons pas besoin de 19 GO, et à seulement 10 GO est suffisant, puis le suivant sont les chiffres:
carottes 5 # des interprètes pour chaque nœud = 3
À ce stade, cela conduirait à 21, puis 19 comme pour notre premier calcul. Mais depuis nous avons pensé que 10 est ok (à supposer peu de surcharge), alors nous ne pouvons pas changer # des exécuteurs par nœud à 6 (comme 63/10). Becase avec 6 exécuteurs testamentaires par nœud et 5 carottes de il descend à 30 cœurs par nœud, quand on n'a que 16 cœurs. Donc, il faut aussi changer le nombre de des carottes pour chaque exécuteur testamentaire.
Pour le calcul de nouveau,
Le nombre magique de 5 à 3 (tout nombre inférieur ou égal à 5). Donc, avec 3 cœurs, et 15 cœurs disponibles - nous obtenir 5 exécuteurs testamentaires par nœud. (5*6 -1) = 29 exécuteurs
Ainsi, la mémoire est 63/5 ~ 12. Dessus de la tête est de 12*.07=.84 Donc, exécuteur testamentaire de la mémoire est de 12 - 1 GO = 11 GO
Les Chiffres définitifs sont 29 exécuteurs testamentaires, 3 carottes, de l'exécuteur testamentaire de la mémoire est de 11 GO
L'Allocation Dynamique:
Remarque : la limite Supérieure pour le nombre d'exécuteurs si l'allocation dynamique est activé. Donc, il dit que l'étincelle de l'application peut manger à l'écart de toutes les ressources si nécessaire. Donc, en un cluster où vous avez d'autres applications sont en cours d'exécution et ils ont aussi besoin de cœurs pour exécuter les tâches, assurez-vous de le faire au niveau du groupe. Je veux dire que vous pouvez allouer nombre de cœurs pour les FILS en fonction de l'utilisateur. Vous pouvez donc créer des spark_user peut-être et puis donner des carottes (min/max) de l'utilisateur. Ces limites sont pour de partage entre l'étincelle et d'autres applications qui s'exécutent sur le FILS.
spark.dynamicAllocation.activé - Lorsque cette option est définie à true - Nous pas besoin de mentionner les exécuteurs. La raison en est ci-dessous:
La statique params nombre nous donner à étincelle soumettre est pour l'ensemble de la durée du travail. Toutefois, si l'allocation dynamique entre en image, il y aurait différentes étapes comme l'
Ce que pour commencer avec :
Nombre Initial de exécuteurs testamentaires (étincelle.dynamicAllocation.initialExecutors)
Combien d' :
Puis, sur la base de la charge (tâches en attente) combien de demande. Ce serait éventuellement être les chiffres que nous donnons à l'étincelle de la soumettre à l'électricité statique. Donc, une fois que la première exécuteur de ce nombre, nous allons à min (étincelle.dynamicAllocation.minExecutors) et max (étincelle.dynamicAllocation.maxExecutors).
Quand à demander ou à donner:
Lorsque nous demandons de nouveau les exécuteurs testamentaires (étincelle.dynamicAllocation.schedulerBacklogTimeout) - Il y a eu des tâches en attente pour cette quantité de durée. en font la demande. nombre d'exécuteurs demandé à chaque tour, augmente de façon exponentielle à partir de la ronde précédente. Par exemple, une application va ajouter 1 exécuteur testamentaire dans le premier tour, puis 2, 4, 8 et ainsi de suite exécuteurs testamentaires dans les tours suivants. À un certain point, au-dessus du maxi entre en image
quand allons-nous donner un exécuteur testamentaire (étincelle.dynamicAllocation.executorIdleTimeout) -
S'il vous plaît corrigez-moi si j'ai raté quelque chose. Le ci-dessus est ma compréhension basée sur le blog, j'ai partagé en question et des ressources en ligne. Je vous remercie.
Références:
Thomas Decaux
Points
2613
Aussi, cela dépend de votre cas d'utilisation, un important config paramètre est:
spark.memory.fraction(Fraction de (heap space - 300 MO) utilisé pour l'exécution et de stockage) à partir de http://spark.apache.org/docs/latest/configuration.html#memory-management.
Si vous ne faites pas de cache/persistent, il 0.1 sorte que vous avez tous la mémoire de votre programme.
Si vous utilisez le cache/persistent, vous pouvez vérifier la mémoire utilisée par:
sc.getExecutorMemoryStatus.map(a => (a._2._1 - a._2._2)/(1024.0*1024*1024)).sum
Avez-vous de lire les données à partir de HDFS ou de HTTP?
Encore une fois, un réglage dépend de votre cas d'utilisation.
