Bölüm 10: Paralel Algoritmalar

Bölüm 10: Paralel Algoritmalar · Çalışma Soruları

Flynn ve PRAMHızlanma, verim, Amdahlİş ve derinlikPRAM ile indirgemeÖnek toplamıBoru hattıFork/Join ve MapReduceYarış durumu

Sercan KÜLCÜ

Çoktan Seçmeli · Modeller ve Ölçütler

Soru 1: Flynn Sınıfı

Bir GPU binlerce pikselin her birine aynı filtre komutunu aynı anda uyguluyor. Bu çalışma Flynn sınıflandırmasında hangisidir?

A: Tek komut akışı birçok veri öğesine aynı anda uygulanır: SIMD (vektör komutları, GPU) ve veri paralelliği. MIMD'de her işlemci kendi programını kendi verisinde yürütür (çok çekirdekli CPU, küme); MISD nadirdir.

Çoktan Seçmeli · Modeller ve Ölçütler

Soru 2: PRAM Türü

Bir PRAM algoritmasında aynı turda birçok işlemci aynı bellek hücresini okuyabiliyor, ama bir hücreye aynı turda yalnızca tek işlemci yazabiliyor. Bu hangi PRAM türüdür?

C: CREW = Concurrent Read, Exclusive Write. EREW'de okuma da dışlayıcıdır; CRCW'de eşzamanlı yazma da serbesttir ve çakışmalar bir kuralla (ortak değer, öncelik, rastgele) çözülür. PRAM ağaç toplamı EREW ile yetinir.

Çıktı Sorusu · Modeller ve Ölçütler

Soru 3: Hızlanma, Verim, Maliyet

En iyi sıralı algoritma T₁ = 90 s sürüyor. Aynı problem p = 6 işlemcide T₆ = 20 s'de çözülüyor. Hızlanma, verim ve maliyeti hesaplayın. Bu paralel çözüm maliyet-optimal midir?

Cevabı göster

Hızlanma S = T₁ / T₆ = 90 / 20 = 4,5 (ideal 6).
Verim E = S / p = 4,5 / 6 = 0,75.
Maliyet C = p · T₆ = 6 · 20 = 120 s > 90 s.

Maliyet T₁'in sabit katı olduğundan (120 = Θ(90)) bu tek ölçüm için asimptotik bir sonuç çıkarılamaz; ama 30 s'lik fark işlemcilerin %25 boşta beklediğini (iletişim, bekleme, sıralı kısım) gösterir.

Çoktan Seçmeli · Modeller ve Ölçütler

Soru 4: Amdahl Yasası

Bir programın %75'i paralelleştirilebiliyor. Amdahl yasasına göre p = 3 işlemcide hızlanma ve işlemci sayısı sonsuza giderken üst sınır nedir?

C: S = 1 / ((1 − f) + f/p) = 1 / (0,25 + 0,25) = 2; p → ∞ iken S → 1 / (1 − f) = 1 / 0,25 = 4. 2,25 = f · p yalnızca paralel kısmı hızlandırır, sıralı kısmı unutur. Sıralı %25 hızlanmayı 4 ile sınırlar.

Çıktı Sorusu · Modeller ve Ölçütler

Soru 5: Hedef Hızlanma için f

p = 16 işlemcide Amdahl yasasına göre S = 8 hızlanma elde etmek için programın en az ne kadarı (f) paralel olmalıdır? Aynı f için p → ∞ sınırı nedir?

Cevabı göster

1 / ((1 − f) + f/16) = 8 ⇔ (1 − f) + f/16 = 1/8 ⇔ 1 − (15/16) f = 1/8 ⇔ f = (7/8) · (16/15) = 14/15 ≈ %93,3.

Sınır 1 / (1 − f) = 1 / (1/15) = 15. Programın yalnızca %6,7'si sıralı olsa bile 16 işlemcinin verimi %50'ye düşer.

Çoktan Seçmeli · Modeller ve Ölçütler

Soru 6: Gustafson Yasası

