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 İleti geçirme 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ı işletim sistemi, usta-köle ve SMP modellerini; TSL, bilet ve MCS kilitlerini; dönme ile geçişi değerlendirmek.

Çizelgeleme

Ortak hazır kuyruğunun sınırlarını, alan paylaşımını ve çete çizelgelemeyi örnek üzerinde uygulamak.

Çoklu bilgisayarlar

Topolojilerin çapını hesaplamak; ileti geçirme, 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 işletim sistemini 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 işletim sistemi 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) ileti 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şımlı bellek yalnız paylaşılan değişkenler için.

UMA: Uniform (tekdüze) Memory Access. 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)ileti 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ış. İletinin 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.

Omega ağı “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 alanı 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).
  • İşletim sistemi: 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

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)Bağıl konum (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 bağıl konum256 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) = 4Bağıl konum (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, bağıl konum = 8. Yerel değil → istek 36’ya gider.

adres 0x24000108Düğüm (8 bit) = 36Blok (18 bit) = 4Bağıl konum (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) = 4Bağıl konum (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) = 2Bağıl konum (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) = 2Bağıl konum (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 iletiler.

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 ileti 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: oku x2. Ç1: oku x3. Ç1: x = 14. Ç0: oku 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: oku x2. Ç1: oku x3. Ç1: x = 14. Ç0: oku 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: oku x2. Ç1: oku x3. Ç1: x = 14. Ç0: oku 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: oku x2. Ç1: oku x3. Ç1: x = 14. Ç0: oku 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: oku x2. Ç1: oku x3. Ç1: x = 14. Ç0: oku 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: oku x2. Ç1: oku x3. Ç1: x = 14. Ç0: oku 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: oku x2. Ç1: oku x3. Ç1: x = 14. Ç0: oku 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;   /* bağıl konum 0 */
  long b;   /* bağıl konum 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 sayaç ayrı satıra konur. Bellek israfı sayaç başına 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: işletim sistemi 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.
  • İşletim sistemi 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 İS’siCPU 2kendi İS’siCPU 3kendi İS’siCPU 4kendi İS’siveri yolubellekbölüm 1veribölüm 2veribölüm 3veribölüm 4veriİS 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 işletim sistemi kopyası çalıştırır. İşletim sistemi 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 işletim sistemi 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 işletim sistemi 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 iletiyle haberleşen ayrı bir düğüm gibi ele alır.

Çok İşlemcili İşletim Sistemleri

Usta-Köle (Master-Slave) Modeli

CPU 1usta: İSCPU 2köle: süreçCPU 3köle: süreçCPU 4köle: süreçveri yolubellekusta İStek hazır listesiköle süreçlerinin bellekleri
  • İşletim sisteminin 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.

Asimetrik çok işlemcili (AMP) düzenin 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 1İS + süreçCPU 2İS + süreçCPU 3İS + süreçCPU 4İS + süreçveri yolubellektek İS kopyasıhazır listesi + kilitdosya tablosu + kilitkullanıcı süreçleri
  • Bellekte tek işletim sistemi 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.

Çok İşlemcili İşletim Sistemleri

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

Ayrı İSUsta-köleSMP
İS 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
ayrı işletim sistemleriCPU1İS 1CPU2İS 2CPU3İS 3CPU4İS 4bellek dört parçaya bölünürusta-köleCPU1İSCPU2kul.CPU3kul.CPU4kul.bellekçağrılar yalnız CPU1’deSMPCPU1İSCPU2İSCPU3İSCPU4İSbellektek çekirdek, herkes çalıştırır
Çok işlemcili işletim sistemi ile çoklu bilgisayar işletim sistemi 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 iletiyle 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 iletisi).

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

Spinlock’lar 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ülür; serbest görününce TSL denenir. 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.

Çoklu kilidin amacı veri tutarsızlığını değil, tutarlılık trafiğini (cache thrashing) önlemektir.

Senkronizasyon · Kodu adım adım çalıştır

TTAS Kilidi: Kod İzleme

void kilitle(int *k) {
  for (;;) {
    while (*k == 1)   /* yerelde dön */
      ;
    if (tsl(k) == 0)  /* serbest göründü */
      return;         /* kilit alındı */
  }
}
void ac(int *k) {
  *k = 0;
}
bellek: kveri yolu: 0 işlemCPU 0M · k=1kilitteCPU 1I · k=–dışarıdaCPU 2I · k=–dışarıdaönbellek satırı durumu: M, E, S, I

