Kalıcı ve Kesintili Kapasite

Önceki iki ders makineyi kiraladı ve açtı; ikisi de aynı varsayımın üzerinde durdu — örnek istendiği sürece ayakta kalır. Kiralamanın bir de bu varsayımı kaldıran biçimi vardır: kesintili kapasite, sağlayıcının başka bir yere gerektiğinde kısa bir bildirimle geri alabildiği kapasitedir ve karşılığında belirgin biçimde ucuza verilir.

M23/K01 bu iki biçimin fiyat farkını ölçtü; o karşılaştırma burada tekrarlanmaz, girdi olarak alınır. Bu dersin sorusu fiyat değil, iş türüdür: aynı indirim dört farklı işe verildiğinde dördü de aynı şeyi kazanmaz, çünkü kesinti geldiğinde dördü aynı şeyi kaybetmez. Ölçü, kesintinin kendisi değil, kesintinin ne götürdüğüdür.

BH13. Dört iş türü bölgesel ölçüm ağının — su sayaçlarından okuma toplayan kurgu yazılımın — işleridir; süreleri ve örnek sayıları kurgudur. BH14. Kesinti oranı 0,06 kesinti/örnek-saattir; üreteç kendi yazılmıştır ve tohum 20260901 görünürdür. BH15. Bildirim süresi 0 ile 300 saniye arasında taranır; her iş türünün kurtarma süresi kurgudur. BH16. Kalıcı kapasite 1,00, kesintili kapasite 0,32 kurgu birimdir; oran M23/K01’den girdi olarak gelir, gerçek bir para birimi değildir. BH17. Uzun koşum ara kayıt tutmaz; kesildiğinde baştan başlar. BH18. Dönem 30 gündür.

Hangi İş Ne Kaybeder

Kesinti bildirimi bir haber değil, bir penceredir: kapasite geri alınmadan önce elde kalan süredir. O pencerede yapılabilecek tek şey işi kurtarmaktır ve her iş türünün kurtarma işlemi farklı sürer. Pencere kurtarma süresinden kısaysa bildirim hiçbir işe yaramaz.

// olcum-agi/is-turleri.mjs — dort is turunun kesintide kaybettigi is (model; urun degil tur)

export const uretec = (tohum) => () =>
  (tohum = (tohum * 1103515245 + 12345) % 2147483648) / 2147483648;

export const BILDIRIM = [0, 30, 60, 120, 300];        // taranan kesinti bildirimi (sn)

// kurtar: bildirim penceresinde isi kurtarmak icin gereken saniye (yetmezse kayip olusur).
// kayip: kurtarilamazsa bir kesintide kaybedilen is (dakika). yeniden: yeniden baslama (dakika).
export const IS = [
  { ad: "gecelik toplu is", ornek: 12, saat: 6, kurtar: 45, kayip: 15, yeniden: 4,
    birim: "ara kayittan beri gecen 15 dk" },
  { ad: "kuyruk iscisi", ornek: 20, saat: 24, kurtar: 90, kayip: 0.75, yeniden: 3,
    birim: "yarim gorev, kuyruga doner" },
  { ad: "uzun suren tek kosum", ornek: 4, saat: 20, kurtar: 660, kayip: 600, yeniden: 6,
    birim: "kosumun yarisi, 10 sa" },
  { ad: "kullaniciya yanit veren servis", ornek: 30, saat: 24, kurtar: 20, kayip: 0.08,
    yeniden: 2, birim: "akistaki 24 istek" },
];

export const kayip = (is, b) => (b >= is.kurtar ? 0 : is.kayip);

