Düğüm Bileşenleri

Bir önceki dersin son senaryosu tek bir varsayımın kırıldığı yerdi: bildirim kaydedilemeyince defter ölmüş bir kopyayı hâlâ çalışıyor saydı. O varsayım — düğümlerin ne çalıştırdıklarını doğru ve zamanında bildirmesi — denetim düzleminin bütün kararlarının altındadır. Bu ders düğüm tarafını parçalarına ayırır ve bildirimin kendisini ölçer.

Üç parça vardır. Aracı süreç düğümün deftere bakan yüzüdür: kendine atanmış kopyaları okur, çalıştırılmasını ister ve sonucu geri bildirir. Çalışma zamanı çıktıyı gerçekten çalıştıran parçadır; yalıtımı ve kaynak sınırları bir önceki kursta ölçülmüştü, burada yalnız aracı sürece durum döndüren taraf olarak durur. Ağ vekili bir servis adını o an çalışan kopyalara çeviren kural kümesini düğümde tutar.

Ölçüm yine bölgesel ölçüm ağı üzerindedir ve kurgudur; koşan şey gerçek bir küme değil, node ile kurulmuş bir modeldir.

KM13. Düğüm tarafı üç parçadır: aracı süreç, çalışma zamanı, ağ vekili. KM14. Aracı süreç her 10 saniyede bir bildirir; bildirim düğüm başına 3 sabit kalem (sağlık, toplam ve kullanılan kapasite) ve kopya başına 2 kalem (durum, kaynak kullanımı) taşır. KM15. Bir periyotta gerçekten değişen kalem oranı 0,02’dir. KM16. Canlılık eşiği E’dir: son bildirimden E saniye geçen düğüm bilinmiyor sayılır ve üzerindeki kopyalar ölü ilan edilip yeniden yaratılır. KM17. Bir günde 4 kalıcı düğüm arızası ve 30 geçici bildirim kesintisi (5–90 saniye) olur; üreteci kendimiz yazdık, tohum 20260403 çıktıda görünür. KM18. Ağ vekili defteri her 5 saniyede okur; düğüm başına kural sayısı servis girişi ile kopya yönlendirme kurallarının toplamıdır, kopya başına istek hızı saniyede 80’dir.

Aracı Sürecin Bildirdiği

// dugum.mjs — dugum tarafinin bildirdigi bilgi ve bildirimin kume olcegindeki yuku. Model.
export const P = 10;                     // bildirim periyodu (saniye)
const SABIT = 3;                         // saglik, toplam kapasite, kullanilan kapasite
export const kalem = (kopya) => SABIT + 2 * kopya;   // kopya basina: durum + kaynak kullanimi
export const DEGISIM = 0.02;             // bir periyotta gercekten degisen kalem orani

if (import.meta.url === `file://${process.argv[1]}`) {
  console.log("dugum  kopya  bildirim/dugum  kalem/sn  gunluk kalem  yazma/sn  yalniz-degisen/sn");
  for (const M of [1, 3, 10, 30, 100, 300]) {
    const kopya = 8, k = kalem(kopya), kalemSn = (M * k) / P;
    console.log(`${String(M).padStart(5)}${String(kopya).padStart(7)}${String(k).padStart(16)}` +
      `${kalemSn.toFixed(1).padStart(10)}${(kalemSn * 86400).toFixed(0).padStart(14)}` +
      `${(M / P).toFixed(1).padStart(10)}${(kalemSn * DEGISIM).toFixed(2).padStart(19)}`);
  }
}

dugum  kopya  bildirim/dugum  kalem/sn  gunluk kalem  yazma/sn  yalniz-degisen/sn
    1      8              19       1.9        164160       0.1               0.04
    3      8              19       5.7        492480       0.3               0.11
   10      8              19      19.0       1641600       1.0               0.38
   30      8              19      57.0       4924800       3.0               1.14
  100      8              19     190.0      16416000      10.0               3.80
  300      8              19     570.0      49248000      30.0              11.40

