Hipervizör Türleri

Önceki ders sorun gidermeyi hipotez başına elenen olasılık sayısına bağladı ve konuyu bir boşlukla kapattı: ölçülen bütün sınırlar tek bir makinenin sınırlarıydı. O makinenin donanımı kendisine aitti, çekirdeği doğrudan o donanımla konuşuyordu, kullanıcı ile çekirdek arasındaki sınır tek sınırdı. Bölgesel ölçüm ağının şube sunucularında bu artık doğru değil: bir şube sunucusunda dört ayrı konuk sistem koşuyor, dördü de aynı işlemciyi, aynı belleği ve aynı diski kullanıyor. İşletim sisteminin çizdiği sınırın altında ikinci bir sınır var ve onu çizen katmanın adı hipervizördür.

Bu ders hipervizörü bir sıfatla değil, iki sayıyla ayırır. Birinci sayı konuk ile donanım arasında kaç katman durduğudur. İkinci sayı her katmanın güvenilir tabana kaç kalem eklediğidir — yani konuk sınırının ayakta kalması için doğru davranması gereken kalem sayısı. Bu iki sayı bir tasarımı öbürüne göre değil, kendi kalem kümesine göre konumlandırır.

SA1 — Ölçüm nesnesi kurgu bölgesel ölçüm ağının bir şube sunucusudur; üzerinde dört konuk sistem koşar. Kalem sayıları modeldir, koşum ve aritmetik gerçektir. SA2 — Hipervizör yalnız iki tür adıyla anılır: çıplak donanım hipervizörü ve barındırılan hipervizör. SA3 — Güvenilir taban, konuk sınırının ayakta kalması için doğru davranması gereken kalemlerin kümesidir. SA4 — Bir katmanın düşmesi, o katmandaki kalemlerden yalnız birinin yanlış davranmasıdır. SA5 — Sınırı geçmek için gereken kalem sayısı, aynı anda yanlış olması gereken katman sayısıdır; her katmanda bir kalem yeter. SA6 — Aday kalem, o katmanlarda yanlış olabilecek kalemlerin toplamıdır.

Katmanlar ve Güvenilir Taban

Çıplak donanım hipervizörü donanımın üstüne doğrudan kurulur; altında genel amaçlı bir işletim sistemi yoktur. Barındırılan hipervizör bir işletim sisteminin üzerinde bir süreç olarak koşar ve konuk sistemler o sürecin içinde çalışır. Fark bir kurulum ayrıntısı değil, konuğun altındaki katman listesinin uzunluğudur.

// katman.mjs — konuk ile donanim arasindaki katmanlar ve guvenilir taban (MODEL).
// Kurgu sube sunucusu: uzerinde dort konuk sistem kosuyor. Urun adi degil, tur adi kullanilir.

// Sistemdeki kalem kumeleri: kisa anahtar -> [ad, kalem sayisi]
export const KUME = {
  kd: ['konuk disk imaji', 4], kb: ['konuk bellek icerigi', 4], ka: ['konuk ag arayuzu', 4],
  hy: ['hipervizor ayar kalemi', 3], ku: ['konak kullanici alani dosyasi', 7],
  ba: ['bellenim ayari', 4],
};
// [katman, guvenilir taban kalemi, konuk-donanim yolunda mi, dustugunde erisilen kumeler]
export const TASARIM = {
  'ciplak donanim hipervizoru': [
    ['yonetim arayuzu', 3, false, ['kd', 'ka', 'hy']],
    ['hipervizor cekirdegi', 6, true, ['kd', 'kb', 'ka', 'hy']],
    ['bellenim ve acilis zinciri', 4, true, ['kd', 'kb', 'ka', 'hy', 'ba']],
  ],
  'barindirilan hipervizor': [
    ['konak kullanici alani', 7, false, ['kd', 'ka', 'hy', 'ku']],
    ['hipervizor sureci', 5, true, ['kd', 'kb', 'ka', 'hy', 'ku']],
    ['konak cekirdegi', 9, true, ['kd', 'kb', 'ka', 'hy', 'ku', 'ba']],
    ['bellenim ve acilis zinciri', 4, true, ['kd', 'kb', 'ka', 'hy', 'ku', 'ba']],
  ],
};
export const say = (anahtarlar) => anahtarlar.reduce((t, a) => t + KUME[a][1], 0);
// Tasarimin kapsadigi kalem evreni: katmanlarin erisebildigi butun kumeler
export const evren = (ad) => say([...new Set(TASARIM[ad].flatMap(([, , , e]) => e))]);