Problem boyutu işlemci sayısıyla birlikte büyütülüyor. Paralel kesir f = 0,8 ve p = 10 iken Gustafson yasasına göre ölçeklenmiş hızlanma kaçtır?

D: S = (1 − f) + f · p = 0,2 + 8 = 8,2. 3,6 Amdahl'ın sonucudur (1 / (0,2 + 0,08) ≈ 3,57): sabit boyutlu problem. 5,0 Amdahl sınırıdır (1 / 0,2). Büyük problemlerde sıralı kısmın payı küçüldüğü için paralellik daha kârlıdır.

Çıktı Sorusu · Modeller ve Ölçütler

Soru 7: İş, Derinlik ve Brent

n = 256 sayı dengeli ikili ağaçla toplanıyor. İş W, derinlik D ve paralellik W / D nedir? p = 16 işlemcide Brent teoremi T_p için hangi üst sınırı verir; alt sınırlar nelerdir?

Cevabı göster

W = n − 1 = 255 toplama; D = log₂ 256 = 8 tur; paralellik 255 / 8 ≈ 31,9 (≈ 32 işlemciden fazlası yarar sağlamaz).
Brent: T₁₆ ≤ W/p + D = 255/16 + 8 ≈ 15,9 + 8 = 23,9 → 24 adım.
Alt sınırlar: T₁₆ ≥ W/p ≈ 15,9 ve T₁₆ ≥ D = 8 → T₁₆ ≥ 16.

16 ≤ T₁₆ ≤ 24: Brent sınırı alt sınırın en çok 2 katıdır.

Çoktan Seçmeli · Modeller ve Ölçütler

Soru 8: Süre Sınırları

Bir paralel algoritmanın işi W = 1000, derinliği D = 50. p = 10 işlemcide T_p için hangi aralık kesin olarak doğrudur?

B: Alt sınırlar T_p ≥ W/p = 100 ve T_p ≥ D = 50 → T ≥ 100. Brent üst sınırı T_p ≤ W/p + D = 150. 100'e tam eşitlik ancak hiç bekleme olmazsa sağlanır, garanti değildir.

Adım Adım Çalıştırma · PRAM ile İndirgeme

Soru 9: PRAM ile En Büyük Öğe

PRAM ağaç toplamı, toplama yerine en büyüğü alacak biçimde değiştirildi. Turlar boyunca dizi nasıl değişir, sonuç ve tur sayısı nedir?

Toplamadaki ağaç, toplama yerine Math.max ile en büyük öğeyi bulur (birleşmeli her işlem olur). Her hücreyi bir işlemci tutuyor.

adim = 1, i = 0: a[0] = max(3, 9) = 9. Bu turdaki öteki i'ler aynı anda çalışır.

adim = 1, i = 2: a[2] = max(4, 1) = 4.

adim = 1, i = 4: a[4] = max(5, 2) = 5.

adim = 1, i = 6: a[6] = max(8, 6) = 8.

adim = 2, i = 0: a[0] = max(9, 4) = 9. Bu turdaki öteki i'ler aynı anda çalışır.

adim = 2, i = 4: a[4] = max(5, 8) = 8.

adim = 4, i = 0: a[0] = max(9, 8) = 9.

adim = 8 → döngü biter. En büyük a[0] = 9: log₂ 8 = 3 tur, 4 + 2 + 1 = 7 karşılaştırma (W = n − 1, D = log₂ n). Soluk hücreler artık okunmaz.

int[] a = {3, 9, 4, 1, 5, 2, 8, 6};
int n = a.length;
for (int adim = 1; adim < n; adim *= 2) {
  // aynı turdaki tüm i'ler paralel
  for (int i = 0; i + adim < n; i += 2 * adim)
    a[i] = Math.max(a[i], a[i + adim]);
}  // tur sonu: senkronizasyon
// en büyük a[0]'da

Çıktı Sorusu · PRAM ile İndirgeme

Soru 10: İkinin Kuvveti Olmayan n