CPU 0 kilidi tutuyor (k = 1, satır onun önbelleğinde M). CPU 1 ve CPU 2 kilitle çağırıyor.

bellek: kveri yolu: 1 işlemCPU 0S · k=1kilitteCPU 1S · k=1dönüyorCPU 2I · k=–dışarıdaönbellek satırı durumu: M, E, S, I

CPU 1 *k’yı okur: ıska, veri yolundan istenir. CPU 0’ın M kopyası paylaşılır; ikisi de S.

bellek: kveri yolu: 2 işlemCPU 0S · k=1kilitteCPU 1S · k=1dönüyorCPU 2S · k=1dönüyorönbellek satırı durumu: M, E, S, I

CPU 2 de okur: üç kopya S. Buraya kadar 2 veri yolu işlemi.

bellek: kveri yolu: 2 işlemCPU 0S · k=1kilitteCPU 1S · k=1dönüyorCPU 2S · k=1dönüyorönbellek satırı durumu: M, E, S, I

İkisi de k = 1 gördükçe kendi önbelleğinde döner: veri yolu sayacı artmaz. Saf TSL döngüsü burada her denemede satırı yazmak için çekerdi.

bellek: kveri yolu: 3 işlemCPU 0M · k=0bıraktıCPU 1I · k=–dönüyorCPU 2I · k=–dönüyorönbellek satırı durumu: M, E, S, I

CPU 0 ac: k = 0 yazmak için diğer kopyaları geçersiz kılar (I); satır CPU 0’da M.

bellek: kveri yolu: 4 işlemCPU 0S · k=0bıraktıCPU 1S · k=0dönüyorCPU 2I · k=–dönüyorönbellek satırı durumu: M, E, S, I

CPU 1’in kopyası geçersiz: yeniden okur (ıska), k = 0 görür ve while’dan çıkar.

bellek: kveri yolu: 5 işlemCPU 0S · k=0bıraktıCPU 1S · k=0dönüyorCPU 2S · k=0dönüyorönbellek satırı durumu: M, E, S, I

CPU 2 de ıska ile k = 0 görür. İkisi de aynı anda “serbest” sanıyor.

bellek: kveri yolu: 6 işlemCPU 0I · k=–bıraktıCPU 1M · k=1kilitteCPU 2I · k=–dönüyorönbellek satırı durumu: M, E, S, I

CPU 1 önce TSL yapar: satırı yazmak için alır (M), eski değer 0 → kilit alındı.

bellek: kveri yolu: 7 işlemCPU 0I · k=–bıraktıCPU 1I · k=–kilitteCPU 2M · k=1dönüyorönbellek satırı durumu: M, E, S, I

CPU 2’nin TSL’i de satırı çeker (CPU 1’in kopyası I) ama eski değer 1: başarısız. Bu yarışın bedeli bir veri yolu işlemi daha.

bellek: kveri yolu: 7 işlemCPU 0I · k=–bıraktıCPU 1I · k=–kilitteCPU 2M · k=1dönüyorönbellek satırı durumu: M, E, S, I

CPU 2 yeniden yerel kopyasında döner. Toplam 7 veri yolu işlemi; bekleme ne kadar uzun sürerse sürsün bu sayı artmaz.

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’den kısaysa dönmek, değilse uyumak ucuzdur.
  • Rekabetçi strateji: geçişin bedeli kadar (2C) dönmek, sonra uyumak → 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 spinlock 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γöncelikli 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çlerde tüm CPU’lar tek bir öncelikli hazır kuyruğundan iş alır: yük kendiliğinden dengelenir, ama tek kilit darboğaz olur ve süreç soğuk önbellekli bir CPU’ya düşebilir.
  • Spinlock tutan iş parçacığının dilimi biterse diğer CPU’lar boşuna döner. Akıllı çizelgeleme: kilidi tutan iş parçacığı bir bayrak koyar, çizelgeleyici bayraklı iş parçacığını kesmez, kritik bölgesini bitirmesi için ona biraz ek süre verir.