if (import.meta.url === `file://${process.argv[1]}`) {
  const s = (x, n) => String(x).padStart(n);
  for (const [ad, katmanlar] of Object.entries(TASARIM)) {
    const taban = katmanlar.reduce((t, [, k]) => t + k, 0);
    const yolda = katmanlar.filter(([, , y]) => y).length;
    const tum = evren(ad);
    console.log(`\n${ad}: guvenilir taban ${taban} kalem, yolda ${yolda} katman, evren ${tum} kalem`);
    console.log(`${'katman'.padEnd(28)}${s('kalem', 6)}${s('yolda', 7)}${s('duserse erisilen', 18)}`);
    for (const [k, n, y, e] of katmanlar)
      console.log(`${k.padEnd(28)}${s(n, 6)}${s(y ? 'evet' : 'hayir', 7)}${s(`${say(e)}/${tum}`, 18)}`);
  }
}

ciplak donanim hipervizoru: guvenilir taban 13 kalem, yolda 2 katman, evren 19 kalem
katman                       kalem  yolda  duserse erisilen
yonetim arayuzu                  3  hayir             11/19
hipervizor cekirdegi             6   evet             15/19
bellenim ve acilis zinciri       4   evet             19/19

barindirilan hipervizor: guvenilir taban 25 kalem, yolda 3 katman, evren 26 kalem
katman                       kalem  yolda  duserse erisilen
konak kullanici alani            7  hayir             18/26
hipervizor sureci                5   evet             22/26
konak cekirdegi                  9   evet             26/26
bellenim ve acilis zinciri       4   evet             26/26

İki tasarımın katman sayısı beklendiği yönde ayrılıyor: çıplak tasarımda konuk ile donanım arasında iki katman var, barındırılan tasarımda üç. Bu sayıya bakıp barındırılan tasarımın daha derin korunduğu söylenebilir; ikinci sütun bunu bozuyor. Aynı üç katmanı taşımanın bedeli güvenilir tabanın on üç kalemden yirmi beş kaleme çıkmasıdır. Eklenen kalemlerin çoğu konuk için değil, konağın kendi işi için oradadır: yedi kalemlik konak kullanıcı alanı, oturum yöneticisinden paket yöneticisine kadar konuğun hiç ihtiyaç duymadığı bileşenlerdir. Konuk sınırı yine de onlara bağlıdır, çünkü hipervizör süreci o kullanıcının dosyalarıyla aynı yerde durur.

Üçüncü sütun asıl bulguyu veriyor. Çıplak tasarımda düşebilecek en zararsız katman yönetim arayüzüdür: düştüğünde on dokuz kalemin on biri erişilir hâle gelir; konuk bellek içeriği dışarıda kalır, çünkü yönetim arayüzü konuğu oluşturur ve siler ama çalışan konuğun belleğini okumaz. Barındırılan tasarımda en zararsız düşüş konak kullanıcı alanıdır ve orada yirmi altı kalemin on sekizi erişilir. Oran olarak yüzde elli sekize karşı yüzde altmış dokuz. Katman eklemek yolu uzattı, ama ilk düşüşün açtığı yüzeyi daraltmadı.

En keskin satır barındırılan tasarımın ikinci satırıdır. Hipervizör süreci düştüğünde erişilen kalem sayısı yirmi ikidir ve bu, konak çekirdeği düştüğünde erişilen sayıdan yalnız dört eksiktir. Sebebi yapısaldır: konuk disk imajları konağın dosya sisteminde, hipervizör sürecini çalıştıran kimliğin dosyaları olarak durur. Sürece erişen, dört konuğun diskine dosya olarak erişir. Konuğun altındaki üçüncü katman donanımı korur, konuğun diskini korumaz.

Sınırı Geçmek İçin Gereken Kalem

Katman sayısı tek başına yalıtım gücü değildir. Ölçü, belirli bir hedefe ulaşmak için aynı anda kaç kalemin yanlış olması gerektiğidir. Aşağıdaki koşum aynı dört hedefi iki tasarımda ayrı ayrı ölçüyor ve her hedef için iki sayı yazıyor: gereken kalem ve o kalemin seçilebileceği aday sayısı.

