Çoklu Süreç

Önceki ders bir duvara tosladı. İşlemci ağırlıklı yükte işçi sayısını ikiden sekize çıkarmak tik sayısını 73’te bıraktı; kazanç ikinci işçide dondu ve bir daha kımıldamadı. Sebebi tabloda yazılıydı: değişmeyen ayar yuva. Yetmiş üç işlemci adımı, bir tikte tek işlemci adımı atılabildiği sürece yetmiş üç tik ister.

İş parçacığı o ayarı değiştiremez, çünkü sekiz iş parçacığı da aynı yorumlayıcının içindedir. Değiştirebilecek olan şey ayrı bir yorumlayıcıdır. Bu ders o yolu ölçer ve iki soru sorar: dört yuva seksen adımı kaça indirir, ve yuva sayısı görev sayısına eşitlendiğinde yükün bileşimi hâlâ bir şey söyler mi?

Ayrı Süreç, Ayrı Yorumlayıcı

Süreç, kendi adres alanı olan bir yürütme birimidir. Süreç ile iş parçacığının farkı İşletim Sistemi Kavramları kursunda mekanizma olarak kuruldu; burada tekrarlanmaz. Bu dersin sorusu yine sayı: ayrı süreç başlatmak modelin hangi ayarını değiştirir?

Ayrı süreç, ayrı bir yorumlayıcı demektir. Ayrı yorumlayıcının kendi genel yorumlayıcı kilidi vardır ve o kilit başkasının kilidiyle ilgilenmez. Dört süreç, dört bağımsız kilit, yani dört yuva. Modeldeki karşılığı doğrudan budur: işlemci yuvası dörde çıkar.

Bu, iş parçacığının yapamadığı şeydir. İş parçacığı işçi ekler, süreç yuva ekler. Önceki dersin duvarı işçi duvarı değil yuva duvarıydı; bu yüzden aşan şey de süreçtir.

Süreçlerin Ödediği Şey Sayılabilir

Ayrı adres alanının bedeli var ve bu bedel kursun ölçü birimiyle yazılabilir.

Aynı süreçteki iki iş parçacığı aynı nesneyi görür; birinin yazdığını öbürü okur. Ayrı iki süreç görmez. Görevi bir sürece vermek, girdisini o sürece taşımak; sonucu almak, geri taşımak demektir. Taşınan şey aktarılabilir bir gösterime çevrilir, öbür uçta geri kurulur.

Bu iş bir süre değil, bir adım dizisidir. Model onu tam olarak böyle sayar: her görevin iki ucuna eklenen bir miktar işlemci adımı. Aktarım adımı da bir işlemci adımıdır ve yuvayı kullanır. Ölçümün son bölümü bedelin hangi büyüklükte kazancı yediğini sorar.

Ölçümün varsayımları:

• EM24 — Çekirdek önceki iki dersin aynısıdır: sekiz görev, görev başına on adım, toplam seksen adım; tohum sabit.
• EM25 — Süreç rejiminin modeldeki karşılığı yuvanın büyümesidir; işçi sekizde sabit tutulur ki tek değişkenin yuva olduğu görülsün.
• EM26 — Gerçek süreç başlatılmaz. Başlatılsaydı hangi sürecin ne zaman ilerlediği işletim sistemine bağlı olurdu ve çıktı yeniden üretilemezdi.
• EM27 — Dört yuva, dört ayrı yorumlayıcı demektir; sekiz yuva, görev sayısı kadar yorumlayıcı.
• EM28 — Alt sınır kuralı sürüyor: tik sayısı, işlemci adımı sayısının yuvaya bölümünün yukarı yuvarlanmış hâlinin altına inemez.
• EM29 — Aktarım bedeli, her görevin iki ucuna eklenen işlemci adımı sayısıdır: giren veri ve dönen sonuç. Bedel bir tam sayıdır ve her görevde aynıdır.
• EM30 — Aktarım adımı yuvayı kullanır; ayrı bir kaynağı yoktur.
• EM31 — Aktarım bedelli ve bedelsiz koşumlar aynı görev dizisinden üretilir; karşılaştırma tabanı, bedel ödemeyen tek akış rejimidir (80 tik).
• EM32 — Süreç başlatmanın kendisi modelde bedelsizdir; sayılan yalnız veri devridir. Gerçek bir sistemde başlatma da bedellidir ve bu, ölçülen kazancı yalnız küçültür.
• EM33 — Görevler bağımsızdır; süreçler arası ortak durum ve eşgüdüm bu ölçümün dışındadır.
• EM34 — Süre ölçülmez; sayılan birim adım, tik ve örtüşen adımdır.
• EM35 — Ölçüm tek koşumdur ve üç yük aynı çekirdekten üretilir.

