---
title: 'Alt Ağlar'
source: 'https://academia.sh/tr/kurslar/bulut-hesaplama-ve-ag/alt-aglar'
course: 'Bulutta Hesaplama ve Ağ'
language: tr
updated: '2026-08-17T18:06:57+00:00'
license: 'CC BY-SA 4.0'
---

# Alt Ağlar

Aynı blok iki eksende bölünür ve her düzende kullanılabilir adres, ayrılan pay, atanmamış artık ve bir alanın kaybındaki örnek sayısı sayılır; genel ve özel alt ağ ayrımının dışarıdan erişilebilir kalemi kaça indirdiği ve karşılığında kaç ek bileşenle kaç yönlendirme tablosu istediği kalem kalem çıkarılır.

Blok seçildi ve içinde sekizinci dönem için altı yüz yetmiş sekiz adreslik bir talep var. Blok
şimdilik tek parça: dört bin doksan altı adres yan yana duruyor ve hiçbiri bir örneğe
verilemiyor. Adres bir alt ağdan dağıtılır, alt ağ bir alana bağlıdır ve alt ağ sınırı çizildikten
sonra o sınır da yerinde kalır.

Bölme kararı iki ekseni birden taşıyor. Birincisi alt ağın boyu: az sayıda büyük parça mı, çok
sayıda küçük parça mı. İkincisi alanlara dağılım: aynı blok kaç alana yayılsın. İkisi de aynı adres
sayısını harcıyor ve bambaşka iki sonuç üretiyor. Üçüncü bir soru bunların üstüne biniyor: her
parça dışarıdan doğrudan erişilebilir olmalı mı.

- **BA7.** Bölme düzenleri ve talep dağılımı kurgusal bölgesel ölçüm ağına aittir. Gerçek bir ağ
  bölünmüyor; ölçülen şey `node` ile kurulan modeldir. Adres aritmetiği gerçektir.
- **BA8.** Önceki dersin `/20` bloğu ve alt ağ başına beş ayrılan adres varsayımı sürüyor.
- **BA9.** Katman payları yüzde olarak elle yazıldı: genel 8, uygulama 62, veri 30. Gerçekte pay
  iş yüküne göre değişir; en yoğun alt ağın hangisi olduğunu kaydırır, tarama mantığını
  değiştirmez.
- **BA10.** Bölme tekdüze varsayıldı: bütün alt ağlar aynı boyda. Gerçekte karışık boy kullanılır;
  atanmamış artığı azaltır, dilim yuvarlaması cezasını kaldırmaz.
- **BA11.** Her örnekte dört kapı dinlediği varsayıldı. Makine düzeyinde bu sayı ayrıca ölçüldü;
  burada yalnız çarpan olarak kullanılıyor.
- **BA12.** Bir alanın kaybı tam kayıp sayıldı. Gerçekte kısmi bozulma daha sıktır; kayıp örnek
  sayısını düşürür, alan sayısıyla ilişkisini değiştirmez.

## Bölme Düzeni Modeli

Model tek bir şeyi ciddiye alıyor: bir bloğu tekdüze bölmek için parça sayısının ikinin kuvveti
olması gerekir. On iki alt ağ isteyen bir düzen on altı dilime bölünür ve dördü atanmadan kalır.
`dilim` işlevi bu yuvarlamayı yapıyor, geri kalan her sayı ondan türüyor.

```js
// bolme.mjs — /20 blogun alt aglara bolunmesi; gercek ag kurulmuyor, aritmetik gercek
export const BLOK = 4096;          // onceki derste secilen /20
export const AYRILAN = 5;          // saglayici her alt agda bes adres ayirir (BA8)
export const ORNEK = 612;          // donem-8 talebi
// Katman paylari yuzde olarak; toplami 100 (BA9)
export const KATMAN = [['genel', 8], ['uygulama', 62], ['veri', 30]];

export const onek = (boyut) => 32 - Math.log2(boyut);
export const dilim = (n) => 2 ** Math.ceil(Math.log2(n));   // duzen ikinin kuvvetine yuvarlanir
export const boyut = (n) => BLOK / dilim(n);
export const kullanilabilir = (n) => boyut(n) - AYRILAN;
// Bir alandaki en kalabalik katmanin ornek sayisi
export const yogun = (alan) => Math.max(...KATMAN.map(([, p]) => Math.ceil(ORNEK * p / 100 / alan)));

export const duzen = (alan, katman = KATMAN.length) => {
  const n = alan * katman, k = kullanilabilir(n);
  const normal = yogun(alan), ariza = alan > 1 ? yogun(alan - 1) : normal;
  return { alan, katman, n, dilim: dilim(n), boyut: boyut(n), kullanilabilir: k,
    toplam: n * k, ayrilan: AYRILAN * n, atanmamis: BLOK - n * boyut(n),
    normal, ariza, kayip: Math.ceil(ORNEK / alan), sigar: normal <= k,
    arizaSigar: ariza <= k, pay: (k / normal) };
};
```

