Aşağıdakiler için, zamanın her noktasında yalnızca bir Spark işinin çalıştığını varsayalım.

Şimdiye kadar aldığım şey

İşte Spark'da neler olduğunu anlıyorum:

1. A SparkContextoluşturulduğunda, her çalışan düğüm bir yürütücü başlatır. Yürütücüler, sürücü programına geri bağlanan ayrı işlemlerdir (JVM). Her yürütücü, sürücü programının kavanozuna sahiptir. Bir sürücüden vazgeçerek, uygulayıcıları kapatır. Her yürütücü bazı bölümlere sahip olabilir.
2. Bir iş yürütüldüğünde, köken grafiğine göre bir yürütme planı oluşturulur.
3. Yürütme işi, çok sayıda komşu (soy grafiğinde) dönüşüm ve eylem içeren, ancak karışık olmayan aşamalar olarak ayrılır. Böylece aşamalar karışıklıklarla ayrılır.

onu anlıyorum

• Görev, Function nesnesini serileştirerek sürücüden bir yürütücüye gönderilen bir komuttur.
• Yürütücü, komutun (görev) serisini kaldırır (sürücü kavanozu ile) ve bir bölüm üzerinde yürütür.

fakat

Soru (lar)

Sahneyi bu görevlere nasıl bölebilirim?

özellikle:

1. Görevler dönüşümler ve eylemler tarafından mı belirleniyor veya bir görevde birden çok dönüşüm / eylem olabilir mi?
2. Görevler bölüm tarafından belirlenir mi (örneğin bölüm başına aşama başına bir görev).
3. Görevler düğümler tarafından belirleniyor mu (örneğin, düğüm başına aşama başına bir görev)?

Ne düşünüyorum (doğru olsa bile sadece kısmi cevap)

Gelen https://0x0fff.com/spark-architecture-shuffle , shuffle görüntü ile açıklanabilir

ve kuralın olduğu izlenimini edindim

her aşama, düğüm sayısına bakılmaksızın # bölüm sayısı görevine ayrılmıştır

İlk resmim için 3 harita görevim ve 3 azaltma görevim olduğunu söyleyebilirim.

0x0fff görüntüsü için, 8 harita görevi ve 3 azaltma görevi olduğunu söyleyebilirim (yalnızca üç turuncu ve üç koyu yeşil dosya olduğu varsayılarak).

Her durumda açık sorular

Bu doğru mu? Ancak bu doğru olsa bile, yukarıdaki sorularımın hepsi cevaplanmıyor, çünkü hala açık, birden fazla işlemin (örneğin birden fazla harita) bir görev içinde mi yoksa her işlem için bir göreve mi ayrılmış olduğu.

Başkaları ne diyor

Spark'daki görev nedir? Spark çalışanı jar dosyasını nasıl yürütür? ve Apache Spark zamanlayıcı dosyaları görevlere nasıl böler? benzer, ama sorumun orada açıkça yanıtlandığını hissetmedim.

Burada çok güzel bir taslak var. Sorularınızı cevaplamak için

• Ayrı task gelmez her biri için her veri bölümü için açılacak ihtiyaç stage. Her bölümün muhtemelen farklı fiziksel konumlarda bulunacağını düşünün - örneğin, HDFS'deki bloklar veya yerel bir dosya sistemi için dizinler / birimler.

StageS gönderiminin DAG Scheduler. Bu, birbirine bağlı olmayan aşamaların paralel olarak yürütmek üzere kümeye sunulabileceği anlamına gelir: bu, kümedeki paralelleştirme yeteneğini en üst düzeye çıkarır. Dolayısıyla, veri akışımızdaki işlemler aynı anda gerçekleşebiliyorsa, birden fazla aşama başlatıldığını göreceğiz.

Aşağıdaki işlem türlerini yaptığımız aşağıdaki oyuncak örneğinde çalışırken bunu görebiliriz:

• iki veri kaynağı yükle
• her iki veri kaynağında ayrı ayrı harita işlemi gerçekleştirme
• onlara katıl
• sonuç üzerinde bazı harita ve filtre işlemleri gerçekleştirin
• sonucu kaydet

Öyleyse kaç aşamaya ulaşacağız?

• İki veri kaynağını paralel olarak yüklemek için her biri 1 kademe = 2 kademe
• Temsil eden bir üçüncü aşama joinise bağımlı diğer iki aşamada
• Not: Birleştirilmiş veriler üzerinde çalışan tüm takip işlemleri aynı aşamada gerçekleştirilebilir, çünkü bunlar sırayla gerçekleşmelidir. Ek aşamaların başlatılmasının bir yararı yoktur, çünkü önceki operasyon tamamlanana kadar çalışmaya başlayamazlar.

