---
title: 'Tahliye ve Öncelikler'
source: 'https://academia.sh/tr/kurslar/orkestrasyon/tahliye-ve-oncelikler'
course: 'Konteyner Orkestrasyonu'
language: tr
updated: '2026-08-17T18:09:09+00:00'
license: 'CC BY-SA 4.0'
---

# Tahliye ve Öncelikler

Kaynak baskısında davranışın modellenmesi: bellek baskısı altında tahliye sırasının isteğin altında, üstünde ve isteksiz kapsüller için hesaplanması, üç sıralama kuralının farklı kapsülleri çıkarması, öncelik sınıfı eklendiğinde yer açmanın kaç kapsülü etkilediği ve zincirin kaç kez uzadığı, sistemin görmediği kalem yüzünden yanlış kapsülü tahliye etmesi.

Buraya kadarki bütün kararlar yerleştirme anında veriliyordu: kapsül bir düğüme düşüyor ve orada
kalıyordu. Kaynak baskısı ise yerleştirmeden sonra doğar ve kararı veren artık zamanlayıcı değildir.
Düğümün belleği dolduğunda bir şey çıkarılmak zorundadır, çıkarma kararını düğüm verir ve kararın
girdisi ilk dersteki iki sayıdır: bildirilen istek ve ölçülen kullanım.

Devredilen karar burada ilk kez **geri alınamaz** bir karardır. Yanlış yerleştirilen kapsül
yerleşemez ve beklemeye devam eder; yanlış tahliye edilen kapsül çalışırken durdurulur. Bu ders iki
şeyi ölçer: baskı altında hangi kapsülün çıkarıldığı, ve öncelik sınıfı eklendiğinde yüksek
öncelikli bir kapsüle yer açmanın kaç kapsülü etkilediği. Ölçülen şey bir modeldir; iş yükü bölgesel
ölçüm ağının (kurgu) servisleridir.

## Baskı Zamanlayıcının Defterinde Görünmüyor

Modelde iki düğüm ve on yedi kapsül var. Gecelik toplu işin iki kapsülü hiç istek bildirmiyor ve
1.400 MiB kullanıyor; faturalama ve okuma toplayıcı isteğinin biraz üstünde, doğrulayıcı altında
çalışıyor. Tahliye üç ayrı sıralama kuralıyla denenir.