if (import.meta.url === `file://${process.argv[1]}`) {
  console.log("is turu".padEnd(32) + "kurtarma".padEnd(11) +
    BILDIRIM.map((b) => `${b} sn`.padEnd(9)).join("") + "kesintide kaybedilen");
  for (const is of IS)
    console.log(is.ad.padEnd(32) + `${is.kurtar} sn`.padEnd(11) +
      BILDIRIM.map((b) => `${kayip(is, b).toFixed(2)}`.padEnd(9)).join("") + is.birim);
  console.log("\n(hucreler bir kesintide kaybedilen is-dakikasidir)");
  const dayanmaz = IS.filter((is) => BILDIRIM.every((b) => kayip(is, b) > 0));
  console.log(`bildirim taramasinin hicbir degerinde kaybi sifirlanmayan is: ` +
    dayanmaz.map((x) => x.ad).join(", "));
  console.log(`gerekcesi: kurtarma ${dayanmaz[0].kurtar} sn istiyor, taramanin en uzun ` +
    `bildirimi ${Math.max(...BILDIRIM)} sn`);
}

is turu                         kurtarma   0 sn     30 sn    60 sn    120 sn   300 sn   kesintide kaybedilen
gecelik toplu is                45 sn      15.00    15.00    0.00     0.00     0.00     ara kayittan beri gecen 15 dk
kuyruk iscisi                   90 sn      0.75     0.75     0.75     0.00     0.00     yarim gorev, kuyruga doner
uzun suren tek kosum            660 sn     600.00   600.00   600.00   600.00   600.00   kosumun yarisi, 10 sa
kullaniciya yanit veren servis  20 sn      0.08     0.00     0.00     0.00     0.00     akistaki 24 istek

(hucreler bir kesintide kaybedilen is-dakikasidir)
bildirim taramasinin hicbir degerinde kaybi sifirlanmayan is: uzun suren tek kosum
gerekcesi: kurtarma 660 sn istiyor, taramanin en uzun bildirimi 300 sn

Tabloda üç satır bir eşikte sıfırlanır, bir satır hiç sıfırlanmaz. Kullanıcıya yanıt veren servis 20 saniyede boşalır ve 30 saniyelik bildirimde kaybı biter; gecelik toplu iş 45 saniyede acil bir ara kayıt alır ve 60 saniyede kurtulur; kuyruk işçisi elindeki 90 saniyelik görevi bitirebilirse kaybetmez. Bu üçünde kesintiye dayanmayı sağlayan şey kapasitenin türü değil, işin bölünebilir olmasıdır: iş küçük parçalara ayrılmışsa bir parçadan fazlası kaybolmaz.

Dördüncü satır bölünmemiş işin ne olduğunu gösterir. Ara kaydı olmayan 20 saatlik koşum, kesinti geldiğinde o ana kadarki bütün ilerlemeyi kaybeder ve bunu kurtarmak 660 saniyelik bir ara kayıt ister. Taramanın en uzun bildirimi 300 saniyedir; bildirim ne kadar uzarsa uzasın kayıp değişmez. Kesintiye hiç dayanmayan iş budur ve adı uzun suren tek kosum’dur. Çözümü daha uzun bir bildirim değildir — işin kendisini bölmektir, yani ara kayıt eklemektir; bu da kapasite kararı değil, uygulama kararıdır.

Otuz Günlük Dönem

Kesinti başına kayıp bir birim fiyattır; asıl soru bu birimin ayda kaç kez ödendiğidir. Aşağıdaki koşum aynı üreteçle 30 günlük bir dönem üretir ve iki bildirim düzeyini — sıfır ve 120 saniye — aynı kesinti dizisi üzerinde karşılaştırır.

// olcum-agi/kesinti-donemi.mjs — 30 gunluk kesintili kapasite kosumu (model)
import { uretec, IS, kayip } from "./is-turleri.mjs";

export const GUN = 30, ORAN = 0.06;      // kesinti/ornek-saat (kurgu)
const r = uretec(20260901);              // tohum gorunur

