Wie man Funken Executor Nummer, Kerne und Executor Speicher stimmt?

Folgende Antwort umfasst die 3 wichtigsten genannten Aspekte in Titel - Anzahl der Vollzieher, Vollstrecker Speicher und Anzahl der Kerne. Es können auch andere Parameter wie Treiber, Speicher, und andere, die ich nicht angesprochen als dieser Antwort, möchte aber noch hinzufügen in Naher Zukunft.

Fall 1 Hardware - 6 Knoten, und Jeder Knoten 16 cores, 64 GB RAM

Jeder Testamentsvollstrecker ist eine JVM-Instanz. So können wir mehrere Testamentsvollstrecker in einem einzigen Knoten

Ersten 1 core und 1 GB benötigt für OS und Hadoop Daemons, so sind 15 Kerne, 63 GB RAM für jeden Knoten

Starten Sie mit, wie die Anzahl der Kerne:

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.

Anzahl der Vollzieher:

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

Speicher für jeden Vollzieher:

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

Endgültigen zahlen - Vollzieher - 17, - Kerne 5, Testamentsvollstrecker Speicher - 19 GB

Fall 2 Hardware : 6 Gleichen Knoten, 32 Cores, 64 GB

5 ist die gleiche für gute Parallelität

Anzahl der Vollzieher für jede node = 32/5 ~ 6

Also insgesamt Vollzieher = 6 * 6 Knoten = 36. Dann die Letzte Zahl ist die 36 - 1 für AM = 35

Testamentsvollstrecker Speicher : 6 Testamentsvollstrecker für jeden Knoten. 63/6 ~ 10 . Über Kopf ist .07 * 10 = 700 MB. Also, Rundung auf 1 GB über den Kopf, wir bekommen 10-1 = 9 GB

Endgültigen zahlen - Vollzieher - 35, - Kerne 5, Testamentsvollstrecker Speicher 9 GB

Fall 3

Den oben genannten Szenarien beginnen mit Annahme der Anzahl der Kerne als Feste und bewegliche # der Vollzieher und der Speicher.

Nun für den ersten Fall, wenn wir denken, wir brauchen nicht, 19 GB, und nur 10 GB ausreichend ist, dann werden die folgenden Nummern:

Kerne 5
# der Vollzieher für jede node = 3

In diesem Stadium dazu führen würde 21, und dann mit 19 nach unserer ersten Berechnung. Aber da dachten wir, dass 10 ist ok (übernehmen wenig Aufwand), dann können wir nicht wechseln # der Vollzieher
pro Knoten 6 (wie 63/10). Becase mit 6 Vollzieher pro Knoten und 5 Kerne kommt es auf 30 Kerne pro Knoten, wenn wir nur 16 Kerne. So müssen wir auch ändern Sie die Anzahl der
Kerne für jeden executor.

Damit die Berechnung wieder,

Die Magische Zahl 5 wird zu 3 - (irgendeine Zahl weniger als oder gleich 5 ist). So mit 3 Kernen und 15 Kerne - wir bekommen 5 Vollzieher pro Knoten. Also (5*6 -1) = 29 Vollzieher

Also Speicher ist 63/5 ~ 12. Über Kopf ist 12*.07=.84
So executor Speicher 12 - 1 GB = 11 GB

Endgültigen Zahlen sind 29 Vollzieher, 3 Kerne, Testamentsvollstrecker Speicher ist mit 11 GB

Die Dynamische Zuordnung:

Hinweis : Obere Schranke für die Anzahl der Vollzieher, wenn die dynamische Zuordnung aktiviert ist. Es sagt also, dass die Funke-Anwendung kann fressen alle Ressourcen, wenn nötig. So in
ein cluster, in dem Sie andere Anwendungen ausgeführt werden, und Sie müssen auch Kerne von tasks ausführen zu bitte stellen Sie sicher, Sie tun es in der cluster-Ebene. Ich meine, Sie können zuweisen
bestimmte Anzahl von Kernen für GARN, basierend auf Benutzer-Zugang. So können Sie spark_user werden können und dann geben die Kerne (min/max) für diesen Benutzer. Diese Grenzen sind für den Austausch zwischen spark und andere Anwendungen, die auf das GARN.

Funken.dynamicAllocation.aktiviert - Wenn dieser auf true gesetzt ist - Wir müssen nicht erwähnen Vollzieher. Der Grund ist unten:

Den statischen params Nummer geben wir an der Funke zu übermitteln ist für die gesamte Arbeit Dauer. Allerdings, wenn die dynamische Zuordnung kommt ins Bild, es würde auf verschiedenen Bühnen wie

Was für den Anfang :

Anfängliche Zahl der Vollzieher (Funken.dynamicAllocation.initialExecutors), um mit zu beginnen

Wie viele :

Dann anhand der Auslastung (anstehender Aufgaben), wie viele zu beantragen. Dies würde letztlich das zahlen, was wir geben im spark-reichen in statischer Weise. Also, sobald die ersten executor-Nummern eingestellt sind, gehen wir zu min (Funken.dynamicAllocation.minExecutors) und max (Funken.dynamicAllocation.maxExecutors) zahlen.

, Wenn Fragen oder geben:

Wenn wir neue Anfrage Vollzieher (Funken.dynamicAllocation.schedulerBacklogTimeout) - Es wurden die anstehenden Aufgaben für diese viel Dauer. so verlangen. Anzahl der Testamentsvollstrecker beantragt, in jeder Runde exponentiell erhöht aus der vorherigen Runde. Zum Beispiel, eine Anwendung hinzufügen 1 Vollstrecker in der ersten Runde, und dann 2, 4, 8 und so weiter Vollzieher in die nachfolgenden Runden. An einem bestimmten Punkt, der über max kommt ins Bild

Wann wir verschenken einen Testamentsvollstrecker (Funken.dynamicAllocation.executorIdleTimeout) -

Bitte korrigieren Sie mich, wenn ich nichts übersehen habe. Das oben ist mein Verständnis basiert auf dem blog, die ich gemeinsam in Frage und einige online-Ressourcen. Danke.

Referenzen:

• http://site.clairvoyantsoft.com/understanding-resource-allocation-configurations-spark-application/
• http://spark.apache.org/docs/latest/configuration.html#dynamic-allocation
• http://spark.apache.org/docs/latest/job-scheduling.html#resource-allocation-policy

InformationsquelleAutor der Antwort Ramzy