Bölüm 12: Çok İşlemcili Sistemler

İşletim Sistemleri
UMA: veri yolu, çapraz çubuk, omega NUMA ve dizin tabanlı tutarlılık MESI ve yanlış paylaşım Çok çekirdek, SMT, GPU Çok işlemcili işletim sistemi türleri Senkronizasyon: TSL, bilet, MCS Çizelgeleme: zaman, alan, çete Çoklu bilgisayar topolojileri Mesaj iletimi ve RPC DSM ve yük dengeleme Sanallaştırma ve konteynerler Dağıtık sistemler ve ara yazılım Bulut ve kümeler
Sercan KÜLCÜ · Giresun Üniversitesi · Bilgisayar Mühendisliği

Giriş

Öğrenme Çıktıları

Donanım

UMA (veri yolu, çapraz çubuk, omega) ve NUMA mimarilerini karşılaştırmak; dizin tabanlı tutarlılığı izlemek.

Önbellek tutarlılığı

MESI durum geçişlerini bir okuma/yazma dizisi üzerinde uygulamak; yanlış paylaşımı bulup gidermek.

İşletim sistemi ve kilitler

Ayrı OS, usta-köle ve SMP modellerini; TSL, bilet ve MCS kilitlerini; dönme ile geçişi değerlendirmek.

Çizelgeleme

Zaman paylaşımı, afinite, alan paylaşımı ve çete çizelgelemeyi örnek üzerinde uygulamak.

Çoklu bilgisayarlar

Topolojilerin çapını hesaplamak; mesaj iletimi, RPC, DSM ve yük dengeleme algoritmalarını açıklamak.

Sanallaştırma ve dağıtık sistemler

Hipervizör türlerini, VT-x/EPT ve konteynerleri; ara yazılım türlerini ve bulutu tanımak.

Giriş

Neden Çok İşlemci?

Simetrik (SMP)

Tüm işlemciler belleğe ve G/Ç’ye eşit hakla erişir; çekirdek kodu her işlemcide çalışabilir.

Asimetrik (AMP)

İşlemciler eşit değildir: biri OS’i yürütür ya da her biri ayrı yazılım çalıştırır.

Küme (cluster)

Ağ ile bağlı bağımsız bilgisayarlar tek sistem gibi çalışır; her düğümün kendi OS’i var.

  • Saat hızı ≈ 2005’ten beri 3–5 GHz’de takıldı (Dennard ölçeklemesinin sonu); transistör bütçesi artık daha çok çekirdeğe gidiyor.
  • İşletim sistemi: işlemci tahsisi, senkronizasyon, süreçler arası iletişim ve paylaşılan verinin tutarlılığı.
BellekCPUCPUCPUCPUCPUCPU(a) paylaşımlı bellekara bağlantıC+MC+MC+MC+MC+MC+M(b) mesaj ileten çoklu bilgisayarİnternetbilgisayarbilgisayarbilgisayarbilgisayarbilgisayarbilgisayar(c) geniş alana dağıtılmış sistem

Amdahl: paralel kesim p ise n işlemcide hızlanma 1 / ((1 − p) + p/n). p = 0,95 için 8 işlemcide 5,93; 64 işlemcide 15,42; sınır 20. “İşlemci ekledikçe performans artar” ancak seri kısım küçükse doğrudur.

Çok İşlemcili Donanım

UMA: Veri Yolu Tabanlı Mimari

veri yoluCPUCPUBellekpaylaşımlı(a) önbellek yokveri yoluCPUönb.CPUönb.Bellekpaylaşımlı(b) her CPU’da önbellekveri yoluCPUönb.özelCPUönb.özelBellekpaylaşımlı(c) önbellek + özel bellek
  • UMA (Uniform Memory Access): her CPU her bellek sözcüğüne aynı sürede erişir; paralel programlama kolaylaşır.
  • (a) Tek veri yolu: CPU sayısı arttıkça yol doyar; 2–4 işlemciden sonra CPU’lar zamanlarının çoğunu beklemekle geçirir.
  • (b) Önbellek okumaların çoğunu yerelde karşılar, trafik azalır; ama aynı satırın kopyaları tutarlı tutulmalıdır (MESI).
  • (c) Özel bellek (private memory): program kodu, sabitler, yığın ve yerel değişkenler; paylaşılan bellek yalnız paylaşılan değişkenler için.

Eski sunumda UMA “Unified Memory Access” diye açılmıştı; doğrusu Uniform (tekdüze). Günümüzde tek bir paylaşılan veri yolu yerine yonga içi halka ya da ızgara ağları kullanılır (Intel mesh, AMD Infinity Fabric).

Çok İşlemcili Donanım

Çapraz Çubuk (Crossbar) Anahtar

M0M1M2M3M4M5M6M7CPU 0CPU 1CPU 2CPU 3CPU 4CPU 5CPU 6CPU 7kesişim noktasıaçıkkapalın × n anahtar → n² kesişim8 → 64 · 64 → 4.0961.024 → 1.048.576

8 CPU (satır) ve 8 bellek modülü (sütun); her kesişimde küçük bir elektronik anahtar var. Hepsi açık.

M0M1M2M3M4M5M6M7CPU 0CPU 1CPU 2CPU 3CPU 4CPU 5CPU 6CPU 7kesişim noktasıaçıkkapalın × n anahtar → n² kesişim8 → 64 · 64 → 4.0961.024 → 1.048.576

CPU 2, M5’e erişmek ister: (2, 5) kesişim noktası kapanır, doğrudan yol kurulur.

M0M1M2M3M4M5M6M7CPU 0CPU 1CPU 2CPU 3CPU 4CPU 5CPU 6CPU 7kesişim noktasıaçıkkapalın × n anahtar → n² kesişim8 → 64 · 64 → 4.0961.024 → 1.048.576aynı anda 3 aktarım

CPU 0 → M1 ve CPU 6 → M3 aynı anda kurulur. Çapraz çubuk engellemesiz (non-blocking): farklı modüllere giden istekler birbirini beklemez.

M0M1M2M3M4M5M6M7CPU 0CPU 1CPU 2CPU 3CPU 4CPU 5CPU 6CPU 7kesişim noktasıaçıkkapalın × n anahtar → n² kesişim8 → 64 · 64 → 4.0961.024 → 1.048.576M5 meşgul → CPU 4 bekler

CPU 4 de M5’i ister: ağda yol var ama modül meşgul; tek çekişme bellek modülündedir. Bedel: kesişim sayısı n² büyür.

Örnek: eski Sun Fire E25K 18 × 18 çapraz çubuk kullanıyordu; bugün yonga içinde çekirdekler ile L3 dilimleri arasında küçük çapraz çubuklar yaygındır.

Çok İşlemcili Donanım

Omega Ağında Yönlendirme

2 × 2ABXYher giriş her çıkışa bağlanabilirbit = 0 → üst çıkış (X)bit = 1 → alt çıkış (Y)mesaj biçimiModülAdresİşlem koduDeğerModül: hangi bellek modülü (yönlendirme etiketi)Adres: modül içindeki sözcükİşlem kodu: READ / WRITEDeğer: yazılacak sözcük (isteğe bağlı)n CPU · n bellek → log₂n aşama × n/2 anahtarn = 8: 3 × 4 = 12 anahtar (çapraz çubukta 64 kesişim)n = 1.024: 10 × 512 = 5.120 anahtar (1.048.576)

Yapı taşı 2 × 2 anahtar: iki giriş, iki çıkış. Mesajın Modül alanı hedef bellek modülünü taşır; anahtarlar yalnız ona bakar.

000001010011100101110111CPUBellek0000010100111001011101111A1B1C1D2A2B2C2D3A3B3C3D

8 CPU, 8 bellek, 3 aşama × 4 anahtar. Aşamalar arasındaki kablolama mükemmel karıştırmadır (adres bitleri bir sola döner).

000001010011100101110111CPUBellek0000010100111001011101111A1B1C1D2A2B2C2D3A3B3C3D

CPU 011, bellek 110’u okumak ister. 1. aşama (1D) hedefin 1. bitine bakar: 1 → alt çıkış; 2D ikinci bit 1 → alt; 3D üçüncü bit 0 → üst. Varış: 110.

000001010011100101110111CPUBellek0000010100111001011101111A1B1C1D2A2B2C2D3A3B3C3Dyanıt: Modül alanına kaynak (011) yazılır, yol tersten izlenir

Yanıt aynı ağdan döner: her anahtar geçişte kaynak bitini Modül alanına yazar; bellek bu etiketle yanıtı 011’e gönderir.

000001010011100101110111CPUBellek0000010100111001011101111A1B1C1D2A2B2C2D3A3B3C3Dçakışma: 2D’nin alt çıkışını iki istek ister

Aynı anda CPU 001 bellek 111’e gitmek ister; iki istek de 2D’nin alt çıkışını kullanır → biri bekler. Omega engellemeli (blocking) bir ağdır.

Eski sunumdaki iki ifade düzeltildi: omega “senkron iletişim” sağlamaz, birçok aktarımı eşzamanlı taşıyabilir ama çakışmada bekletir; anahtar sayısı (n/2)·log₂n olduğu için çapraz çubuktan çok daha az donanım ve güç ister.

Çok İşlemcili Donanım

NUMA Çok İşlemcileri

Düğüm 0 (soket)çekirdekçekirdekçekirdekçekirdekL3 (paylaşımlı)bellek denetl.yerel DRAMDüğüm 1 (soket)çekirdekçekirdekçekirdekçekirdekL3 (paylaşımlı)bellek denetl.yerel DRAMyerel ≈ 80 nsyerel ≈ 80 nsUPI / IFuzak ≈ 140 ns: düğüm 0 → düğüm 1 belleği (ara bağlantı üzerinden)
  • NUMA (Non-Uniform Memory Access): tüm CPU’lar tek adres uzayı görür; uzak belleğe de sıradan LOAD/STORE ile erişilir.
  • Uzak erişim yerelden yavaştır. NC-NUMA: önbellek tutarlılığı yok; CC-NUMA: dizin tabanlı tutarlılık (bugünkü sunucuların hepsi).
  • OS: süreci ve sayfalarını aynı düğümde tutar (ilk dokunma ilkesi, Linux otomatik NUMA dengeleme, numactl).
Ortalama erişim = y · tyerel + (1 − y) · tuzak
y = 0,9 → 0,9·80 + 0,1·140 = 86 ns
y = 0,5 → 110 ns (%28 daha yavaş)
gecikmeler örnek değerdir

Eski sunumda “Non-unified” yazıyordu; terim Non-Uniform Memory Access’tir. Tek soketli yongalar da içeride NUMA olabilir (AMD EPYC’de NPS ayarı, Intel SNC).