export const kosum = (is) => {
  const saat = is.ornek * is.saat * GUN;
  let kesinti = 0;
  for (let i = 0; i < saat; i++) if (r() < ORAN) kesinti++;
  const yeniden = kesinti * is.yeniden;
  const olc = (b) => (60 * saat) / (60 * saat + kesinti * kayip(is, b) + yeniden);
  return { saat, kesinti, yeniden, sifir: kesinti * kayip(is, 0),
    yuz: kesinti * kayip(is, 120), verimSifir: olc(0), verimYuz: olc(120) };
};

// Ara kaydi olmayan 20 saatlik kosum: her denemede bastan baslar.
export const tekKosum = (is) => {
  const TOPLAM = GUN * 24;
  let gecen = 0, deneme = 0, biten = 0, bosa = 0;
  while (gecen < TOPLAM) {
    deneme++;
    let h = 0;
    while (h < is.saat && gecen < TOPLAM) { h++; gecen++; if (r() < ORAN) break; }
    if (h === is.saat) biten++; else { bosa += h; gecen += is.yeniden / 60; }
  }
  return { deneme, biten, bosa, kalici: Math.floor(TOPLAM / is.saat) };
};

if (import.meta.url === `file://${process.argv[1]}`) {
  console.log(`${GUN} gun, kesinti orani ${ORAN}/ornek-saat, tohum 20260901\n`);
  console.log("is turu".padEnd(32) + "ornek-saat".padEnd(12) + "kesinti".padEnd(10) +
    "kayip sa (0 sn)".padEnd(17) + "kayip sa (120 sn)".padEnd(19) +
    "yeniden sa".padEnd(12) + "verim 0 sn".padEnd(12) + "verim 120 sn");
  const s = {};
  for (const is of IS) {
    const k = (s[is.ad] = kosum(is));
    console.log(is.ad.padEnd(32) + String(k.saat).padEnd(12) + String(k.kesinti).padEnd(10) +
      (k.sifir / 60).toFixed(1).padEnd(17) + (k.yuz / 60).toFixed(1).padEnd(19) +
      (k.yeniden / 60).toFixed(1).padEnd(12) +
      `%${(100 * k.verimSifir).toFixed(1)}`.padEnd(12) + `%${(100 * k.verimYuz).toFixed(1)}`);
  }
  const uzun = IS.find((x) => x.ad === "uzun suren tek kosum");
  const t = tekKosum(uzun);
  console.log(`\nara kaydi olmayan ${uzun.saat} saatlik kosum: ${t.deneme} deneme, ` +
    `${t.biten} tamamlanma; kalici kapasitede ${t.kalici} tamamlanma`);
  console.log(`bosa giden kosum saati: ${t.bosa}; tamamlanma orani ` +
    `%${(100 * t.biten / t.kalici).toFixed(0)}`);
  const srv = s["kullaniciya yanit veren servis"], kuy = s["kuyruk iscisi"];
  console.log(`0 sn bildirimde: servis ${srv.kesinti * 24} istek dusuruyor, ` +
    `kuyruk ${kuy.kesinti} gorevi kuyruga geri koyuyor`);
}

30 gun, kesinti orani 0.06/ornek-saat, tohum 20260901

is turu                         ornek-saat  kesinti   kayip sa (0 sn)  kayip sa (120 sn)  yeniden sa  verim 0 sn  verim 120 sn
gecelik toplu is                2160        137       34.3             0.0                9.1         %98.0       %99.6
kuyruk iscisi                   14400       964       12.1             0.0                48.2        %99.6       %99.7
uzun suren tek kosum            2400        164       1640.0           1640.0             16.4        %59.2       %59.2
kullaniciya yanit veren servis  21600       1450      1.9              0.0                48.3        %99.8       %99.8

ara kaydi olmayan 20 saatlik kosum: 66 deneme, 15 tamamlanma; kalici kapasitede 36 tamamlanma
bosa giden kosum saati: 415; tamamlanma orani %42
0 sn bildirimde: servis 34800 istek dusuruyor, kuyruk 964 gorevi kuyruga geri koyuyor