Ç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ş çizelgeleyicileri (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 ileti 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; iletiler 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 işletim sistemi kopyası çalışır. İletişim yalnız iletiyle.
  • Bir ileti 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 ileti 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 · Kodu adım adım çalıştır

E-küp Yönlendirme: Kod İzleme

void yonlendir(int src, int dst, int d) {
  int u = src;
  for (int b = d - 1; b >= 0; b--) {
    int m = 1 << b;
    if ((u ^ dst) & m) {  /* bit farklı */
      u ^= m;             /* komşuya geç */
      printf("%d ", u);
    }
  }
}
0000000100100011010001010110011110001001101010111100110111101111u = 0110 · u ⊕ dst = 1011

0110’dan (6) 1101’e (13) ileti. u ⊕ dst = 1011: üç bit farklı, yani en kısa yol 3 atlama. Kesikli kenarlar 4. boyut (iki 3-küp arası).

0000000100100011010001010110011110001001101010111100110111101111u = 1110 · u ⊕ dst = 0011 · bit 3

b = 3: bit farklı → u’nun 3. biti çevrilir, ileti komşu 1110 (14) düğümüne geçer.

0000000100100011010001010110011110001001101010111100110111101111u = 1110 · u ⊕ dst = 0011 · bit 2

b = 2: bu bit u ile dst’de aynı (1); atlama yok.

0000000100100011010001010110011110001001101010111100110111101111u = 1100 · u ⊕ dst = 0001 · bit 1

b = 1: bit farklı → u’nun 1. biti çevrilir, ileti komşu 1100 (12) düğümüne geçer.

0000000100100011010001010110011110001001101010111100110111101111u = 1101 · u ⊕ dst = 0000 · bit 0

b = 0: bit farklı → u’nun 0. biti çevrilir, ileti komşu 1101 (13) düğümüne geçer.

0000000100100011010001010110011110001001101010111100110111101111u = 1101 · u ⊕ dst = 0000

Hedefe 3 atlamada ulaşıldı: 0110 → 1110 → 1100 → 1101. Her düğüm yalnız kendi adresine ve hedefe bakarak karar verir; bitler hep soldan sağa düzeltildiği için yol döngüsüzdür.

Ç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: ileti iletiliyorçalışıyorsend(m)ileti gitti, dönüşbasit ve güvenli; ama CPU iletim boyunca boşta bekler

(a) Bloke eden (blocking, senkron) send: çağrı ileti 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 (eş zamansız) 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ış durumları)
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 ileti (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 iletiye 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 iletiyi 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 iletiyi 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 alanı → 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 alanı yanılsamasını üretir

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

paylaşılan sanal adres alanı: 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 alanı: sayfa 0–150123456789101112131415CPU 0 belleği025910CPU 1 belleği1368CPU 2 belleği47111214CPU 3 belleği1315İS sayfayı ağdan getirir; CPU 1’de artık yok

İşletim sistemi 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 alanı: 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; yazınca 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 ileti 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 ileti 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üğümler yoklanır:“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 1eş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 İSLinuxuygulamalarmisafir İSWindowsuygulamalarmisafir İSFreeBSDuygulamalar(a) Tip 1 (çıplak donanım)DonanımAna makine İS (host)uygulamaHipervizör (süreç)misafir İS + uygulamalar(b) Tip 2 (barındırılan)
  • Tip 1: VMware ESXi, Xen (XCP-ng), Microsoft Hyper-V; Linux KVM çekirdeği hipervizöre dönüştürür (bulutların çoğu: AWS Nitro, Google). Hyper-V açılınca Windows da bir kök bölümde çalışır.
  • Tip 2: VirtualBox, VMware Workstation/Fusion, Parallels, UTM. Saf tip 2 yorumlar ya da ikili çevirir (KVM’siz QEMU); pratik tip 2 çekirdek modülüyle VT-x/AMD-V kullanır.
  • Popek–Goldberg (1974): hassas komutların hepsi ayrıcalıklıysa (kullanıcı modunda tuzağa düşüyorsa) makine sanallaştırılabilir.
  • Klasik x86 bu koşulu sağlamıyordu (ör. POPF kullanıcı modunda sessizce başarısız olur) → ikili çeviri, sonra VT-x/AMD-V.

Kullanım nedenleri: sunucu birleştirme, çalışan VM’i başka makineye taşıma (canlı göç) ve anlık görüntü; bulutun temeli budur. Tip 2’de G/Ç ana İS’den geçtiği için ek yük daha fazladır.

Sanallaştırma

Tuzak ve Benzet: VT-x / AMD-V

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

Misafir işletim sistemi kendini çekirdek modunda sanır ama gerçek denetim hipervizördedir. Intel VT-x / AMD-V (2005–06) yeni bir mod ekler: root (hipervizör) ve non-root (misafir).

sanal makine (VMX non-root modu)misafir uygulamamisafir çekirdek: mov cr3, rax · out 0x3f8 · hltHipervizör (VMX root modu)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 modu)misafir uygulamamisafir çekirdek: mov cr3, rax · out 0x3f8 · hltHipervizör (VMX root modu)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 modu)misafir uygulamamisafir çekirdek: mov cr3, rax · out 0x3f8 · hltHipervizör (VMX root modu)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. Misafir işletim sisteminin 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 işletim sistemi 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 işletim sistemi 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 İS 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ı İSevet (Linux üstünde Windows)hayır (aynı çekirdek ailesi)
ÖrnekKVM, Hyper-V, ESXiDocker, Podman, Kubernetes pod’ları