// sinir.mjs — ayni hedef kumesi iki tasarimda: siniri gecmek icin gereken kalem ve aday kalem.
// "Gereken" = ayni anda yanlis olmasi gereken katman sayisi. "Aday" = o katmanlarin kalem toplami.
import { TASARIM, say, evren } from './katman.mjs';

const HEDEF = [                      // [hedef, erisilmesi gereken kalem kumeleri]
  ['komsu konugun diski', ['kd']], ['komsu konugun bellegi', ['kb']],
  ['bellenim ayarini degistirme', ['ba']], ['donanima dogrudan erisim', null],
];
const olc = (ad, gerek) => {
  const katman = TASARIM[ad];
  if (gerek === null) {              // donanim: yoldaki her katmanda bir kalem yanlis olmali
    const yol = katman.filter(([, , y]) => y);
    return [yol.length, yol.reduce((t, [, n]) => t + n, 0)];
  }
  const yeten = katman.filter(([, , , e]) => gerek.every((g) => e.includes(g)));
  return [1, yeten.reduce((t, [, n]) => t + n, 0)];
};

const ADLAR = Object.keys(TASARIM);
const s = (x, n) => String(x).padStart(n);
console.log(`${''.padEnd(29)}${'ciplak donanim'.padStart(16)}${'barindirilan'.padStart(18)}`);
console.log(`${'hedef'.padEnd(29)}${s('gereken', 8)}${s('aday', 8)}${s('gereken', 10)}${s('aday', 8)}`);
for (const [h, g] of HEDEF) {
  const [a1, b1] = olc(ADLAR[0], g), [a2, b2] = olc(ADLAR[1], g);
  console.log(`${h.padEnd(29)}${s(a1, 8)}${s(b1, 8)}${s(a2, 10)}${s(b2, 8)}`);
}
const bir = HEDEF.filter(([, g]) => g !== null).length;
console.log(`\n${bir} hedefte gereken kalem iki tasarimda da 1; fark aday sayisindadir`);
for (const ad of ADLAR) {
  const k = TASARIM[ad];
  const enaz = Math.min(...k.map(([, , , e]) => say(e)));
  console.log(`${ad.padEnd(27)} taban ${s(k.reduce((t, [, n]) => t + n, 0), 2)} kalem,`
    + ` tek katman dustugunde en az ${enaz}/${evren(ad)} kaleme erisiliyor`);
}

                               ciplak donanim      barindirilan
hedef                         gereken    aday   gereken    aday
komsu konugun diski                 1      13         1      25
komsu konugun bellegi               1      10         1      18
bellenim ayarini degistirme         1       4         1      13
donanima dogrudan erisim            2      10         3      18

3 hedefte gereken kalem iki tasarimda da 1; fark aday sayisindadir
ciplak donanim hipervizoru  taban 13 kalem, tek katman dustugunde en az 11/19 kaleme erisiliyor
barindirilan hipervizor     taban 25 kalem, tek katman dustugunde en az 18/26 kaleme erisiliyor

Dört hedefin üçünde gereken kalem sayısı iki tasarımda da birdir. Komşu konuğun diskine ulaşmak için tek bir katmanın tek bir kalemi yeter; komşunun belleği için de öyle. Katman sayısındaki fark bu üç satırın hiçbirinde görünmüyor, çünkü katmanlar konuk ile donanım arasında art arda durur, konuk ile komşu konuk arasında değil. Yan yana duran iki konuğu ayıran şey aynı hipervizördür ve o hipervizör tek bir kalem kümesidir.

Fark aday sütununda. Komşunun diski için çıplak tasarımda on üç, barındırılan tasarımda yirmi beş aday kalem var — yaklaşık iki kat. Bellenim ayarı satırı oranı daha da açıyor: çıplak tasarımda bellenim ayarına yalnız açılış zincirinin dört kalemi üzerinden ulaşılabilirken, barındırılan tasarımda konak çekirdeği de bellenimi yazabildiği için aday sayısı dörtten on üçe çıkıyor. Yalıtım gücü gereken kalem sayısıdır; o sayı ikisinde de bir olduğuna göre, iki tasarımı ayıran şey sınırın gücü değil, o tek kalemin kaç aday arasından çıkabileceğidir.