Çok İşlemcili Donanım

Dizin Tabanlı CC-NUMA

adres 0x24000108Düğüm (8 bit)Blok (18 bit)Ofset (6 bit)ara bağlantı ağı (256 düğüm)Düğüm 20CPUönbellekDüğüm 82CPUblok 2Düğüm 36RAM 16 MiB2¹⁸ satır × 64 Bdizin0–1–2823–4–32 bit adres = 8 bit düğüm + 18 bit blok + 6 bit ofset256 düğüm × 16 MiB = 4 GiB · her düğüm kendi bloklarının dizinini tutar

Tanenbaum’un örneği: 256 düğüm, düğüm başına 16 MiB, 64 baytlık satırlar. Her düğüm kendi belleğindeki satırların dizinini tutar.

adres 0x24000108Düğüm (8 bit) = 36Blok (18 bit) = 4Ofset (6 bit) = 8ara bağlantı ağı (256 düğüm)Düğüm 20CPUönbellekDüğüm 82CPUblok 2Düğüm 36RAM 16 MiB2¹⁸ satır × 64 Bdizin0–1–2823–4–istek: düğüm 36, blok 4 (READ)

Düğüm 20’deki CPU LOAD 0x24000108 yürütür: düğüm = 0x24 = 36, blok = 4, ofset = 8. Yerel değil → istek 36’ya gider.

adres 0x24000108Düğüm (8 bit) = 36Blok (18 bit) = 4Ofset (6 bit) = 8ara bağlantı ağı (256 düğüm)Düğüm 20CPUönbellekDüğüm 82CPUblok 2Düğüm 36RAM 16 MiB2¹⁸ satır × 64 Bdizin0–1–2823–4–dizin girdisi 4 boş → satır hiçbir önbellekte yok

Düğüm 36 dizinine bakar: girdi 4 boş, satır hiçbir önbellekte değil. Güncel kopya kendi RAM’indedir.

adres 0x24000108Düğüm (8 bit) = 36Blok (18 bit) = 4Ofset (6 bit) = 8ara bağlantı ağı (256 düğüm)Düğüm 20CPUblok 4Düğüm 82CPUblok 2Düğüm 36RAM 16 MiB2¹⁸ satır × 64 Bdizin0–1–2823–420satır düğüm 20’ye gönderilir · girdi 4 ← 20

Satır düğüm 20’ye gönderilir ve dizin girdisi 4’e 20 yazılır: “bu satırın kopyası 20’de”.

adres 0x24000080Düğüm (8 bit) = 36Blok (18 bit) = 2Ofset (6 bit) = 0ara bağlantı ağı (256 düğüm)Düğüm 20CPUblok 4Düğüm 82CPUblok 2Düğüm 36RAM 16 MiB2¹⁸ satır × 64 Bdizin0–1–2823–420yeni istek: blok 2 · dizin: düğüm 82’de önbellekte!

Şimdi düğüm 20, blok 2’yi ister (0x24000080). Dizin: satır düğüm 82’de önbelleklenmiş.

adres 0x24000080Düğüm (8 bit) = 36Blok (18 bit) = 2Ofset (6 bit) = 0ara bağlantı ağı (256 düğüm)Düğüm 20CPUblok 4, 2Düğüm 82CPUblok 2 geçersizDüğüm 36RAM 16 MiB2¹⁸ satır × 64 Bdizin0–1–2203–42082’ye geçersiz kıl → sonra satırı 20’ye gönder · girdi 2 ← 20

Düğüm 36, 82’ye “geçersiz kıl” (gerekirse geri yaz) gönderir, sonra satırı 20’ye yollar; girdi 2 ← 20. Veri yolu dinlemesi (snooping) yerine noktadan noktaya mesajlar.

Bu basit tasarımda bir satır tek düğümde önbelleklenebilir. Gerçek sistemler kopya kümesini bit vektörü ya da sınırlı işaretçi listesiyle tutar; çok çekirdekli yongalarda “snoop filter” aynı işi görür.

Çok İşlemcili Donanım

Önbellek Tutarlılığı Sorunu

Çekirdek 0Çekirdek 1x = 5önbellek (eski)x = 7önbellek (yeni)veri yolu / ara bağlantıx = 5ana bellekload x → 5 ? (beklenen 7)
  • Her çekirdeğin özel önbelleği aynı belleğin kopyalarını tutar. Biri yazarsa diğerinin kopyası eskir.
  • Tutarlılık (coherence): aynı adrese yapılan yazmalar tüm çekirdeklerce aynı sırada görülür; okuma en son yazılan değeri döndürür.
  • Dinleme (snooping): tüm önbellek denetleyicileri ortak yolu dinler; az çekirdekte uygun.
  • Dizin (directory): kopyaların listesi tutulur, yalnız ilgili düğümlere mesaj gider; çok çekirdek ve NUMA için ölçeklenir.
  • İki temel politika: yazınca geçersiz kıl (write-invalidate, yaygın) ve yazınca güncelle (write-update).

Tutarlılık tek bir adresle ilgilidir; farklı adreslerin sırası bellek tutarlılık modelinin (x86-TSO, ARM zayıf model) konusudur; bu yüzden kilitler bellek bariyerleri içerir.

Çok İşlemcili Donanım

MESI Protokolü

durumyerel okumayerel yazmab. okudub. yazdıMMisabetMisabetSgeri yazIgeri yazEEisabetMsessizS—I—SSisabetMBusUpgrS—I—IESBusRdMBusRdXI—I—kesikli çerçeve: durum değişmez · E/S: başka kopya yoksa E
DurumAnlamı
M ModifiedTek kopya, kirli; bellek eski. Atılırken geri yazılır.
E ExclusiveTek kopya, temiz. Yazma veri yoluna çıkmadan M olur.
S SharedBirden çok temiz kopya olabilir. Yazmak için önce diğerleri geçersiz kılınır.
I InvalidKopya geçersiz; erişim önbellek kaçırmasıdır.

Intel MESIF (F: yanıtı veren kopya), AMD MOESI (O: kirli ama paylaşılan) bu protokolün türevleridir.

Çok İşlemcili Donanım

MESI Adım Adım

işlem dizisi1. Ç0: read x2. Ç1: read x3. Ç1: x = 14. Ç0: read x5. Ç0: x = 26. Ç0: x = 3Çekirdek 0Isatır xdeğer = —Çekirdek 1Isatır xdeğer = —veri yolu: —x = 0bellek

Başlangıç: x yalnız bellekte (0). İki önbellekte de satır I.

işlem dizisi1. Ç0: read x2. Ç1: read x3. Ç1: x = 14. Ç0: read x5. Ç0: x = 26. Ç0: x = 3Çekirdek 0Esatır xdeğer = 0Çekirdek 1Isatır xdeğer = —veri yolu: BusRdx = 0bellek

Ç0 okur: BusRd, başka kopya yok → E (tek ve temiz).

işlem dizisi1. Ç0: read x2. Ç1: read x3. Ç1: x = 14. Ç0: read x5. Ç0: x = 26. Ç0: x = 3Çekirdek 0Ssatır xdeğer = 0Çekirdek 1Ssatır xdeğer = 0veri yolu: BusRdx = 0bellek

Ç1 okur: Ç0 isteği dinler, “bende var” der → ikisi de S. Bellek hâlâ güncel.

işlem dizisi1. Ç0: read x2. Ç1: read x3. Ç1: x = 14. Ç0: read x5. Ç0: x = 26. Ç0: x = 3Çekirdek 0Isatır xdeğer = —Çekirdek 1Msatır xdeğer = 1veri yolu: BusUpgrx = 0bellek (eski)

Ç1 yazar: S durumunda yazmak için BusUpgr (geçersiz kıl) yayınlanır → Ç0 I, Ç1 M; bellek artık eski.

işlem dizisi1. Ç0: read x2. Ç1: read x3. Ç1: x = 14. Ç0: read x5. Ç0: x = 26. Ç0: x = 3Çekirdek 0Ssatır xdeğer = 1Çekirdek 1Ssatır xdeğer = 1veri yolu: BusRd + Flushx = 1bellek

Ç0 okur: kaçırma. Ç1 kirli satırı Flush eder (veri Ç0’a ve belleğe), ikisi de S, bellek = 1.

işlem dizisi1. Ç0: read x2. Ç1: read x3. Ç1: x = 14. Ç0: read x5. Ç0: x = 26. Ç0: x = 3Çekirdek 0Msatır xdeğer = 2Çekirdek 1Isatır xdeğer = —veri yolu: BusUpgrx = 1bellek (eski)

Ç0 yazar: yine geçersiz kılma → Ç0 M, Ç1 I.

işlem dizisi1. Ç0: read x2. Ç1: read x3. Ç1: x = 14. Ç0: read x5. Ç0: x = 26. Ç0: x = 3Çekirdek 0Msatır xdeğer = 3Çekirdek 1Isatır xdeğer = —veri yolu: —x = 1bellek (eski)

Ç0 tekrar yazar: zaten M, veri yolu trafiği yok. Yazma ağırlıklı özel veri bu yüzden ucuzdur.

Çok İşlemcili Donanım

Yanlış Paylaşım (False Sharing)

struct sayaclar {      /* kötü */
  long a;   /* ofset 0 */
  long b;   /* ofset 8 */
};

struct dolgulu {       /* iyi */
  _Alignas(64) long a;
  _Alignas(64) long b;
};

/* iş parçacığı 0: for(..) s.a++;
   iş parçacığı 1: for(..) s.b++; */
  • Tutarlılık birimi satırdır (64 B), değişken değil.
  • Java: @Contended; Linux: ____cacheline_aligned.
  • DSM’de aynı sorun sayfa boyutunda olur: bağımsız iki değişken aynı sayfadaysa sayfa makineler arasında gidip gelir.
64 B önbellek satırıabÇekirdek 0: a++satır: —Çekirdek 1: b++satır: —mantıkta paylaşım yok, donanımda var

a ve b bağımsız sayaçlar ama aynı satırda.

64 B önbellek satırıabÇekirdek 0: a++satır: MÇekirdek 1: b++satır: Isatır karşıya taşınır: ~50–150 ns

Ç0 a++: satırı M olarak alır, Ç1’in kopyası geçersiz.

64 B önbellek satırıabÇekirdek 0: a++satır: IÇekirdek 1: b++satır: Msatır karşıya taşınır: ~50–150 ns

Ç1 b++: satır Ç1’e taşınır (M), Ç0’daki geçersiz olur.

64 B önbellek satırıabÇekirdek 0: a++satır: MÇekirdek 1: b++satır: Isatır karşıya taşınır: ~50–150 ns