Bildirimin içeriği azdır: sekiz kopyalı bir düğüm her periyotta 19 kalem gönderir. Yükü yapan şey içerik değil sıklıktır. Üç yüz düğümlü bir kümede saniyede 570 kalem, günde 49 milyon kalem bildirilir; bunun için düğümler saniyede 30 yazma üretir.

Son sütun asıl sayıyı veriyor. Bildirilen 570 kalemin gerçekten değişmiş olanı 11,4’tür — yüzde iki. Kalan yüzde doksan sekiz, hiçbir şeyin değişmediğini söylemenin bedelidir. Bu ölçü bir önceki dersin doğrulama turunun düğüm tarafındaki karşılığıdır: orada denetim düzlemi 0 yazma için 26 kalem okuyordu, burada düğümler hiçbir değişiklik olmadığı için 558 kalem gönderiyor.

Bu yükü kesmenin kolay göründüğü yer bir tuzaktır. Yalnız değişeni bildirmek kalem sayısını elliye bölerdi, ama kümenin canlılık kararı bildirimin içeriğine değil varlığına dayanır. Susan bir düğüm ile “hiçbir şey değişmedi” diyen bir düğüm defterde aynı görünür; ikisini ayırt eden tek şey bildirimin gelip gelmediğidir. Bu yüzden bildirim boşken bile gönderilir ve bildirim yükünün büyük kısmı bilginin kendisi için değil, kanıtı için ödenir.

Bildirimin kapsamı ayrı bir sınırdır. Aracı süreç çalışma zamanına kopyanın ayakta olup olmadığını sorar ve aldığı yanıtı iletir; kopyanın işini yapıp yapmadığını sormaz. Ölçüm ağında bir toplayıcı kopyası ayakta durup sayaç okumalarını hiç işlemiyor olabilir — süreç yaşıyordur, kaynak kullanımı düşüktür, bildirim calisiyor der. Defterde bu kopya sağlıklıdır, ağ vekili ona trafik yollar ve denetleyici yöneticisi eksik kopya görmediği için hiçbir iş yapmaz. Üç bileşenin üçü de doğru çalışır ve sonuç yanlıştır, çünkü kararın dayandığı kalem bildirimde yoktur. Kapsamı genişletmek — kopyanın kendi durumunu ayrıca bildirmesini istemek — bu kalemi ekler, ama beraberinde ayrı bir soru getirir: o bildirimi kim, ne sıklıkta ve neye bakarak üretecek.

Kümenin Eski Gerçeği Doğru Sandığı Süre

// eski-gercek.mjs — bildirim kaybolunca kume ne kadar sure eski gercegi dogru saniyor.
import { P } from "./dugum.mjs";
const uretec = (tohum) => { let s = tohum >>> 0;          // kendi uretecimiz; tohum gorunur
  return () => (s = (s * 1664525 + 1013904223) >>> 0) / 4294967296; };
const GUN = 86400, KOPYA = 3, ISTEK = 80, V = 5;   // dugum basina kopya, kopya basina istek/sn,
const rnd = uretec(20260403);                      // V: ag vekilinin depoyu okuma periyodu
const ariza = Array.from({ length: 4 }, () => rnd() * GUN);            // kalici dugum arizasi
const kesinti = Array.from({ length: 30 }, () => ({ t: rnd() * GUN, d: 5 + rnd() * 85 }));

console.log(`kesintilerin en uzunu ${Math.max(...kesinti.map((k) => k.d)).toFixed(1)} sn` +
  `   bildirim periyodu ${P} sn   vekil okuma periyodu ${V} sn`);
console.log("esik  ort-fark-etme  en-kotu  yanlis-olu-ilani  bosuna-kopya  kayip-istek");
for (const E of [20, 30, 40, 60, 90, 100, 120, 300]) {
  const g = ariza.map((t) => Math.floor(t / P) * P + E - t);           // eski gercegin suresi
  const yanlis = kesinti.filter((k) => Math.floor(k.t / P) * P + E < k.t + k.d).length;
  const kayip = g.reduce((s, x) => s + (x + V) * KOPYA * ISTEK, 0);
  console.log(`${String(E).padStart(4)}${(g.reduce((a, b) => a + b) / g.length).toFixed(1).padStart(15)}` +
    `${Math.max(...g).toFixed(1).padStart(9)}${String(yanlis).padStart(18)}` +
    `${String(yanlis * KOPYA).padStart(14)}${kayip.toFixed(0).padStart(13)}`);
}