```js
// zamanlama/tahliye.mjs — bellek baskisinda tahliye sirasi. Kurulan sey bir MODELDIR.
// Dugum kimi cikaracagina karar verirken yalniz bildirilen istegi ve olculen kullanimi gorur.
export const BELLEK = 4096, DUGUM_SAYISI = 2;
export const ESIK = 0.9;            // ZO19: doluluk %90'i asinca bellek baskisi baslar
const TOHUM = 20260803;

// ad, adet, istek, gercek/taban carpani, bildirilen oncelik, gercek kritiklik (sistem gormez)
export const SERVIS = [
  ["faturalama", 3, 512, 1.15, 900, 1], ["dogrulayici", 4, 704, 0.90, 700, 2],
  ["okuma-toplayici", 6, 384, 1.10, 500, 2], ["gecelik-toplu", 2, 0, 0, 100, 3],
  ["arsiv-tarama", 2, 256, 1.00, 200, 3],   // ZO21: dusuk oncelikli, istegi bildirilmis servis
];
export const TOPLU_GERCEK = 1400;   // ZO20: istek bildirmeyen toplu is kapsulu 1400 MiB kullanir

export function isYuku(faturaIstek = 512) {
  let s = TOHUM % 2147483647;
  const r = () => (s = (s * 48271) % 2147483647) / 2147483647;
  return SERVIS.flatMap(([ad, n, istek, kat, onc, krit]) =>
    Array.from({ length: n }, (_, i) => {
      const it = ad === "faturalama" ? faturaIstek : istek;
      const g = kat === 0 ? TOPLU_GERCEK : Math.round(istek * kat * (0.95 + 0.1 * r()));
      return { ad: `${ad}-${i + 1}`, servis: ad, istek: it, gercek: g, oncelik: onc, kritik: krit };
    }));
}

export const yerlestir = (kapsuller, n = DUGUM_SAYISI) => {
  const d = Array.from({ length: n }, (_, i) => ({ ad: `d${i}`, istek: 0, kapsul: [] }));
  for (const k of kapsuller) {
    const x = d.find((y) => y.istek + k.istek <= BELLEK);
    if (x !== undefined) { x.istek += k.istek; x.kapsul.push(k); }
  }
  return d;
};

export const kullanim = (d) => d.kapsul.reduce((t, k) => t + k.gercek, 0);

// Uc siralama kurali. Ilk sirada olan once cikarilir.
export const KURAL = {
  "en cok kullanan": (a, b) => b.gercek - a.gercek,
  "istek farki": (a, b) => (b.gercek - b.istek) - (a.gercek - a.istek),
  "oncelik + istek farki": (a, b) =>
    a.oncelik - b.oncelik || (b.gercek - b.istek) - (a.gercek - a.istek),
};

export function tahliyeEt(dugum, sirala) {
  const hedef = BELLEK * ESIK, cikan = [];
  const sira = [...dugum.kapsul].sort(sirala);
  while (kullanim(dugum) > hedef && sira.length > 0) {
    const k = sira.shift();
    dugum.kapsul = dugum.kapsul.filter((x) => x !== k);
    cikan.push(k);
  }
  return cikan;
}

if (process.argv[1].endsWith("tahliye.mjs")) {
  const d = yerlestir(isYuku());
  console.log(`model: ${DUGUM_SAYISI} dugum x ${BELLEK} MiB, ${isYuku().length} kapsul ` +
    `(tohum ${TOHUM}); baski esigi ${BELLEK * ESIK} MiB`);
  d.forEach((x) => console.log(`  ${x.ad}: ${x.kapsul.length} kapsul, istek ${x.istek} MiB, ` +
    `gercek ${kullanim(x)} MiB, doluluk %${((kullanim(x) / BELLEK) * 100).toFixed(1)}`));
  const s = (x, n = 15) => String(x).padStart(n);
  console.log(`\nd0 uzerinde tahliye sirasi (${(BELLEK * ESIK).toFixed(0)} MiB'ye inene kadar):`);
  console.log(`${"kural".padEnd(34)}${s("tahliye")}${s("kazanilan MiB")}${s("kritik kayip")}` +
    `${s("kalan doluluk")}`);
  for (const [ad, sirala] of Object.entries(KURAL)) {
    const x = yerlestir(isYuku())[0];
    const c = tahliyeEt(x, sirala);
    console.log(`${ad.padEnd(34)}${s(c.length)}${s(c.reduce((t, k) => t + k.gercek, 0))}` +
      `${s(c.filter((k) => k.kritik === 1).length)}` +
      `${s("%" + ((kullanim(x) / BELLEK) * 100).toFixed(1))}`);
  }
  const x = yerlestir(isYuku(640))[0];
  const c = tahliyeEt(x, KURAL["istek farki"]);
  console.log(`${"istek farki, fatura istegi 640".padEnd(34)}${s(c.length)}` +
    `${s(c.reduce((t, k) => t + k.gercek, 0))}${s(c.filter((k) => k.kritik === 1).length)}` +
    `${s("%" + ((kullanim(x) / BELLEK) * 100).toFixed(1))}`);
  console.log(`\ncikarilan kapsuller (kural: istek farki): ` +
    yerlestir(isYuku()).slice(0, 1).flatMap((y) => tahliyeEt(y, KURAL["istek farki"]))
      .map((k) => `${k.ad}(${k.gercek}/${k.istek})`).join(", "));
}
```

```
model: 2 dugum x 4096 MiB, 17 kapsul (tohum 20260803); baski esigi 3686.4 MiB
  d0: 9 kapsul, istek 4032 MiB, gercek 6898 MiB, doluluk %168.4
  d1: 8 kapsul, istek 3136 MiB, gercek 3266 MiB, doluluk %79.7