`ariza` alanı modelin ikinci iddiasıdır: bir alan düştüğünde yük kalan alanlara dağılır ve en
yoğun alt ağın talebi büyür. Bölme düzeni normal günde sığıyor diye arıza gününde de sığmak
zorunda değil, çünkü alt ağın sınırı o gün genişletilemez.

## İki Eksende Tarama

```js
// kosum1.mjs — ayni /20 blok iki eksende bolunur: alt ag boyu ve alan sayisi
import { BLOK, ORNEK, AYRILAN, onek, yogun, duzen } from './bolme.mjs';

const ALAN = 4, KATMAN = 3, N = ALAN * KATMAN;
console.log(`${BLOK} adreslik blok, ${ALAN} alan x ${KATMAN} katman = ${N} alt ag, ${ORNEK} ornek`);
console.log(`${'alt ag'.padEnd(7)} ${'dilim'.padStart(6)} ${'kullanilabilir'.padStart(14)} ` +
  `${'toplam'.padStart(7)} ${'ayrilan'.padStart(8)} ${'atanmamis'.padStart(10)} ${'en yogun'.padStart(9)}  durum`);
for (const b of [1024, 512, 256, 128, 64, 32]) {
  const d = BLOK / b, k = b - AYRILAN, y = yogun(ALAN), yer = d >= N;
  console.log(`/${String(onek(b)).padEnd(6)} ${String(d).padStart(6)} ${String(k).padStart(14)} ` +
    `${String(yer ? N * k : '-').padStart(7)} ${String(yer ? AYRILAN * N : '-').padStart(8)} ` +
    `${String(yer ? BLOK - N * b : '-').padStart(10)} ${String(y).padStart(9)}  ` +
    (!yer ? `${N} alt ag kurulamaz, en cok ${d}` : y <= k ? `sigar, ${(k / y).toFixed(1)}x pay` : `en yogun katman sigmiyor`));
}

console.log(`\nayni blok, ${KATMAN} katman sabit, alan sayisi taranir:`);
console.log(`${'alan'.padEnd(5)} ${'alt ag'.padStart(7)} ${'dilim'.padStart(6)} ${'kullanilabilir'.padStart(14)} ` +
  `${'en yogun'.padStart(9)} ${'buyume payi'.padStart(12)} ${'bir alan dusunce'.padStart(17)} ${'ariza sonrasi'.padStart(14)}`);
for (const a of [2, 3, 4, 6, 8]) {
  const d = duzen(a);
  console.log(`${String(a).padEnd(5)} ${String(d.n).padStart(7)} ${String(d.dilim).padStart(6)} ` +
    `${String(d.kullanilabilir).padStart(14)} ${String(d.normal).padStart(9)} ${`${d.pay.toFixed(1)}x`.padStart(12)} ` +
    `${`${d.kayip} ornek`.padStart(17)} ${`${d.ariza}/${d.kullanilabilir}`.padStart(14)}`);
}
```

```
4096 adreslik blok, 4 alan x 3 katman = 12 alt ag, 612 ornek
alt ag   dilim kullanilabilir  toplam  ayrilan  atanmamis  en yogun  durum
/22          4           1019       -        -          -        95  12 alt ag kurulamaz, en cok 4
/23          8            507       -        -          -        95  12 alt ag kurulamaz, en cok 8
/24         16            251    3012       60       1024        95  sigar, 2.6x pay
/25         32            123    1476       60       2560        95  sigar, 1.3x pay
/26         64             59     708       60       3328        95  en yogun katman sigmiyor
/27        128             27     324       60       3712        95  en yogun katman sigmiyor

ayni blok, 3 katman sabit, alan sayisi taranir:
alan   alt ag  dilim kullanilabilir  en yogun  buyume payi  bir alan dusunce  ariza sonrasi
2           6      8            507       190         2.7x         306 ornek        380/507
3           9     16            251       127         2.0x         204 ornek        190/251
4          12     16            251        95         2.6x         153 ornek        127/251
6          18     32            123        64         1.9x         102 ornek         76/123
8          24     32            123        48         2.6x          77 ornek         55/123
```