Arada: milisaniyelerde açılan Firecracker mikro-VM’leri (AWS Lambda), gVisor ve Kata Containers, konteyner kolaylığını VM yalıtımıyla birleştirir. WSL 2 de hafif bir Hyper-V VM’inde gerçek Linux çekirdeği çalıştırır; Windows’taki Linux konteynerleri bu VM’de koşar.

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 işletim sistemini, 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 işletim sistemi ç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).

Gerçek dağıtık işletim sistemleri (Amoeba, Plan 9) araştırmada kaldı; bugün her düğüm kendi işletim sistemini ç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
çok işlemciRAMCCCCCCpaylaşılan bellekçoklu bilgisayarara bağlantıC+MC+MC+MC+MC+MC+Mileti, özel ağdağıtık sisteminternetbilg.bilg.bilg.bilg.tam bilgisayarlar, geniş alan

Tanenbaum (MOS 4e, Şekil 8-29). Dağıtık sistemde çevre birimleri paylaşılmaz: her düğüm kendi tam setine sahiptir. Ç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 çekilir(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 Hizmet Türleri

ProtokolKatmanHizmetNot
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ğ aygıtı izlemev3 kimlik doğrulama ve şifreleme ekler

Güvenilir hizmet: teslim ve sıra garanti, alındı onayı (ACK). Bağlantı yönelimli: önce kurulum, sonra veri, sonra sonlandırma; bağlantısız hizmet kurulum maliyeti olmadan her paketi bağımsız gönderir. 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.

Port 80 ve her nesne için yeni TCP bağlantısı açıp kapatma 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).

SII ve DII ayrı mekanizmalardır; SII, DII’nin derlenmiş sürümü değildir. 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 · Kodu adım adım çalıştır

Linda in(): Kod İzleme

