Durum Bilgili Uygulamalar

Kalıcı birim talebi kapsülün verisini kapsülden uzun yaşatıyor. Bu, tek bir talep ile tek bir birim arasındaki bağ için yeterli. Ölçüm ağının doğrulayıcısı ise tek kopya değil: beş kopya koşuyor, her kopyanın kendi 40 Gi’lik verisi var ve kopyalar bu veriyi birbirinin yerine geçerek sunamıyor. Kopya bir sayaç aralığının sahibi; o aralığın verisi onun biriminde.

Kopya kümesi bu varsayımın tam tersini kurar. Onun için kopyalar birbirinin yerine geçebilir; adları koşum boyunca kalıcı değildir, çünkü ada bağlı hiçbir şey olmaması gerekir. Ada bağlı bir birim ortaya çıktığı anda bu varsayım bozulur: yeniden yaratılan kopyanın adı değişmişse hangi birime bağlanacağını söyleyecek bir bilgi kalmaz.

Bu ders devredilen kararı şöyle adlandırıyor: hangi kopya hangi veriye sahiptir ve yeniden yaratıldığında nereye bağlanır. Kararı verecek sistemin kopya başına üç kalem bilmesi gerekiyor — sıra numarası, birim bağı, hazır olma durumu. Sayılan üç şey: aynı olay dizisinde iki nesne kaç öksüz birim bırakıyor, sıralı başlatmanın tur maliyeti ne, sıraya uyulmadığında ne bozuluyor.

Aynı Olay Dizisi, İki Nesne

İki nesne aynı altı olaydan geçiyor: kurulum, düğüm arızası, yeniden yaratma, ölçek küçültme, tam yeniden başlatma, ölçek büyütme. Karşılaştırma yalnız bu dizinin sonunda anlam kazanıyor; tek bir olayda ikisi de aynı görünür.

• TN37 — Kopyalar, birimler, küme üyeliği ve parça sahipliği node içinde kurulan bir modeldir; gerçek bir küme koşturulmuyor.
• TN38 — Ölçüm ağı kurgudur. Doğrulayıcı beş kopya koşuyor, her kopyanın 40 Gi’lik kendi birimi var ve üç düğüme sırayla yerleşiyorlar.
• TN39 — Sıralı kümede kopya adı sıra numarasından türüyor ve birim talebi ada bağlı; kopya kümesinde ad her yaratımda yeniden üretiliyor ve her yeni ad yeni bir birim talebi doğuruyor.
• TN40 — Ölçek küçültmede sıralı küme en yüksek sıra numarasını kaldırıyor; kopya kümesinde giden kopya üreteçle seçiliyor. Kaldırılan kopyanın birimi silinmiyor, sahipsiz kalıyor.
• TN41 — Hazır olma süreleri 1–3 tur arasında üreteçle veriliyor. Sıralı başlatmada her kopya öncekinin hazır olmasını bekliyor, durdurma ters sırada ve kopya başına bir tur.
• TN42 — Üyelik modeli: sıra sıfır tohumdur, tohum açık değilken açılan kopya kendi üyeliğini kurar ve sonradan birleşme yoktur. Parça sahipliği her üyelik içinde parça mod üye sayısı ile dağıtılıyor; parça p’nin verisi fiziksel olarak sıra p mod 5’in birimindedir. Tohum 20260807.

// olcum/kimlik.mjs — sirali kume ile sirasiz kopya kumesi ayni olay dizisinde.
// MODEL: kopyalar, birimler, uyelik ve parca sahipligi node icinde kurulan modeldir; gercek bir
// kume kosturulmuyor. Sayilar modelin sayilaridir.
const N = 5, DUGUM = ["d1", "d2", "d3"], PARCA = 12, TOHUM = 20260807;
let s = TOHUM % 2147483647;
const rast = () => (s = (s * 48271) % 2147483647) / 2147483647;
const ek = () => Array.from({ length: 4 }, () => "abcdefghijklmnopqrstuvwxyz"[Math.floor(rast() * 26)]).join("");