Üst tablonun ilk iki satırı adres sayısıyla ilgili değil. `/23` alt ağında beş yüz yedi
kullanılabilir adres var, on iki alt ağın toplam talebinden fazla — ama blok yalnız sekiz parçaya
bölünüyor ve dört alan ile üç katmanın çarpımı sekize sığmıyor. Bloğun sınırı adres sayısında
değil, parça sayısında bağlıyor.

Alt tarafta ise adres yeter, parça sığar ve düzen yine tutmaz: `/26` alt ağının elli dokuz
kullanılabilir adresine doksan beş örneklik uygulama katmanı girmiyor. Pencere iki satır geniş.
`/24` düzeninde en yoğun alt ağın iki buçuk katlık payı var, `/25` düzeninde payı bire üçte bir
düşüyor — bir büyüme adımı sonrasında alt ağ doluyor ve alt ağ sınırı o gün genişletilemiyor.
Ayrılan altmış adres her satırda aynı, ağırlığı değil: `/24` düzeninde atanan üç bin yetmiş iki
adresin yüzde ikisi, `/26` düzeninde yedi yüz altmış sekiz adresin yüzde sekizi. Atanmamış sütunu
bin yirmi dörtten üç bin yedi yüz on ikiye çıkıyor; bu adresler kaybolmuyor ama seçilen dilim
boyuna kilitleniyor — `/26` seçen bir plan gelecekte de `/26` ekleyebilir.

Alt tablo ikinci ekseni ölçüyor ve beklenmedik bir ceza çıkarıyor. Alan sayısı ikinin kuvveti
olduğunda büyüme payı iki buçuk katın üstünde kalıyor: iki alanda 2,7 kat, dört alanda 2,6, sekiz
alanda 2,6. Üç ve altı alan aynı bloğu daha kötü kullanıyor — 2,0 ve 1,9 kat. Sebep adres talebi
değil, yuvarlama: dokuz alt ağ on altı dilime, on sekiz alt ağ otuz iki dilime yuvarlanıyor ve
karşılığı alınmayan dilimler alt ağ boyunu bir kademe küçültüyor. Alan sayısını üçe çekmek
dayanıklılık adına alınmış bir karardır ve bedelini adres planında ödetir.

Son iki sütun arıza etkisini ayırıyor. Bir alanın kaybı iki alanda üç yüz altı örnek, sekiz alanda
yetmiş yedi örnek götürüyor: aynı blok, aynı adres sayısı, dört kat fark. Arıza sonrası sütununda ise
her düzen sığıyor — kalan alanlara dağılan yük en yoğun alt ağı dolduramıyor. Bölme düzeni arıza
gününde adres yüzünden değil, ayakta kalan örnek sayısı yüzünden ayrışıyor.

## Genel ve Özel Ayrımı

