Bölüm 12: Çok İşlemcili Sistemler
Giriş
Öğrenme Çıktıları
UMA (veri yolu, çapraz çubuk, omega) ve NUMA mimarilerini karşılaştırmak; dizin tabanlı tutarlılığı izlemek.
MESI durum geçişlerini bir okuma/yazma dizisi üzerinde uygulamak; yanlış paylaşımı bulup gidermek.
Ayrı OS, usta-köle ve SMP modellerini; TSL, bilet ve MCS kilitlerini; dönme ile geçişi değerlendirmek.
Zaman paylaşımı, afinite, alan paylaşımı ve çete çizelgelemeyi örnek üzerinde uygulamak.
Topolojilerin çapını hesaplamak; mesaj iletimi, RPC, DSM ve yük dengeleme algoritmalarını açıklamak.
Hipervizör türlerini, VT-x/EPT ve konteynerleri; ara yazılım türlerini ve bulutu tanımak.
Giriş
Neden Çok İşlemci?
Tüm işlemciler belleğe ve G/Ç’ye eşit hakla erişir; çekirdek kodu her işlemcide çalışabilir.
İşlemciler eşit değildir: biri OS’i yürütür ya da her biri ayrı yazılım çalıştırır.
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ığı.
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
- 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
8 CPU (satır) ve 8 bellek modülü (sütun); her kesişimde küçük bir elektronik anahtar var. Hepsi açık.
CPU 2, M5’e erişmek ister: (2, 5) kesişim noktası kapanır, doğrudan yol kurulur.
CPU 0 → M1 ve CPU 6 → M3 aynı anda kurulur. Çapraz çubuk engellemesiz (non-blocking): farklı modüllere giden istekler birbirini beklemez.
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
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.
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).
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.
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.
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
- 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).
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
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.
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.
Düğüm 36 dizinine bakar: girdi 4 boş, satır hiçbir önbellekte değil. Güncel kopya kendi RAM’indedir.
Satır düğüm 20’ye gönderilir ve dizin girdisi 4’e 20 yazılır: “bu satırın kopyası 20’de”.
Şimdi düğüm 20, blok 2’yi ister (0x24000080). Dizin: satır düğüm 82’de önbelleklenmiş.
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
- 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ü
| Durum | Anlamı |
|---|---|
| M Modified | Tek kopya, kirli; bellek eski. Atılırken geri yazılır. |
| E Exclusive | Tek kopya, temiz. Yazma veri yoluna çıkmadan M olur. |
| S Shared | Birden çok temiz kopya olabilir. Yazmak için önce diğerleri geçersiz kılınır. |
| I Invalid | Kopya 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
Başlangıç: x yalnız bellekte (0). İki önbellekte de satır I.
Ç0 okur: BusRd, başka kopya yok → E (tek ve temiz).
Ç1 okur: Ç0 isteği dinler, “bende var” der → ikisi de S. Bellek hâlâ güncel.
Ç1 yazar: S durumunda yazmak için BusUpgr (geçersiz kıl) yayınlanır → Ç0 I, Ç1 M; bellek artık eski.
Ç0 okur: kaçırma. Ç1 kirli satırı Flush eder (veri Ç0’a ve belleğe), ikisi de S, bellek = 1.
Ç0 yazar: yine geçersiz kılma → Ç0 M, Ç1 I.
Ç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.
a ve b bağımsız sayaçlar ama aynı satırda.
Ç0 a++: satırı M olarak alır, Ç1’in kopyası geçersiz.
Ç1 b++: satır Ç1’e taşınır (M), Ç0’daki geçersiz olur.
Her artırmada satır yeniden taşınır: “ping-pong”; iki iş parçacığı tek iş parçacığından yavaş çalışabilir.
Çö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
L1/L2 özel, L3 paylaşımlı. Sunucu soketi: 192 çekirdek (AMD EPYC 9005), 288 E-çekirdek (Xeon 6900E).
Çekirdek grupları ayrı kalıplarda; tek sokette bile L3 ve bellek uzaklığı farklıdır.
big.LITTLE, Apple ve Intel P/E: OS işi enerjiye göre yerleştirir (Linux EAS, Thread Director).
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)
- 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
- 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
- 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
- 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)
- 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ı OS | Usta-köle | SMP | |
|---|---|---|---|
| OS kopyası | CPU başına bir | bir (ustada) | bir (herkes çalıştırır) |
| Sistem çağrısı nerede? | yerel CPU | usta CPU | yerel CPU |
| Hazır listesi | CPU başına | tek, ustada | tek ya da CPU başına + dengeleme |
| Yük dengeleme | yok | iyi | iyi |
| Ölçeklenebilirlik | iyi ama paylaşım yok | usta darboğaz | kilit tasarımına bağlı, en iyi |
| Karmaşıklık | en düşük | düşük | en yüksek |
| Günümüz | sanal makineler, bölümleme | gömülü AMP, eski sistemler | Linux, Windows, macOS, BSD |
Senkronizasyon
TSL ve Veri Yolu Kilidi
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 1 kilidi okur: 0 (serbest).
CPU 1 yazmadan önce CPU 2 de okur: yine 0.
CPU 1 1 yazar, CPU 2 de 1 yazar.
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.
Çö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); } }
İki sayaç: next bilet dağıtır, serving sırası geleni gösterir.
T0 bilet alır: getAndIncrement atomiktir (x86 LOCK XADD) → my = 0.
T1 de bilet alır: my = 1. İki CPU aynı anda çağırsa da biletler farklıdır.
T0: serving == 0 → döngüden çıkar, sayac++ yapar.
T1 döner: serving’i kendi önbelleğindeki S kopyadan okur, veri yolunu meşgul etmez; onSpinWait = x86 PAUSE.
T0 bırakır: serving++. Yazma T1’in kopyasını geçersiz kılar (tek tutarlılık mesajı).
T1 yeni değeri okur: 1 == my → girer. Kilit adildir: kimse aç kalmaz.
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) 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
qspinlockbu 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ı?
- 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), WindowsCRITICAL_SECTIONdö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
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ı.
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.
CPU 7 de aynı yolla B’yi alır.
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
- 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.
Çizelgeleme
Alan Paylaşımı (Space Sharing)
- 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
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.
Ç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.
Dilim 1: B (3) ve C (3) birlikte; tüm CPU’lar dilimlere eşzamanlı başlar ve biter (zaman dilimi senkronize).
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.
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
- Ç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
| n = 1.024 düğüm | halka | ızgara 32×32 | simit 32×32 | hiperküp (10B) |
|---|---|---|---|---|
| çap (en uzak iki düğüm) | 512 | 62 | 32 | 10 |
| bağlantı sayısı | 1.024 | 1.984 | 2.048 | 5.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
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.
Kaynak ⊕ hedef = 1011: üç bit farklı. Soldan ilk farklı bit düzeltilir → 1000 (alt küpten üst küpe geçiş).
Sonraki farklı bit: 1010.
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ç
Örnek: 4 KiB paket, 10 Gb/s bağlantılar; bir bağlantıdan geçmesi 4096 × 8 / 10⁹ ≈ 3,28 µs.
Sakla ve ilet (store-and-forward): anahtar 1 paketin tamamını tampona alır, denetler, sonra iletir.
Üç bağlantı → 3 × 3,28 = 9,83 µs. Gecikme atlama sayısıyla doğrusal büyür.
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
(a) Bloke eden (blocking, senkron) send: çağrı mesaj iletilene kadar dönmez.
(b) Bloke etmeyen (asenkron) send: hemen döner; ama tampon iletim bitene kadar kullanılamaz.
| Seçenek | Bedel |
|---|---|
| Bloke eden gönderim | CPU iletim boyunca boşta |
| Bloke etmeyen + çekirdeğe kopyala | fazladan kopya için CPU zamanı |
| Bloke etmeyen + bitince kesme | programlaması 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)
İstemci sonuc = topla(3, 4) der; sıradan yerel çağrı gibi görünür.
1: İstemci, istemci koçanını (stub) yerel bir prosedür gibi çağırır.
2: Koçan parametreleri mesaja paketler (marshalling) ve çekirdeğe sistem çağrısı yapar.
3: Çekirdek mesajı ağ üzerinden sunucu makinesine gönderir.
4: Sunucu çekirdeği mesajı sunucu koçanına verir.
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)
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.
Sayfalar makinelere dağıtılmıştır. CPU 0 sayfa 10’a erişince MMU sayfa hatası üretir.
OS sayfanın kimde olduğunu bulur, ister; sayfa CPU 0’a taşınır ve komut yeniden yürütülü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
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.
Alfabetik atama: kesilen (makineler arası) kenarların toplamı 24.
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
Gönderici başlatmalı: yeni iş gelince yükü eşiği aşan düğüm rastgele düğümleri yoklar (Eager ve diğ., 1986).
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.
İş taşındı. Sakınca: sistem tümüyle yüklüyken yoklamaların hepsi boşa gider ve yükü artırır.
Alıcı başlatmalı: bir işi biten ve boş kalan düğüm kendisi iş arar; yoklama maliyeti boştaki düğüme yüklenir.
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
- 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.
POPFkullanı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
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).
Misafir çekirdek hassas bir komut yürütür: sayfa tablosunu değiştirmek (CR3), G/Ç portu, HLT…
Donanım komutu çalıştırmaz: VM çıkışı (VM exit) ile hipervizöre tuzak kurar; neden VMCS’ye yazılır.
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)
- 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:
virtiodisk/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
- 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
| Sanal makine | Konteyner | |
|---|---|---|
| Yalıtım sınırı | donanım düzeyi, ayrı çekirdek | aynı çekirdek: namespace, cgroup, seccomp |
| Başlama / ek yük | saniyeler, GB bellek | milisaniyeler, MB bellek |
| Farklı OS | evet (Linux üstünde Windows) | hayır (aynı çekirdek ailesi) |
| Örnek | KVM, Hyper-V, ESXi | Docker, 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
- 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 bilgisayar | Dağıtık sistem |
|---|---|---|---|
| Düğüm yapısı | CPU | CPU, RAM, ağ arayüzü | tam bilgisayar |
| Çevre birimleri | hepsi paylaşılır | paylaşılır (belki disk hariç) | her düğümde tam set |
| Konum | aynı raf | aynı oda | dünya çapında olabilir |
| Düğümler arası iletişim | paylaşılan RAM | özel ara bağlantı | geleneksel ağ |
| İşletim sistemi | bir, paylaşılan | çok, aynı | çok, farklı olabilir |
| Dosya sistemi | bir, paylaşılan | bir, paylaşılan | her düğümün kendi |
| Yönetim | tek kurum | tek kurum | birç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
- 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
| Protokol | Katman | Servis | Not |
|---|---|---|---|
| IP (v4/v6) | ağ | bağlantısız, güvenilmez | adresleme ve yönlendirme |
| TCP | taşıma | bağlantı yönelimli, güvenilir bayt akışı | onay, yeniden iletim, akış ve tıkanıklık denetimi |
| UDP | taşıma | bağlantısız, güvenilmez datagram | sağlama toplamı var; yeniden iletim yok. DNS, oyun, ses |
| QUIC | taşıma (UDP üstü) | bağlantı yönelimli, güvenilir, şifreli | HTTP/3 (2022) bunu kullanır |
| DNS | uygulama | ad → IP adresi | hiyerarşik, dağıtık, önbellekli |
| HTTP/HTTPS | uygulama | Web belgeleri | HTTPS = HTTP + TLS, port 443 |
| SMTP | uygulama | e-posta aktarımı | sunucular arası; okuma IMAP ile |
| FTP → SFTP | uygulama | dosya aktarımı | FTP şifresizdir; yerini SFTP/HTTPS aldı |
| SNMP | uygulama | ağ cihazı izleme | v3 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
Kullanıcı www.ornek.org/index.html adresini yazar. Web: birbirine bağlı belgelerden oluşan dev bir yönlendirilmiş çizge.
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).
3: Sunucunun 443 numaralı portuna TCP bağlantısı ve TLS el sıkışması (HTTP/3’te ikisi tek adımda, QUIC ile).
4–5: GET /index.html isteği; sunucu HTML’yi döndürür, tarayıcı metni görüntülemeye baş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
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ı.
Uzaktan erişim modeli: dosya sunucuda kalır; istemci read/write isteklerini ağ üzerinden gönderir (NFS, SMB).
İki dosya sunucusu, her biri kendi dizin ağacıyla.
Tüm istemciler sunucuları aynı yere bağlar (mount) → tek, ortak ad alanı.
İ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 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).
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şım | Kural | Örnek |
|---|---|---|
| UNIX semantiği | her yazma hemen herkese görünür | tek makine; önbelleksiz uzak erişim |
| Oturum semantiği | değişiklik dosya kapanınca görünür | AFS; NFS kapat-aç tutarlılığı |
| Değişmez dosyalar | dosya yazılamaz, yenisi oluşturulur | nesne depolama, Git nesneleri |
| İşlemler (transactions) | hep ya da hiç, sıralanabilir | veritabanları |
Çözümler tutarlılık ile performans arasında takas yapar.
Dağıtık Sistemler
Nesne Tabanlı Ara Yazılım: CORBA
- 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
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.
out demeti uzaya koyar (bloke etmez).
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.
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
- 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
- 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
UMA (veri yolu, çapraz çubuk n², omega (n/2)log₂n) ve NUMA; tutarlılık için dinleme ya da dizin.
MESI geçişleri; yazmalar geçersiz kılma üretir; yanlış paylaşım satır düzeyinde olur, dolgu ile çözülür.
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.
Ortak kuyruk → CPU başına kuyruk + afinite + dengeleme; alan paylaşımı ve çete çizelgeleme.
Topoloji çapı, sakla-ilet ve kesip geç, bloke eden/etmeyen gönderim, RPC, DSM, yük dengeleme.
Tip 1/2, VT-x, EPT, konteyner; ara yazılım: belge, dosya, nesne, koordinasyon; bulut.
Özet
Kontrol Soruları
- 64 × 64 çapraz çubukta kaç kesişim, 64 girişli omega ağında kaç 2 × 2 anahtar var?
- Omega ağında CPU 011 → bellek 110 isteği hangi anahtar ve çıkışlardan geçer?
- Yerel 80 ns, uzak 140 ns, erişimlerin %75’i yerel: ortalama erişim süresi?
- MESI’de E ve S durumundaki bir satıra yazmanın veri yolu açısından farkı nedir?
- İki iş parçacığının ayrı sayaçları neden birbirini yavaşlatabilir? Çözüm?
- Bilet kilidi saf TSL döngüsünden hangi iki açıdan üstündür?
- Çete çizelgelemenin iki koşulu nedir, hangi sorunu çözer?
- 256 düğümlü hiperküpün çapı nedir? 16 × 16 simidin çapı nedir?
- 4 düzeyli tablolar ve EPT ile TLB kaçırması en kötü kaç bellek erişimi ister?
in("abc", ? x, 5)(x int),("abc", 2, 5)ve("abc", 2.0, 5)demetlerinden hangisiyle eşleşir?
Cevaplar
- 64² = 4.096 kesişim; log₂64 = 6 aşama × 32 = 192 anahtar.
- 1D (bit 1 → alt), 2D (bit 1 → alt), 3D (bit 0 → üst).
- 0,75 · 80 + 0,25 · 140 = 95 ns.
- E → M sessizdir (veri yolu yok); S → M için geçersiz kılma (BusUpgr) yayınlanmalıdır.
- Aynı 64 B satırdalar: her yazma satırı diğer çekirdekten koparır (yanlış paylaşım). Hizalama/dolgu ile ayrı satırlara koy.
- Adil (FIFO, açlık yok) ve beklerken yazma yapmaz, yalnız okur → daha az tutarlılık trafiği.
- Üyeler aynı anda, farklı CPU’larda; dilimler eşzamanlı başlar. Konuşan iş parçacıkları birbirini dilim boyu beklemez.
- log₂256 = 8; 2 · ⌊16/2⌋ = 16.
- (4 + 1)² − 1 = 24.
- 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).