Yalnız son satırda gereken sayı birden büyük: donanıma doğrudan erişmek çıplak tasarımda iki, barındırılan tasarımda üç kalemin aynı anda yanlış olmasını ister. Barındırılan tasarımın kazandığı tek yer burasıdır ve kazandığı şey donanımdır — konuk verisi değil.

Zincirin Kökü

İki tasarımın ortak katmanı bellenim ve açılış zinciridir ve iki tabloda da düştüğünde her şeye erişilen katman odur: çıplak tasarımda 19/19, barındırılan tasarımda 26/26. O dört kalemi ayrı ayrı saymak yetmez, çünkü aralarında bir sıra vardır: her halka bir sonrakini yükler. İmzalı açılış bu sıraya bir doğrulama koyar — her halka bir öncekince imzalanmış olduğu için doğrulanır ve zincirin kökü donanımdaki güvenilir platform birimidir.

// acilis.mjs — imzali acilisin acilis zincirindeki gereken ve aday kalemi nasil degistirdigi (MODEL).
// Zincirin koku donanimdaki guvenilir platform birimidir; her halka bir oncekince dogrulanir.
const ZINCIR = ['acilis bellenimi', 'acilis yukleyicisi', 'cekirdek imaji', 'hipervizor modulu'];

// imzasiz: dogrulanmayan ilk halkanin sirasi (null ise butun zincir dogrulanir)
const olc = (imzali, imzasiz = null) => {
  if (!imzali) return [1, ZINCIR.length, 0];        // her halka tek basina degistirilebilir
  const kes = imzasiz === null ? ZINCIR.length : ZINCIR.indexOf(imzasiz);
  // kesilen halkadan sonrasi dogrulanmiyor: tek kalem yeter, aday o kalan halkalardir
  if (kes < ZINCIR.length) return [1, ZINCIR.length - kes, ZINCIR.length - 1];
  return [ZINCIR.length, 1, ZINCIR.length];         // kok anahtar tek aday, halkalar yeniden imzalanir
};

const s = (x, n) => String(x).padStart(n);
console.log(`acilis zinciri ${ZINCIR.length} halka: ${ZINCIR.join(' -> ')}`);
console.log(`${'duzen'.padEnd(34)}${s('gereken', 8)}${s('aday', 6)}${s('yeniden imzalanan', 19)}`);
for (const [ad, imzali, imzasiz] of [['imzasiz acilis', false, null], ['imzali acilis', true, null],
  ['imzali acilis, son halka imzasiz', true, 'hipervizor modulu'],
  ['imzali acilis, cekirdek imzasiz', true, 'cekirdek imaji']]) {
  const [g, a, y] = olc(imzali, imzasiz);
  console.log(`${ad.padEnd(34)}${s(g, 8)}${s(a, 6)}${s(y, 19)}`);
}

acilis zinciri 4 halka: acilis bellenimi -> acilis yukleyicisi -> cekirdek imaji -> hipervizor modulu
duzen                              gereken  aday  yeniden imzalanan
imzasiz acilis                           1     4                  0
imzali acilis                            4     1                  4
imzali acilis, son halka imzasiz         1     1                  3
imzali acilis, cekirdek imzasiz          1     2                  3

İmzasız düzende dört halkanın herhangi biri tek başına değiştirilebilir: gereken kalem bir, aday dört. İmzalı düzende son halkayı değiştirmek için ondan köke kadar bütün zinciri değiştirmek gerekir; gereken kalem dörde çıkar, aday ise donanımdaki tek kök anahtara iner. Bu, dersteki tek sayısal iyileşmedir — hem gereken sayı büyür hem aday sayısı küçülür.

Son iki satır bedeli ve kırılganlığı birlikte gösteriyor. İmzalı zincirin her güncellemesi üç ya da dört halkanın yeniden imzalanmasını ister; bu, yama sürecine eklenen sabit bir iştir. Kırılganlık daha keskin: zincirde tek bir imzasız halka varsa gereken kalem dörtten bire düşer. Son halka imzasız bırakıldığında gereken kalem bir, aday da birdir — yani doğrulanmamış tek bir hipervizör modülü, dört halkalık zincirin bütün kazancını siler. Çekirdek imzasız bırakıldığında aday ikiye çıkar. Zincir en zayıf halkasının değil, doğrulanmayan ilk halkasının gücündedir.