kesintilerin en uzunu 84.6 sn   bildirim periyodu 10 sn   vekil okuma periyodu 5 sn
esik  ort-fark-etme  en-kotu  yanlis-olu-ilani  bosuna-kopya  kayip-istek
  20           17.3     19.9                26            78        21408
  30           27.3     29.9                21            63        31008
  40           37.3     39.9                19            57        40608
  60           57.3     59.9                13            39        59808
  90           87.3     89.9                 2             6        88608
 100           97.3     99.9                 0             0        98208
 120          117.3    119.9                 0             0       117408
 300          297.3    299.9                 0             0       290208

Birinci sütun kümenin yanıldığı süredir. Eşik ne olursa olsun küme bir arızayı en az E eksi bir periyot, en çok E saniye sonra öğrenir: 40 saniyelik eşikte ortalama 37,3 saniye boyunca ölü bir düğümü canlı sayar. Bu süre sıfırlanamaz, çünkü bir arızanın kendini bildirmesi diye bir şey yoktur — kümenin elindeki tek kanıt gelmeyen bildirimdir ve gelmeyen bir şeyin ne zaman gelmediğine karar vermek için beklemek gerekir.

İkinci ve üçüncü sütunlar bekleme süresinin kısaltılmasının bedelidir. Eşik 20 saniyeye indirildiğinde otuz geçici kesintinin yirmi altısı kalıcı arıza sanıldı; küme 78 kopyayı boşuna ölü ilan edip yerine yenisini açtı — üstelik eski kopyalar ölmemişti, düğüm birkaç saniye sonra geri döndü. Eşik büyüdükçe bu sayı düşüyor: 60 saniyede 13, 90 saniyede 2, 100 saniyede sıfır.

Sıfırın nerede olduğu tesadüf değil. Kesintilerin en uzunu 84,6 saniyedir ve bildirim periyodu 10 saniyedir; eşiğin bu ikisinin toplamını geçtiği ilk basamakta yanlış ilan biter. Doğru eşik kümenin kendi ölçülerinden değil, ağın davranışından türer — kümenin bilmediği ve ölçmediği bir dağılımın en uzun kuyruğundan. Kesintiler bir gün 84,6 yerine 130 saniye sürerse 100 saniyelik eşik sessizce yanlış ilan üretmeye başlar ve bunun kümede bir alarmı yoktur.

Son sütun ödemenin öteki yarısıdır. Ağ vekilinin kuralı ancak kopya ölü ilan edildikten sonra güncellendiği için, o ana kadar gelen istekler çalışmayan kopyalara gönderilir. Yanlış ilanı sıfırlayan 100 saniyelik eşikte gün boyunca 98.208 istek ölü kopyalara gitti; 20 saniyelik eşikte bu sayı 21.408’di. İki uç arasındaki seçim bir ayar değil, iki yanlışın paylaştırılmasıdır: hızlı davranan küme sağlam kopyaları öldürür, sabırlı küme ölü kopyalara trafik yollar. Hiçbir eşik ikisini birden sıfırlamaz ve ikisini birden sıfırlayacak bilgi düğümde yoktur. Ölçüm ağında bunun karşılığı somuttur — 98 bin sayaç okuma isteği yanıtsız kalır ve gecelik toplu iş eksik veriyle başlar.

Bildirim Gecikmesi Nerede Birikiyor

Bir kopyanın düşmesi ile bunun deftere geçip karara dönüşmesi arasında dört ayrı bekleme vardır ve her biri kendi periyodunu bekletir.

// gecikme.mjs — bir olayin dorda bolunmus bildirim gecikmesi. Her asama kendi periyodunu bekletir.
import { P } from "./dugum.mjs";
const uretec = (tohum) => { let s = tohum >>> 0;
  return () => (s = (s * 1664525 + 1013904223) >>> 0) / 4294967296; };