function kosum(tur) {
  const birim = new Map();                     // birim adi -> sahip kopya adi (bos ise null)
  let kopya = [], kayit = [];
  const yarat = (sira) => {
    const ad = tur === "sirali" ? `dgr-${sira}` : `dgr-${ek()}`;
    const b = `veri-${ad}`, vardi = birim.has(b);
    birim.set(b, ad);
    return { sira, ad, birim: b, vardi, dugum: DUGUM[sira % DUGUM.length] };
  };
  const sil = (k) => { birim.set(k.birim, null); kopya = kopya.filter((x) => x !== k); };
  const olay = (etiket, yeni) => {
    const oksuz = [...birim.values()].filter((v) => v === null).length;
    kayit.push([etiket, yeni.length, yeni.filter((k) => k.vardi).length, kopya.length, oksuz]);
  };
  let y = Array.from({ length: N }, (_, i) => yarat(i)); kopya = [...y]; olay("ilk kurulum", y);
  for (const k of kopya.filter((k) => k.dugum === "d2")) sil(k); olay("dugum d2 arizasi", []);
  const eksik = [0, 1, 2, 3, 4].filter((i) => !kopya.some((k) => k.sira === i));
  y = eksik.map((i) => yarat(i)); kopya.push(...y); olay("yeniden yaratma", y);
  for (let i = 0; i < 2; i += 1) {             // olcek 5 -> 3
    const aday = tur === "sirali" ? kopya.reduce((a, b) => (b.sira > a.sira ? b : a))
      : kopya[Math.floor(rast() * kopya.length)];
    sil(aday);
  }
  const kalanSira = kopya.map((k) => k.sira).sort();
  olay(`olcek 5->3 (giden ${[0, 1, 2, 3, 4].filter((i) => !kalanSira.includes(i)).join(",")})`, []);
  const eski = [...kopya]; for (const k of eski) sil(k);
  y = eski.map((k) => yarat(k.sira)); kopya = [...y]; olay("tam yeniden baslatma", y);
  const bos = [0, 1, 2, 3, 4].filter((i) => !kopya.some((k) => k.sira === i)).slice(0, 2);
  y = bos.map((i) => yarat(i)); kopya.push(...y); olay("olcek 3->5", y);
  return { kayit, oksuz: [...birim.values()].filter((v) => v === null).length, birim: birim.size };
}

console.log(`${"olay".padEnd(26)}${"nesne".padStart(13)}${"yaratilan".padStart(11)}${"eski birime donen".padStart(19)}${"acik kopya".padStart(12)}${"oksuz birim".padStart(13)}`);
for (const tur of ["sirali", "sirasiz"]) {
  const r = kosum(tur);
  for (const [e, yaratilan, donen, acik, oksuz] of r.kayit)
    console.log(`${e.padEnd(26)}${(tur === "sirali" ? "sirali kume" : "kopya kumesi").padStart(13)}` +
      `${String(yaratilan).padStart(11)}${String(donen).padStart(19)}${String(acik).padStart(12)}${String(oksuz).padStart(13)}`);
  console.log(`  -> ${tur}: toplam ${r.birim} birim yaratildi, ${r.oksuz} tanesi oksuz (${r.oksuz * 40} Gi sahipsiz)`);
}

// --- sirali baslatma ve durdurmanin tur maliyeti ---
console.log(`\n${"kopya".padEnd(7)}${"hazir olma turlari".padStart(20)}${"sirali baslatma".padStart(17)}${"paralel".padStart(9)}${"sirali durdurma".padStart(17)}${"paralel".padStart(9)}${"fark".padStart(7)}`);
s = TOHUM % 2147483647;
for (const n of [3, 5, 9]) {
  const hazir = Array.from({ length: n }, () => 1 + Math.floor(rast() * 3));
  const sb = hazir.reduce((a, b) => a + b, 0), pb = Math.max(...hazir);
  console.log(`${String(n).padEnd(7)}${hazir.join(",").padStart(20)}${String(sb).padStart(17)}${String(pb).padStart(9)}` +
    `${String(n).padStart(17)}${String(1).padStart(9)}${String(sb + n - pb - 1).padStart(7)}`);
}