Ağaç toplamı kodu a = {4, 2, 7, 1, 3, 5} (n = 6) dizisiyle çalıştırılıyor. Her turda hangi toplamalar yapılır; sonunda a[0] ve dizi nedir? Toplam kaç toplama ve kaç tur?

int n = a.length;
for (int adim = 1; adim < n; adim *= 2) {
  // aynı turdaki tüm i'ler paralel
  for (int i = 0; i + adim < n; i += 2 * adim)
    a[i] = a[i] + a[i + adim];
}  // tur sonu: senkronizasyon

Cevabı göster

adim = 1: i = 0, 2, 4 → a[0] = 6, a[2] = 8, a[4] = 8 → [6, 2, 8, 1, 8, 5]
adim = 2: i = 0 → a[0] = 6 + 8 = 14; i = 4'te 4 + 2 < 6 sağlanmaz
adim = 4: i = 0 → a[0] = 14 + 8 = 22

Dizi [22, 2, 8, 1, 8, 5], a[0] = 22 = 4 + 2 + 7 + 1 + 3 + 5. 5 toplama (= n − 1), 3 tur (= ⌈log₂ 6⌉). i + adim < n koşulu eşi olmayan hücreyi (a[4]) bir sonraki tura bırakır.

Çoktan Seçmeli · PRAM ile İndirgeme

Soru 11: n = 32 Sayının Toplamı

n = 32 sayı PRAM ağaç toplamıyla toplanıyor. Tur sayısı, ilk turda çalışan işlemci sayısı ve toplam toplama sayısı nedir?

A: log₂ 32 = 5 tur; ilk turda n/2 = 16 işlemci çift toplar; 16 + 8 + 4 + 2 + 1 = 31 = n − 1 toplama. Turlar ilerledikçe çalışan işlemci yarıya iner: n işlemciyle maliyet Θ(n log n) olur.

Klasik Soru · PRAM ile İndirgeme

Soru 12: Maliyet-Optimal Toplama

n işlemcili PRAM ağaç toplamı neden maliyet-optimal değildir? p = n / log₂ n işlemciyle nasıl maliyet-optimal yapılır? n = 1024 için iki sürümün işlemci sayısı, süresi ve maliyetini karşılaştırın.

Cevabı göster

n işlemciyle T = log₂ n, maliyet p · T = n log₂ n; en iyi sıralı algoritma Θ(n). Turlar ilerledikçe işlemcilerin çoğu boşta bekler.

Düzeltme: her işlemci önce kendi log₂ n'lik bloğunu sıralı toplar (O(log n)), sonra n / log₂ n kısmi toplam ağaçla birleştirilir (O(log n)). Maliyet (n / log n) · O(log n) = Θ(n).

n = 1024	p	T	Maliyet p · T
n işlemci	1024	10	10 240
n / log₂ n	≈ 102	≈ 9 + 7 = 16	≈ 1 632 = Θ(n)

İkinci sürümde süre biraz uzar (bloğu toplamak 9 adım, 102 kısmi toplamın ağacı ⌈log₂ 102⌉ = 7 tur), ama işlemci-zaman 6 kat azalır.

Adım Adım Çalıştırma · Önek Toplamı

Soru 13: Hillis–Steele İzleme

Hillis–Steele önek toplamı [3, 1, 4, 1, 5, 9, 2, 6] dizisine uygulanıyor. Her turda hangi değerler hesaplanır, kaç toplama yapılır?

Amaç kapsayıcı önek toplamı: her i için x₀ + … + xᵢ. Her hücreyi bir işlemci tutuyor.

d = 1: i ≥ 1 olan 7 işlemci aynı anda y[i] = x[i] + x[i − 1] hesaplar (çizgiler okunan iki hücre). Okumalar eski x'ten yapılır.

Tur sonu x = y: artık her hücre 2 öğelik pencerenin toplamı (pencere başta kesilir).

d = 2: i ≥ 2 olan 6 işlemci aynı anda y[i] = x[i] + x[i − 2] hesaplar (çizgiler okunan iki hücre). Okumalar eski x'ten yapılır.