Demet *in_ara(Sablon *s) {
  for (Demet *d = uzay; d; d = d->snr) {
    if (d->n != s->n) continue;
    int ok = 1;
    for (int k = 0; ok && k < s->n; k++)
      if (d->tur[k] != s->tur[k] ||
          (s->sabit[k] && !esit(d, s, k)))
        ok = 0;          /* alan uymadı */
    if (ok) { cikar(d); return d; }
  }
  return NULL;           /* bloke ol */
}
şablon:"abc"2? int idemet uzayı:d1"abc"2d2"xyz"27d3"abc"14d4"abc"25d5"abc"29

Uzayda 5 demet var. Süreç in("abc", 2, ? int i) çağırıyor: 3 alanlı, ilk iki alan sabit, üçüncü tam sayı türünden biçimsel parametre.

şablon:"abc"2? int idemet uzayı:d1"abc"2d2"xyz"27d3"abc"14d4"abc"25d5"abc"29

d1: 2 alanlı, şablon 3 alanlı → hemen atlanır (continue).

şablon:"abc"2? int idemet uzayı:d1"abc"2d2"xyz"27d3"abc"14d4"abc"25d5"abc"29

d2, alan 0: "xyz" ≠ "abc" → ok = 0, sonraki demete geçilir.

şablon:"abc"2? int idemet uzayı:d1"abc"2d2"xyz"27d3"abc"14d4"abc"25d5"abc"29

d3, alan 1: 1 ≠ 2 → ok = 0, sonraki demete geçilir.

şablon:"abc"2? int idemet uzayı:d1"abc"2d2"xyz"27d3"abc"14d4"abc"25d5"abc"29

d4: alan sayısı ve türler uyuyor, sabitler eşit; biçimsel alan i = 5 alır. Demet uzaydan çıkarılır.

şablon:"abc"2? int idemet uzayı:d1"abc"2d2"xyz"27d3"abc"14d5"abc"29

d4 artık uzayda yok; d5 de eşleşirdi ama ilk bulunan alındı (Linda hangisinin seçileceğini tanımlamaz). Aynı çağrı yeniden yapılıyor.

şablon:"abc"2? int idemet uzayı:d1"abc"2d2"xyz"27d3"abc"14d5"abc"29

d1: 2 alanlı, şablon 3 alanlı → hemen atlanır (continue).

şablon:"abc"2? int idemet uzayı:d1"abc"2d2"xyz"27d3"abc"14d5"abc"29

d2, alan 0: "xyz" ≠ "abc" → ok = 0, sonraki demete geçilir.

şablon:"abc"2? int idemet uzayı:d1"abc"2d2"xyz"27d3"abc"14d5"abc"29

d3, alan 1: 1 ≠ 2 → ok = 0, sonraki demete geçilir.

şablon:"abc"2? int idemet uzayı:d1"abc"2d2"xyz"27d3"abc"14d5"abc"29

d5: alan sayısı ve türler uyuyor, sabitler eşit; biçimsel alan i = 9 alır. Demet uzaydan çıkarılır.

şablon:"abc"2? int idemet uzayı:d1"abc"2d2"xyz"27d3"abc"14

Üçüncü bir in("abc", 2, ? int i) eşleşme bulamaz ve NULL döner: süreç, biri uyan bir demeti out ile koyana kadar bloke olur.

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 hizmetine 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ımİSsanallaştırmasunucu, depolama, ağIaaSuygulamaveriçalışma zamanıara yazılımİSsanallaştırmasunucu, depolama, ağPaaSuygulamaveriçalışma zamanıara yazılımİSsanallaştırmasunucu, depolama, ağFaaSuygulamaveriçalışma zamanıara yazılımİSsanallaştırmasunucu, depolama, ağSaaSuygulamaveriçalışma zamanıara yazılımİSsanallaş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 işletim sisteminin 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.

İşletim sistemi ve kilitler

Ayrı işletim sistemi, usta-köle, SMP; TSL için veri yolu/satır kilidi, TTAS, bilet ve MCS; kısa beklemede dönme, uzunda uyuma.

Çizelgeleme

Ortak kuyrukta tek kilit ve soğuk önbellek; birbirine bağlı iş parçacıkları için 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 konur.
  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ı (2023), 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 · Terim sözlüğü
1 / 1