// --- siraya uyulmadiginda: kume uyeligi ve veri sahipligi ---
function uyelik(sira) {
  const gruplar = [];
  for (const i of sira) {
    const tohumlu = gruplar.find((g) => g.includes(0));
    if (i === 0 || !tohumlu) gruplar.push([i]); else tohumlu.push(i);
  }
  const iddia = Array.from({ length: PARCA }, () => []);
  for (const g of gruplar) for (let p = 0; p < PARCA; p += 1) iddia[p].push(g[p % g.length]);
  return {
    uyelik: gruplar.length,
    cift: iddia.filter((a) => a.length > 1).length,
    yanlis: iddia.reduce((a, l, p) => a + l.filter((k) => k !== p % N).length, 0),
    verisiz: iddia.filter((a, p) => !a.includes(p % N)).length,
  };
}
console.log(`\n${"baslatma sirasi".padEnd(18)}${"uyelik".padStart(8)}${"cift iddia edilen".padStart(19)}${"yanlis iddia".padStart(14)}${"verisiz sunulan".padStart(17)}`);
const siralar = [[0, 1, 2, 3, 4]];
for (let i = 0; i < 3; i += 1) {
  const p = [0, 1, 2, 3, 4];
  for (let j = p.length - 1; j > 0; j -= 1) { const k = Math.floor(rast() * (j + 1)); [p[j], p[k]] = [p[k], p[j]]; }
  siralar.push(p);
}
for (const sira of siralar) {
  const r = uyelik(sira);
  console.log(`${sira.join(",").padEnd(18)}${String(r.uyelik).padStart(8)}${String(r.cift).padStart(19)}` +
    `${String(r.yanlis).padStart(14)}${String(r.verisiz).padStart(17)}`);
}
console.log(`${PARCA} parca, ${N} kopya, tohum ${TOHUM}; bilgi kalemi: kopya basina 3 (sira, birim bagi, hazir olma) = ${N * 3}`);

olay                              nesne  yaratilan  eski birime donen  acik kopya  oksuz birim
ilk kurulum                 sirali kume          5                  0           5            0
dugum d2 arizasi            sirali kume          0                  0           3            2
yeniden yaratma             sirali kume          2                  2           5            0
olcek 5->3 (giden 3,4)      sirali kume          0                  0           3            2
tam yeniden baslatma        sirali kume          3                  3           3            2
olcek 3->5                  sirali kume          2                  2           5            0
  -> sirali: toplam 5 birim yaratildi, 0 tanesi oksuz (0 Gi sahipsiz)
ilk kurulum                kopya kumesi          5                  0           5            0
dugum d2 arizasi           kopya kumesi          0                  0           3            2
yeniden yaratma            kopya kumesi          2                  0           5            2
olcek 5->3 (giden 0,1)     kopya kumesi          0                  0           3            4
tam yeniden baslatma       kopya kumesi          3                  0           3            7
olcek 3->5                 kopya kumesi          2                  0           5            7
  -> sirasiz: toplam 12 birim yaratildi, 7 tanesi oksuz (280 Gi sahipsiz)

kopya    hazir olma turlari  sirali baslatma  paralel  sirali durdurma  paralel   fark
3                     2,1,1                4        2                3        1      4
5                 1,2,3,3,1               10        3                5        1     11
9         1,1,1,1,2,3,1,1,1               12        3                9        1     17

baslatma sirasi     uyelik  cift iddia edilen  yanlis iddia  verisiz sunulan
0,1,2,3,4                1                  0             0                0
2,1,0,3,4                3                 12            30                6
1,4,3,0,2                4                 12            38                2
0,1,2,4,3                1                  0             4                4
12 parca, 5 kopya, tohum 20260807; bilgi kalemi: kopya basina 3 (sira, birim bagi, hazir olma) = 15

Ad Kalıcı mı, Birim Geri Geliyor mu

İlk tablonun ilk iki satırı iki nesnede aynı: beş kopya kuruldu, d2 düştü, iki kopya gitti, iki birim öksüz kaldı. Ayrışma yeniden yaratma satırında başlıyor. Sıralı küme eksik iki sıra numarasını gördüğü için aynı iki adı yeniden üretiyor; ad aynı olduğu için birim talebi de aynı ve iki kopya da eski birimine dönüyor, öksüz sayısı sıfıra iniyor. Kopya kümesi iki yeni ad üretiyor; yeni ad yeni talep doğuruyor, eski birime dönen kopya sayısı sıfır ve iki öksüz birim yerinde duruyor.