Bildirimin değeri iş türüne göre başka bir yerde birikir. Gecelik toplu işte 120 saniyelik bildirim ayda 34,3 iş-saatini kurtarır — bir ayın toplam işinin yüzde 1,6’sı. Servis satırında kurtarılan iş yalnız 1,9 saattir, ama o 1,9 saatin içinde 34.800 istek vardır ve her biri bir kullanıcının beklediği bir yanıttır. Aynı ölçü birimi iki iş türünde farklı şey ifade eder: toplu işte kaybedilen şey zaman, serviste kaybedilen şey kullanıcıdır.

Yeniden başlama sütunu bildirimle hiç kurtulamayan bedeldir. Servis ayda 1450 kesinti alır ve her biri iki dakikalık bir açılış ister; toplamı 48,3 saattir — kurtarılan 1,9 saatin yirmi beş katı. Kesintili kapasitede açılış süresi bir kereye mahsus değildir; önceki dersin 48,9 saniyesi burada ayda 1450 kez ödenen bir kalemdir.

Üçüncü satır iki kere okunmalıdır. Kaba hesap, ortalama kaybı koşumun yarısı sayar ve verimi yüzde 59,2 bulur. Deneme deneme koşturulduğunda gerçek yüzde 42 çıkar: 66 denemenin yalnız 15’i tamamlanır, 415 koşum saati boşa gider ve kalıcı kapasitede ayda 36 kez biten iş kesintilide 15 kez biter. Ortalama kayıp varsayımı burada yanıltır, çünkü kayıp koşumun yarısı değil, kesintiye kadar geçen sürenin tamamıdır ve uzun koşumda bu süre beklenenden büyüktür.

Bedel ve Karışım

Kayıp sayıldıktan sonra fiyat farkı anlamlı hale gelir. Kesintili kapasite ucuzdur ama kaybedilen iş yeniden yapılır; yeniden yapılan iş de saat tutar. Karşılaştırma bu yüzden birim fiyat üzerinden değil, aynı işi bitirmek için tutulan saat üzerinden yapılır.

// olcum-agi/kapasite-bedeli.mjs — kalici ile kesintili kapasitenin is turu basina bedeli (model)
import { IS } from "./is-turleri.mjs";
import { kosum, tekKosum } from "./kesinti-donemi.mjs";

const KALICI = 1.0, KESINTILI = 0.32;    // M23/K01'den girdi: kurgu birim, gercek fiyat degil
const KARISIM = [1.0, 0.7, 0.5, 0.3];    // kalici payi taramasi

// Uretec sirasi onceki kosumla ayni tutulur: once dort is, sonra tek kosum denemesi.
const K = IS.map(kosum), T = tekKosum(IS[2]);