Ölçüm

"""Coklu surec: yuva eklemek ve yuvanin gorev sayisina ulasmasi."""

TOHUM = 20260817
ISLEMCI, GC = "islemci", "g_c"


def uretec(tohum):
    d = tohum % 2147483646 + 1

    def r(n):
        nonlocal d
        d = (d * 48271) % 2147483647
        return d % n
    return r


def gorevler(sayi=8, adim=10, gc_payi=7, tohum=TOHUM):
    """Her gorev bir adim dizisi; gc_payi/10 orani girdi/cikti adimi."""
    r, liste = uretec(tohum), []
    for i in range(sayi):
        liste.append([GC if r(10) < gc_payi else ISLEMCI for _ in range(adim)])
    return liste


def kosum(gorevler, isci, islemci_yuvasi):
    """Donen: tik, ortusen adim, islemci adimi, g/c adimi."""
    kalan = [list(g) for g in gorevler]
    tik = ortusen = islemci_adim = gc_adim = 0
    while any(kalan):
        etkin = [i for i, g in enumerate(kalan) if g][:isci]
        if not etkin:
            break
        yuva, ilerleyen = islemci_yuvasi, 0
        for i in etkin:
            adim = kalan[i][0]
            if adim == ISLEMCI:
                if yuva <= 0:
                    continue
                yuva -= 1
                islemci_adim += 1
            else:
                gc_adim += 1
            kalan[i].pop(0)
            ilerleyen += 1
        tik += 1
        ortusen += max(0, ilerleyen - 1)
    return tik, ortusen, islemci_adim, gc_adim


def aktarimli(gorevler, bedel):
    """Her gorevin iki ucuna 'bedel' kadar islemci adimi ekler: veri devri."""
    return [[ISLEMCI] * bedel + list(t) + [ISLEMCI] * bedel for t in gorevler]


YUKLER = (("girdi/çıktı ağırlıklı", 7), ("dengeli", 5), ("işlemci ağırlıklı", 1))

print("yuva sayısı arttıkça (işçi hep sekiz)")
print(f"{'yuva':>5s} " + " ".join(f"{ad:>25s}" for ad, _ in YUKLER))
print(f"{'':5s} " + " ".join(f"{'tik / örtüşen':>25s}" for _ in YUKLER))
for yuva in range(1, 9):
    hucre = []
    for ad, pay in YUKLER:
        tik, ortusen, _, _ = kosum(gorevler(gc_payi=pay), 8, yuva)
        hucre.append(f"{f'{tik} / {ortusen}':>25s}")
    print(f"{yuva:5d} " + " ".join(hucre))

g = gorevler(gc_payi=1)
tek = kosum(g, 1, 1)[0]
print()
print(f"işlemci ağırlıklı yük, tek akış {tek} tik")
for yuva in (1, 4, 8):
    tik, ortusen, islemci_adim, _ = kosum(g, 8, yuva)
    print(f"  {yuva} yuva: {tik:3d} tik, {ortusen:3d} örtüşen adım, "
          f"kazanç {tek - tik:3d} tik, alt sınır "
          f"{-(-islemci_adim // yuva):3d}")