Ölçek küçültmede giden kopyaların kimliği de ayrı. Sıralı kümede giden kopyalar 3 ve 4 — en yüksek iki sıra, ve bu kural koşumdan koşuma değişmez. Kopya kümesinde giden kopyalar 0 ve 1 oldu; seçim üretecin verdiği sıradandır ve başka bir koşumda başka bir çift gider. Fark yalnız hangi kopyanın gittiği değil: sıralı kümede küçültmenin hangi veriyi kenara koyduğu önceden bilinir, büyütme geldiğinde aynı iki kopya aynı iki birime döner. Tabloda bu, son satırdaki 2 sayısıdır.

Dizinin sonundaki iki satır özeti veriyor. Sıralı küme boyunca 5 birim yaratıldı ve sonunda öksüz kalan 0. Kopya kümesi aynı olaylarda 12 birim yarattı ve 7’si öksüz kaldı — 280 Gi’lik veri, hiçbir kopyanın bağlanmadığı birimlerde duruyor. Bu veri kaybolmuş değil; kaybolan şey ona ulaşacak ad. Kimlik kalıcı olmayınca kalıcı depolamanın kendisi de erişilemez hâle geliyor: kalıcılık ve kimlik ayrı ayrı çözülebilen sorunlar değil.

Yedi öksüz birimin ikinci bir bedeli daha var. Onları silecek bir yaşam döngüsü yok — kopya gittiğinde birim durur, çünkü içindeki veri değerli olabilir. Karar bir insana kalır ve o insanın veri-dgr-qxlm gibi bir adın hangi geceye, hangi sayaç aralığına ait olduğunu bilmesi gerekir. Ad kalıcı olmadığı için bu bilgi hiçbir yerde durmuyor; kalan tek seçenek birimi açıp içine bakmaktır. Sıralı kümede aynı soru sorulmaz, çünkü veri-dgr-3 adı zaten yanıtı taşır.

Sıralı Başlatmanın Tur Maliyeti

İkinci tablo, sıralı kimliğin karşılığında ödenen bedeli veriyor. Sıralı küme kopyaları teker teker açar; her kopya bir öncekinin hazır olma denetiminden geçmesini bekler. Durdurma ters sırada, yine teker teker.

Beş kopyada hazır olma süreleri 1, 2, 3, 3, 1 tur. Sıralı başlatma bunların toplamı olan 10 tur sürüyor; hepsi aynı anda açılsaydı en yavaş kopyanın süresi olan 3 tur yeterdi. Durdurma sıralı 5 tur, paralel 1 tur. İki uçtaki toplam fark 11 tur. Dokuz kopyada başlatma 12 tura, durdurma 9 tura çıkıyor, fark 17 tur. Ölçek büyüdükçe fark toplama göre büyüyor: paralel maliyet en yavaş kopyaya bağlı kalırken sıralı maliyet kopya sayısıyla doğrusal artıyor.

Bu bedel bir bilgi bedelidir. Sistemin sırayı uygulayabilmesi için her adımda “önceki kopya gerçekten hazır mı” sorusunu yanıtlaması gerekiyor ve bu yanıt bir denetimden geliyor. Denetim gevşetilirse tur kazanılır, ama sıra güvencesi de kaybedilir — sonraki tablo bunun ne demek olduğunu sayıyor.

Bedelin karşılıksız kaldığı bir durum da var ve onu adlandırmak gerekiyor. Sıra, kopyalar arasında bir kuruluş bağımlılığı olduğu için ödenir: biri tohum, ötekiler ona katılır. Kopyaların birbirinden haberi olmayan bir uygulamada böyle bir bağımlılık yoktur; o durumda beş kopya için ödenen 11 tur hiçbir şey satın almaz, yalnız yayın penceresini uzatır. Ölçüm ağında ayrım nettir: doğrulayıcı kopyaları ortak bir üyelik kurar, okuma toplayıcının kopyaları kurmaz — biri sıralı küme ister, öteki istemez.

Sıra Bozulunca: Üyelik ve Sahiplik

Üçüncü tablo iki ayrı bozulmayı ayırıyor. Doğru sırada — 0,1,2,3,4 — tek üyelik kuruluyor, çift iddia edilen parça yok, yanlış iddia yok, verisiz sunulan parça yok.