Her artırmada satır yeniden taşınır: “ping-pong”; iki iş parçacığı tek iş parçacığından yavaş çalışabilir.

64 B önbellek satırı × 2abÇekirdek 0: a++satır a: MÇekirdek 1: b++satır b: Mayrı satırlar: ikisi de M kalırtutarlılık trafiği yok

Çözüm: hizalama/dolgu ile her sayacı ayrı satıra koy. Bellek israfı 56 B, kazanç çoğu zaman kat kat hız.

Çok İşlemcili Donanım

Çok Çekirdekli ve Heterojen Yongalar

çok çekirdekli yonga (homojen)Çekirdek 0L1L2Çekirdek 1L1L2Çekirdek 2L1L2Çekirdek 3L1L2L3 (paylaşımlı, dilimli) + yonga içi ağbellek denetleyicisiPCIe / G/Çheterojen yongaPbüyükPbüyükEEEEGPUNPUbirleşik bellek (LPDDR)
Çok çekirdek (CMP)

L1/L2 özel, L3 paylaşımlı. Sunucu soketi: 192 çekirdek (AMD EPYC 9005), 288 E-çekirdek (Xeon 6900E).

Yongacıklar (chiplet)

Çekirdek grupları ayrı kalıplarda; tek sokette bile L3 ve bellek uzaklığı farklıdır.

Büyük–küçük çekirdek

big.LITTLE, Apple ve Intel P/E: OS işi enerjiye göre yerleştirir (Linux EAS, Thread Director).

Hızlandırıcılar

GPU ve NPU aynı yongada, aynı belleği paylaşır; sürücü üzerinden zamanlanır.

Çok İşlemcili Donanım

Eşzamanlı Çoklu İş Parçacığı (SMT)

(a) tek iş parçacığıt0t1t2t3t4t5(b) SMT: 2 donanım iş parçacığıt0t1t2t3t4t5boş yuva: önbellek kaçırma, bağımlılıkmavi: iş parçacığı A · turuncu: B
  • Bir fiziksel çekirdek iki mantıksal CPU gibi görünür (Intel Hyper-Threading, AMD SMT); yazmaç kümeleri ikidir, yürütme birimleri ve L1/L2 ortaktır.
  • Kazanç tipik olarak %10–30; iki iş parçacığı aynı birimi isterse hiç yoktur. Çizelgeleyici önce boş fiziksel çekirdekleri doldurmalıdır.
  • Güvenlik: ortak önbellek yan kanal açar (L1TF, MDS) → Linux core scheduling yalnız güvenilen iş parçacıklarını aynı çekirdeğe koyar. Intel Lunar Lake (2024) P-çekirdeklerinde SMT’yi kaldırdı.

Çok İşlemcili Donanım

GPU ve Heterojen Hesaplama

CPU: gecikme odaklıçekirdekçekirdekçekirdekçekirdekbüyük önbellekGPU: verim odaklı (SIMT)SM 0SM 1SM 2SM 3SM 4SM 5HBM / GDDR bellek: TB/s bant genişliği
  • GPU binlerce basit şeridi 32’lik gruplar (warp/wavefront) hâlinde aynı komutla yürütür: veri paralel işler (grafik, yapay zekâ, bilimsel hesap).
  • Programlama: CUDA, ROCm/HIP, OpenCL, SYCL; CPU çekirdeği (kernel) başlatır, veri taşır, sonucu bekler.
  • OS ve sürücü: GPU belleğini yönetir, bağlamları zaman paylaşımlı çalıştırır, birleşik/paylaşılan sanal bellek (IOMMU, sayfa hatası) sağlar.
  • Kümelerde düğüm başına 4–8 GPU, aralarında NVLink; düğümler arası InfiniBand/RoCE ile RDMA.

Çok İşlemcili İşletim Sistemleri

Her CPU’nun Kendi İşletim Sistemi

CPU 1kendi OS’iCPU 2kendi OS’iCPU 3kendi OS’iCPU 4kendi OS’iveri yolubellekbölüm 1veribölüm 2veribölüm 3veribölüm 4veriOS kodu (salt okunur, paylaşılan)
  • Bellek CPU sayısı kadar bölüme ayrılır; her CPU kendi bölümünde bağımsız bir OS kopyası çalıştırır. OS kodu paylaşılabilir, verisi ayrıdır.
  • Sistem çağrısı yerel CPU’da yakalanır ve işlenir.

Artıları

  • Basit: tek işlemcili OS neredeyse değişmeden kullanılır.
  • Bölümler arası kilit gerekmez.

Eksileri

  • Süreçler paylaşılmaz: bir CPU aşırı yüklüyken diğeri boşta.
  • Sayfalar paylaşılmaz; her OS kendi tampon önbelleğini tutar → tutarsız disk blokları.

Bugünkü karşılığı: bölümlenmiş (partitioned) sistemler ve hipervizör üzerindeki ayrı sanal makineler; araştırmada Barrelfish “multikernel” her çekirdeği mesajla haberleşen ayrı bir düğüm gibi ele alır.

Çok İşlemcili İşletim Sistemleri

Usta-Köle (Master-Slave) Modeli

CPU 1usta: OSCPU 2köle: süreçCPU 3köle: süreçCPU 4köle: süreçveri yolubellekusta OStek hazır listesiköle süreçlerinin bellekleri
  • OS’in tek kopyası ve tabloları yalnız usta CPU’dadır; tüm sistem çağrıları ustaya yönlendirilir.
  • Köleler ustanın verdiği kullanıcı süreçlerini çalıştırır; tek hazır listesi olduğu için yük dengelidir.

Artıları

  • Basit, tutarlı: çekirdek verisine tek CPU dokunur.
  • Yük dengeleme kendiliğinden.

Eksileri

  • Usta darboğaz olur: sistem çağrısı yoğun işlerde birkaç CPU’dan sonra ölçeklenmez.
  • Usta çökerse tüm sistem durur.

Pptx’teki “AMP”nin klasik biçimi budur. Bugün gömülü yongalarda asimetrik düzen yaşar: Linux çalıştıran Cortex-A çekirdeklerin yanında RTOS çalıştıran bir Cortex-M çekirdeği (OpenAMP, remoteproc).

Çok İşlemcili İşletim Sistemleri

Simetrik Çok İşlemciler (SMP)

CPU 1OS + süreçCPU 2OS + süreçCPU 3OS + süreçCPU 4OS + süreçveri yolubellektek OS kopyasıhazır listesi + kilitdosya tablosu + kilitkullanıcı süreçleri
  • Bellekte tek OS kopyası; her CPU çekirdek kodunu çalıştırabilir. Sistem çağrısı onu yapan CPU’da işlenir.
  • Sorun: iki CPU aynı anda aynı çekirdek tablosuna dokunabilir → kilitler.
  • İlk adım tek büyük çekirdek kilidi (Linux BKL, 2.0); 2.6.39’da (2011) tamamen kaldırıldı. Bugün binlerce ince taneli kilit, RCU ve CPU başına veri.

Artıları

  • Darboğaz yok, tüm CPU’lar çekirdeği çalıştırır.
  • Bellek ve süreçler dinamik dengelenir.

Eksileri

  • Çekirdek tabloları kritik bölgelere bölünmeli.
  • Kilit sırası hatası → kilitlenme (Bölüm 7).

Çok İşlemcili İşletim Sistemleri

Üç Modelin Karşılaştırması

Ayrı OSUsta-köleSMP
OS kopyasıCPU başına birbir (ustada)bir (herkes çalıştırır)
Sistem çağrısı nerede?yerel CPUusta CPUyerel CPU
Hazır listesiCPU başınatek, ustadatek ya da CPU başına + dengeleme
Yük dengelemeyokiyiiyi
Ölçeklenebilirlikiyi ama paylaşım yokusta darboğazkilit tasarımına bağlı, en iyi
Karmaşıklıken düşükdüşüken yüksek
Günümüzsanal makineler, bölümlemegömülü AMP, eski sistemlerLinux, Windows, macOS, BSD
Çok işlemcili OS ile çoklu bilgisayar OS’i farklıdır: çok işlemcide tüm CPU’lar aynı fiziksel belleği görür; çoklu bilgisayarda her düğümün kendi belleği vardır ve iletişim yalnız mesajla olur.

Senkronizasyon

TSL ve Veri Yolu Kilidi

CPU 1TSL R, LOCKCPU 2TSL R, LOCKveri yoluLOCK = 0bellek sözcüğüTSL = oku + yaz (iki ayrı veri yolu döngüsü)iki CPU aynı anda dener

Tek işlemcide TSL (test and set lock) bölünmez bir komuttur. Çok işlemcide bellek sözcüğünü okuma ve yazma ayrı veri yolu döngüleridir.

CPU 1TSL R, LOCKCPU 2TSL R, LOCKveri yoluLOCK = 0bellek sözcüğü1. CPU 1 okur: 0

CPU 1 kilidi okur: 0 (serbest).

CPU 1TSL R, LOCKCPU 2TSL R, LOCKveri yoluLOCK = 0bellek sözcüğü1. CPU 1 okur: 02. CPU 2 okur: 0

CPU 1 yazmadan önce CPU 2 de okur: yine 0.

CPU 1TSL R, LOCKCPU 2TSL R, LOCKveri yoluLOCK = 1bellek sözcüğü1. CPU 1 okur: 02. CPU 2 okur: 03. CPU 1 yazar: 14. CPU 2 yazar: 1

CPU 1 1 yazar, CPU 2 de 1 yazar.

CPU 1TSL R, LOCKCPU 2TSL R, LOCKveri yoluLOCK = 1bellek sözcüğü1. CPU 1 okur: 02. CPU 2 okur: 03. CPU 1 yazar: 14. CPU 2 yazar: 1ikisi de 0 okudu → ikisi de kritik bölgede!

Sonuç: ikisi de “kilit benim” sanır, karşılıklı dışlama bozulur. Kesmeleri kapatmak da işe yaramaz: o yalnız kendi CPU’sunu durdurur.

CPU 1TSL R, LOCKCPU 2yol kilitli: beklerveri yoluLOCK = 1bellek sözcüğü1. CPU 1 okur: 02. CPU 1 yazar: 1 (aynı kilitli döngüde)LOCK öneki / satır kilidi

Çözüm: TSL okuma–yazma süresince veri yolunu kilitler. Bugün x86 LOCK öneki çoğunlukla yalnız önbellek satırını M durumunda tutar; ARM LDXR/STXR ya da LSE CAS kullanır.

Senkronizasyon

Bilet Kilidi (Ticket Lock)