İşte o oyuncak programı

val sfi  = sc.textFile("/data/blah/input").map{ x => val xi = x.toInt; (xi,xi*xi) }
val sp = sc.parallelize{ (0 until 1000).map{ x => (x,x * x+1) }}
val spj = sfi.join(sp)
val sm = spj.mapPartitions{ iter => iter.map{ case (k,(v1,v2)) => (k, v1+v2) }}
val sf = sm.filter{ case (k,v) => v % 10 == 0 }
sf.saveAsTextFile("/data/blah/out")

Ve işte sonucun DAG'ı

Şimdi: kaç görev ? Görev sayısı eşit olmalıdır

Toplamı ( Stage* #Partitions in the stage)

Bu, farklı parçaları daha iyi anlamanıza yardımcı olabilir:

• Aşama: bir görevler topluluğudur. Aynı işlem farklı veri alt kümelerine (bölümlere) karşı çalışır.
• Görev: dağıtılmış veri kümesinin bir bölümündeki bir çalışma birimini temsil eder. Yani her aşamada, görev sayısı = bölüm sayısı veya dediğiniz gibi "bölüm başına aşama başına bir görev".
• Her yürütücü bir iplik kabı üzerinde çalışır ve her kap bir düğümde bulunur.
• Her aşamada birden fazla yürütücü kullanılır, her yürütücüye birden çok vcores atanır.
• Her oylama aynı anda tam bir görevi yerine getirebilir
• Böylece, herhangi bir aşamada, birden fazla görev paralel olarak yürütülebilir. çalışan görev sayısı = kullanılan vcores sayısı.

Doğru anlarsam, sizi şaşırtan 2 (ilgili) şey vardır:

1) Bir görevin içeriğini ne belirler?

2) Yürütülecek görev sayısını ne belirler?

Spark'ın motoru ardışık rdds'deki basit işlemleri bir araya "yapıştırır" , örneğin:

rdd1 = sc.textFile( ... )
rdd2 = rdd1.filter( ... )
rdd3 = rdd2.map( ... )
rdd3RowCount = rdd3.count

böylece rdd3 (tembel olarak) hesaplandığında, kıvılcım rdd1'in her bölümü için bir görev oluşturur ve her görev rdd3 ile sonuçlanacak şekilde hem filtre hem de çizgi başına yürütür.

Görev sayısı bölüm sayısına göre belirlenir. Her RDD'nin belirli sayıda bölümü vardır. HDFS'den okunan bir kaynak RDD için (örneğin sc.textFile (...) kullanılarak) bölüm sayısı, giriş biçimi tarafından oluşturulan bölünmelerin sayısıdır. RDD'lerde yapılan bazı işlemler, farklı sayıda bölüm içeren bir RDD ile sonuçlanabilir:

rdd2 = rdd1.repartition( 1000 ) will result in rdd2 having 1000 partitions ( regardless of how many partitions rdd1 had ).

Başka bir örnek de birleşimlerdir:

rdd3 = rdd1.join( rdd2  , numPartitions = 1000 ) will result in rdd3 having 1000 partitions ( regardless of partitions number of rdd1 and rdd2 ).

(Çoğu) bölüm sayısını değiştiren işlemler bir karıştırmayı içerir, Örneğin:

rdd2 = rdd1.repartition( 1000 ) 

gerçekte ne olur? rdd1'in her bölümündeki görevin, rdd2'nin tam olarak 1000 bölüme sahip olmasını sağlamak için aşağıdaki aşamada okunabilen bir son çıktı üretmesi gerekir (Nasıl yaparlar? Hash veya Sort ). Bu taraftaki görevlere bazen "Harita (yan) görevleri" denir. Daha sonra rdd2 üzerinde çalışacak bir görev bir bölüm (rdd2!) Üzerinde çalışacak ve bu bölümle ilgili harita tarafı çıktılarının nasıl okunacağını / birleştirileceğini bulmalıdır. Bu taraftaki görevlere bazen "Görevleri azalt (yan) görevleri" denir.

İki soru birbiriyle ilişkilidir: Bir aşamadaki görev sayısı (birbirine yapıştırılmış ardışık rdds için ortak olan) bölümlerin sayısıdır ve bir RDD'nin bölüm sayısı (bazı bölümlerin bölüm sayısını belirterek) arasında değişebilir örneğin karıştırmaya neden olan işlem).

Bir sahnenin yürütülmesi başladıktan sonra görevleri görev alanlarını işgal edebilir. Eşzamanlı görev alanı sayısı numExecutors * ExecutorCores şeklindedir. Genel olarak, bunlar farklı, bağımlı olmayan aşamalardan gelen görevler tarafından işgal edilebilir.