Tur sonu x = y: artık her hücre 4 öğelik pencerenin toplamı (pencere başta kesilir).

d = 4: i ≥ 4 olan 4 işlemci aynı anda y[i] = x[i] + x[i − 4] hesaplar (çizgiler okunan iki hücre). Okumalar eski x'ten yapılır.

Sonuç [3, 4, 8, 9, 14, 23, 25, 31]. log₂ 8 = 3 tur (D), ama 7 + 6 + 4 = 17 toplama (W = O(n log n)); sıralı algoritma 7 toplama yapar: iş-verimli değil.

int[] x = {3, 1, 4, 1, 5, 9, 2, 6};
int n = x.length;
for (int d = 1; d < n; d *= 2) {
  int[] y = x.clone();  // tur başı kopya
  for (int i = d; i < n; i++)  // hepsi paralel
    y[i] = x[i] + x[i - d];
  x = y;  // senkronizasyon
}

Çıktı Sorusu · Önek Toplamı

Soru 14: Kopyasız Önek Toplamı

Hillis–Steele kodunda tur başı kopya kaldırılıp hesap aynı dizi üzerinde yapılıyor. {2, 4, 1, 3, 5} için çıktı nedir, doğru önek toplamı nedir? Hata neden kaynaklanır?

int[] x = {2, 4, 1, 3, 5};
int n = x.length;
for (int d = 1; d < n; d *= 2)
  for (int i = d; i < n; i++)
    x[i] += x[i - d];  // kopya yok!
System.out.println(Arrays.toString(x));

Cevabı göster

Çıktı: [2, 6, 9, 16, 26]; doğrusu [2, 6, 7, 10, 15].

d = 1: i artan sırayla gezilir; x[2] += x[1] okunduğunda x[1] bu turda zaten güncellenmiştir → tek turda sıralı önek oluşur: [2, 6, 7, 10, 15].
d = 2 ve d = 4 turları bu doğru sonuca yeniden ekler: [2, 6, 9, 16, 24] → [2, 6, 9, 16, 26].

PRAM'da bir turdaki tüm okumalar yazmalardan önce olur; sıralı simülasyonda bunu kopya (ya da i'yi azalan sırada gezmek) sağlar. Gerçek paralel kodda bu, turlar arası senkronizasyon (bariyer) unutulunca ortaya çıkan yarışa karşılık gelir.

Çoktan Seçmeli · Önek Toplamı

Soru 15: Hillis–Steele'in İşi

n = 16 öğeli bir diziye Hillis–Steele önek toplamı uygulanıyor. Toplam kaç toplama yapılır?

D: d = 1, 2, 4, 8 turlarında n − d toplama: 15 + 14 + 12 + 8 = 49 = n log₂ n − (n − 1). 15 sıralı algoritmanın işidir; 64 = n log₂ n kaba üst sınırdır. Blelloch yukarı/aşağı süpürmesi O(n) işle (≈ 2(n − 1) = 30) aynı O(log n) derinliğe ulaşır.

Adım Adım Çalıştırma · Boru Hattı

Soru 16: Boru Hattı İzleme

p = 4 işlemci, m = 3 satır; sütunlar p0: (2, 1, 3), p1: (4, 2, 1), p2: (1, 5, 2), p3: (3, 1, 4). Boru hattı kodu her adımda hangi toplamaları yapar?

4 işlemci zincir (p0 → p1 → p2 → p3), her biri 3 satırlık bir sütun tutuyor. Hedef: her satırda p_j, p0 … p_j toplamını tutsun. p0'ın değerleri zaten sonuçtur (yeşil).

t = 0: p0→p1 satır 0: 4 + 2 = 6.

t = 1: p0→p1 satır 1: 2 + 1 = 3; p1→p2 satır 0: 1 + 6 = 7.

t = 2: p0→p1 satır 2: 1 + 3 = 4; p1→p2 satır 1: 5 + 3 = 8; p2→p3 satır 0: 3 + 7 = 10.

t = 3: p1→p2 satır 2: 2 + 4 = 6; p2→p3 satır 1: 1 + 8 = 9.