import java.util.concurrent.atomic.*;
public class Bilet {
  static AtomicInteger next = new AtomicInteger();
  static volatile int serving = 0;
  static int sayac = 0;
  static void lock() {
    int my = next.getAndIncrement();
    while (serving != my) Thread.onSpinWait();
  }
  static void unlock() { serving++; }
  public static void main(String[] a)
      throws Exception {
    Runnable is = () -> {
      for (int i = 0; i < 100_000; i++) {
        lock(); sayac++; unlock(); } };
    Thread t0 = new Thread(is);
    Thread t1 = new Thread(is);
    t0.start(); t1.start(); t0.join(); t1.join();
    System.out.println("sayac = " + sayac);
  }
}
next = 0sıradaki biletserving = 0hizmetteki biletT0 · my = —dışarıdaT1 · my = —dışarıdabilet sırası = varış sırası (FIFO)

İki sayaç: next bilet dağıtır, serving sırası geleni gösterir.

next = 1sıradaki biletserving = 0hizmetteki biletT0 · my = 0dönüyorT1 · my = —dışarıdabilet sırası = varış sırası (FIFO)

T0 bilet alır: getAndIncrement atomiktir (x86 LOCK XADD) → my = 0.

next = 2sıradaki biletserving = 0hizmetteki biletT0 · my = 0dönüyorT1 · my = 1dönüyorbilet sırası = varış sırası (FIFO)

T1 de bilet alır: my = 1. İki CPU aynı anda çağırsa da biletler farklıdır.

next = 2sıradaki biletserving = 0hizmetteki biletT0 · my = 0kritik bölgeT1 · my = 1dönüyorbilet sırası = varış sırası (FIFO)

T0: serving == 0 → döngüden çıkar, sayac++ yapar.

next = 2sıradaki biletserving = 0hizmetteki biletT0 · my = 0kritik bölgeT1 · my = 1dönüyorbilet sırası = varış sırası (FIFO)

T1 döner: serving’i kendi önbelleğindeki S kopyadan okur, veri yolunu meşgul etmez; onSpinWait = x86 PAUSE.

next = 2sıradaki biletserving = 1hizmetteki biletT0 · my = 0dışarıdaT1 · my = 1dönüyorbilet sırası = varış sırası (FIFO)

T0 bırakır: serving++. Yazma T1’in kopyasını geçersiz kılar (tek tutarlılık mesajı).

next = 2sıradaki biletserving = 1hizmetteki biletT0 · my = 0dışarıdaT1 · my = 1kritik bölgebilet sırası = varış sırası (FIFO)

T1 yeni değeri okur: 1 == my → girer. Kilit adildir: kimse aç kalmaz.

next = 200000sıradaki biletserving = 200000hizmetteki biletT0 · my = —bittiT1 · my = —bittibilet sırası = varış sırası (FIFO)

2 × 100.000 artırma, kayıp yok. Kilitsiz sayac++ ile sonuç çoğu çalıştırmada 200.000’den küçük çıkar.

Senkronizasyon

Dönen Kilitler ve Önbellek Trafiği

(a) TSL ile dönme(b) önce oku, sonra TSL(c) MCS: herkes kendi bayrağındakilit satırıCPU 0CPU 1CPU 2her deneme yazma → satırsürekli gidip gelirkilit satırıS kopyaCPU 0S kopyaCPU 1S kopyaCPU 2yerel okuma: trafik yokserbest kalınca herkes saldırırtailCPU 2sahipCPU 0bekleCPU 1beklekuyrukdüğümleribırakan yalnız sıradakine yazar
  • (a) Saf TSL döngüsü her denemede yazar: kilit satırı CPU’lar arasında sürekli taşınır, sahibin işi de yavaşlar.
  • (b) Önce oku, sonra TSL (TTAS): yerel kopya üzerinde dön; serbest görününce TSL dene. Ek olarak üstel geri çekilme (backoff) çakışmayı azaltır.
  • (c) MCS (Mellor-Crummey & Scott, 1991): her bekleyenin ayrı satırda kendi bayrağı; bırakma tek bir uzak yazmadır. Linux qspinlock bu fikre dayanır.

Eski sunumdaki “önbellekte veri tutarsızlığını önlemek için çoklu kilit” ifadesi düzeltildi: amaç tutarsızlığı değil, tutarlılık trafiğini (cache thrashing) önlemektir.

Senkronizasyon

Dönmek mi, Geçiş Yapmak mı?

kilit t = 3 µs’de serbest kalıyor; bağlam değiştirme C = 5 µsdöndönüyor (3 µs)kritik bölgegeççıkış Cbaşka işdönüş Ckritik b.036912151821µs
  • Dönme (spin): CPU boşa harcanır ama kilit serbest kalır kalmaz devam edilir. Kısa kritik bölgeler için.
  • Geçiş (switch, block): CPU başka işe verilir; bedeli iki bağlam değiştirme + soğuk önbellek.
  • Kural: beklenen bekleme < 2C ise dön, değilse uyu.
  • Rekabetçi strateji: C kadar dön, sonra uyu → en kötü durumda en iyinin 2 katı maliyet.
  • Uygulamada: Linux futex + uyarlamalı mutex (sahip çalışıyorsa dön), Windows CRITICAL_SECTION dönme sayısı, Java’da kilit şişirme.
  • Çekirdekte kesme kapalı bölgelerde yalnız dönen kilit kullanılabilir.

Çizelgeleme

Zaman Paylaşımı: Ortak Hazır Kuyruğu

16 CPUCPU 0PCPU 1QCPU 2RCPU 3boştaCPU 4SCPU 5TCPU 6UCPU 7boştaCPU 8VCPU 9WCPU 10XCPU 11YCPU 12ZCPU 13αCPU 14βCPU 15γöncelik kuyrukları (tek yapı, tek kilit)öncelik 7ABCöncelik 6DEöncelik 5Föncelik 4GHIöncelik 3JKöncelik 2öncelik 1LMNöncelik 0

Bağımsız süreçler için en basit yol: tek sistem çapında öncelikli hazır kuyruğu. CPU 3 ve CPU 7 boşa çıktı.

16 CPUCPU 0PCPU 1QCPU 2RCPU 3ACPU 4SCPU 5TCPU 6UCPU 7boştaCPU 8VCPU 9WCPU 10XCPU 11YCPU 12ZCPU 13αCPU 14βCPU 15γöncelik kuyrukları (tek yapı, tek kilit)öncelik 7BCöncelik 6DEöncelik 5Föncelik 4GHIöncelik 3JKöncelik 2öncelik 1LMNöncelik 0kilitle → en yüksek öncelikli işi al → kilidi bırak

CPU 3 yapıyı kilitler, en yüksek öncelikli A’yı alır. Yük kendiliğinden dengelenir: hiçbir CPU iş varken boş kalmaz.

16 CPUCPU 0PCPU 1QCPU 2RCPU 3ACPU 4SCPU 5TCPU 6UCPU 7BCPU 8VCPU 9WCPU 10XCPU 11YCPU 12ZCPU 13αCPU 14βCPU 15γöncelik kuyrukları (tek yapı, tek kilit)öncelik 7Cöncelik 6DEöncelik 5Föncelik 4GHIöncelik 3JKöncelik 2öncelik 1LMNöncelik 0kilitle → en yüksek öncelikli işi al → kilidi bırak

CPU 7 de aynı yolla B’yi alır.

16 CPUCPU 0PCPU 1QCPU 2RCPU 3ACPU 4SCPU 5TCPU 6UCPU 7BCPU 8VCPU 9WCPU 10XCPU 11YCPU 12ZCPU 13αCPU 14βCPU 15γöncelik kuyrukları (tek yapı, tek kilit)öncelik 7Cöncelik 6DEöncelik 5Föncelik 4GHIöncelik 3JKöncelik 2öncelik 1LMNöncelik 016 CPU tek kilide çekişir · A sonraki sefer başka CPU’da: soğuk önbellek

Sorunlar: tek kilit darboğaz olur; süreç farklı CPU’ya düşer, önbelleği soğuktur. Dönen kilit tutarken dilimi biten iş parçacığı diğerlerini döndürür (çözüm: “akıllı çizelgeleme” bayrağı).

Çizelgeleme

Afinite ve Yük Dengeleme

CPU 0ABCDCPU 1ECPU 2boşCPU 3FGçekme (pull): D, CPU 2’yezamanlama alanları (sched domains)SMTen ucuzçekirdekL2LLCL3NUMAen pahalı
  • Afinite: iş parçacığını son çalıştığı CPU’da tut; önbelleği ve TLB’si sıcaktır. Yumuşak (OS tercih eder) ya da katı (taskset, sched_setaffinity).
  • İki düzeyli çizelgeleme: iş bir CPU’ya atanır, sonra o CPU’nun kendi kuyruğundan çalışır; kilit çekişmesi yok.
  • Yük dengeleme: itme (periyodik görev fazlalığı boşlara taşır) ve çekme (boş CPU iş çalar). Linux önce yakın alanlarda (SMT, LLC), sonra NUMA düğümleri arasında dengeler.
  • Linux 6.6’dan (2023) beri CPU başına kuyruklarda CFS yerine EEVDF kullanılır.
Etkileşimli deneme: Çok Çekirdekli Çizelgeleme ve Yük Dengeleme Benzetimi sayfasında görevleri çekirdeklere dağıtıp afinite ve dengelemenin etkisini izleyin.

Çizelgeleme

Alan Paylaşımı (Space Sharing)

0A1A2B3B4B5C6C7C8A9A10B11B12B13C14C15C16D17D18D19D20D21D22C23C24D25D26D27D28D29D30boşta31boştaİş A: 4 CPUİş B: 6 CPUİş C: 8 CPUİş D: 12 CPU2 CPU boşta, sıradaki iş bekler4 + 6 + 8 + 12 + 2 = 32
  • Birbirine bağlı iş parçacıkları aynı anda ayrı CPU’larda çalıştırılır: iş başladığında istediği kadar CPU’ya ayrılır, bitene kadar onları tutar.
  • CPU başına çok programlama yok → bağlam değiştirme yok. Yetecek CPU yoksa iş, yeterli CPU boşalana kadar bekler (en basit: FCFS).
  • Sakınca: iş parçacığı G/Ç için bloke olunca CPU’su boşa durur. Bugün HPC kümelerinde iş zamanlayıcıları (Slurm, PBS) düğümleri böyle bölümler.

Çizelgeleme

Çete (Gang) Çizelgeleme

iki CPU, 100 ms’lik dilimler, A ve B işleri zaman paylaşımlıCPU 0A0B0A0B0CPU 1B1A1B1A1istek (t = 0)A1 isteği ancak t = 100’de görür, yanıtı A0 t = 200’de alıryanıt (t = 100)0 ms100 ms200 ms300 ms400 msbirbiriyle konuşan iş parçacıkları farklı zamanlarda çalışırsa her mesaj bir dilim bekler