print()
print("aktarım bedeli: her göreve iki uçta 'bedel' kadar işlemci adımı")
print(f"{'bedel':>6s} {'adım':>5s} {'dört yuva':>10s} {'örtüşen':>8s} "
      f"{'tek akış':>9s} {'kazanç':>7s}")
for bedel in (0, 1, 2, 4, 8, 15):
    gg = aktarimli(g, bedel)
    tik, ortusen, _, _ = kosum(gg, 8, 4)
    print(f"{bedel:6d} {sum(len(t) for t in gg):5d} {tik:10d} {ortusen:8d} "
          f"{tek:9d} {tek - tik:7d}")

yuva sayısı arttıkça (işçi hep sekiz)
 yuva     girdi/çıktı ağırlıklı                   dengeli         işlemci ağırlıklı
                  tik / örtüşen             tik / örtüşen             tik / örtüşen
    1                   31 / 49                   42 / 38                    73 / 7
    2                   16 / 64                   23 / 57                   38 / 42
    3                   11 / 69                   18 / 62                   29 / 51
    4                   10 / 70                   16 / 64                   20 / 60
    5                   10 / 70                   12 / 68                   19 / 61
    6                   10 / 70                   10 / 70                   19 / 61
    7                   10 / 70                   10 / 70                   16 / 64
    8                   10 / 70                   10 / 70                   10 / 70

işlemci ağırlıklı yük, tek akış 80 tik
  1 yuva:  73 tik,   7 örtüşen adım, kazanç   7 tik, alt sınır  73
  4 yuva:  20 tik,  60 örtüşen adım, kazanç  60 tik, alt sınır  19
  8 yuva:  10 tik,  70 örtüşen adım, kazanç  70 tik, alt sınır  10

aktarım bedeli: her göreve iki uçta 'bedel' kadar işlemci adımı
 bedel  adım  dört yuva  örtüşen  tek akış  kazanç
     0    80         20       60        80      60
     1    96         24       72        80      56
     2   112         28       84        80      52
     4   144         36      108        80      44
     8   208         52      156        80      28
    15   320         80      240        80       0

Dört Yuva: Seksenden Yirmiye

Orta blok önceki dersin duvarını yıkıyor. İşlemci ağırlıklı yükte tek yuva 73 tik veriyordu; dört yuva aynı seksen adımı 20 tikte bitiriyor. Kazanç 60 tik, örtüşen adım 60.

Karşılaştırma dersin bütün noktasını taşıyor. İş parçacığı bu yükte 7 tik kazandırmıştı; süreç 60 kazandırıyor. Değişen şey görev sayısı değil, işçi sayısı değil, çizelgeleyici değil — yalnız yuva.

Alt sınır sütunu da yerini buluyor: 73 işlemci adımı dört yuvaya bölündüğünde alt sınır 19, ulaşılan 20. Bir tiklik boşluk kalıyor, çünkü koşumun sonuna doğru yuvaları dolduracak kadar canlı görev kalmıyor. Sekiz yuvada alt sınır 10 ve ulaşılan da 10 — bu kez tam oturuyor.

Buradan pratik bir okuma çıkıyor: işlemci ağırlıklı bir yükte kazanç, yuva sayısına bölünmeyle gelir. İşlemci adımı sayısı sabit; onları kaç yuvaya dağıttığınız tik sayısını belirler. İş parçacığı bu bölmeyi yapamaz.

Yuva Görev Sayısına Ulaştığında Yük Kaybolur

Üst tablonun son satırı bu dersin ikinci ölçümü ve kursun dördüncü okuması: sekiz yuvada üç yükün üçü de 10 tik ve 70 örtüşen adım veriyor.