t = 4: p2→p3 satır 2: 4 + 6 = 10. Bitti: m + p − 2 = 5 adım (saf yöntem m(p − 1) = 9); p3 satır toplamlarını (10, 9, 10) tutar.

for (int t = 0; t < m + p - 2; t++)
  // tüm j'ler aynı anda
  for (int j = 0; j < p - 1; j++) {
    int r = t - j;
    if (r >= 0 && r < m)
      x[j + 1][r] += x[j][r];
  }

Çoktan Seçmeli · Boru Hattı

Soru 17: Boru Hattı Adım Sayısı

Doğrusal zincirdeki boru hattında p = 6 işlemci ve m = 50 satır var. Boru hattıyla kaç adım gerekir; satırları tek tek zincir boyunca taşıyan saf yöntem kaç adım sürer?

B: Boru hattı m + p − 2 = 54 adım; saf yöntem her satırı p − 1 = 5 adımda taşır: m(p − 1) = 250. 50, hattın dolma süresini unutmaktır. Verim m / (m + p − 2) = 50/54 ≈ 0,93: m ≫ p iken 1'e yaklaşır.

Çıktı Sorusu · Boru Hattı

Soru 18: Boru Hatlı Ağaç

Sunumdaki boru hatlı ağaçta (7 işlemci, derinlik h = 3, bir düğüm turda en çok bir ileti alabilir, en fazla çocuk sayısı 2) her işlemci k = 5 bileşenli bir vektör tutsaydı tüm bileşenlerin kökte toplanması kaç tur sürerdi? Bileşenleri sırayla indirgeyen saf yöntemle karşılaştırın.

Cevabı göster

Yeni bir bileşen 2 turda bir yola çıkabilir: p1 ve p0 iki çocuktan ileti alır, bir bileşen onları 2 tur meşgul eder.

Tur = h + (k − 1) · 2 = 3 + 4 · 2 = 11; saf yöntem k · h = 5 · 3 = 15.

k büyüdükçe boru hatlı ağaç ≈ 2k, saf yöntem 3k tur sürer. Genel: tur ≈ h + (k − 1) · (en fazla çocuk sayısı).

Adım Adım Çalıştırma · Fork/Join ve MapReduce

Soru 19: Fork/Join Sıralama İzleme

new ForkJoinPool().invoke(new SiralamaGorevi(new int[]{5, 2, 4, 1})) çalışıyor. Görev ağacı nasıl oluşur ve sonuç nasıl birleşir?

Kök görev [5, 2, 4, 1]; uzunluk 4 > 1, orta = 2.

İki alt görev kopyalarla oluşturulur ve fork() ile havuza verilir: [5, 2] ve [4, 1] aynı anda çalışabilir.

Her alt görev de böler ve fork eder: 4 yaprak görev [5], [2], [4], [1].

Taban durum: 1 öğeli diziler zaten sıralıdır, hemen döner.

join(): her ebeveyn iki çocuğun sonucunu bekler ve birleştirir: [2, 5] ve [1, 4]. Bu iki birleştirme paralel yapılır.

Kök görev son birleştirmeyi tek başına yapar: [1, 2, 4, 5]. Bu sıralı birleştirme derinliği D(n) = D(n/2) + Θ(n) = Θ(n) yapar; iş Θ(n log n), paralellik yalnızca Θ(log n).

protected int[] compute() {
  if (dizi.length <= 1) return dizi;
  int orta = dizi.length / 2;
  var sol = new SiralamaGorevi(
      Arrays.copyOfRange(dizi, 0, orta));
  var sag = new SiralamaGorevi(
      Arrays.copyOfRange(dizi, orta, dizi.length));
  sol.fork();  // paralel başlat
  sag.fork();
  return birlestir(sol.join(), sag.join());
}

Çoktan Seçmeli · Fork/Join ve MapReduce

Soru 20: Paralel Birleştirme Sıralamasının Derinliği