Sorun: A0 ve A1 iletişim kuruyor ama dilimleri kaymış. A0’ın t = 0’daki isteğini A1 ancak 100 ms sonra görür; yanıt da 100 ms bekler.

CPU →CPU 0CPU 1CPU 2CPU 3CPU 4CPU 5dilim 0A0A1A2A3A4A5dilim 1dilim 2dilim 3dilim 4dilim 5dilim 6dilim 7A: 6 iş p.B, C: 3’erD: 5 · E: 7

Çete çizelgelemede ilgili iş parçacıkları bir çetedir. Dilim 0: A’nın 6 iş parçacığının hepsi aynı anda, 6 CPU’da.

CPU →CPU 0CPU 1CPU 2CPU 3CPU 4CPU 5dilim 0A0A1A2A3A4A5dilim 1B0B1B2C0C1C2dilim 2dilim 3dilim 4dilim 5dilim 6dilim 7A: 6 iş p.B, C: 3’erD: 5 · E: 7

Dilim 1: B (3) ve C (3) birlikte; tüm CPU’lar dilimlere eşzamanlı başlar ve biter (zaman dilimi senkronize).

CPU →CPU 0CPU 1CPU 2CPU 3CPU 4CPU 5dilim 0A0A1A2A3A4A5dilim 1B0B1B2C0C1C2dilim 2D0D1D2D3D4E0dilim 3E1E2E3E4E5E6dilim 4dilim 5dilim 6dilim 7A: 6 iş p.B, C: 3’erD: 5 · E: 7

Dilim 2–3: D (5) + E0, sonra E’nin kalan 6 iş parçacığı. Bir çetenin tüm üyeleri aynı dilimde koşar; mesajlar hemen yanıtlanır.

CPU →CPU 0CPU 1CPU 2CPU 3CPU 4CPU 5dilim 0A0A1A2A3A4A5dilim 1B0B1B2C0C1C2dilim 2D0D1D2D3D4E0dilim 3E1E2E3E4E5E6dilim 4A0A1A2A3A4A5dilim 5B0B1B2C0C1C2dilim 6D0D1D2D3D4E0dilim 7E1E2E3E4E5E6A: 6 iş p.B, C: 3’erD: 5 · E: 7

Döngü tekrar eder. İki koşul: çete üyeleri aynı anda başlar ve hepsi farklı CPU’lardadır. Günümüzde sanal makinelerde vCPU’ların birlikte çizelgelenmesi (co-scheduling) aynı fikirdir.

Çoklu Bilgisayarlar

Çoklu Bilgisayarlar ve Ağ Arayüzleri

düğüm 1CPUkullanıcı tamponuçekirdek tamponuNIC belleğiağ arayüzü(NIC)düğüm 2CPUkullanıcı tamponuçekirdek tamponuNIC belleğiağ arayüzü(NIC)anahtarara bağlantı12453: kabloRDMA: NIC doğrudankullanıcı tamponuna yazar(1, 2, 4, 5 kopyaları yok)
  • Çoklu bilgisayar (multicomputer, küme): her düğüm CPU + RAM + ağ arayüzü; bellek paylaşılmaz, her düğümde kendi OS kopyası çalışır. İletişim yalnız mesajla.
  • Bir mesaj en kötü 5 kez kopyalanır; her kopya mikrosaniye harcar. Çözüm: NIC belleğini kullanıcı alanına eşle, DMA ve RDMA (InfiniBand, RoCE): çekirdek hiç devreye girmez.
  • Kullanım: büyük ölçekli simülasyon, HPC, yapay zekâ eğitimi; TOP500 sistemleri on binlerce düğümlü çoklu bilgisayarlardır.

Çoklu Bilgisayarlar

Ara Bağlantı Topolojileri

(a) tek anahtar · çap 2(b) halka (8) · çap 4(c) ızgara 4×4 · çap 6(d) çift simit 4×4 · çap 4(e) küp (8) · çap 3(f) 4B hiperküp (16) · çap 4
n = 1.024 düğümhalkaızgara 32×32simit 32×32hiperküp (10B)
çap (en uzak iki düğüm)512623210
bağlantı sayısı1.0241.9842.0485.120

Çap = en kötü durumda atlama sayısı; hiperküpte log₂n. Bugünkü süper bilgisayarlar çoğunlukla fat-tree ve dragonfly topolojisi kullanır; Fugaku 6B simit (Tofu) ağına sahiptir.

Çoklu Bilgisayarlar

Hiperküpte Yönlendirme

0000000100100011010001010110011110001001101010111100110111101111alt küp: ilk bit 0üst küp: ilk bit 1hedef 1011atlama: 0

4B hiperküp: 16 düğüm, her düğüm 4 komşuya bağlı; komşular tek bir bitte farklıdır. 0000’dan 1011’e mesaj gidecek.

0000000100100011010001010110011110001001101010111100110111101111alt küp: ilk bit 0üst küp: ilk bit 1hedef 1011atlama: 1

Kaynak ⊕ hedef = 1011: üç bit farklı. Soldan ilk farklı bit düzeltilir → 1000 (alt küpten üst küpe geçiş).

0000000100100011010001010110011110001001101010111100110111101111alt küp: ilk bit 0üst küp: ilk bit 1hedef 1011atlama: 2

Sonraki farklı bit: 1010.

0000000100100011010001010110011110001001101010111100110111101111alt küp: ilk bit 0üst küp: ilk bit 1hedef 1011atlama: 3

Son bit: 1011. Atlama sayısı = farklı bit sayısı (Hamming uzaklığı) = 3; en kötü durum d = log₂16 = 4. Kural yerel olduğu için yönlendirme tablosu gerekmez.

Çoklu Bilgisayarlar

Sakla ve İlet ya da Kesip Geç

Aanahtar 1anahtar 2Bsakla ve ilet: paket her anahtarda tamamen alınır, sonra iletilirgecikme ≈ atlama × (paket / bant genişliği)t = 0 µs

Örnek: 4 KiB paket, 10 Gb/s bağlantılar; bir bağlantıdan geçmesi 4096 × 8 / 10⁹ ≈ 3,28 µs.

Aanahtar 1anahtar 2Bsakla ve ilet: paket her anahtarda tamamen alınır, sonra iletilirgecikme ≈ atlama × (paket / bant genişliği)t = 3,28 µs

Sakla ve ilet (store-and-forward): anahtar 1 paketin tamamını tampona alır, denetler, sonra iletir.

Aanahtar 1anahtar 2Bsakla ve ilet: paket her anahtarda tamamen alınır, sonra iletilirgecikme ≈ atlama × (paket / bant genişliği)t = 9,83 µs

Üç bağlantı → 3 × 3,28 = 9,83 µs. Gecikme atlama sayısıyla doğrusal büyür.

Aanahtar 1anahtar 2Bkesip geç / solucan deliği: başlık okunur okunmaz ileri gönderilirpaketin parçaları (flit) aynı anda birden çok bağlantıdat ≈ 3,38 µs (bir paket süresi + küçük başlık gecikmeleri)

Kesip geç (cut-through) ve solucan deliği (wormhole): başlık gelince yol kurulur, paket boru gibi akar → ≈ 3,38 µs. HPC ağları ve veri merkezi anahtarları böyle çalışır.

Çoklu Bilgisayarlar

Bloke Eden ve Etmeyen Gönderim

gönderen süreççalışıyortuzak, kopyalaBLOKE: mesaj iletiliyorçalışıyorsend(m)mesaj gitti, dönüşbasit ve güvenli; ama CPU iletim boyunca boşta bekler

(a) Bloke eden (blocking, senkron) send: çağrı mesaj iletilene kadar dönmez.

gönderen süreççalışıyortuzakhemen çalışmaya devamsend(m)tampon m hâlâ gönderiliyor!paralellik var; ama gönderen m’yi iletim bitmeden değiştirirse ne olur?

(b) Bloke etmeyen (asenkron) send: hemen döner; ama tampon iletim bitene kadar kullanılamaz.

SeçenekBedel
Bloke eden gönderimCPU iletim boyunca boşta
Bloke etmeyen + çekirdeğe kopyalafazladan kopya için CPU zamanı
Bloke etmeyen + bitince kesmeprogramlaması zor (yarış koşulları)
Yazınca kopyala (CoW)tampon yazılırsa yine fazladan kopya

Tanenbaum’un dört seçeneği. Alıcı tarafta da benzer: bloke eden receive, yoklama (polling) ya da açılan iş parçacığı / etkin mesaj (active message).

MPI’de MPI_Send/MPI_Recv bloke eden, MPI_Isend/MPI_Irecv + MPI_Wait bloke etmeyen çağrılardır; Linux’ta io_uring ve sıfır kopya MSG_ZEROCOPY aynı soruna modern yanıtlardır.

Çoklu Bilgisayarlar

Uzak Prosedür Çağrısı (RPC)

istemci makinesiİstemciİstemci koçanıİşletim sistemi (çekirdek)sunucu makinesiSunucuSunucu koçanıİşletim sistemi (çekirdek)ağ12345amaç: uzak çağrıyı yerel çağrı gibi göstermek (Birrell ve Nelson, 1984)

İstemci sonuc = topla(3, 4) der; sıradan yerel çağrı gibi görünür.

istemci makinesiİstemciİstemci koçanıİşletim sistemi (çekirdek)sunucu makinesiSunucuSunucu koçanıİşletim sistemi (çekirdek)ağ12345

1: İstemci, istemci koçanını (stub) yerel bir prosedür gibi çağırır.

istemci makinesiİstemciİstemci koçanıİşletim sistemi (çekirdek)sunucu makinesiSunucuSunucu koçanıİşletim sistemi (çekirdek)ağ12345topla | 3 | 4

2: Koçan parametreleri mesaja paketler (marshalling) ve çekirdeğe sistem çağrısı yapar.

istemci makinesiİstemciİstemci koçanıİşletim sistemi (çekirdek)sunucu makinesiSunucuSunucu koçanıİşletim sistemi (çekirdek)ağ12345topla | 3 | 4

3: Çekirdek mesajı ağ üzerinden sunucu makinesine gönderir.

istemci makinesiİstemciİstemci koçanıİşletim sistemi (çekirdek)sunucu makinesiSunucuSunucu koçanıİşletim sistemi (çekirdek)ağ12345

4: Sunucu çekirdeği mesajı sunucu koçanına verir.

istemci makinesiİstemciİstemci koçanıİşletim sistemi (çekirdek)sunucu makinesiSunucuSunucu koçanıİşletim sistemi (çekirdek)ağ12345yanıt (7) ters yoldan: sunucu → koçan → çekirdek → ağ → istemci