```js
// kosum2.mjs — ayni 12 alt ag uc erisim duzeninde; disaridan gorunen yuzey sayilir
import { ORNEK, KATMAN } from './bolme.mjs';

const ALAN = 4, KAPI = 4;                    // ornek basina dinleyen kapi (BA11)
const sayi = (p) => Math.ceil(ORNEK * p / 100 / ALAN) * ALAN;
const ORNEKLER = Object.fromEntries(KATMAN.map(([ad, p]) => [ad, sayi(p)]));
const TOPLAM = Object.values(ORNEKLER).reduce((a, b) => a + b, 0);
console.log(`${ALAN} alan x ${KATMAN.length} katman: ` +
  KATMAN.map(([ad]) => `${ad} ${ORNEKLER[ad]}`).join(', ') + `, toplam ${TOPLAM} ornek, ornek basina ${KAPI} kapi`);

// [ad, genel adresli katmanlar, dis dengeleyici, alan basina donusturme gecidi]
const DUZEN = [
  ['ayrim yok', ['genel', 'uygulama', 'veri'], 0, 0],
  ['yalniz genel katman', ['genel'], 0, 0],
  ['hicbiri genel', [], 1, 1],
];
console.log(`\n${'duzen'.padEnd(20)} ${'genel ag'.padStart(9)} ${'ozel ag'.padStart(8)} ${'genel adres'.padStart(12)} ` +
  `${'acik kalem'.padStart(11)} ${'ozel ornek'.padStart(11)} ${'ek bilesen'.padStart(11)} ${'tablo'.padStart(6)}`);
for (const [ad, genel, dng, gec] of DUZEN) {
  const genelAg = genel.length * ALAN, ozelAg = (KATMAN.length - genel.length) * ALAN;
  const genelOrnek = genel.reduce((a, k) => a + ORNEKLER[k], 0);
  const kalem = genelOrnek * KAPI + dng;      // dis dengeleyici tek kapi dinliyor
  const bilesen = 1 + dng + gec * ALAN;       // internet gecidi + dengeleyici + alan basina gecit
  const tablo = gec ? 1 + ALAN : genelAg && ozelAg ? 2 : 1;
  console.log(`${ad.padEnd(20)} ${String(genelAg).padStart(9)} ${String(ozelAg).padStart(8)} ` +
    `${String(genelOrnek).padStart(12)} ${String(kalem).padStart(11)} ${String(TOPLAM - genelOrnek).padStart(11)} ` +
    `${String(bilesen).padStart(11)} ${String(tablo).padStart(6)}`);
}
console.log(`\nblok icinde her ornek her ornege ulasabiliyor: ${TOPLAM} x ${TOPLAM - 1} yon, uc duzende de ayni`);
console.log(`disa acik kalem: ${TOPLAM * KAPI} -> ${ORNEKLER.genel * KAPI} -> 1`);
```

```
4 alan x 3 katman: genel 52, uygulama 380, veri 184, toplam 616 ornek, ornek basina 4 kapi

duzen                 genel ag  ozel ag  genel adres  acik kalem  ozel ornek  ek bilesen  tablo
ayrim yok                   12        0          616        2464           0           1      1
yalniz genel katman          4        8           52         208         564           1      2
hicbiri genel                0       12            0           1         616           6      5

blok icinde her ornek her ornege ulasabiliyor: 616 x 615 yon, uc duzende de ayni
disa acik kalem: 2464 -> 208 -> 1
```

Ayrım yapılmayan düzen bir tercih gibi görünmüyor çünkü kimse onu seçmiyor; alt ağ oluşturulurken
genel adres atama davranışı açık bırakıldığı için oluyor. Sonucu iki bin dört yüz altmış dört
kalem: altı yüz on altı örneğin dördü de dışarıdan erişilebilir. Genel katmanı ayırmak bu sayıyı
iki yüz sekize indiriyor — on iki kat — ve tek maliyeti yönlendirme tablosunun ikiye çıkması.

Üçüncü satır ayrımın sonuna kadar götürülmüş hâli. Dışarıdan erişilebilen tek kalem, yük
dengeleyicinin dinlediği kapıdır. Altı yüz on altı örnek hâlâ dört kapı dinliyor; hiçbiri
dışarıdan çağrılamıyor. Bedeli sağ iki sütunda: bileşen sayısı birden altıya, yönlendirme tablosu
birden beşe çıkıyor. Beş tablo, dört alanın her birinin kendi geçidine bakması gerektiği için
doğuyor ve bu sayı yeni bir yükün habercisidir — her yeni alt ağ artık bir tabloya değil, doğru
tabloya yazılmak zorunda.

Son iki satır ayrımın ölçmediği şeyi söylüyor. Blok içinde altı yüz on altı örnek birbirine
ulaşabiliyor ve bu sayı üç düzende de aynı: alt ağ ayrımı iç yüzeye dokunmuyor. Ayrıca altı yüz on
altı örneğin altı yüz on altısı artık kendi başına dışarıya çıkamıyor; çıkabilmesi için sayılan
altı bileşenden dördü var. Bu iki eksik ilerideki iki dersin konusudur: birincisi kuralların
hangi tabloda ve hangi sırayla yazıldığı, ikincisi kapalı bir alt ağın dışarıya nasıl çıktığı.
İkisinin de faturası bu derste açılan ayrımdan doğuyor — dışa açık kalemi 2.464'ten 1'e indiren
karar, aynı anda beş tablo ve dört geçit borcu yazıyor.