Yukarıdaki yedi satır boyunca üç sütun birbirinden ayrıydı. Tek yuvada 31, 42 ve 73 gibi üç ayrı sayı vardı; dört yuvada 10, 16 ve 20. Sekizinci satırda üçü de aynı yere düşüyor ve aradaki bütün fark kayboluyor.

Sebebi tanımda: yuva sayısı görev sayısına eşitlendiğinde hiçbir görev yuva bulamadığı için beklemez. Her tikte canlı olan her görev bir adım atar. Sekiz görevin her biri on adım taşıdığına göre on tik gerekir ve her tikte sekiz görev ilerlediğinden tik başına yedi örtüşen adım birikir: 10 tik, 70 örtüşen adım. Adımların türü artık hiçbir şey belirlemiyor.

Bu, ölçümün en sık yanlış okunan yeridir. “Girdi/çıktı ağırlıklı iş şu rejimi ister, işlemci ağırlıklı iş bu rejimi ister” cümlesi doğrudur ama koşulludur: kısıt varken doğrudur. Kısıt kalkınca yükün bileşimi bir ayrım üretmez. Yükün bileşimini sormanın anlamlı olduğu yer, yuvanın görev sayısından az olduğu yerdir — ki gerçek bir makinede her zaman öyledir.

Girdi/Çıktı Ağırlıklı Yükte Süreç

Üst tablonun ilk sütunu ayrı bir soruyu yanıtlıyor: süreç, zaten iş parçacığının iyi çalıştığı yükte ne yapar?

Girdi/çıktı ağırlıklı yükte tek yuva 31 tik veriyordu; dört yuva 10’a indiriyor. Kazanç var, ama iki şey dikkat çekiyor. Birincisi, bu yükte dördüncü yuvadan sonra hiçbir kazanç yok — dört, beş, altı, yedi ve sekiz yuva aynı 10 / 70 satırını veriyor. Kısıt artık yuva değil, görev başına düşen on adım.

İkincisi ve önemlisi, bu sütun aktarım bedelini içermiyor. Bu yükte işlemci adımı yalnız 26; taşınacak veri ise iş parçacığı rejimindekiyle aynı. Dört yuvanın kazandırdığı 21 tike karşılık her göreve iki uçta üçer aktarım adımı eklemek bile hesabı tersine çevirmeye yeter. Bekleyen bir iş için süreç açmak, beklemeyi taşıma bedeliyle değiş tokuş etmektir.

Genel kural olarak yazılabilecek şey şu: yuva eklemenin karşılığını işlemci adımı sayısı belirler, aktarımın bedelini ise taşınan verinin boyu. İkisi aynı yükte birbirinden bağımsız değişir. Süreç, işlemci adımı çok ve taşınan veri az olduğunda kazandırır; ikisi tersine döndüğünde en pahalı rejimdir.

Eşzamanlılığın birden çok makineye yayılması Sistem Tasarımı ve Dağıtık Sistemler müfredatının konusudur ve burada tekrarlanmaz. Bu kursun ölçtüğü her şey tek makinede, tek program içinde geçiyor; aktarım bedeli de o sınırın içindeki bir bedeldir. Ayrı süreçlere dağıtmakla ayrı makinelere dağıtmak arasındaki fark modelde tek bir sayıda toplanır: aktarım bedelinin büyüklüğü. Yön aynıdır, ölçek değildir.

Yuva Eklemek Doğrusal Kazandırmaz

Üst tablonun işlemci ağırlıklı sütunu tek başına okunmayı hak ediyor: 73, 38, 29, 20, 19, 19, 16, 10.

İkinci yuva 35 tik kazandırıyor, üçüncü 9, dördüncü 9, beşinci 1, altıncı 0, yedinci 3, sekizinci 6. Eğri ne doğrusal ne de düzgün azalan. Altıncı yuva hiçbir şey kazandırmıyor; yedinci ve sekizinci yeniden kazandırıyor.