5: Koçan parametreleri açar ve sunucu prosedürünü yerel olarak çağırır; yanıt aynı yoldan geri döner.

Zorluklar: işaretçiler (başka adres uzayı → kopyala-geri yükle), uzunluğu bilinmeyen diziler, global değişkenler, kısmi hatalar (çağrı en az bir kez mi, en çok bir kez mi?). Koçan (stub) arayüz tanımından otomatik üretilir; bugün gRPC + Protocol Buffers, Thrift, Java RMI.

Çoklu Bilgisayarlar

Dağıtık Paylaşımlı Bellek (DSM)

UygulamaÇalışma zamanıİşletim sistemiDonanım(a) donanımUygulamaÇalışma zamanıİşletim sistemiDonanım(b) işletim sistemiUygulamaÇalışma zamanıİşletim sistemiDonanım(c) kullanıcı yazılımıturuncu katman paylaşılan adres uzayı yanılsamasını üretir

DSM, belleği paylaşmayan makinelerde paylaşımlı bellek yanılsaması verir. Katman donanım (NUMA), OS (sayfa tabanlı, Li ve Hudak 1989) ya da kullanıcı kitaplığı olabilir.

paylaşılan sanal adres uzayı: sayfa 0–150123456789101112131415CPU 0 belleği0259CPU 1 belleği136810CPU 2 belleği47111214CPU 3 belleği1315CPU 0 sayfa 10’a erişir → sayfa hatası (CPU 0’da yok)

Sayfalar makinelere dağıtılmıştır. CPU 0 sayfa 10’a erişince MMU sayfa hatası üretir.

paylaşılan sanal adres uzayı: sayfa 0–150123456789101112131415CPU 0 belleği025910CPU 1 belleği1368CPU 2 belleği47111214CPU 3 belleği1315OS sayfayı ağdan getirir; CPU 1’de artık yok

OS sayfanın kimde olduğunu bulur, ister; sayfa CPU 0’a taşınır ve komut yeniden yürütülür.

paylaşılan sanal adres uzayı: sayfa 0–150123456789101112131415CPU 0 belleği025910CPU 1 belleği136810CPU 2 belleği47111214CPU 3 belleği1315salt okunur sayfa çoğaltılır: CPU 0 ve CPU 1’de kopya; yazmada kopyalar geçersiz kılınır

Sayfa salt okunursa çoğaltılır (replication): iki CPU da yerel okur. Yazmada diğer kopyalar geçersiz kılınır; aynı sayfadaki bağımsız değişkenler yanlış paylaşıma yol açar.

Sayfa (4 KiB) ağda pahalıdır ve kaba tanelidir; bu yüzden DSM yerini mesaj iletimine (MPI) ve PGAS dillerine bıraktı. Bugünkü karşılığı CXL ile makineler arası bellek havuzlarıdır.

Çoklu Bilgisayarlar

Çizge Kuramsal Deterministik Atama

3223231425114321ABCDGHEFItoplam trafik 39

9 süreç (düğüm) ve aralarındaki mesaj trafiği (kenar ağırlığı). 3 makineye 3’er süreç atanacak; hedef: ağ trafiğini en aza indirmek.

3223231425114321ABCDGHEFIdüğüm 1: A, B, Cdüğüm 2: D, E, Fdüğüm 3: G, H, Iağ trafiği = 24

Alfabetik atama: kesilen (makineler arası) kenarların toplamı 24.

3223231425114321ABCDGHEFIdüğüm 1: A, B, Cdüğüm 2: D, G, Hdüğüm 3: E, F, Iağ trafiği = 15

En iyi bölümleme (tüm 280 dengeli seçenek denendi): 15. Çok konuşan süreçler aynı makinede; problem genelde NP-zordur, sezgisel yöntemlerle çözülür.

Çoklu Bilgisayarlar

Dağıtık Sezgisel Yük Dengeleme

9367148yük ≥ 7: aşırı yüklürastgele düğüm yokla:“yükün ne?”kırmızı: aşırı yüklü (≥ 7)yeşil: az yüklü (≤ 2)

Gönderici başlatmalı: yeni iş gelince yükü eşiği aşan düğüm rastgele düğümleri yoklar (Eager ve diğ., 1986).

9367148yoklanan: 3 ve 7?eşiğin altında olan bulunurkırmızı: aşırı yüklü (≥ 7)yeşil: az yüklü (≤ 2)

Yoklama sınırlı sayıda yapılır (ör. N = 3); eşiğin altında bir düğüm bulunursa iş ona gönderilir, bulunamazsa yerelde çalışır.

8367248gönderici başlatmalı:iş yükü 1 olan düğüme gönderildikırmızı: aşırı yüklü (≥ 7)yeşil: az yüklü (≤ 2)

İş taşındı. Sakınca: sistem tümüyle yüklüyken yoklamaların hepsi boşa gider ve yükü artırır.

8367048alıcı başlatmalı:boş kalan düğüm iş ararkırmızı: aşırı yüklü (≥ 7)yeşil: az yüklü (≤ 2)

Alıcı başlatmalı: bir işi biten ve boş kalan düğüm kendisi iş arar; yoklama maliyeti boştaki düğüme yüklenir.

7367148aşırı yüklü düğümbir işi boş düğüme verdikırmızı: aşırı yüklü (≥ 7)yeşil: az yüklü (≤ 2)

Yüklü bir düğüm işini devretti. Yük yüksekken iyi çalışır. Bugünkü karşılığı iş çalma (work stealing): Cilk, Java ForkJoinPool, Go ve Tokio çalışma zamanları.

Sanallaştırma

Hipervizörler: Tip 1 ve Tip 2

DonanımHipervizör (VMM)misafir OSLinuxuygulamalarmisafir OSWindowsuygulamalarmisafir OSFreeBSDuygulamalar(a) Tip 1 (çıplak donanım)DonanımAna makine OS (host)uygulamaHipervizör (süreç)misafir OS + uygulamalar(b) Tip 2 (barındırılan)
  • Tip 1: VMware ESXi, Xen, Microsoft Hyper-V; Linux KVM çekirdeği hipervizöre dönüştürür (bulutların çoğu: AWS Nitro, Google). Sunucu ve bulut.
  • Tip 2: VirtualBox, VMware Workstation, Parallels, QEMU (TCG). Masaüstünde deneme ve geliştirme.
  • Popek–Goldberg (1974): hassas komutların hepsi ayrıcalıklıysa (kullanıcı kipinde tuzağa düşüyorsa) makine sanallaştırılabilir.
  • Klasik x86 bu koşulu sağlamıyordu (ör. POPF kullanıcı kipinde sessizce başarısız olur) → ikili çeviri, sonra VT-x/AMD-V.

Sanallaştırma

Tuzak ve Benzet: VT-x / AMD-V

sanal makine (VMX non-root kipi)misafir uygulamamisafir çekirdek: mov cr3, rax · out 0x3f8 · hltHipervizör (VMX root kipi)donanımVMCSmisafir durumuana makine durumuçıkış nedenitüm durum burada

Misafir OS kendini çekirdek kipinde sanır ama gerçek denetim hipervizördedir. Intel VT-x / AMD-V (2005–06) yeni bir kip ekler: root (hipervizör) ve non-root (misafir).

sanal makine (VMX non-root kipi)misafir uygulamamisafir çekirdek: mov cr3, rax · out 0x3f8 · hltHipervizör (VMX root kipi)donanımVMCSmisafir durumuana makine durumuçıkış nedenihassas komut!

Misafir çekirdek hassas bir komut yürütür: sayfa tablosunu değiştirmek (CR3), G/Ç portu, HLT…

sanal makine (VMX non-root kipi)misafir uygulamamisafir çekirdek: mov cr3, rax · out 0x3f8 · hltHipervizör (VMX root kipi)donanımVMCSmisafir durumuana makine durumuçıkış nedeniVM çıkışıneden: CR erişimi

Donanım komutu çalıştırmaz: VM çıkışı (VM exit) ile hipervizöre tuzak kurar; neden VMCS’ye yazılır.

sanal makine (VMX non-root kipi)misafir uygulamamisafir çekirdek: mov cr3, rax · out 0x3f8 · hltHipervizör (VMX root kipi)donanımVMCSmisafir durumuana makine durumuçıkış nedeniVM çıkışıneden: CR erişimiVM girişibenzetildi:gölge/EPT güncellendi

Hipervizör komutun etkisini benzetir (emulate), sanal donanım durumunu günceller ve VM girişi ile misafire döner. Bir çıkış ~1 µs’dir; sık çıkışlar performansı düşürür.

Donanım desteğinden önce VMware (1999) hassas komutları çalışma anında ikili çeviri ile değiştiriyordu. Eski sunumdaki “misafir OS donanıma erişemez, komutu hipervizöre iletir” ifadesi kesinleştirildi: yalnız hassas komutlar tuzağa düşer, diğerleri doğrudan donanımda çalışır.

Sanallaştırma

Yarı Sanallaştırma (Paravirtualization)

Donanım(a) çıplak donanımLinuxdonanıma doğrudanDonanım(b) tam sanallaştırmadeğiştirilmemiş Linuxhassas komut → tuzak / çeviriVMware (hipervizör)Donanım(c) yarı sanallaştırmadeğiştirilmiş Linuxhassas komut yokhiperçağrı arayüzüXen (hipervizör)
  • Misafir OS değiştirilir: hassas komutlar yerine hipervizöre doğrudan hiperçağrı (hypercall) yapar — sistem çağrısının bir alt katmandaki benzeri.
  • Tuzak ve benzetme maliyeti yok, daha hızlı; ama kaynak kodu değiştirilebilen OS gerekir (Xen 2003).
  • VMI (Virtual Machine Interface), tek çekirdeğin hem donanımda hem farklı hipervizörlerde çalışması için önerildi; 2011’de Linux’tan kaldırıldı. Bugün yarı sanallaştırma sürücülerde yaşar: virtio disk/ağ, paravirt saat, Hyper-V aydınlatmaları.

Günümüz bulutlarında CPU ve bellek donanım destekli tam sanallaştırılır; G/Ç ise virtio ya da SR-IOV ile doğrudan aygıt ataması kullanır.

Sanallaştırma

Bellek Sanallaştırma: Gölge Tablo ve EPT