if (import.meta.url === `file://${process.argv[1]}`) {
  console.log(`kalici ${KALICI.toFixed(2)} birim/ornek-saat, kesintili ${KESINTILI} birim ` +
    `(kurgu; basabas verim %${(100 * KESINTILI / KALICI).toFixed(0)})\n`);
  console.log("is turu".padEnd(32) + "verim".padEnd(9) + "kalici birim".padEnd(14) +
    "kesintili birim".padEnd(17) + "tasarruf".padEnd(11) + "sure carpani");
  IS.forEach((is, i) => {
    const k = K[i], verim = i === 2 ? T.biten / T.kalici : k.verimYuz;
    const kalici = k.saat * KALICI, kesintili = (k.saat / verim) * KESINTILI;
    console.log(is.ad.padEnd(32) + `%${(100 * verim).toFixed(1)}`.padEnd(9) +
      kalici.toFixed(0).padEnd(14) + kesintili.toFixed(0).padEnd(17) +
      `%${(100 * (1 - kesintili / kalici)).toFixed(0)}`.padEnd(11) + (1 / verim).toFixed(2));
  });
  const srv = IS[3], s = K[3];
  console.log("\nservis icin kalici/kesintili karisimi (30 ornek, ayni kapasite):");
  console.log("kalici pay".padEnd(13) + "kalici ornek".padEnd(14) + "kesintili ornek".padEnd(17) +
    "aylik birim".padEnd(13) + "bir anda kaybedilebilir");
  for (const p of KARISIM) {
    const kal = Math.round(srv.ornek * p), kes = srv.ornek - kal;
    const birim = (kal * KALICI + (kes / s.verimYuz) * KESINTILI) * srv.saat * 30;
    console.log(`%${(100 * p).toFixed(0)}`.padEnd(13) + String(kal).padEnd(14) +
      String(kes).padEnd(17) + birim.toFixed(0).padEnd(13) +
      `%${(100 * kes / srv.ornek).toFixed(0)} kapasite`);
  }
  const ELDE = ["is turunun kesintili kapasiteye konmasi", "ara kayit sikligi",
    "bildirim penceresinde yapilacak is", "kalici/kesintili karisim orani", "yeniden deneme politikasi"];
  const DEVIR = ["kesinti ani", "bildirim suresi", "ayni anda geri alinan ornek sayisi",
    "kapasitenin geri gelme zamani"];
  const GERI_YOK = ["kesilen ornegin yerel diskindeki kaydedilmemis is",
    "bildirim penceresinde yarim kalan dis yazma", "kosum baslayinca ara kayit eklenememesi"];
  console.log(`\nkarar defteri: ${ELDE.length} kalem elde, ${DEVIR.length} kalem saglayicida`);
  console.log(`  saglayicida: ${DEVIR.join(", ")}`);
  for (const g of GERI_YOK) console.log(`  geri alinamaz — ${g}`);
}

kalici 1.00 birim/ornek-saat, kesintili 0.32 birim (kurgu; basabas verim %32)

is turu                         verim    kalici birim  kesintili birim  tasarruf   sure carpani
gecelik toplu is                %99.6    2160          694              %68        1.00
kuyruk iscisi                   %99.7    14400         4623             %68        1.00
uzun suren tek kosum            %41.7    2400          1843             %23        2.40
kullaniciya yanit veren servis  %99.8    21600         6927             %68        1.00

servis icin kalici/kesintili karisimi (30 ornek, ayni kapasite):
kalici pay   kalici ornek  kesintili ornek  aylik birim  bir anda kaybedilebilir
%100         30            0                21600        %0 kapasite
%70          21            9                17198        %30 kapasite
%50          15            15               14264        %50 kapasite
%30          9             21               11329        %70 kapasite

karar defteri: 5 kalem elde, 4 kalem saglayicida
  saglayicida: kesinti ani, bildirim suresi, ayni anda geri alinan ornek sayisi, kapasitenin geri gelme zamani
  geri alinamaz — kesilen ornegin yerel diskindeki kaydedilmemis is
  geri alinamaz — bildirim penceresinde yarim kalan dis yazma
  geri alinamaz — kosum baslayinca ara kayit eklenememesi

Tasarruf sütunu üç iş türünde aynıdır — yüzde 68 — ve bu, verimin yüzde 99’un üstünde kaldığı her işin indirimin tamamını aldığı anlamına gelir. Uzun koşumda tasarruf yüzde 23’e iner. Dikkat çeken şey tasarrufun hâlâ artı olmasıdır: başabaş verim yüzde 32’dir ve koşumun verimi yüzde 41,7, yani eşiğin üstündedir. Kesintili kapasite bu iş için de kâğıt üzerinde ucuzdur.

Kararı ucuzluk vermez, son sütun verir. Süre çarpanı 2,40’tır: aynı koşum kesintili kapasitede iki buçuk kat uzun sürer ve ayda 36 yerine 15 kez biter. Gecelik bir rapor iki gün gecikiyorsa ödenen şey birim değil, sonucun geç gelmesidir ve o bedel bu tabloda hiç görünmez. Ucuzluk ölçülebilir, gecikmenin değeri işe göre değişir — kesintili kapasitenin gerçek sınırı buradadır.