Bunun kaynağı kurgunun ayrıntısında: kazanç, o tikte işlemci adımı isteyen görev sayısına bağlı. Beş yuva varken çoğu tikte zaten beş görev istemiyorsa altıncı yuva boş durur. Sonlara doğru görevler eşitlenince yeni yuva yeniden iş bulur.

Bunun genel dersi şu: yuva sayısını iki katına çıkarmak tik sayısını yarıya indirmez. Kazanç, adım dizilerinin o anki hizasına bağlıdır ve ancak ölçülerek bilinir. Yuva sayısını artırırken durulacak yeri belirleyen şey bir formül değil, iki ardışık ölçüm arasındaki farktır.

Aktarım Bedeli Kazancı Yer

Alt tablo süreç rejiminin faturasını kesiyor. Bedel sıfırken dört yuva 20 tik veriyordu ve kazanç 60‘tı. Her göreve iki uçta birer aktarım adımı eklendiğinde toplam adım 80’den 96’ya çıkıyor, tik 24 oluyor, kazanç 56’ya iniyor. İki adımda kazanç 52, dört adımda 44, sekiz adımda 28.

On beş adımda kazanç 0: 320 adımlık iş dört yuvada 80 tikte bitiyor, yani bedel ödemeyen tek akışın tam olarak bittiği yerde. Bu noktadan sonra süreç rejimi kaybetmeye başlar.

Sayının okunuşu şudur: süreç eklemenin kazancı, veri devrinin adım sayısıyla yarışır. Görev başına on adımlık bir iş için otuz adımlık devir bedeli kazancı tamamen siler. Bu oran kurguya bağlıdır ve genel bir eşik değildir; genel olan şey ilişkinin kendisidir. Küçük görevleri süreçlere dağıtmak, devrin işten büyük olması demektir.

Tablonun örtüşen adım sütunu buradaki tuzağı da gösteriyor. Bedel arttıkça örtüşen adım 60’tan 240’a çıkıyor — sayı büyüyor, kazanç küçülüyor. Örtüşen adım tek başına okunduğunda yanıltır: eklenen adımlar da örtüşür. Bir ölçümün paydası neyse, okunması gereken şey odur; burada payda tek akışın 80 tikidir ve karşılaştırma ona göredir.

Özet

• Süreç eklemek modelde yuva sayısını büyütür: ayrı süreç ayrı yorumlayıcı, ayrı yorumlayıcı ayrı kilittir. İş parçacığının yapamadığı budur.
• İşlemci ağırlıklı yükte dört yuva seksen adımı 20 tike indirir; kazanç 60 tik, örtüşen adım 60. Aynı yükte tek yuvanın kazancı 7 tikti.
• Sekiz yuvada üç yükün üçü de 10 tik / 70 örtüşen adım verir. Yuva görev sayısına ulaştığında işlemci adımı kısıt olmaktan çıkar ve yükün bileşimi sonucu belirlemez.
• Yuva eklemenin kazancı doğrusal değildir: işlemci ağırlıklı yükte ikinci yuva 35, beşinci 1, altıncı 0 tik kazandırır. Durulacak yer ölçülerek bulunur.
• Her göreve iki uçta 15’er aktarım adımı eklendiğinde dört yuvanın kazancı 60 tikten 0’a iner: 320 adımlık iş 80 tikte biter, bedelsiz tek akışla aynı yerde.

Sonraki Adım

Buraya kadar iki rejim de örtüşmeyi dışarıdan aldı: iş parçacığı işletim sisteminden işçi istedi, süreç ayrı bir yorumlayıcıdan yuva istedi. İkisinde de hangi görevin ne zaman ilerleyeceğine karar veren şey kodun dışındaydı. Sonraki ders üçüncü yolu ölçer: örtüşmeyi işletim sisteminden istemeyen, kendi isteğiyle denetimi bırakan kod. Sorusu şu — bir eş yordam denetimi ne sıklıkla bırakırsa ne kadar örtüşme çıkar, ve hiç bırakmazsa ne olur?