misafir sanal (GVA)misafir fiziksel (GPA)ana makine fiziksel (HPA)misafir sayfa tablosu(misafir OS yönetir)EPT / NPT(hipervizör yönetir)gölge sayfa tablosu: GVA → HPA doğrudan (yazılımla güncel tutulur)TLB kaçırmada 2B tablo yürüyüşü: 4 düzey → (4+1)² − 1 = 24 bellek erişimi · 5 düzey → 35
  • Gölge sayfa tabloları: hipervizör, misafirin tablolarını salt okunur yapar; her değişiklikte tuzak kurup GVA → HPA kopyasını günceller. Çok VM çıkışı.
  • EPT (Intel, 2008) / NPT (AMD): donanım iki tabloyu birlikte yürür; misafir kendi tablosunu tuzaksız değiştirir.
  • TLB kaçırma pahalılaşır → büyük sayfalar (2 MiB / 1 GiB) ve VM etiketli TLB (VPID/ASID) kullanılır.
  • Aşırı tahsis: balon sürücüsü misafirden bellek geri alır; KSM aynı içerikli sayfaları birleştirir (yazınca kopyala).

Sanallaştırma

Konteynerler ve Sanal Makineler

(a) sanal makinelerDonanımHipervizörmisafir çekirdekkitaplıklaruygulama 1misafir çekirdekkitaplıklaruygulama 2misafir çekirdekkitaplıklaruygulama 3(b) konteynerlerDonanımAna makine çekirdeği: namespaces + cgroupskonteyner çalışma zamanı (containerd, runc)kitaplıklaruygulama 1kitaplıklaruygulama 2kitaplıklaruygulama 3
Sanal makineKonteyner
Yalıtım sınırıdonanım düzeyi, ayrı çekirdekaynı çekirdek: namespace, cgroup, seccomp
Başlama / ek yüksaniyeler, GB bellekmilisaniyeler, MB bellek
Farklı OSevet (Linux üstünde Windows)hayır (aynı çekirdek ailesi)
ÖrnekKVM, Hyper-V, ESXiDocker, Podman, Kubernetes pod’ları

Arada: Firecracker mikro-VM’leri (AWS Lambda), gVisor ve Kata Containers, konteyner kolaylığını VM yalıtımıyla birleştirir.

Dağıtık Sistemler

Dağıtık Sistemler ve Ara Yazılım

WindowsdonanımLinuxdonanımmacOSdonanımLinuxdonanımOrtak uygulamaAra yazılım (middleware)tek tip arayüz: belge, dosya, nesne ya da koordinasyon modeliağ
  • Dağıtık sistem: ağ üzerinden haberleşen özerk bilgisayarlar; her biri kendi OS’ini, belleğini ve kaynaklarını yönetir, kullanıcıya tek bir tutarlı sistem gibi görünmeye çalışır.
  • Düğümler farklı donanım ve OS çalıştırabilir, farklı kurumlara ait olabilir, dünyaya yayılabilir. Ortaklık ara yazılım katmanıyla sağlanır.
  • Dört paradigma: belge (Web), dosya (NFS, SMB), nesne (CORBA, RMI, gRPC), koordinasyon (Linda, yayınla-abone ol).

Eski sunumdaki “kaynak tahsisi dağıtık işletim sistemi tarafından yönetilir” ifadesi düzeltildi: gerçek dağıtık OS’ler (Amoeba, Plan 9) araştırmada kaldı; bugün her düğüm kendi OS’ini çalıştırır, dağıtımı ara yazılım ve küme yöneticileri (Kubernetes) yapar.

Dağıtık Sistemler

Üç Sistem Türünün Karşılaştırması

ÖzellikÇok işlemciÇoklu bilgisayarDağıtık sistem
Düğüm yapısıCPUCPU, RAM, ağ arayüzütam bilgisayar
Çevre birimlerihepsi paylaşılırpaylaşılır (belki disk hariç)her düğümde tam set
Konumaynı rafaynı odadünya çapında olabilir
Düğümler arası iletişimpaylaşılan RAMözel ara bağlantıgeleneksel ağ
İşletim sistemibir, paylaşılançok, aynıçok, farklı olabilir
Dosya sistemibir, paylaşılanbir, paylaşılanher düğümün kendi
Yönetimtek kurumtek kurumbirçok kurum

Tanenbaum (MOS 4e, Şekil 8-29). Eski sunumda dağıtık sistemde çevre birimleri “tümü paylaşılır” yazıyordu; doğrusu her düğümün kendi tam setine sahip olmasıdır. Çoklu bilgisayarda da disk her zaman paylaşılmaz.

Dağıtık Sistemler

Ağ Donanımı ve Kapsülleme

(a) klasik: ortak kabloB1B2B3B4CSMA/CD: çarpışmada geri çekil(b) anahtarlamalı: yıldızanahtarB1B2B3B4tam çift yönlü, çarpışma yokkapsülleme: her katman başlık ekleruygulamaveri (HTTP)taşımaTCPveriağIPTCPveribağlantıEthIPTCPveriFCSalıcıda başlıklar ters sırayla çıkarılır
  • Klasik Ethernet (1976) tek kabloyu paylaşıyordu; bugün her bilgisayar bir anahtara bağlı, bağlantılar 1–400 Gb/s ve tam çift yönlü.
  • LAN’lar yönlendiricilerle birbirine, yerel ağlar ISS’lere ve İnternet omurgasına (yüksek hızlı fiber hatlar, değişim noktaları) bağlanır.

Dağıtık Sistemler

Ağ Protokolleri ve Servis Türleri

ProtokolKatmanServisNot
IP (v4/v6)ağbağlantısız, güvenilmezadresleme ve yönlendirme
TCPtaşımabağlantı yönelimli, güvenilir bayt akışıonay, yeniden iletim, akış ve tıkanıklık denetimi
UDPtaşımabağlantısız, güvenilmez datagramsağlama toplamı var; yeniden iletim yok. DNS, oyun, ses
QUICtaşıma (UDP üstü)bağlantı yönelimli, güvenilir, şifreliHTTP/3 (2022) bunu kullanır
DNSuygulamaad → IP adresihiyerarşik, dağıtık, önbellekli
HTTP/HTTPSuygulamaWeb belgeleriHTTPS = HTTP + TLS, port 443
SMTPuygulamae-posta aktarımısunucular arası; okuma IMAP ile
FTP → SFTPuygulamadosya aktarımıFTP şifresizdir; yerini SFTP/HTTPS aldı
SNMPuygulamaağ cihazı izlemev3 kimlik doğrulama ve şifreleme ekler

Güvenilir servis: teslim ve sıra garanti, alındı onayı (ACK). Bağlantı yönelimli: önce kurulum, sonra veri, sonra sonlandırma; bağlantısız servis kurulum maliyeti olmadan her paketi bağımsız gönderir. Eski sunumdaki “UDP’de hata algılama yok” düzeltildi: UDP sağlama toplamıyla bozuk paketi algılar ama düzeltmez ya da yeniden göndermez.

Dağıtık Sistemler

Belge Tabanlı Ara Yazılım: Web

TarayıcıistemciDNS çözücüwww.ornek.org203.0.113.10belgeler ve bağlantılar

Kullanıcı www.ornek.org/index.html adresini yazar. Web: birbirine bağlı belgelerden oluşan dev bir yönlendirilmiş çizge.

TarayıcıistemciDNS çözücüwww.ornek.org203.0.113.10A? www.ornek.org

1–2: Tarayıcı (işletim sisteminin çözücüsü üzerinden) DNS’e www.ornek.org’un adresini sorar; yanıt: 203.0.113.10 (önbellekte tutulur).

TarayıcıistemciDNS çözücüwww.ornek.org203.0.113.10SYNSYN-ACKACK + TLS ClientHelloTLS ServerHello, sertifika

3: Sunucunun 443 numaralı portuna TCP bağlantısı ve TLS el sıkışması (HTTP/3’te ikisi tek adımda, QUIC ile).

TarayıcıistemciDNS çözücüwww.ornek.org203.0.113.10GET /index.html HTTP/2200 OK + HTML

4–5: GET /index.html isteği; sunucu HTML’yi döndürür, tarayıcı metni görüntülemeye başlar.

TarayıcıistemciDNS çözücüwww.ornek.org203.0.113.10logo.png · stil.css · uyg.js (paralel akışlar)

6: HTML’deki resim, CSS ve betikler aynı bağlantı üzerinden, HTTP/2–3’te paralel akışlarla alınır; bağlantı bir süre açık kalır.

Eski sunumdaki akış (port 80, her nesne için yeni TCP bağlantısı, sonra kapat) HTTP/1.0 dönemine aitti; bugün varsayılan HTTPS (443), kalıcı bağlantılar ve HTTP/2–3 çoğullamasıdır.

Dağıtık Sistemler

Dosya Sistemi Tabanlı Ara Yazılım

İstemciSunucudosyakopya1. dosyanın tamamı indirilir2. yerelde okunur/yazılır3. yeni hâli geri yüklenir

Yükleme/indirme modeli: dosya bütün olarak istemciye kopyalanır, kullanılır, geri gönderilir (FTP benzeri; eski AFS). Basit ama büyük dosyada pahalı.

İstemciSunucudosyaread(fd, 4 KiB)veriwrite(fd, ...)tamamdosya sunucuda kalır

Uzaktan erişim modeli: dosya sunucuda kalır; istemci read/write isteklerini ağ üzerinden gönderir (NFS, SMB).

sunucu 1sunucu 2kökABCkökDEkare: dizin · daire: dosya

İki dosya sunucusu, her biri kendi dizin ağacıyla.

istemci 1köks1ABCs2DEistemci 2köks1ABCs2DEaynı ad alanı: /s1/A her istemcide aynı dosya

Tüm istemciler sunucuları aynı yere bağlar (mount) → tek, ortak ad alanı.

istemci 1köks1ABCs2DEistemci 2köks2DEevnotlaristemci 2’de /s1 yok, /s2/D ise iki istemcide aynı

İstemciler farklı şeyler bağlarsa her biri farklı görünüm görür; aynı yol farklı istemcide farklı dosya olabilir.

Adlandırma: makine:/yol (konum şeffaf değil) → uzak sistemi yerel ağaca bağlama → tüm makinelerde aynı tek ad alanı (konumdan bağımsızlık). Bugünkü örnekler: NFSv4, SMB 3, nesne depolama (S3).

Dağıtık Sistemler

Dosya Paylaşımının Anlamı

tek makinea b cA: write(c)B: read → abcher okuma en son yazmayı görür: UNIX semantiği

Tek işlemcide işlemler sıralıdır: A “c” ekler, ardından B okur ve “abc” görür (sıralı tutarlılık).

Dosya sunucusua bİstemci 1önbellek: a b cİstemci 2okur → a b1. a b okundu2. c yerelde eklendi3. eski veri!

Dağıtık sistemde istemci 1 dosyayı önbelleğinde değiştirir; sunucu bunu henüz bilmez. İstemci 2 sunucudan okur ve eski “ab”yi görür.