2,1,0,3,4 sırasında tohum üçüncü sırada açılıyor. Ondan önce açılan iki kopya tohumu bulamayınca kendi üyeliklerini kuruyor: üç ayrı üyelik. Her üyelik 12 parçayı kendi üye sayısına göre dağıttığı için 12 parçanın hepsi çift iddia ediliyor ve 30 iddia yanlış kopyaya düşüyor. Altı parça, verisi kendisinde olmayan kopyalar tarafından sunuluyor. 1,4,3,0,2 sırasında bölünme dörde çıkıyor ve yanlış iddia 38’e yükseliyor.

Son satır en sinsi durumdur ve tek başına okunmalıdır. 0,1,2,4,3 sırasında tohum en başta açılıyor, üyelik bölünmüyor — tek üyelik, çift iddia sıfır. Buna rağmen dört parça verisi olmayan bir kopyaya düşüyor, çünkü sahiplik dağıtımı katılma sırasına göre yapılıyor ve 4 ile 3 yer değiştirmiş. Yani sıra ihlali iki farklı arıza üretiyor: gözle görülür olanı üyeliğin bölünmesi, görülmeyeni sahipliğin kaymasıdır. İkincisinde küme sağlıklı görünür, sorgular yanıtlanır, yalnız dört parçanın yanıtı yanlış kopyadan gelir.

Devrin bedeli burada tek satırda toplanıyor: karar kopya başına üç kaleme dayanıyor — sıra numarası, birim bağı, hazır olma durumu; beş kopya için 15 kalem. Bu kalemlerin hepsi doğru ve zamanında üretilirse öksüz birim 0, üyelik 1, yanlış iddia 0. Sıra numarası kalemi düşerse 7 öksüz birim, hazır olma kalemi düşerse bölünmüş üyelik ve kayan sahiplik ortaya çıkıyor.

Özet

• Aynı altı olayda sıralı küme 5 birim yaratıp 0’ını öksüz bırakıyor; kopya kümesi 12 birim yaratıp 7’sini öksüz bırakıyor (280 Gi sahipsiz veri).
• Ad kalıcılığı birim bağının önkoşuludur: yeniden yaratmada sıralı kümede 2 kopyanın 2’si eski birimine döndü, kopya kümesinde 0’ı döndü.
• Ölçek küçültmede sıralı küme en yüksek sırayı kaldırıyor (3 ve 4) ve büyütmede aynı iki kopya aynı birimlere geri dönüyor; kopya kümesinde giden çift (0 ve 1) koşuma bağlı ve geri dönüş yok.
• Sıralı başlatmanın bedeli tur cinsindendir: beş kopyada 10 tura karşı 3 tur, dokuz kopyada 12 tura karşı 3 tur; durdurmayla birlikte toplam fark 11 ve 17 tur.
• Sıra ihlali iki ayrı arıza üretiyor: tohum geç açılınca üyelik 3–4’e bölünüyor ve 12 parçanın hepsi çift iddia ediliyor; tohum erken açılıp katılma sırası bozulunca üyelik tek kalıyor ama 4 parça verisi olmayan kopyaya düşüyor.
• Karar kopya başına üç kaleme dayanıyor (sıra, birim bağı, hazır olma); beş kopya için 15 kalem.

Sonraki Adım

Sıralı küme ile kopya kümesi arasındaki fark ölçüldü ve ikisinin de ortak bir varsayımı var: kapsüller bitmez. Kopya sayısı istenen değere getirilir ve orada tutulur; bir kapsül sonlanırsa bu bir arızadır ve yeniden başlatılır. Ölçüm ağının gecelik toplu işi bu varsayıma uymuyor. O iş başlar, günün okumalarını doğrular, faturalama girdisini üretir ve biter — bitmesi beklenen davranıştır, arıza değil. Bittiğini kim, neye bakarak söyleyecek; bitmezse kaç kez denenecek; her gece aynı saatte başlaması gerekiyorsa o saati kim koruyacak? Sonraki ders bir kerelik ve yinelenen görevleri iki ayrı nesneyle kurup şunları sayıyor: tamamlanma güvencesi kaç denemeye mal oluyor, paralellik ile tamamlanma sayısı ayarları hangi sonucu veriyor, kaçırılan koşumda ne oluyor ve önceki koşum bitmeden yenisi geldiğinde üç politika birbirinden nasıl ayrılıyor.