İki yarıyı paralel sıralayıp sıralı birleştiren Fork/Join birleştirme sıralaması için derinlik D(n) ve paralellik W / D nedir?

D: İki yarı paralel olduğu için D(n) = D(n/2) + Θ(n) (birleştirme sıralı) = Θ(n); W = Θ(n log n) → paralellik Θ(log n): n = 10⁶ için ≈ 20 çekirdekten fazlası pek yararlı olmaz. B tamamen sıralı sürümdür; Θ(log³ n) derinlik için birleştirmenin de paralel olması gerekir.

Çıktı Sorusu · Fork/Join ve MapReduce

Soru 21: MapReduce Kelime Sayma

Kelimeler: "elma armut elma kiraz armut elma muz kiraz" (8 kelime). 3 map görevi var; parça boyu ⌊8/3⌋ = 2, son görev kalan tüm kelimeleri alıyor. Her map görevinin ara sonucu ve reduce sonrası toplam nedir?

protected Map<String, Integer> compute() {
  Map<String, Integer> sonuc = new HashMap<>();
  for (String kelime : parca)
    sonuc.merge(kelime, 1, Integer::sum);
  return sonuc;
}
// Reduce
for (Map<String, Integer> m : ara)
  m.forEach((k, v) ->
      toplam.merge(k, v, Integer::sum));

Cevabı göster

Görev	Parça	Ara sonuç (map)
1	elma armut	elma 1, armut 1
2	elma kiraz	elma 1, kiraz 1
3	armut elma muz kiraz	armut 1, elma 1, muz 1, kiraz 1

Reduce (merge(k, v, Integer::sum)): elma 3, armut 2, kiraz 2, muz 1.

Her map görevinin kendi HashMap'i olduğu için paylaşılan durum ve kilit yoktur. Son görev 4 kelime aldığı için yük dengesizdir; HashMap yineleme sırası tanımsız olduğundan yazdırma sırası farklı çıkabilir.

Çıktı Sorusu · Fork/Join ve MapReduce

Soru 22: Satır Başına Görev

A = [[1, 2, 3], [4, 5, 6], [7, 8, 9]], B = [[9, 8, 7], [6, 5, 4], [3, 2, 1]]. SatirGorevi görevi satir = 1 için C'nin hangi satırını hesaplar ve ne yazar? n × n matriste bu yaklaşımın işi ve derinliği nedir?

protected void compute() {
  for (int j = 0; j < n; j++) {
    C[satir][j] = 0;
    for (int k = 0; k < n; k++)
      C[satir][j] += A[satir][k] * B[k][j];
  }
}

Cevabı göster

C[1] = (4·9 + 5·6 + 6·3, 4·8 + 5·5 + 6·2, 4·7 + 5·4 + 6·1) = [84, 69, 54].

n görev, her biri n² çarpma-toplama: W = Θ(n³); görevler bağımsız ve paralel, ama bir satır içinde sıralı: D = Θ(n²). Her görev yalnızca kendi satırına yazdığı için yarış yoktur.

Adım Adım Çalıştırma · Yarış Durumu

Soru 23: Kayıp Güncelleme

İki iş parçacığı paylaşılan sayac'ı aşağıdaki sırayla iç içe geçerek artırıyor: İP1 oku, İP2 oku, İP1 artır, İP2 artır, İP1 yaz, İP2 yaz. sayac sonunda kaçtır?

Paylaşılan sayac = 0. İki iş parçacığı (İP1, İP2) birer kez artıracak; beklenen sonuç 2. sayac++ aslında bu üç adımdır.

İP1 okur: t₁ = 0.

İP1 yazmadan önce zamanlayıcı İP2'ye geçer: İP2 de 0 okur.

İP1 kendi yerel kopyasını artırır: t₁ = 1 (bellek hâlâ 0).

İP2 de artırır: t₂ = 1.

İP1 yazar: sayac = 1.

İP2 yazar: sayac = 1. İP1'in artışı kayboldu (lost update): sonuç 1. Çözüm: AtomicInteger.incrementAndGet(), synchronized ya da her görevin yerel sonucu + birleştirme.