Karışım tablosu servisin ara yolunu sayar. Kapasitenin yüzde 30’u kesintiliye çevrilince aylık bedel 21.600’den 17.198 birime iner ve bir anda kaybedilebilecek kapasite yüzde 30’a çıkar; yüzde 70’i çevrilince bedel 11.329’a iner ama kapasitenin yüzde 70’i tek bir kararla geri alınabilir hale gelir. Kalıcı pay, kesinti anında ayakta kalması gereken en küçük kapasitedir.

Karar defterinde dokuz kalemin beşi elde, dördü sağlayıcıdadır — ve devredilen dördü bu kursta şimdiye kadarki en ağır devirdir, çünkü içlerinde kesintinin anı vardır. Geri alınamayan üç kalem de bu devirden doğar: kesilen örneğin yerel diskindeki kaydedilmemiş iş geri gelmez, bildirim penceresinde yarım kalan bir dış yazma geri alınmaz, ve koşum başladıktan sonra ara kayıt eklenemez. Üçüncüsü en sinsisidir: kesintili kapasiteye geçiş kararı geri alınabilir, ama o anda koşan işin kesintiye dayanıp dayanmadığı koşum sırasında değiştirilemez.

Özet

• Bildirim penceresi ancak kurtarma süresinden uzunsa işe yarar: servis 20, toplu iş 45, kuyruk işçisi 90 saniyede kurtulur; ara kaydı olmayan 20 saatlik koşum 660 saniye ister ve taramanın hiçbir değerinde kaybı sıfırlanmaz.
• Kesintiye hiç dayanmayan iş uzun suren tek kosum’dur; çözümü daha uzun bildirim değil, işin bölünmesidir — bu da kapasite değil uygulama kararıdır.
• Aynı ölçü birimi farklı şey anlatır: 120 saniyelik bildirim toplu işte ayda 34,3 iş-saati, serviste 1,9 saat kurtarır — ama o 1,9 saat 34.800 istektir.
• Yeniden başlama bildirimle kurtulmayan bedeldir: servis ayda 1450 kesinti alır ve 48,3 saat açılışa gider, kurtarılan sürenin yirmi beş katı.
• Ortalama kayıp varsayımı uzun koşumda yanıltır: kaba hesap yüzde 59,2 verim der, deneme deneme koşumda yüzde 42 çıkar — 66 denemenin 15’i tamamlanır, 415 saat boşa gider.
• Dokuz kalemin beşi elde, dördü sağlayıcıdadır; kesintili kapasite üç iş türünde yüzde 68 tasarruf verir, uzun koşumda yüzde 23 verir ama süreyi 2,40 katına çıkarır.

Sonraki Adım

Bu üç ders bir örneğin bütün kararlarını saydı: ailesi, boyutu, imajı, açılışta yaptığı iş, kalıcı mı kesintili mi olduğu. Sayılan her kalem tek bir örnek için verilmiş bir karardır — ve kesintili kapasite bölümü bu kararların sık sık yeniden verildiğini gösterdi: ayda 1450 örnek açılıyor.

O 1450 örneğin her birinde aynı aile, aynı boyut, aynı imaj, aynı alt ağ ve aynı başlangıç betiği seçilmek zorundadır. Elle başlatılan bir örnekte bu seçimlerin her biri ayrı bir yazma işlemidir ve her yazma bir sapma fırsatıdır. Sonraki ders bu kalemleri tek bir tanıma toplar ve sorar: elle başlatılan örneklerle şablondan başlatılanlar bir dönem sonunda kaç kalemde birbirinden ayrışıyor, şablon güncellenince kaç örnek geride kalıyor ve şablonun kendisi kaç girdilik bir yüzey açıyor?