Bedelin Yazıldığı Yer

Çıplak tasarımın on üç kalemlik tabanı bedavaya gelmiyor. O tasarımda makine yalnız konuk sistem çalıştırır: konak üzerinde tarayıcı, yerel araç, dosya paylaşımı ya da saha ekibinin günlük işi yoktur. Barındırılan tasarımdaki yedi kalemlik konak kullanıcı alanı bir israf değil, o makinenin meşru işidir. Saha ekiplerinin dizüstü bilgisayarlarında bu iş vazgeçilebilir değildir; şube sunucusunda vazgeçilebilir olduğu için çıplak tasarım anlamlıdır.

Bedelin ikinci kalemi yönetimdir. Çıplak tasarımda yönetim arayüzü ayrı bir katman olarak sayıldı ve düştüğünde on bir kaleme erişildi. Barındırılan tasarımda ayrı bir yönetim katmanı yok, çünkü yönetim konağın kendi oturumundan yapılır; o oturum zaten yirmi altı kalemin on sekizine erişiyor. Yönetimi ayrı bir katmana çıkarmak bir kalem eklemek pahasına erişilen kalemi daraltır — bu kursta ölçülen ilk takas budur ve üç kalem karşılığında yedi kalemlik bir daralma verir.

Bu ölçümlerin hiçbiri iki tür arasında bir sıralama vermez. Şube sunucusunda konağın kendi işi yoksa çıplak tasarım on iki kalemlik daha küçük bir taban ve bir katman daha kısa bir yol karşılığında yönetimi ayrı bir arayüze taşımayı ister. Saha dizüstü bilgisayarında o iş vazgeçilemez olduğu için barındırılan tasarımın yirmi beş kalemlik tabanı bir seçim değil, o makinenin tanımıdır. Ölçünün söylediği tek şey, seçilen tasarımın hangi sayıyla gelmiş olduğudur.

Özet

• Çıplak donanım hipervizöründe konuk ile donanım arasında iki katman, barındırılan hipervizörde üç katman vardır; güvenilir taban sırasıyla 13 ve 25 kalemdir.
• Tek bir katman düştüğünde erişilen en küçük kalem oranı çıplak tasarımda 11/19, barındırılan tasarımda 18/26’dır: katman eklemek ilk düşüşün açtığı yüzeyi daraltmamıştır.
• Barındırılan tasarımda hipervizör süreci düştüğünde 22/26 kaleme erişilir, çünkü dört konuğun disk imajı konağın dosya sisteminde o sürecin kimliğine ait dosyalardır.
• Dört hedefin üçünde sınırı geçmek için gereken kalem sayısı iki tasarımda da birdir; fark aday sayısındadır (13’e karşı 25, 10’a karşı 18, 4’e karşı 13).
• Yalnız donanıma doğrudan erişimde sayı ikiye ve üçe çıkar; barındırılan tasarımın fazladan katmanı donanımı korur, konuk diskini korumaz.
• Dört halkalık açılış zincirinde imzalı açılış gereken kalemi 1’den 4’e çıkarır ve aday kalemi 4’ten 1’e indirir; doğrulanmayan tek bir halka gereken kalemi yeniden 1’e düşürür.

Sonraki Adım

Bu dersin bütün ölçümü katmanları üst üste saydı: konuk, hipervizör, konak, donanım. Ama konuk ile konak arasında yalnız bir yığın yok; ikisi çalışırken bir dizi kalemi aynı anda kullanıyor. Aynı zamanlayıcı ikisinin iş parçacıklarını sıraya diziyor, aynı fiziksel bellek sayfaları paylaştırılıyor, konuğun gördüğü disk ve ağ kartı konakta koşan bir öykünme kodudur, üstüne bir de paylaşılan dizin ve pano gibi rahatlık için açılmış kalemler var. Sonraki ders kaçış riskini bu paylaşılan kalemler üzerinden sayar: konuk ile konak kaç kalemi paylaşıyor, paylaşılan her kalem kaç yol açıyor ve o kalemler kapatıldığında geriye kaç yol kalıyor.