Bu derste elde kalan karar beş kalemdir: dilim boyu, alan sayısı, katman sayısı, hangi katmanın
genel olacağı ve her alt ağın hangi alana bağlanacağı. Devredilen üç kalem hiç sorulmuyor: alt ağ
başına kesilen beş adres, tekdüze bölmede parça sayısının ikinin kuvvetine yuvarlanması ve bir alt
ağın oluşturulduktan sonra alan değiştirememesi. Devredilen üçünden ikisi yukarıdaki tabloların
sayılarını doğrudan üretiyor — altmış adreslik kesinti ve üç alanda 2,0 kata düşen büyüme payı.
Bir kalemin sağlayıcıda olması onu etkisiz yapmıyor, yalnız görünmez yapıyor.

Geri alınamayan kalem burada alt ağ sınırıdır. Bir alt ağ oluşturulup içine örnek yerleştikten
sonra öneki genişletilemez, daraltılamaz ve başka bir alana taşınamaz. Dilim boyu seçimi bunun
üstüne biner: `/24` seçen plan gelecekte de `/24` ekler. Alan ataması da kalıcıdır — üç alan
seçmenin bedeli 2,0 katlık büyüme payıdır ve o pay dolduğunda çözüm yeni alt ağ eklemektir, var
olanı büyütmek değil.

## Özet

- Aynı 4096 adreslik blok, aynı 12 alt ağ: `/22` ve `/23` düzenleri adres yüzünden değil parça
  sayısı yüzünden kurulamıyor, `/26` ve `/27` düzenlerinde 95 örneklik en yoğun katman 59 ve 27
  kullanılabilir adrese sığmıyor. Pencere iki satır geniş.
- Ayrılan 60 adres her düzende aynı, ağırlığı değil: `/24` düzeninde atananın yüzde 2'si, `/26`
  düzeninde yüzde 8'i. Atanmamış artık 1.024'ten 3.712'ye çıkıyor ve seçilen dilim boyuna
  kilitleniyor.
- Alan sayısı ikinin kuvveti olduğunda büyüme payı 2,6–2,7 kat; 3 ve 6 alanda 2,0 ve 1,9 kata
  düşüyor. Ceza dilim yuvarlamasından geliyor: 9 alt ağ 16 dilime, 18 alt ağ 32 dilime yuvarlanıp
  alt ağ boyunu bir kademe küçültüyor.
- Bir alanın kaybı 2 alanda 306, 8 alanda 77 örnek götürüyor — dört kat fark. Arıza sonrası her
  düzende adres yetiyor; düzenler ayakta kalan örnek sayısında ayrışıyor.
- Genel ve özel ayrımı dışa açık kalemi 2.464'ten 208'e, oradan 1'e indiriyor ve genel adres
  sayısını 616'dan 0'a çekiyor. Karşılığı 1 bileşen ve 1 tablo yerine 6 bileşen ve 5 tablodur; iç
  yüzey olan 616 örneklik erişilebilirlik üç düzende de değişmiyor.

## Sonraki Adım

Beş yönlendirme tablosu son koşumda tek bir sayı olarak geçti, oysa asıl yükü orada. Dört alanın
özel alt ağları kendi geçidine, genel alt ağlar başka bir yere bakıyor ve hangi trafiğin nereye
gittiği bu tabloların içinde yazılı. Sonraki dersin sorusu bu kuralları kalem kalem çıkarır: bir
hedef adres verildiğinde hangi satır kazanıyor ve en uzun önek eşleşmesi hangi durumlarda
sezgiye aykırı bir yol seçiyor, eksik ya da fazla yazılmış tek bir satır kaç alt ağı erişilemez
bırakıyor ve trafiği beklenmedik bir yoldan çıkarınca çıkış ücretine ne ekliyor, aynı kural kaç
tabloda tekrarlanıyor ve on üçüncü alt ağ eklendiğinde kaç tabloya dokunmak gerekiyor.