const rnd = uretec(20260404), N = 20000;
const C = 2, YAZ = 0.05, U = 15;        // calisma zamani yoklama, depo yazma, uzlasma periyodu
const asama = [["calisma zamani yoklama", C], ["araci surec bildirimi", P],
  ["arayuz + depo yazma", 0], ["denetleyici yoneticisi turu", U]];

let toplam = new Array(N).fill(0);
console.log("asama                         periyot  ort(sn)  en kotu(sn)  yigilmis ort(sn)");
for (const [ad, periyot] of asama) {
  const pay = toplam.map(() => (periyot ? rnd() * periyot : YAZ));
  toplam = toplam.map((x, i) => x + pay[i]);
  console.log(`${ad.padEnd(29)}${(periyot || YAZ).toFixed(2).padStart(8)}` +
    `${(pay.reduce((a, b) => a + b) / N).toFixed(2).padStart(9)}` +
    `${Math.max(...pay).toFixed(2).padStart(13)}` +
    `${(toplam.reduce((a, b) => a + b) / N).toFixed(2).padStart(18)}`);
}
console.log(`olay ${N}   en kotu uctan uca ${Math.max(...toplam).toFixed(2)} sn` +
  `   asama sayisi ${asama.length}`);

asama                         periyot  ort(sn)  en kotu(sn)  yigilmis ort(sn)
calisma zamani yoklama           2.00     1.00         2.00              1.00
araci surec bildirimi           10.00     4.99        10.00              5.99
arayuz + depo yazma              0.05     0.05         0.05              6.04
denetleyici yoneticisi turu     15.00     7.49        15.00             13.53
olay 20000   en kotu uctan uca 26.36 sn   asama sayisi 4

Ortalama uçtan uca gecikme 13,53 saniye, en kötüsü 26,36 saniyedir. Dağılım öğreticidir: gecikmenin 1,00 saniyesi çalışma zamanının yoklamasından, 4,99 saniyesi aracı sürecin bildirim periyodundan, 0,05 saniyesi yazma işleminden, 7,49 saniyesi denetleyici yöneticisinin turundan gelir. Yani gecikmenin yarısından fazlası düğüm tarafında değil, denetim düzleminin kendi periyodundadır.

Bu ayrım hangi ayarın işe yaradığını belirler. Aracı sürecin bildirim periyodunu ikiye bölmek ortalamayı 2,5 saniye düşürür ve bildirim yükünü ikiye katlar; denetleyici yöneticisinin tur periyodunu ikiye bölmek 3,75 saniye düşürür ve düğümlere hiçbir yük bindirmez, ama defter okuma yükünü ikiye katlar. Aynı gecikme iki ayrı yerde ve iki ayrı fiyata satılır; hangi ayarın ucuz olduğu kümenin nerede darlaştığına bağlıdır.

Ağ Vekilinin Kural Sayısı

// vekil.mjs — ag vekilinin kural sayisi servis sayisiyla nasil buyuyor; degisim nereye yayiliyor.
const M = 30, r = 5, V = 5, DEGISIKLIK = 200;   // dugum, kopya/servis, okuma periyodu, kopya/gun
const kural = (S) => S * (1 + r);               // dugum basina: servis girisi + kopya yonlendirme

console.log(`dugum ${M}   kopya/servis ${r}   vekil okuma periyodu ${V} sn`);
console.log("servis  kopya  kural/dugum  kume kurali  tek degisiklik  okunan kalem/sn  gunluk yazma");
for (const S of [2, 4, 8, 16, 32, 64]) {
  console.log(`${String(S).padStart(6)}${String(S * r).padStart(7)}${String(kural(S)).padStart(13)}` +
    `${String(M * kural(S)).padStart(13)}${String(M).padStart(16)}` +
    `${((M * S * r) / V).toFixed(0).padStart(17)}${String(DEGISIKLIK * M).padStart(14)}`);
}

dugum 30   kopya/servis 5   vekil okuma periyodu 5 sn
servis  kopya  kural/dugum  kume kurali  tek degisiklik  okunan kalem/sn  gunluk yazma
     2     10           12          360              30               60          6000
     4     20           24          720              30              120          6000
     8     40           48         1440              30              240          6000
    16     80           96         2880              30              480          6000
    32    160          192         5760              30              960          6000
    64    320          384        11520              30             1920          6000