YaklaşımKuralÖrnek
UNIX semantiğiher yazma hemen herkese görünürtek makine; önbelleksiz uzak erişim
Oturum semantiğideğişiklik dosya kapanınca görünürAFS; NFS kapat-aç tutarlılığı
Değişmez dosyalardosya yazılamaz, yenisi oluşturulurnesne depolama, Git nesneleri
İşlemler (transactions)hep ya da hiç, sıralanabilirveritabanları

Çözümler tutarlılık ile performans arasında takas yapar.

Dağıtık Sistemler

Nesne Tabanlı Ara Yazılım: CORBA

istemci makinesiİstemciistemci koçanıORB (nesne istek aracısı)işletim sistemisunucu makinesiSunucu nesnesiiskelet (skeleton)ORB (nesne istek aracısı)işletim sistemiIIOP
  • IDL: arayüzler dilden bağımsız tanımlanır; derleyici istemci koçanı ve sunucu iskeletini üretir.
  • ORB: nesnenin yerini bulur, çağrıyı paketler, IIOP ile iletir: ağ şeffaflığı.
  • SII (statik çağırma): derleme zamanında IDL’den üretilen koçanlarla; hızlı, tür denetimli.
  • DII (dinamik çağırma): arayüz çalışma anında keşfedilir (arayüz deposu).

Eski sunumdaki “SII, DII’nin önceden derlenmiş sürümüdür” ifadesi düzeltildi: ikisi ayrı mekanizmalardır. CORBA (OMG, 1991) bugün eski sistemlerde yaşar; yeni sistemlerde gRPC/Protobuf, REST ve Java RMI tercih edilir.

Dağıtık Sistemler

Koordinasyon Tabanlı Ara Yazılım: Linda

demet uzayı (tuple space)("abc", 2, 5)("matris-1", i, j, 0.5)("bit", 3)Süreç ASüreç Bout · in · rd · eval

Linda (Gelernter, 1985): süreçler birbirini tanımaz; ortak, kalıcı bir demet uzayı üzerinden haberleşir. Demet: türlü alanlardan oluşan kayıt.

demet uzayı (tuple space)("abc", 2, 5)("matris-1", i, j, 0.5)("bit", 3)("abc", 2, 9)Süreç ASüreç Bout("abc", 2, 9)

out demeti uzaya koyar (bloke etmez).

demet uzayı (tuple space)("abc", 2, 5)("matris-1", i, j, 0.5)("bit", 3)("abc", 2, 9)Süreç ASüreç Bin("abc", 2, ? i)şablon eşleşiyor

in bir şablonla arar: alan sayısı aynı, karşılıklı alanlar aynı türde, sabit alanlar eşit olmalı. ? i biçimsel parametredir. Birden çok eşleşmede biri rastgele seçilir.

demet uzayı (tuple space)("matris-1", i, j, 0.5)("bit", 3)("abc", 2, 9)Süreç ASüreç Bi = 5demet uzaydan alındı

Eşleşen demet uzaydan çıkarılır, i = 5 atanır. Eşleşme yoksa in bloke olur. rd okur ama çıkarmaz; eval yeni süreç başlatır. Senkronizasyon da böylece kendiliğinden gelir.

Dağıtık Sistemler

Yayınla-Abone Ol ve Jini

sensör 1yayıncısensör 2yayıncıborsayayıncıaracı (broker)sicaklik/izmirsicaklik/giresunhisse/XYZpanelabonealarmabonemobil uyg.abone
  • Yayıncı bir konuya yayınlar, abone ilgilendiği konulara abone olur; taraflar birbirinin kimliğini bilmez: zaman ve uzayda ayrıklık.
  • Abone ve konu dinamik eklenir → ölçeklenebilir, esnek. Teslim garantisi aracının ayarına bağlıdır (en çok bir kez / en az bir kez / kalıcı kuyruk).
  • Bugün: MQTT (IoT), Apache Kafka, RabbitMQ, bulut kuyrukları.
  • Jini (Sun, 1998): Java aygıtları ağda birbirini önceden yapılandırma olmadan keşfeder, arama servisine kaydolur, Java RMI ile kullanır; kiralama (lease) ile kayıtlar kendiliğinden düşer.
  • Apache River adıyla sürdü ama bugün etkin değil; fikirleri servis keşfinde (mDNS/DNS-SD, Consul, Kubernetes servisleri) yaşıyor.

Dağıtık Sistemler

Bulut ve Kümeler

şirket içiuygulamaveriçalışma zamanıara yazılımOSsanallaştırmasunucu, depolama, ağIaaSuygulamaveriçalışma zamanıara yazılımOSsanallaştırmasunucu, depolama, ağPaaSuygulamaveriçalışma zamanıara yazılımOSsanallaştırmasunucu, depolama, ağFaaSuygulamaveriçalışma zamanıara yazılımOSsanallaştırmasunucu, depolama, ağSaaSuygulamaveriçalışma zamanıara yazılımOSsanallaştırmasunucu, depolama, ağkullanıcı yönetirsağlayıcı yönetir
  • Küme: hızlı ağla bağlı, tek yönetimdeki sunucular (HPC, veri merkezi). Bulut: bu kaynakların ağ üzerinden, isteğe bağlı ve kullandıkça öde biçiminde sunulması (AWS, Azure, Google Cloud).
  • Altyapı: KVM/Nitro sanallaştırma, konteynerler ve Kubernetes (pod’ları düğümlere çizelgeler, çökeni yeniden başlatır: dağıtık OS’in bugünkü karşılığı).
  • Bu bölümün tüm konuları burada birleşir: NUMA sunucular, sanal makineler, RDMA ağları, yük dengeleme, yayınla-abone ol kuyrukları.

Özet

Özet

Donanım

UMA (veri yolu, çapraz çubuk n², omega (n/2)log₂n) ve NUMA; tutarlılık için dinleme ya da dizin.

Önbellek

MESI geçişleri; yazmalar geçersiz kılma üretir; yanlış paylaşım satır düzeyinde olur, dolgu ile çözülür.

OS ve kilitler

Ayrı OS, usta-köle, SMP; TSL için veri yolu/satır kilidi, TTAS, bilet ve MCS; kısa beklemede dön, uzunda uyu.

Çizelgeleme

Ortak kuyruk → CPU başına kuyruk + afinite + dengeleme; alan paylaşımı ve çete çizelgeleme.

Çoklu bilgisayar

Topoloji çapı, sakla-ilet ve kesip geç, bloke eden/etmeyen gönderim, RPC, DSM, yük dengeleme.

Sanallaştırma ve dağıtık

Tip 1/2, VT-x, EPT, konteyner; ara yazılım: belge, dosya, nesne, koordinasyon; bulut.

Özet

Kontrol Soruları

  1. 64 × 64 çapraz çubukta kaç kesişim, 64 girişli omega ağında kaç 2 × 2 anahtar var?
  2. Omega ağında CPU 011 → bellek 110 isteği hangi anahtar ve çıkışlardan geçer?
  3. Yerel 80 ns, uzak 140 ns, erişimlerin %75’i yerel: ortalama erişim süresi?
  4. MESI’de E ve S durumundaki bir satıra yazmanın veri yolu açısından farkı nedir?
  5. İki iş parçacığının ayrı sayaçları neden birbirini yavaşlatabilir? Çözüm?
  6. Bilet kilidi saf TSL döngüsünden hangi iki açıdan üstündür?
  7. Çete çizelgelemenin iki koşulu nedir, hangi sorunu çözer?
  8. 256 düğümlü hiperküpün çapı nedir? 16 × 16 simidin çapı nedir?
  9. 4 düzeyli tablolar ve EPT ile TLB kaçırması en kötü kaç bellek erişimi ister?
  10. in("abc", ? x, 5) (x int), ("abc", 2, 5) ve ("abc", 2.0, 5) demetlerinden hangisiyle eşleşir?
Cevaplar
  1. 64² = 4.096 kesişim; log₂64 = 6 aşama × 32 = 192 anahtar.
  2. 1D (bit 1 → alt), 2D (bit 1 → alt), 3D (bit 0 → üst).
  3. 0,75 · 80 + 0,25 · 140 = 95 ns.
  4. E → M sessizdir (veri yolu yok); S → M için geçersiz kılma (BusUpgr) yayınlanmalıdır.
  5. Aynı 64 B satırdalar: her yazma satırı diğer çekirdekten koparır (yanlış paylaşım). Hizalama/dolgu ile ayrı satırlara koy.
  6. Adil (FIFO, açlık yok) ve beklerken yazma yapmaz, yalnız okur → daha az tutarlılık trafiği.
  7. Üyeler aynı anda, farklı CPU’larda; dilimler eşzamanlı başlar. Konuşan iş parçacıkları birbirini dilim boyu beklemez.
  8. log₂256 = 8; 2 · ⌊16/2⌋ = 16.
  9. (4 + 1)² − 1 = 24.
  10. Yalnız ("abc", 2, 5): ikinci alanın türü int olmalı.

Özet

Kaynaklar

  • A. S. Tanenbaum, H. Bos, Modern Operating Systems, 4. baskı (2014) / 5. baskı (2022), Pearson — Bölüm 8: Multiple Processor Systems; Bölüm 7: Virtualization and the Cloud.
  • A. Silberschatz, P. B. Galvin, G. Gagne, Operating System Concepts, 10. baskı, Wiley, 2018 — Bölüm 5.5 (Multi-Processor Scheduling), 18 (Virtual Machines), 19 (Networks and Distributed Systems).
  • R. H. Arpaci-Dusseau, A. C. Arpaci-Dusseau, Operating Systems: Three Easy Pieces (OSTEP), ostep.org — “Multiprocessor Scheduling”, “Locks”, “Distributed Systems”, “Sun’s NFS”, “AFS”, Ek: “Virtual Machine Monitors”.
  • J. L. Hennessy, D. A. Patterson, Computer Architecture: A Quantitative Approach, 6. baskı, Morgan Kaufmann, 2017 — Bölüm 5: Thread-Level Parallelism (tutarlılık, MESI, dizin protokolleri).
  • J. M. Mellor-Crummey, M. L. Scott, “Algorithms for Scalable Synchronization on Shared-Memory Multiprocessors”, ACM TOCS, 1991; A. D. Birrell, B. J. Nelson, “Implementing Remote Procedure Calls”, ACM TOCS, 1984; G. J. Popek, R. P. Goldberg, CACM, 1974.
  • Linux çekirdek belgeleri: “CFS/EEVDF Scheduler”, “Scheduler Domains”, “NUMA Memory Policy”, “Core Scheduling”; Intel SDM Cilt 3 (VMX, EPT).

Son

Bölüm 12: Çok İşlemcili Sistemler
Sonraki bölüm: Güvenlik
1 / 1 Sercan KÜLCÜ, Tüm hakları saklıdır.