// İş parçacığı 1 ve 2 aynı kodu çalıştırır:
int t = sayac;  // oku
t = t + 1;  // artır
sayac = t;  // yaz

Çoktan Seçmeli · Yarış Durumu

Soru 24: Yarışın Sonucu

İki iş parçacığının her biri paylaşılan int sayac değişkenini (başta 0) senkronizasyonsuz olarak sayac++ ile 1000'er kez artırıyor. Program bitince sayac için hangisi kesin olarak doğrudur?

B: Her kayıp güncelleme bir artışı siler, değer asla eklenmez: sonuç ≤ 2000, ama zamanlamaya bağlı olarak (her çalıştırmada farklı) daha küçük olabilir. Hata her çalıştırmada görülmeyebilir; bu yüzden yarış durumları zor ayıklanır.

Çoktan Seçmeli · Yarış Durumu

Soru 25: Güvenli Ziyaret Kümesi

Eşzamanlı çizge gezinmesinde birçok görev aynı ziyaret kümesini paylaşıyor. Bir düğümün yalnızca bir kez gezilmesini hangi kod garanti eder?

C: Eşzamanlı küme ve add'in dönüş değeri kontrol ile eklemeyi tek atomik işlem yapar. B'de küme güvenli olsa da contains ile add arasında başka bir görev aynı düğümü ekleyebilir (iki ayrı adım). HashSet eşzamanlı yazmada iç yapısı bozulabileceği için A ve D güvenli değildir.

Klasik Soru · Yarış Durumu

Soru 26: fork, compute, join

Fork/Join birleştirme sıralamasında sol.fork(); sag.fork(); birlestir(sol.join(), sag.join()) yerine sol.fork(); int[] y = sag.compute(); int[] x = sol.join(); yazmak neden daha iyidir? Ayrıca küçük parçalar için bir eşik neden gerekir?

Cevabı göster

İki alt görevi de fork eden iş parçacığı, sonra join'de boşta bekler. Birini doğrudan compute() ile kendisi çalıştırırsa iş parçacığı yararlı iş yapar; havuza verilen görev sayısı yarıya iner.
Her görev nesnesi, kopya dizi ve havuz işlemleri bir yük getirir. 1 öğeye kadar inmek milyonlarca küçük görev üretir: görev oluşturma yükü kazancı yer.
Eşik: if (dizi.length < 1000) { Arrays.sort(dizi); return dizi; } gibi; küçük parçalar sıralı çözülür.

ForkJoinPool iş çalma ile boşta kalan çekirdeklere bekleyen görevleri verir; bu yüzden kalan paralellik yine kullanılır.

Klasik Soru · Yarış Durumu

Soru 27: Paralelleştirilemeyen Döngü

Aşağıdaki iki döngüden hangisi PRAM'da O(log n) derinlikte paralelleştirilebilir, hangisi paralelleştirilemez? Neden? (a) for i: y[i] = y[i − 1] + x[i] (b) for i: x[i] = f(x[i − 1]), f keyfi bir fonksiyon.

Cevabı göster

İkisi de veri bağımlılığı (adım i, adım i − 1'i bekler) içeriyor gibi görünür, ama:

(a) önek toplamıdır. Toplama birleşmeli olduğu için parantezler değiştirilebilir: Hillis–Steele (W = O(n log n)) ya da Blelloch (W = O(n)) ile D = O(log n).
(b) keyfi f için birleşmeli bir "birleştirme" işlemi yoktur: x[i]'yi bilmek için x[i − 1] gerçekten hesaplanmış olmalıdır. Bağımlılık zinciri n uzunluğundadır: D = Θ(n), paralellik 1.

Genel kural: derinlik, en uzun bağımlılık zinciridir. Birleşmeli bir işlem zinciri ağaca çevirmeye izin verir (indirgeme, tarama); keyfi yineleme vermez.

Son

Bölüm 10: Paralel Algoritmalar: Çalışma Soruları

Konu anlatımı: Paralel Algoritmalar sunumu · Terim sözlüğü