İki sütun iki ayrı eksende büyüyor. Kural sayısı servis sayısıyla büyür: iki serviste düğüm başına 12 kural, altmış dört serviste 384. Küme geneli bunun düğüm sayısıyla çarpımıdır ve 11.520 kurala ulaşır, çünkü aynı kural kümesi otuz düğümün her birinde ayrı ayrı durur. Vekilin defteri okuma yükü de aynı eksende büyür: saniyede 60 kalemden 1.920 kaleme.

Değişimin yayılımı ise servis sayısından bağımsızdır. Tek bir kopyanın doğması ya da ölmesi, kaç servis olursa olsun, otuz düğümde otuz kural yazması doğurur — çünkü her düğümün o servise erişebilmesi gerekir. Günde iki yüz kopya değişikliği 6.000 kural yazmasına çıkar ve bu sayı servis sayısı otuz iki katına çıksa da değişmez.

Ayrım işletim açısından önemlidir: yeni servis eklemek durağan maliyeti büyütür (kural sayısı, bellek, okuma yükü), düğüm eklemek ya da kopyaları sık değiştirmek akan maliyeti büyütür (kural yazma, yayılma penceresi). Bir önceki bölümdeki kayıp istek sayısı da bu pencerede birikir: kopya ölü ilan edildikten sonra kuralın güncellenmesi vekilin okuma periyodu kadar daha gecikir. Bu beş saniye otuz düğümün her birinde ayrı ayrı ve farklı anlarda kapanır; kural değişimi kümeye tek bir anda değil, bir pencere boyunca yayılır.

Özet

• Sekiz kopyalı bir düğüm her periyotta 19 kalem bildirir; 300 düğümde bu günde 49 milyon kalem eder ve bunun yalnız 11,4 kalem/saniyesi gerçekten değişmiştir — kalan yüzde doksan sekiz, bilginin değil düğümün hâlâ ayakta olduğunun kanıtı için ödenir.
• Bir olayın karara dönüşmesi dört beklemeden geçer ve ortalama 13,53, en kötü 26,36 saniye sürer; bunun 7,49 saniyesi düğümden değil denetleyici yöneticisinin tur periyodundan gelir.
• Küme bir arızayı en az eşik eksi bir periyot, en çok eşik kadar sonra öğrenir; 40 saniyelik eşikte ortalama 37,3 saniye boyunca ölü bir düğümü canlı sayar ve bu süre sıfırlanamaz.
• Eşik 20 saniyeye indirilince 30 geçici kesintinin 26’sı kalıcı arıza sanıldı ve 78 kopya boşuna açıldı; yanlış ilan ancak eşik en uzun kesinti (84,6 sn) ile bir bildirim periyodunun toplamını geçince, 100 saniyede sıfırlandı.
• Yanlış ilanı sıfırlayan eşikte ölü kopyalara giden istek 98.208’e çıktı; 20 saniyelik eşikte 21.408’di — iki uç arasındaki seçim iki yanlışın paylaştırılmasıdır.
• Ağ vekilinin kural sayısı servis sayısıyla büyür (12 → 384 düğüm başına, küme geneli 11.520), değişimin yayılımı ise servis sayısından bağımsızdır: tek kopya değişikliği 30 düğümde 30 kural yazması, günde 6.000.

Sonraki Adım

İki ders iki tarafı ayrı ayrı ölçtü: denetim düzlemi kararı üretiyor, düğümler durumu bildiriyor. İkisini birbirine bağlayan şey henüz adlandırılmadı — istenen durum ile gerçek durumun sürekli karşılaştırılıp farkın kapatılması. Bir sonraki ders bu konunun merkezidir ve uzlaşma döngüsünü küme ölçeğinde gerçekten yazar: yakınsama turu, tur başına iş, ve bu dersin bıraktığı soru — rapor gecikmesi büyüdükçe döngü kaç kopyayı gereksiz açıyor, kaçını boşuna siliyor, ve döngü periyodu ile rapor gecikmesi arasında nasıl bir ilişki var.