d0 uzerinde tahliye sirasi (3686 MiB'ye inene kadar):
kural                                     tahliye  kazanilan MiB   kritik kayip  kalan doluluk
en cok kullanan                                 3           3452              0          %84.1
istek farki                                     3           3401              1          %85.4
oncelik + istek farki                           3           3224              0          %89.7
istek farki, fatura istegi 640                  2           2800              0          %89.7

cikarilan kapsuller (kural: istek farki): gecelik-toplu-1(1400/0), gecelik-toplu-2(1400/0), faturalama-2(601/512)
```

## Üç Sıralama Kuralı, Üç Ayrı Kurban

İlk iki satır kararın neden düğüme kaldığını gösteriyor. Zamanlayıcının defterinde d0 dolu ve
tutarlıdır: 4.096 MiB'nin 4.032'si dağıtılmıştır, kalan 64 MiB için başka kapsül alınmaz. Gerçek
kullanım ise 6.898 MiB, yani **yüzde 168,4**. Aradaki bütün fark istek bildirmeyen iki kapsülden
gelir. Defter doğruyken düğüm baskı altındadır ve defteri tutan bileşenin bundan haberi yoktur.

Üç kural üç ayrı kapsülü çıkarıyor. **En çok kullanan** kuralı iki toplu iş kapsülünü ve bir
doğrulayıcıyı alıyor; 3.452 MiB kazanıyor, kritik bir kapsül kaybetmiyor. **İstek farkı** kuralı —
kullanımın isteği ne kadar aştığına bakan kural — iki toplu iş kapsülünden sonra faturalamayı
çıkarıyor. Son satırdaki dökümde nedeni görünür: faturalama 512 MiB bildirip 601 kullandığı için
aşımı 89 MiB, okuma toplayıcı 384 bildirip 422 kullandığı için aşımı 38 MiB. Kural, **daha dürüst
bildirimde bulunanı** değil, isteğine daha yakın bildirim yapanı korur.

**Öncelik sınıfı** eklendiğinde kural düzeliyor: kapsül başına bir bildirim kalemi daha (on yedi
kalem) eklenmiş oluyor ve kritik kayıp birden sıfıra iniyor. Kazanılan bellek 3.401 yerine 3.224
MiB, yani daha az; buna karşılık çıkarılanlar en düşük öncelikli kapsüller.

Dördüncü satır bu bilginin bir **beyan** olmasının bedelini veriyor. Faturalamanın isteği 512 yerine
640 yazılsaydı — hiçbir şey değişmeden, yalnız bildirim büyütülerek — kapsül isteğinin altında
görünür ve tahliye sırasında son sıraya düşerdi: iki tahliye, kritik kayıp sıfır. İsteği şişirmek
ilk derste kapasite israfıydı; burada bir **korunma** aracıdır ve sistem ikisini birbirinden ayırt
edemez.

## Yer Açma ve Zincir

Baskı tek yönlü değildir. Yüksek öncelikli bir kapsül geldiğinde ve hiçbir düğümde yer kalmadığında
sistem kendi eliyle yer açar: daha düşük öncelikli kapsülleri çıkarır. Çıkarılan kapsül kaybolmaz,
kuyruğa geri döner ve kendisinden düşük öncelikli birini çıkarabilir. Zincir böyle uzar.

```js
// zamanlama/yer-acma.mjs — yuksek oncelikli kapsul icin dusuk oncelikliyi cikarma ve zincir.
import { BELLEK, isYuku, yerlestir } from "./tahliye.mjs";

// ZO22: gece yarisi gelen acil faturalama kapsulleri: oncelik 1000, istek 700 MiB
const ACIL = (n) => Array.from({ length: n }, (_, i) =>
  ({ ad: `acil-fatura-${i + 1}`, servis: "acil-fatura", istek: 700, gercek: 700,
     oncelik: 1000, kritik: 1, derinlik: 0 }));
const TUR_SINIRI = 60;                 // ZO23: zincir bu tur sayisinda kesilir

// ZO24: iki dugum secim kurali — en az kapsul cikaran dugum, ya da ilk uyan dugum.
function yerAc(gelenler, kural) {
  const d = yerlestir(isYuku());
  const kuyruk = [...gelenler];
  let tahliye = 0, zincir = 0, derin = 0, tur = 0;
  const yerlesemeyen = [];
  while (kuyruk.length > 0 && tur++ < TUR_SINIRI) {
    const k = kuyruk.shift();
    const bos = (x) => BELLEK - x.istek;
    const dogrudan = d.find((x) => bos(x) >= k.istek);
    if (dogrudan !== undefined) {
      dogrudan.istek += k.istek; dogrudan.kapsul.push(k); continue;
    }
    // Her dugum icin: kac kapsul cikarilirsa yer acilir. Yalniz DUSUK oncelikli cikarilabilir.
    const planlar = d.map((x) => {
      const aday = x.kapsul.filter((p) => p.oncelik < k.oncelik)
        .sort((a, b) => a.oncelik - b.oncelik || a.istek - b.istek);
      let acilan = bos(x); const cikan = [];
      for (const p of aday) { if (acilan >= k.istek) break; acilan += p.istek; cikan.push(p); }
      return { x, cikan, olur: acilan >= k.istek };
    }).filter((p) => p.olur);
    if (planlar.length === 0) { yerlesemeyen.push(k); continue; }
    const p = kural === "en az cikaran"
      ? planlar.reduce((a, b) => (b.cikan.length < a.cikan.length ? b : a))
      : planlar[0];
    for (const c of p.cikan) {
      p.x.kapsul = p.x.kapsul.filter((y) => y !== c);
      p.x.istek -= c.istek; tahliye++;
      if (k.derinlik > 0) zincir++;
      c.derinlik = (k.derinlik ?? 0) + 1;
      derin = Math.max(derin, c.derinlik);
      kuyruk.push(c);
    }
    p.x.istek += k.istek; p.x.kapsul.push(k);
  }
  const yerlesen = gelenler.filter((g) => d.some((x) => x.kapsul.includes(g))).length;
  return { tahliye, zincir, derin, yerlesemeyen: yerlesemeyen.length, yerlesen, tur: tur - 1 };
}

const s = (x, n = 14) => String(x).padStart(n);
console.log("yer acma: acil kapsul sayisi taraniyor (bos istek d0 64 MiB, d1 960 MiB)");
console.log(`${"kural".padEnd(16)}${"acil".padEnd(6)}${s("acil yerlesen")}${s("tahliye")}` +
  `${s("zincirleme")}${s("en derin")}${s("yerlesemeyen")}`);
for (const kural of ["en az cikaran", "ilk uyan"])
  for (const n of [1, 2, 3, 4, 5]) {
    const o = yerAc(ACIL(n), kural);
    console.log(`${kural.padEnd(16)}${String(n).padEnd(6)}${s(o.yerlesen)}${s(o.tahliye)}` +
      `${s(o.zincir)}${s(o.derin)}${s(o.yerlesemeyen)}`);
  }

// Sistemin gormedigi kalem: gercek kritiklik. Cikarilan kapsullerin kritiklik dagilimi.
const o = yerAc(ACIL(3), "ilk uyan");
console.log(`\nuc acil kapsul icin 'ilk uyan' kurali: ${o.tahliye} tahliye, ${o.zincir} zincirleme, ` +
  `${o.yerlesemeyen} kapsul acikta; 'en az cikaran' kuralinda ` +
  `${yerAc(ACIL(3), "en az cikaran").tahliye} tahliye`);
console.log(`bildirilen oncelik kalemi: 17 kapsul + gelen acil kapsuller; olculen kritiklik kalemi: 0`);
```

```
yer acma: acil kapsul sayisi taraniyor (bos istek d0 64 MiB, d1 960 MiB)
kural           acil   acil yerlesen       tahliye    zincirleme      en derin  yerlesemeyen
en az cikaran   1                  1             0             0             0             0
en az cikaran   2                  2             2             0             1             2
en az cikaran   3                  3             4             0             1             4
en az cikaran   4                  4             6             0             1             6
en az cikaran   5                  5            10             2             2             7
ilk uyan        1                  1             0             0             0             0
ilk uyan        2                  2             6             2             2             2
ilk uyan        3                  3             9             4             2             4
ilk uyan        4                  4            12             6             2             6
ilk uyan        5                  5            15             8             2             7

uc acil kapsul icin 'ilk uyan' kurali: 9 tahliye, 4 zincirleme, 4 kapsul acikta; 'en az cikaran' kuralinda 4 tahliye
bildirilen oncelik kalemi: 17 kapsul + gelen acil kapsuller; olculen kritiklik kalemi: 0
```

## Aynı Sonuç, Üç Katı Sarsıntı

Tek acil kapsül hiçbir şeyi tahliye etmiyor; boş istek yetiyor. İkinci kapsülden itibaren yer açma
başlıyor ve iki düğüm seçim kuralı aynı sonucu çok farklı bedelle veriyor. **En az çıkaran** kuralı
iki acil kapsül için iki tahliye yapıyor; **ilk uyan** kuralı aynı iki kapsül için altı tahliye
yapıyor ve bunların ikisi zincirlemedir. Beş acil kapsülde fark on tahliyeye karşı on beş tahliyedir
ve iki kuralda da açıkta kalan kapsül sayısı yedidir. **Sonuç aynı, sarsıntı üç katı.** Düğüm seçimi
bir yerleştirme ayrıntısı gibi görünür ve doğrudan yeniden başlatılan kapsül sayısını belirler.

Zincirleme sütunu devrin ikinci bedelini gösteriyor: çıkarılan kapsül kuyruğa döndüğünde kendisi de
bir çıkarma başlatıyor ve zincir en fazla iki derinliğe iniyor. Derinliğin ikide kalması bir tasarım
başarısı değil, bir kaza sonucudur. Merdivende altı ayrı öncelik değeri vardır ve her basamak yalnız
kendisinden düşük basamakları çıkarabilir; zincir ikinci adımda kesiliyor, çünkü merdivenin en alt
basamağındaki kapsüller istek bildirmemiştir ve onları çıkarmak defterde hiç yer açmaz. Aynı model
en alttaki kapsüllere gerçekçi bir istek yazılsaydı zincir bir adım daha uzardı — yani zincirin
uzunluğunu belirleyen şey öncelik tasarımı kadar bildirimin kendisidir.

Üçüncü ve en sessiz sonuç, açıkta kalan kapsüllerdir. Beş acil kapsül yerleşirken yedi kapsül
düğümsüz kalıyor ve bunlar hiçbir yere geri dönmüyor, çünkü kendilerinden düşük öncelikli
çıkarılabilir kapsül kalmamıştır. Gecelik toplu işin kapsülleri bu tabloda hiç yer açmaz: istek
bildirmedikleri için onları çıkarmak defterde **sıfır MiB** boşaltır. Gerçekte 1.400 MiB serbest
kalır, ama yer açma kararı isteğe bakar, kullanıma değil.

Kararın dayandığı bilgi on yedi kapsülün öncelik bildirimi ve gelen kapsüllerin öncelikleridir.
Ölçülen kritiklik kalemi sıfırdır. Sistem faturalamayı, önemsiz olduğunu düşündüğü için değil,
**önemi hakkında hiçbir kalemi bulunmadığı** için çıkarır; öncelik sınıfı bu boşluğu kapatan bir
beyandır ve beyanın doğruluğunu sınayan bir ölçüm yoktur. Bütün kapsüllere en yüksek öncelik
yazıldığında sıralama tamamen kaybolur ve sistem yine istek farkına döner.

## Özet

- Bellek baskısı zamanlayıcının defterinde görünmez: d0'ın defteri 4.096 MiB'nin 4.032'sini dağıtmış
  ve tutarlıdır, gerçek kullanım yüzde 168,4'tür ve fark istek bildirmeyen iki kapsülden gelir.
- Üç sıralama kuralı üç ayrı kapsülü çıkarıyor: en çok kullanan kuralı 3.452 MiB kazanıp kritik
  kapsül kaybetmiyor, istek farkı kuralı 3.401 MiB kazanıp bir kritik kapsül çıkarıyor, öncelik
  eklenince kritik kayıp sıfıra iniyor.
- İstek farkı kuralı isteğini şişireni ödüllendirir: faturalamanın bildirimi 512 yerine 640 olsaydı
  tahliye sayısı üçten ikiye, kritik kayıp birden sıfıra inerdi ve hiçbir şey gerçekte değişmezdi.
- Yer açmada düğüm seçim kuralı sonucu değil bedeli belirliyor: iki acil kapsül için en az çıkaran
  kuralı iki, ilk uyan kuralı altı tahliye yapıyor; beş kapsülde on ve on beş, açıkta kalan sayısı
  ikisinde de yedi.
- Zincirleme iki derinliğe kadar iniyor ve öncelik merdiveninin basamak sayısıyla sınırlı; istek
  bildirmeyen kapsülleri çıkarmak defterde sıfır MiB açtığı için yer açmada hiç kullanılmıyorlar.
- Karar on yedi öncelik bildirimine dayanıyor, ölçülen kritiklik kalemi sıfır; yanlış tahliyenin
  kaynağı kuralın kötülüğü değil, iş değerini taşıyan tek bir ölçümün bulunmamasıdır.

## Sonraki Adım

Bu iki ders kümenin sabit kapasitesini paylaştırıyor: kim nereye girer, sıkışınca kim çıkar. Üçüncü
bir seçenek hiç sorulmadı — kopya sayısını değiştirmek. Bölgesel ölçüm ağının okuma toplayıcısı gün
içinde dalgalanan bir yük görür ve kopya sayısı sabit kaldığı sürece bu dalganın bedeli ya boş
kapasite ya da kuyruk olur. Bu kararı da bir denetleyiciye devretmek mümkündür: bir ölçüt izlenir,
hedefle karşılaştırılır, kopya sayısı ayarlanır. Sonraki ders o denetleyiciyi yazar ve ölçütün
gecikmesi arttıkça salınımın nasıl büyüdüğünü sayar.
