--- title: 'Anahtarlama ve Yönlendirme' source: 'https://academia.sh/tr/kurslar/anahtarlama-ve-yonlendirme' language: tr updated: '2026-08-17T04:39:16+00:00' license: 'CC BY-SA 4.0' lessons: 17 outcomes: - 'Anahtar ve yönlendirici davranışını tablolar üzerinden açıklar' - 'Statik ve dinamik yönlendirme arasında ölçüte dayalı seçim yapar' - 'Katmanlı ağ topolojilerini karşılaştırır' --- # Anahtarlama ve Yönlendirme Anahtarın ve yönlendiricinin kararı yerel bir tablodan okunur; tablo paylaşılan bir gerçeğin kopyasıdır ve kurs, kopyaların anlaşmadığı sürede paketin başına ne geldiğini sayar. ## Ağ Cihazları Yineleyicinin, hub'ın ve anahtarın çarpışma ve yayın alanlarına etkisi, eşleştirme tablosunun öğrenme ve iletme kararı, sanal yerel ağlarla bölütleme, döngü önleme ve bağlantı toplama. ### Yineleyici, Hub ve Anahtar Source: https://academia.sh/tr/kurslar/anahtarlama-ve-yonlendirme/yineleyici-hub-ve-anahtar Üç cihaz sınıfı aynı kırk çerçevede ölçülür: yineleyici ve hub tek çarpışma alanı kurup 280 teslim ve 34 çakışma üretir, tablosuz anahtar çakışmayı sıfırlar ama 240 gereksiz kopyayı sürdürür, tablolu anahtar teslimi 40'a indirir. Önceki kurs bir aracının **iletiden** ne okuyabildiğini saydı. Orada karar iletide yazana bakılarak alınıyordu: yöntem alanı bir şey söylüyordu, durum kodu bir şey söylüyordu ve aracı yalnız bunları okuyarak yürüyordu. İleti kapandığında aracı kör kalıyordu. Bir anahtarın kararı böyle alınmaz. Çerçeveyi alan cihaz onu **kendi tablosuna** bakarak çıkışa verir; çerçevede yazan hedef adresi yalnız tabloya sorulan sorudur, yanıtın kendisi değil. Yanıt cihazın belleğindedir. Ve o bellekteki şey, paylaşılan bir gerçeğin **kopyasıdır** — kopya eskiyebilir, eksik olabilir, komşusununkiyle çelişebilir. Bu kursun tek konusu budur. Bu dersin sorusu ise daha önce gelir: karar veren bir cihaz ile karar vermeyen bir cihaz aynı trafikte nasıl ayrışır? #### Karar Nereden Okunur Kurs boyunca ölçülen şey tek bir düzenektir. Bir **tablo** vardır; tablo bir hedefi bir çıkışa eşler. Cihaz gelen çerçeveyi ya da paketi alır, hedefini tabloda arar ve bulduğu çıkışa verir. Tablonun kendisi cihazın icadı değildir: ağın gerçek biçiminden türer, ama o gerçeğin **yerel bir kopyası** olarak tutulur. Kopyanın gerçekle uyuşup uyuşmadığını ölçebilmek için gerçeği ayrıca yazmak gerekir. Kurs boyunca buna **kâhin** denir: topolojiyi biz kurduğumuz için her hedefin nerede olduğu bilinir. Kâhin bir cihazın elindeki bilgi değildir; ölçümün elindeki cetveldir. Kopya gerçeğe uymadığında paketin başına üç şeyden biri gelir ve kurs bu üç adı sonuna kadar kullanır. **Ulaştı:** paket hedefine vardı. **Döngü:** paket aynı bağdan ikinci kez geçti ya da atlama sınırını yaktı; ölmedi, dolaşıyor. **Kara delik:** çıkış tabloda yok ya da artık gerçek bir çıkış değil; paket orada bitti. Bu derste ölçülen tek kader **ulaştı**'dır, çünkü tek bir cihazın tablosu kendi başına bir döngü kuramaz. Döngü en az iki tablonun anlaşmazlığıdır ve iki tablo bu konunun sonraki derslerinde ortaya çıkar. #### Üç Cihaz Sınıfı Aynı yerel ağda duran üç cihaz sınıfı, kararı üç ayrı yerden okur. **Yineleyici (repeater)** hiçbir yerden okumaz. İki bölütü birleştirir ve bir yandan gelen sinyali tazeleyip öbür yana basar. Çerçeveyi çözmez, adrese bakmaz, tablo tutmaz. Yaptığı iş sinyalin zayıflamasını gidermektir; mesafe kazandırır, karar kazandırmaz. **Hub** çok bacaklı bir yineleyicidir. Bir bacaktan gelen sinyali kalan bütün bacaklara basar. Bacak sayısı ikiden büyüktür, ama karar düzeneği aynıdır: yoktur. **Anahtar (switch)** kararı bir tablodan okur. Tablo donanım adresini bir bacağa eşler; çerçevenin hedef adresi tabloda varsa çerçeve yalnız o bacağa çıkar. Tabloyu nasıl doldurduğu — gelen çerçevenin kaynak adresini geldiği bacakla birlikte yazması ve hedefi bilinmeyen çerçeveyi **taşırması (flooding)** — Ağ Modelleri kursundaki Ethernet ve MAC Adresleri dersinde kuruldu ve burada tekrarlanmaz. Burada tablo hazır kabul edilir; ölçülen şey tablonun **varlığının** ne kazandırdığıdır. Ayrım katman ayrımıdır. Yineleyici ile hub sinyal düzeyinde çalışır: taşıdıkları şey bit dizisidir, çerçeve değil. Anahtar bağlantı katmanında çalışır: çerçeveyi bir birim olarak tanır, adres alanlarını okur ve bir karar verir. Bir cihazın hangi katmanda durduğu, ne kadar hızlı olduğunu değil, **neye bakabildiğini** söyler. #### İletme Kipleri Anahtarın kararı zaman içinde bir noktada verilir ve bu noktanın seçimi iki kip doğurur. **Depola ve ilet** kipinde anahtar çerçevenin tamamını alır, denetim dizisini doğrular ve ancak sonra bacağa verir. Bozuk bir çerçeve çıkışa hiç konmaz; bedeli, çerçevenin uzunluğuyla orantılı bir bekleyiştir. **Kes ve ilet** kipinde anahtar hedef adresini okur okumaz çıkışı seçer ve kalan baytları akarken geçirir. Bekleyiş adres alanı kadardır, çerçeve uzunluğundan bağımsızdır. Bedeli şudur: denetim dizisi çerçevenin sonundadır, yani karar verildiğinde henüz görülmemiştir. Bozuk bir çerçeve de iletilir ve hatayı ancak alıcı bulur. Seçim bir doğru–yanlış seçimi değil, neyin sayıldığına bağlı bir dengedir: birinde gecikme, öbüründe boşa harcanan iletim. Bu dersin ölçümü kipten bağımsızdır ve her iki kipte de aynıdır, çünkü sayılan şey kararın **ne zaman** verildiği değil, verilip verilmediğidir. #### İki Alan İki kapsam ayrılır ve bu ayrım üç cihazı birbirinden ayıran ilk ölçüdür. **Çarpışma alanı (collision domain)**, aynı anda gönderim yapıldığında sinyallerin çakışabileceği cihaz kümesidir. Yineleyici ve hub tek bir ortak ortam kurar: sekiz istasyon tek bir çarpışma alanındadır. Anahtarın her bacağı ayrı bir çarpışma alanıdır; bir bacaktaki gönderim öbür bacaktaki gönderimle çakışmaz. **Yayın alanı (broadcast domain)**, bir yayın çerçevesinin ulaştığı cihaz kümesidir. Üç cihazın hiçbiri yayın alanını bölmez. Anahtar da bölmez: hedefi bir grup adresi olan çerçeve her bacağa çıkar. Yayın alanını bölen düzenek bu konunun ilerleyen derslerinin konusudur. #### Çift Yönlü Bacak ve Tampon Anahtarın her bacağının ayrı bir çarpışma alanı olması, o alanda çarpışma **olabileceği** anlamına gelir. Bacakta tek bir istasyon varsa ve bacak çift yönlü çalışıyorsa, gönderme ile alma ayrı yollarda yürür ve çakışacak iki gönderim hiç doğmaz. Anahtarın çakışmayı sıfırlaması bu yapıdan gelir: çarpışma alanı küçültülmemiş, **boşaltılmıştır.** Bunun bir bedeli vardır ve ölçümdeki kuyruk sütunu onu sayar. Ortak ortamda iki gönderim aynı anda olamaz; anahtarda olabilir, çünkü giriş bacakları birbirinden bağımsızdır. İki giriş aynı çıkışı istediğinde anahtar birini tutmak zorundadır ve tuttuğu yer bir **tampondur.** Tampon dolarsa çerçeve atılır — kaybın yeri ortamdan cihaza taşınmıştır. Aynı gerekçe bacak hızları eşit olmadığında da işler. Hızlı bir bacaktan gelip yavaş bir bacağa çıkacak çerçeve, aradaki farkı tamponda bekler. Ortak ortamda böyle bir fark tanımsızdı: herkes aynı hızda konuşurdu, çünkü herkes aynı teldeydi. Ölçümün kurgusu şudur: sekiz istasyon, tek bir cihaza sekiz bacaktan bağlıdır. Kırk çerçeve gönderilir; her çerçevenin bir kaynağı, bir hedefi ve bir zaman dilimi vardır. Cihazın tablosu şu dökümdeki gibi okunur. ```text # ogretilen dokum, calistirilmamistir eslestirme tablosu (anahtar) adres bacak a 1 b 2 ... h 8 bir cercevenin izi kaynak a, hedef e hub -> 2,3,4,5,6,7,8 (yedi kopya, altisi gereksiz) anahtar -> 5 (tek kopya) hedef tabloda yoksa anahtar -> 2,3,4,5,6,7,8 (tasirma; hub ile ayni) ``` #### Ölçümün Varsayımları - **AC1** — Sekiz istasyon tek bir cihaza sekiz bacaktan bağlıdır ve her istasyon tek bir bacaktadır. Kâhin bu yerleşimi biz kurduğumuz için bilinir: hangi adresin hangi bacakta olduğunu ölçüm bilir, cihaz bilmeyebilir. - **AC2** — Kırk çerçeve üretilir. Kaynak ile hedef bir üreteçten, zaman dilimi ayrı bir üreteçten çekilir; her üreteç tek bir modülüsle çağrılır. Kaynak ile hedefin aynı olduğu çekiliş atılır. - **AC3** — Zaman dilimi sayısı yirmidir. Kırk çerçevenin yirmi dilime dağılması yüklü bir ortam demektir; ölçülen şey mutlak çakışma sayısı değil, aynı yükün üç cihazda ne olduğudur. - **AC4** — Ortak ortamda bir dilimde birden çok gönderen varsa o dilimdeki çerçevelerin hepsi **çakışmış** sayılır. Ayrı bacaklarda çakışma olmaz; aynı dilimde aynı çıkış bacağını isteyen fazladan her çerçeve **kuyruğa** yazılır. - **AC5** — Dört rejim karşılaştırılır: yineleyici, hub, tablosu boş anahtar ve tablosu tam anahtar. Tablosu boş anahtar öğrenmeyen bir kurgudur; amacı bacak yalıtımının kazancını tablonun kazancından ayırmaktır. - **AC6** — Yük ekseni dilim sayısıyla kurulur: aynı kırk çerçeve kırk, yirmi ve on dilime sığdırılır. Dilim sayısı değiştiğinde çekilişler baştan yapılır, bu yüzden yük satırları birbirinin alt kümesi değildir; karşılaştırılan şey aynı çerçeve dizisi değil, aynı yoğunluk kuralıdır. - **AC7** — Kümenin çözünürlüğü kırk çerçevedir; ölçülebilen en küçük fark $1/40 = 0{,}025$'tir. Bundan küçük bir fark bu kümeyle savunulmaz. #### Ölçüm ```python """Uc cihaz sinifi ayni trafikte: alan sayisi ve iletilen cerceve. Kaynak ile hedef bir uretecten, zaman dilimi ayri bir uretecten cekilir; her uretec tek bir modulusle cagrilir. """ TOHUM = 20260810 ISTASYONLAR = ["a", "b", "c", "d", "e", "f", "g", "h"] DILIM = 20 def uretec(tohum): d = tohum % 2147483646 + 1 def r(n): nonlocal d d = (d * 48271) % 2147483647 return d % n return r def cerceveler(sayi=40, dilim=DILIM): r, z, liste = uretec(TOHUM), uretec(TOHUM + 1), [] while len(liste) < sayi: x, y = ISTASYONLAR[r(8)], ISTASYONLAR[r(8)] if x != y: liste.append({"kaynak": x, "hedef": y, "dilim": z(dilim)}) return liste def kahin(): """Gercek: hangi istasyon hangi bacakta duruyor.""" return {a: i + 1 for i, a in enumerate(ISTASYONLAR)} def olc(C, tablo, ortak_ortam): yer, dolu, cikan = kahin(), {}, {} teslim = gereksiz = cakisan = 0 for c in C: dolu[c["dilim"]] = dolu.get(c["dilim"], 0) + 1 for c in C: bacak = tablo.get(c["hedef"]) cikis = ([bacak] if bacak is not None else [b for b in yer.values() if b != yer[c["kaynak"]]]) teslim += len(cikis) gereksiz += sum(1 for b in cikis if b != yer[c["hedef"]]) if ortak_ortam: cakisan += 1 if dolu[c["dilim"]] > 1 else 0 else: for b in cikis: cikan[(c["dilim"], b)] = cikan.get((c["dilim"], b), 0) + 1 kuyruk = sum(n - 1 for n in cikan.values() if n > 1) return teslim, gereksiz, cakisan, kuyruk C, TAM = cerceveler(), kahin() print(f"çerçeve {len(C)} | istasyon {len(ISTASYONLAR)} | zaman dilimi {DILIM}") print() print(f"{'cihaz':<18s} {'bacak':>5s} {'çarpışma':>8s} {'yayın':>5s} " f"{'teslim':>6s} {'gereksiz':>8s} {'çakışan':>7s} {'kuyruk':>6s}") for ad, bacak, tablo, ortak in (("yineleyici", 2, {}, True), ("hub", 8, {}, True), ("anahtar, tablosuz", 8, {}, False), ("anahtar, tablolu", 8, TAM, False)): t, g, ca, ku = olc(C, tablo, ortak) print(f"{ad:<18s} {bacak:5d} {1 if ortak else bacak:8d} {1:5d} " f"{t:6d} {g:8d} {ca:7d} {ku:6d}") print() print(f"{'dilim':>5s} {'hub çakışan':>11s} {'tablosuz kuyruk':>15s} " f"{'tablolu kuyruk':>14s}") for d in (40, 20, 10): Cd = cerceveler(40, d) _, _, ca, _ = olc(Cd, {}, True) _, _, _, k0 = olc(Cd, {}, False) _, _, _, k1 = olc(Cd, TAM, False) print(f"{d:5d} {ca:11d} {k0:15d} {k1:14d}") ``` ``` çerçeve 40 | istasyon 8 | zaman dilimi 20 cihaz bacak çarpışma yayın teslim gereksiz çakışan kuyruk yineleyici 2 1 1 280 240 34 0 hub 8 1 1 280 240 34 0 anahtar, tablosuz 8 8 1 280 240 0 151 anahtar, tablolu 8 8 1 40 0 0 6 dilim hub çakışan tablosuz kuyruk tablolu kuyruk 40 27 102 3 20 34 151 6 10 38 202 10 ``` #### İki Ayrı Kazanç İlk iki satır **birbirinin aynıdır** ve bu bir eksiklik değil, dersin ilk bulgusudur. Yineleyicinin iki bacağı, hubın sekiz bacağı vardır; ürettikleri alan sayısı da, teslim ettikleri kopya sayısı da, çakışan çerçeve sayısı da aynı çıkar. Bacak eklemek karar kazandırmaz. İkisi de kararı hiçbir yerden okumadığı için aynı cihazdır. Üçüncü satır bacak yalıtımını yalnız başına ölçer. Tablosu boş anahtar hâlâ taşırıyor: **280** teslim, **240** gereksiz kopya — hubın verdiğinin aynısı. Değişen tek şey çakışmadır: **34**'ten **0**'a iner. Bacaklar ayrı çarpışma alanları olduğu için iki gönderim artık birbirini bozmaz. Bozulmayan gönderimler yok olmaz, **kuyruğa** girer: aynı dilimde aynı bacağa çıkmak isteyen **151** fazladan kopya sıra bekler. Çarpışma kaybolmadı, **kuyruğa dönüştü.** Dördüncü satır tablonun kazancını ekler. Teslim **280**'den **40**'a, gereksiz kopya **240**'tan **0**'a iner: kırk çerçevenin her biri tam olarak bir bacağa çıkar. Kuyruk da **151**'den **6**'ya düşer, çünkü artık bir bacağı yalnız gerçekten oraya giden çerçeveler ister. Ayrım şudur: **bacak yalıtımı çakışmayı kaldırır, tablo gereksiz kopyayı kaldırır.** İkisi ayrı düzenektir ve ayrı ölçülür. Tablosuz bir anahtar kablolamada hubdan iyidir, iş yükünde ondan farksızdır. Sayılan farklar ölçüm bandının içindedir. Kırk çerçevelik bir kümede ölçülebilen en küçük fark $1/40 = 0{,}025$'tir; buradaki farklar bir çerçeve değil, onlarca çerçeve düzeyindedir. Çakışmadaki **34** çerçevelik düşüş kümenin **0,850**'si, gereksiz kopyadaki **240** birimlik düşüş ise çerçeve başına altı kopyadır. Bu ölçekteki bir farkın işareti kurgunun ayrıntısına bağlı değildir. #### Yük Arttığında Alt tablo aynı kırk çerçeveyi üç ayrı yoğunlukta gönderiyor: kırk dilime yayıldığında hafif, on dilime sıkıştığında ağır bir yük. Ortak ortamda çakışan çerçeve **27**'den **34**'e, oradan **38**'e çıkıyor. Artış yavaşlıyor çünkü tavan bellidir: kırk çerçevenin kırkı da çakışabilir ve ötesi yoktur. Ortak ortamın yük altındaki davranışı budur — bozulma **kaybedilen çerçeveyle** ölçülür ve doyuma gider. Anahtarda aynı yük kuyruk olarak görünür. Tablolu anahtarda kuyruk **3**, **6**, **10** girdiye çıkıyor; tablosuz anahtarda **102**, **151**, **202**. İki gözlem çıkar. Birincisi, anahtarda yük **kayıp** değil **bekleyiş** üretir: çerçeve yok olmaz, sırasını bekler. İkincisi, taşırma kuyruğu yaklaşık yirmi katına çıkarıyor — çünkü her çerçeve bir bacak değil yedi bacak istiyor. Tablonun kazancı yük arttıkça büyüyor: hafif yükte aradaki fark **99** girdi, ağır yükte **192**. Bir uyarı da üst tablodan okunur. Yayın alanı sütunu dört satırda da **1**'dir. Anahtar tabloyla ne kadar iyi karar verirse versin, hedefi bir grup adresi olan çerçeveyi bütün bacaklara vermek zorundadır — çünkü o çerçevenin hedefi tabloda hiçbir zaman tek bir bacağa düşmez. Sekiz istasyonluk bir alanda tek bir yayın çerçevesi yedi teslim üretir; alan büyüdükçe bu sayı alanla birlikte büyür. #### Özet - Karar bu kursta iletide yazandan okunmaz; cihazın **tablosundan** okunur ve tablo paylaşılan bir gerçeğin yerel kopyasıdır. - Paketin üç kaderi vardır — **ulaştı**, **döngü**, **kara delik**; tek bir cihazın tablosu kendi başına döngü kuramaz, döngü en az iki tablonun anlaşmazlığıdır. - Yineleyici ile hub aynı cihazdır: kırk çerçevede ikisi de **1** çarpışma alanı, **280** teslim, **240** gereksiz kopya ve **34** çakışan çerçeve verir. - Bacak yalıtımı çakışmayı **34**'ten **0**'a indirir ama gereksiz kopyaya dokunmaz; çakışma yok olmaz, **151** kuyruk girdisine dönüşür. Tablo teslimi **280**'den **40**'a, gereksiz kopyayı **240**'tan **0**'a, kuyruğu **151**'den **6**'ya indirir. - Yük arttıkça ortak ortamda çakışma **27**, **34**, **38** ile kırka doyar; anahtarda aynı yük **3**, **6**, **10** kuyruk girdisi olur — kayıp değil, bekleyiş. - Üç cihazın hiçbiri yayın alanını bölmez; dört rejimde de yayın alanı sayısı **1** kalır. #### Sonraki Adım Bu ölçümde anahtarın tablosu hazır kabul edildi: sekiz adresin sekizi de doğru bacakla eşlenmişti. Gerçekte tablo öyle başlamaz ve öyle kalmaz. Bir anahtar açıldığında tablosu boştur; bir istasyon susarsa girdisi bir süre sonra silinir; bir istasyon başka bacağa taşınırsa girdisi bir süre boyunca yanlış kalır. Sonraki ders tablonun **yaşını** ölçer: öğrenilmemiş ve yaşlanmış girdinin kaç çerçeveyi taşırttığını ve taşırmanın hangi alanı büyüttüğünü. ### Eşleştirme Tabloları Source: https://academia.sh/tr/kurslar/anahtarlama-ve-yonlendirme/eslestirme-tablolari Tablonun yaşı iki yönlü bir seçimdir: kırk çerçevede ömrü sınırsız girdi 110 teslim ve 3 kara delik verir, iki çerçevelik ömür kara deliği sıfırlar ama teslimi 278'e çıkarır. Önceki ders anahtarın tablosunu hazır kabul etti: sekiz adresin sekizi de doğru bacakla eşlenmişti ve tablo bu yüzden kırk çerçevenin kırkını da tek bacağa çıkardı. O varsayım altında tablo teslimi 280'den 40'a indirdi. Gerçek bir tablo öyle başlamaz ve öyle kalmaz. Anahtar açıldığında tablo boştur; girdiler gözlem yoluyla dolar; hiç konuşmayan bir istasyonun girdisi hiç yazılmaz; ve bir kez yazılan girdi sonsuza kadar doğru kalmaz, çünkü istasyon başka bir bacağa taşınabilir. Bu dersin sorusu tablonun ne yaptığı değil, **ne kadar yaşadığıdır.** #### Üç Ayrı Eksiklik Bir tablo üç ayrı biçimde yetersiz kalır ve üçünün bedeli aynı değildir. **Öğrenilmemiş girdi.** Adres tabloda hiç yoktur. Anahtar hedefin nerede olduğunu bilmez ve çerçeveyi gelen bacak dışındaki bütün bacaklara verir. Çerçeve hedefine **ulaşır**; bedel yalnızca gereksiz kopyalardır. Öğrenme düzeneğinin kendisi — kaynak adresin geldiği bacakla birlikte yazılması ve hedefi bilinmeyen çerçevenin **taşırılması (flooding)** — Ağ Modelleri kursundaki Ethernet ve MAC Adresleri dersinde kuruldu ve burada tekrarlanmaz. **Yaşlanmış girdi.** Adres tabloda vardı, ama girdi konduğundan beri geçen süre girdinin ömrünü aştı ve girdi silindi. Sonuç öğrenilmemiş girdiyle aynıdır: taşırma, ulaşan çerçeve, gereksiz kopya. Ayrı sayılmasının nedeni farklı bir kaynaktan gelmesidir — biri hiç öğrenilmemiş olmaktan, öbürü **unutulmuş** olmaktan doğar. **Eskimiş girdi.** Adres tabloda vardır, girdi tazedir ve **yanlıştır.** İstasyon başka bir bacağa taşınmış, tablo hâlâ eski bacağı göstermektedir. Anahtar bu durumda taşırmaz; emin adımlarla yanlış bacağa çıkar. Çerçeve orada kimseyi bulamaz ve **kara deliğe** düşer. Üç eksiklikten yalnız bu üçüncüsü çerçeveyi öldürür. Ayrım şuraya varır: taşırma **pahalıdır ama doğrudur**, eskimiş girdi **ucuzdur ve yanlıştır.** Girdinin ömrü bu ikisi arasında bir seçimdir. #### Taşırma Hangi Alanda İş Üretir Taşırılan bir çerçeve, hedefi tek bir istasyon olmasına rağmen bütün bacaklara çıkar. Önceki dersin iki kapsamı burada ayrışır. Taşırma **çarpışma alanını** büyütmez: bacaklar hâlâ birbirinden yalıtılmıştır ve çıkan kopyalar birbiriyle çakışmaz. Taşırma **yayın alanını** kullanır: kopyalar tam olarak bir yayın çerçevesinin gideceği yere gider. Sonuç şudur: **öğrenilmemiş bir hedef, tek bir çerçeveyi geçici olarak bir yayın çerçevesine çevirir.** Yayın alanı ne kadar büyükse taşırmanın bedeli o kadar büyür ve bu bedel taşırılan çerçeve sayısıyla çarpılır. Bir istasyonun hiç konuşmaması bu bedeli kalıcı hâle getirir. Ölçümdeki `h` istasyonu hiç çerçeve göndermez; kaynak adresi hiçbir çerçevede görünmediği için tabloya hiç yazılmaz. Ona giden her çerçeve, ölçümün sonuna kadar taşırılır. Tablonun satır sayısı bu yüzden sekiz değil yedidir. #### Tablo Bacağa Değil Adrese Bakar Tablonun yönü ilk bakışta ters görünür: anahtarın sekiz bacağı vardır ama tablo bacakları değil **adresleri** sayar. Bir bacakta tek bir istasyon olmak zorunda değildir. O bacağa başka bir anahtar bağlıysa, arkasındaki bütün istasyonların adresleri aynı bacakla eşlenir; sanallaştırılmış bir konak da tek bir bacaktan birden çok adres gösterebilir. Bunun iki sonucu vardır. Birincisi, tablonun satır sayısı bacak sayısıyla değil **görülen adres sayısıyla** büyür; ölçümdeki yedi satır sekiz istasyondan gelir, dokuz bacaktan değil. İkincisi, aynı adres iki bacakta birden görünemez: yeni bir gözlem geldiğinde girdi güncellenir, çoğaltılmaz. Bir adresin iki bacak arasında sürekli gidip gelmesi, tablonun kendisiyle çelişmesi değil, ağın çelişkili gözlem üretmesidir — kaynağı bu konunun ilerleyen bir dersinin konusudur. Tablonun kapasitesi de sonludur. Girdi sayısı kapasiteyi aştığında bir girdi yer açmak için düşer ve düşen girdinin adresine giden çerçeveler taşırılır. Bu, ömrü kısaltmakla aynı sonucu verir; farkı, seçimin yönetici tarafından değil doluluk tarafından yapılmasıdır. ```text # ogretilen dokum, calistirilmamistir eslestirme tablosu (an 12) adres bacak yazildigi an a 1 13 b 2 9 c 3 11 <- bu girdi an 12'de eskiyor d 4 8 e 5 10 f 6 12 g 7 5 (h icin satir yok: hic gonderim yapmadi) an 12'de: c istasyonu bacak 3'ten bacak 9'a tasinir. an 15, hedef c -> tablo bacak 3 der -> kimse yok -> kara delik girdi yaslanirsa -> tasirma -> butun bacaklar -> ulasir c yeniden gonderirse -> girdi bacak 9 olur -> ulasir ``` #### Ölçümün Varsayımları - **AC8** — Sekiz istasyon dokuz bacaklı bir anahtara bağlıdır; dokuzuncu bacak boştur ve taşınmanın hedefidir. Kâhin yerleşimi biz kurduğumuz için bilinir ve her an hangi adresin hangi bacakta olduğunu söyler. - **AC9** — Kırk çerçeve tek bir üreteçten, tek bir modülüsle çekilir. Kaynağın hedefe eşit olduğu ve kaynağın sessiz istasyon olduğu çekilişler atılır; sessiz istasyon böylece hiç gönderim yapmaz. - **AC10** — Zaman birimi çerçevedir: girdinin yaşı, konduğu çerçeveden bu yana geçen çerçeve sayısıdır. Ömrü `None` olan rejimde girdi hiç silinmez. - **AC11** — Tablo yalnız kaynak adresten öğrenir ve her çerçevede önce öğrenme, sonra iletme yapılır. Bu sıra gerçek düzenekle aynıdır ve ölçümü etkiler: bir istasyonun kendi gönderimi kendi girdisini tazeler. - **AC12** — Taşınma rejiminde bir istasyon 12. çerçevede boş bacağa geçer ve bunu kimseye bildirmez. Tablo ancak iki yoldan düzelir: girdi yaşlanır ya da istasyon yeniden gönderim yapar. - **AC13** — Kader adları ortak tanımdakilerle aynıdır. Çerçeve hedefin gerçek bacağına bir kopya bırakıyorsa **ulaştı**, bırakmıyorsa **kara delik** sayılır. Tek anahtarlı bu kurguda **döngü** oluşamaz. - **AC14** — Kümenin çözünürlüğü kırk çerçevedir; ölçülebilen en küçük fark $1/40 = 0{,}025$'tir. #### Ölçüm ```python """Tablonun yasi: ogrenilmemis ve yaslanmis girdinin bedeli. Ogrenme duzenegi Ag Modelleri kursunda kuruldu; burada olculen sey girdinin ne kadar yasadigidir. """ TOHUM = 20260810 ISTASYONLAR = ["a", "b", "c", "d", "e", "f", "g", "h"] BACAK = 9 SESSIZ = "h" TASINAN, TASINMA_ANI = "c", 12 def uretec(tohum): d = tohum % 2147483646 + 1 def r(n): nonlocal d d = (d * 48271) % 2147483647 return d % n return r def cerceveler(sayi=40): r, liste = uretec(TOHUM), [] while len(liste) < sayi: x, y = ISTASYONLAR[r(8)], ISTASYONLAR[r(8)] if x != y and x != SESSIZ: liste.append({"an": len(liste), "kaynak": x, "hedef": y}) return liste def kahin(an, tasinma): """Gercek yerlesim; tasinma aninda bir istasyon bos bacaga gecer.""" yer = {a: i + 1 for i, a in enumerate(ISTASYONLAR)} if tasinma and an >= TASINMA_ANI: yer[TASINAN] = BACAK return yer def olc(C, yas, tasinma): tablo, kader = {}, {"ulasti": 0, "kara delik": 0} tasir = {"ogrenilmemis": 0, "yaslanmis": 0} teslim = gereksiz = 0 for c in C: yer = kahin(c["an"], tasinma) tablo[c["kaynak"]] = (yer[c["kaynak"]], c["an"]) girdi = tablo.get(c["hedef"]) taze = girdi is not None and (yas is None or c["an"] - girdi[1] < yas) if taze: cikis = [girdi[0]] else: tasir["yaslanmis" if girdi else "ogrenilmemis"] += 1 cikis = [b for b in range(1, BACAK + 1) if b != yer[c["kaynak"]]] teslim += len(cikis) gereksiz += sum(1 for b in cikis if b != yer[c["hedef"]]) kader["ulasti" if yer[c["hedef"]] in cikis else "kara delik"] += 1 return tasir, kader, teslim, gereksiz, len(tablo) C = cerceveler() print(f"çerçeve {len(C)} | bacak {BACAK} | sessiz istasyon {SESSIZ}, hedef " f"olduğu çerçeve {sum(1 for c in C if c['hedef'] == SESSIZ)} | " f"taşırma tavanı {len(C) * (BACAK - 1)}") BASLIK = (f"{'yaş':>5s} {'öğrenilmemiş':>12s} {'yaşlanmış':>9s} {'ulaştı':>6s} " f"{'kara delik':>10s} {'teslim':>6s} {'gereksiz':>8s} {'satır':>5s}") for tasinma in (False, True): print() print("taşınma var" if tasinma else "taşınma yok") print(BASLIK) for yas in (None, 20, 10, 5, 2): t, k, te, g, n = olc(C, yas, tasinma) print(f"{str(yas):>5s} {t['ogrenilmemis']:12d} {t['yaslanmis']:9d} " f"{k['ulasti']:6d} {k['kara delik']:10d} {te:6d} {g:8d} {n:5d}") ``` ``` çerçeve 40 | bacak 9 | sessiz istasyon h, hedef olduğu çerçeve 4 | taşırma tavanı 320 taşınma yok yaş öğrenilmemiş yaşlanmış ulaştı kara delik teslim gereksiz satır None 10 0 40 0 110 70 7 20 10 0 40 0 110 70 7 10 10 6 40 0 152 112 7 5 10 14 40 0 208 168 7 2 10 24 40 0 278 238 7 taşınma var yaş öğrenilmemiş yaşlanmış ulaştı kara delik teslim gereksiz satır None 10 0 37 3 110 73 7 20 10 0 37 3 110 73 7 10 10 6 38 2 152 114 7 5 10 14 39 1 208 169 7 2 10 24 40 0 278 238 7 ``` #### Öğrenilmemiş Girdinin Değişmeyen Payı Her iki tabloda da `öğrenilmemiş` sütunu **10**'dur ve hiçbir ömür değeri onu değiştirmez. Bu sayı iki parçadan oluşur: tablonun boş başlamasından doğan ilk karşılaşmalar ve sessiz istasyona giden **4** çerçeve. İlk parça bir kez ödenir, ikinci parça ölçüm boyunca ödenir. Sonuç önemlidir: **girdinin ömrünü uzatmak öğrenilmemiş girdiyi azaltmaz.** Ömür yalnız girdinin ne kadar yaşayacağını belirler, hiç yazılmamış bir girdiyi doğurmaz. Sessiz bir istasyonu tabloya sokmanın tek yolu onu konuşturmaktır. Tablo yalnız gözlemden beslendiği için, hiç gözlem üretmeyen bir uç tablonun görüş alanının tümüyle dışında kalır ve ona giden her çerçeve bu görüşsüzlüğün bedelini öder. Ömrü sınırsız bırakan rejim **110** teslim veriyor; hepsi taşırılabilirse tavan **320**'dir. Yani tablo, doğru çalıştığı hâliyle bile teslimin **üçte birinden azını** üretiyor — geri kalanı zaten tasarruf. Ömür kısaldıkça bu tasarruf eriyor: **10** çerçevelik ömürde teslim **152**, **5**'te **208**, **2**'de **278**. Son satırda anahtar tavanın **0,869**'una çıkmıştır; tablo neredeyse hükümsüzdür ve cihaz karar veren bir cihaz olmaktan çıkmıştır. #### Ömrün İki Yönü Alt tablo aynı ömür dizisini bir taşınmayla birlikte okuyor ve yön değişiyor. Ömrü sınırsız bırakan rejimde **3** çerçeve kara deliğe düşüyor. Üçü de taşınmadan sonra, taşınan istasyon yeniden konuşmadan önce gönderilmiş çerçevelerdir; tablo o aralıkta emin ve yanlıştır. **20** çerçevelik ömür aynı sonucu veriyor, çünkü ölçüm bitmeden hiçbir girdi o yaşa ulaşmıyor: bir ömür değeri, ölçüm penceresinden uzunsa sınırsız ömürden ayırt edilemez. **10** çerçevelik ömürde kara delik **2**'ye, **5**'te **1**'e, **2**'de **0**'a iner. Düzeltmeyi yapan şey bir bildirim değildir — kimse taşınmayı duyurmaz. Düzeltmeyi yapan şey **unutmaktır:** girdi silindiği anda anahtar yeniden bilmediğini kabul eder ve taşırır, taşırılan çerçeve de yeni bacağa uğradığı için ulaşır. Bedel aynı satırlarda duruyor. Kara deliği **3**'ten **0**'a indirmek teslimi **110**'dan **278**'e çıkarıyor: bir çerçeveyi kurtarmanın bedeli ortalama elli altı fazladan kopyadır. Üç çerçeve kırk çerçevelik kümede **0,075**'tir ve çözünürlüğün üç katıdır, yani ölçülebilir bir farktır; ama kaybı sıfırlamak için ödenen kopya, taşırma tavanının yarısından fazlasıdır. Örüntü şudur: **girdinin ömrü, yanlış bilme süresi ile bilmeme maliyeti arasında bir seçimdir.** Uzun ömür tabloyu ucuzlatır ve yanılgıyı uzatır; kısa ömür yanılgıyı kısaltır ve tabloyu hükümsüzleştirir. İkisini birden sıfırlayan bir ömür yoktur, çünkü anahtarın taşınmayı öğrenmesinin tek yolu yeni bir gözlemdir ve gözlem gelene kadar geçen süre ölçülemez. #### Ömür Tek Başına Seçilmez Ölçümde tek bir ömür vardı, çünkü tek bir tablo vardı. Gerçek bir yolda aynı hedefe ait iki ayrı önbellek yan yana durur: anahtardaki eşleştirme tablosu ve gönderen konaktaki adres çözümleme önbelleği. İkincisi Ağ Modelleri kursundaki ARP dersinde kuruldu ve burada tekrarlanmaz; burada önemli olan yalnız ömürlerinin **birbirine göre** seçilmesidir. İki ömür eşit olmadığında bir bakışımsızlık doğar. Gönderen konak hedefin donanım adresini önbelleğinde tutmaya devam ederken anahtardaki girdi silinmişse, konak sorgu yapmadan çerçeve göndermeyi sürdürür ve anahtar her çerçeveyi taşırır. Hedef istasyon yalnızca yanıt veren bir uçsa — yani kendiliğinden konuşmuyorsa — girdisi yeniden yazılmaz ve taşırma sürekli hâle gelir. Ölçümdeki sessiz istasyonun kalıcı **10** payı bu durumun küçük bir örneğidir. Kural şudur: anahtardaki girdinin ömrü, üst katmandaki adres önbelleğinin ömründen kısa seçilirse taşırma bir arıza değil, **tasarımın olağan sonucu** olur. Ters yönde seçildiğinde ise eskimiş girdinin ömrü uzar ve kara delik penceresi genişler. Ölçümün iki tablosu bu iki yönü ayrı ayrı gösteriyor; seçim ikisinin arasındadır. #### Tablolar Birbirini Bilmez Ölçüm tek bir anahtarla yapıldı ve bu, sonucu olduğundan iyimser gösterir. İki anahtar yan yana durduğunda ortada iki tablo vardır ve **aralarında hiçbir eşitleme yoktur.** Her anahtar yalnız kendi bacaklarından geçen çerçeveleri görür; kendi gördüğünü yazar, görmediğini bilmez. Bir anahtarın tazelediği girdi, öbüründe çoktan yaşlanmış olabilir. Bu, tablonun bir kusuru değil tanımıdır: tablo paylaşılan bir gerçeğin **yerel kopyasıdır.** Kopyayı güncel tutan bir bildirim yoktur; güncelliği sağlayan tek şey aynı trafiği görmektir. Aynı trafiği görmeyen iki anahtar, aynı adres için farklı bacaklar gösterebilir. Tek anahtarlı kurguda bunun bedeli görünmedi, çünkü ölçülen tek kader **kara delikti**: yanlış bacağa çıkan çerçeve orada bitiyordu. İki tablo olduğunda üçüncü bir kader açılır. Bir anahtar çerçeveyi ileri, öbürü geri gönderirse çerçeve ölmez; iki cihaz arasında gidip gelir. **Döngü, tek bir tablonun yapabileceği bir şey değildir** — en az iki tablonun anlaşmazlığıdır ve bu konunun ilerleyen bir dersinde ilk kez sayılacaktır. #### Özet - Tablo üç ayrı biçimde yetersiz kalır: **öğrenilmemiş** ve **yaşlanmış** girdi taşırmaya, **eskimiş** girdi kara deliğe yol açar; ilk ikisi pahalı ama doğru, üçüncüsü ucuz ve yanlıştır. - Taşırma çarpışma alanını değil **yayın alanını** kullanır: taşırılan bir çerçeve tek bir hedefe gitmesine rağmen yayın çerçevesi gibi iş üretir. - Öğrenilmemiş girdi sayısı bütün ömür değerlerinde **10** kalır; **4**'ü hiç konuşmayan istasyona gider ve tablo bu yüzden sekiz değil **7** satırda kalır. - Ömür kısaldıkça teslim **110**, **152**, **208**, **278** diye büyür; son değer taşırma tavanı **320**'nin **0,869**'udur ve tabloyu hükümsüz bırakır. - Taşınma rejiminde kara delik **3**, **3**, **2**, **1**, **0** diye iner; düzeltmeyi yapan şey bir bildirim değil, girdinin unutulmasıdır. #### Sonraki Adım Bu ölçümde taşırma hep aynı yere gitti: dokuz bacağın tümüne. Bunun nedeni sekiz istasyonun tek bir yayın alanında olmasıydı — önceki dersin ölçümünde de yayın alanı sayısı her rejimde birdi. Oysa taşırmanın bedeli doğrudan bu alanın büyüklüğüyle çarpılıyor. Sonraki ders alanı bölmeyi ölçer: aynı fiziksel anahtar üzerinde birden çok yayın alanı tanımlandığında taşırma kaç kopyaya iner, tablo kaç satıra çıkar ve bölütlemenin kendi ürettiği kara delik nereden gelir. ### Sanal Yerel Ağlar Source: https://academia.sh/tr/kurslar/anahtarlama-ve-yonlendirme/sanal-yerel-aglar Bölütleme yayın alanını böler ama tablo satırını bölmez: kırk çerçevede taşırma teslimi 280'den 51'e ve 8'e iner, satır sayısı 16'da kalır, bedeli 23 ile 32 arasında kara deliktir. Önceki ders taşırmanın bedelini saydı ve bedelin nereden geldiğini gösterdi: taşırılan çerçeve yayın alanının tamamına gider, yani maliyeti doğrudan o alanın büyüklüğüyle çarpılır. Sekiz istasyonluk bir alanda tek bir taşırma sekiz kopyaya mal olurken, aynı taşırma seksen istasyonluk bir alanda seksen kopyaya mal olur. Buradan görünen çıkış yolu alanı küçültmektir. Ama alanı küçültmenin bilinen yolu ağı fiziksel olarak ayırmaktır: ayrı anahtarlar, ayrı kablolar, ayrı yerler. Bu dersin sorusu şudur: aynı fiziksel anahtar üzerinde, kabloları değiştirmeden birden çok yayın alanı tanımlanabilir mi ve tanımlanırsa **ne kazanılır, ne ödenir?** #### Kimlik Bağlantı Noktasına Verilir **Sanal yerel ağ (VLAN)**, bir anahtarın bacaklarını numaralı kümelere ayırmasıdır. Her bacağa bir **kimlik** atanır; anahtar, bir bacaktan gelen çerçeveyi yalnız aynı kimliğe sahip bacaklara verir. Taşırma da bu kurala uyar: hedefi bilinmeyen çerçeve bütün bacaklara değil, yalnız kendi kimliğinin bacaklarına taşırılır. Düzeneğin tamamı budur ve çerçevede hiçbir şey değiştirmez. İstasyon kimliğin varlığından haberdar değildir; gönderdiği çerçeve sıradan bir çerçevedir. Kimlik anahtarın yapılandırmasında yaşar, çerçevede değil. Bir bacağın kimliği değiştirildiğinde istasyon başka bir yayın alanına taşınmış olur ve bunu fark etmez. Bunun doğrudan sonucu, yayın alanı sayısının artık kablolamaya bağlı olmamasıdır. Sekiz bacaklı tek bir anahtar dört yayın alanı taşıyabilir; sekiz ayrı anahtar tek bir yayın alanı taşıyabilir. Alanın sınırı fiziksel değil, bildirimseldir. #### Etiketli Bağlantı Tek anahtarda kimlik çerçeveye yazılmaz, çünkü yazılmasına gerek yoktur: çerçevenin hangi kimliğe ait olduğu geldiği bacaktan bilinir. İki anahtar yan yana gelince bu bilgi kaybolur. Aradaki tek kabloyu paylaşan çerçevelerin hangi kimliğe ait olduğu, öbür anahtar için belirsizdir. Çözüm, kimliği çerçeveye yazmaktır. **Etiketli bağlantı (trunk link)** üzerinde çerçeve, kaynak adresi ile tür alanı arasına dört baytlık bir etiket alarak geçer. | Alan | Genişlik | Taşıdığı | |---|---|---| | Etiket protokol imi | 16 bit | Çerçevenin etiketli olduğunu gösteren sabit değer | | Öncelik | 3 bit | Çerçevenin işlem önceliği | | Atılabilirlik imi | 1 bit | Tıkanıklıkta önce atılabileceği bildirimi | | Kimlik | 12 bit | Sanal yerel ağın numarası | Kimlik alanı 12 bittir; en küçük ve en büyük değerler ayrıldığı için kullanılabilir kimlik sayısı 4094'tür. Etiket yalnız etiketli bağlantı üzerinde bulunur: çerçeve bir istasyona çıkarken etiketi düşürülür, çünkü istasyon etiketten haberdar değildir. ```text # ogretilen dokum, calistirilmamistir etiketsiz cerceve (istasyon <-> anahtar) hedef | kaynak | tur | yuk | denetim etiketli cerceve (anahtar <-> anahtar) hedef | kaynak | ETIKET | tur | yuk | denetim ^ 4 bayt: im + oncelik + atilabilirlik + kimlik bacak yapilandirmasi (anahtar 1) bacak 1 etiketsiz, kimlik 1 bacak 2 etiketsiz, kimlik 1 bacak 3 etiketsiz, kimlik 2 bacak 4 etiketsiz, kimlik 2 bacak 5 ETIKETLI, tasidigi kimlikler: 1, 2 ``` Etiketli bağlantının hangi kimlikleri taşıyacağı ayrı bir karardır. Bir kimliğin öbür anahtarda hiç üyesi yoksa o kimliği taşımanın karşılığı yoktur; taşınmadığında o kimliğe ait hiçbir çerçeve karşıya geçmez ve karşıdaki anahtar o kimliğin adreslerini hiç görmez. Ölçüm bu kararın bedelini ayrıca sayar. Kimliğin bacağa atanması tek yöntem değildir. Bacak tabanlı atamada karar kabloya bağlıdır: bacak neyse kimlik odur, oraya hangi istasyon takılırsa takılsın. Adres tabanlı atamada anahtar gelen çerçevenin kaynak adresine bakar ve kimliği bir eşleme tablosundan okur; istasyon taşınsa da kimliği taşınır. İkincisi taşınabilirlik kazandırır, karşılığında anahtarın tuttuğu ikinci bir tabloyu ve o tablonun güncelliğini borç yazar. Ölçüm bacak tabanlı atamayı kullanır, çünkü sayılan şey atamanın yöntemi değil bölütlemenin kendisidir. #### Etiketsiz Kimlik ve İki Yanın Anlaşmazlığı Etiketli bir bağlantıda etiketsiz bir çerçeve göründüğünde ne yapılacağı ayrıca belirlenir. Her etiketli bağlantının bir **etiketsiz kimliği** vardır: etiketsiz gelen çerçeve o kimliğe sayılır, o kimlikten çıkan çerçeve etiketsiz gönderilir. Alan kimliği taşıdığı için değil, taşımadığı için tanınır. Bu, kursun eksenine ait bir yapılandırma yüzeyi açar. Etiketsiz kimliğin ne olduğu, bağlantının iki ucunda **ayrı ayrı** yazılır ve aralarında bir eşitleme yoktur. İki uç aynı numarayı yazmışsa sorun yoktur. Ayrı numaralar yazmışsa, bir uçtan etiketsiz çıkan çerçeve öbür uçta başka bir alana sayılır: çerçeve **bir yayın alanından öbürüne, hiçbir cihazın kararı olmadan geçer.** Ortada bir arıza belirtisi yoktur — bağlantı ayaktadır, sayaçlar temizdir, çerçeveler düşmez. Görünen tek şey, ayrılmış olması gereken iki alanın bazı çerçeveleri paylaşmasıdır. **Daraltma** üç adımdadır. Birincisi, etiketsiz kimlik iki uçta da aynı değere yazılır ve bu değer yapılandırmanın gözden geçirilen bir parçası sayılır. İkincisi, etiketsiz kimlik hiçbir istasyona atanmayan bir numaraya çekilir; o alanda üye yoksa yanlış eşleşmenin taşıyacağı bir trafik de olmaz. Üçüncüsü, etiketli bağlantının taşıdığı kimlik listesi en dar biçimde yazılır: iki yanda da üyesi olan kimlikler taşınır, ötekiler taşınmaz. Ölçümün üçüncü rejimi bu dar yapılandırmanın uç hâlidir. #### Ölçümün Varsayımları - **AC15** — İki anahtar vardır, her birine dört istasyon bağlıdır ve aralarında tek bir etiketli bağlantı durur. Kâhin yerleşimi biz kurduğumuz için bilinir. - **AC16** — Kırk çerçeve tek bir üreteçten, tek bir modülüsle çekilir; kaynağın hedefe eşit olduğu çekiliş atılır. Aynı çerçeve dizisi dört bölütlemede de kullanılır. - **AC17** — Dört rejim karşılaştırılır: bölütsüz; iki alan, her ikisi de iki anahtara **yayılan**; iki alan, her biri tek anahtarda **yerel**; dört alan, hepsi yayılan. - **AC18** — Teslim sütunu **taşırma** rejimini sayar: hedef tabloda yokmuş gibi, çerçeve kendi alanındaki bütün istasyonlara verilir. Amaç bölütlemenin taşırma üzerindeki etkisini yalıtmaktır; tablonun kendi kazancı önceki derste ölçüldü. - **AC19** — Etiketli bağlantı, iki yanda da üyesi olan kimliği taşır; üyesi olmayan kimliği taşımaz. Bu, yapılandırmanın en dar biçimidir. - **AC20** — Tablo satırı `(kimlik, adres)` çiftidir ve bir anahtar yalnız **gördüğü** kaynağı yazar. Karşı anahtarın kaynağını görmesi, etiketli bağlantının o kimliği taşımasına bağlıdır. - **AC21** — Kaynağı ile hedefi ayrı kimliklerde olan çerçeve **kara delik** sayılır: anahtar onu kendi alanı içinde taşırır, hedef o alanda olmadığı için hiçbir kopya hedefe ulaşmaz. Kümenin çözünürlüğü kırk çerçevedir, en küçük ölçülebilir fark $1/40 = 0{,}025$. #### Ölçüm ```python """Bolutlemenin yayin alanina, tablo satirina ve etiketli baglantiya etkisi.""" TOHUM = 20260810 ISTASYONLAR = ["a", "b", "c", "d", "e", "f", "g", "h"] ANAHTAR = {"a": 1, "b": 1, "c": 1, "d": 1, "e": 2, "f": 2, "g": 2, "h": 2} BOLUT = { "bölütsüz": {a: 1 for a in ISTASYONLAR}, "iki alan, yayılan": {"a": 1, "b": 1, "c": 2, "d": 2, "e": 1, "f": 1, "g": 2, "h": 2}, "iki alan, yerel": {"a": 1, "b": 1, "c": 1, "d": 1, "e": 2, "f": 2, "g": 2, "h": 2}, "dört alan, yayılan": {"a": 1, "b": 2, "c": 3, "d": 4, "e": 1, "f": 2, "g": 3, "h": 4}, } def uretec(tohum): d = tohum % 2147483646 + 1 def r(n): nonlocal d d = (d * 48271) % 2147483647 return d % n return r def cerceveler(sayi=40): r, liste = uretec(TOHUM), [] while len(liste) < sayi: x, y = ISTASYONLAR[r(8)], ISTASYONLAR[r(8)] if x != y: liste.append({"kaynak": x, "hedef": y}) return liste def tasinan_kimlikler(kimlik): """Etiketli baglanti, iki yanda da uyesi olan kimligi tasir.""" return {k for k in set(kimlik.values()) if {ANAHTAR[s] for s in ISTASYONLAR if kimlik[s] == k} == {1, 2}} def olc(C, kimlik): tasinan = tasinan_kimlikler(kimlik) satir = {1: set(), 2: set()} kader = {"ulasti": 0, "kara delik": 0} teslim = gereksiz = etiketli = 0 for c in C: k, x, y = kimlik[c["kaynak"]], c["kaynak"], c["hedef"] satir[ANAHTAR[x]].add((k, x)) if k in tasinan: satir[3 - ANAHTAR[x]].add((k, x)) if kimlik[y] != k: kader["kara delik"] += 1 continue cikis = [s for s in ISTASYONLAR if kimlik[s] == k and s != x] teslim += len(cikis) gereksiz += sum(1 for s in cikis if s != y) etiketli += 1 if ANAHTAR[y] != ANAHTAR[x] else 0 kader["ulasti"] += 1 return kader, teslim, gereksiz, etiketli, len(satir[1]) + len(satir[2]) C = cerceveler() print(f"çerçeve {len(C)} | istasyon {len(ISTASYONLAR)} | anahtar 2") print() print(f"{'bölütleme':<19s} {'alan':>4s} {'ulaştı':>6s} {'kara delik':>10s} " f"{'teslim':>6s} {'gereksiz':>8s} {'etiketli':>8s} {'satır':>5s}") for ad, kimlik in BOLUT.items(): k, t, g, e, s = olc(C, kimlik) print(f"{ad:<19s} {len(set(kimlik.values())):4d} {k['ulasti']:6d} " f"{k['kara delik']:10d} {t:6d} {g:8d} {e:8d} {s:5d}") ``` ``` çerçeve 40 | istasyon 8 | anahtar 2 bölütleme alan ulaştı kara delik teslim gereksiz etiketli satır bölütsüz 1 40 0 280 240 29 16 iki alan, yayılan 2 17 23 51 34 14 16 iki alan, yerel 2 11 29 33 22 0 8 dört alan, yayılan 4 8 32 8 0 8 16 ``` #### Alan Bölünür, Satır Bölünmez Taşırma sütunu bölütlemenin vaadini tutuyor. Bölütsüz ağda kırk çerçevenin taşırılması **280** teslim üretiyor; iki alana bölündüğünde **51**'e, dört alana bölündüğünde **8**'e iniyor. Alan sayısı ikiye katlandığında bedel yaklaşık dörtte birine düşüyor, çünkü hem taşırılan çerçeve sayısı hem de her taşırmanın ulaştığı istasyon sayısı birlikte küçülüyor. Dört alanlı rejimde gereksiz kopya **0**'a iniyor ve bunun nedeni ilginçtir. O rejimde her alanda iki istasyon vardır; bir istasyonun kendi alanına taşırdığı çerçeve, alandaki tek öteki istasyona — yani tam olarak hedefe — gider. **Alan iki istasyona indiğinde taşırma ile öğrenilmiş iletme aynı şeydir.** Tablo o alanda hiçbir kazanç sağlamaz; bölütleme tablonun işini yapmıştır. Satır sütunu ise vaadi tutmuyor. Dört rejimin üçünde satır sayısı **16**'dır: bölütleme yayın alanını bölmesine rağmen tablo satırını bölmemiştir. Gerekçe doğrudandır — tablo, adresleri kimliğe göre ayırır ama **yok etmez.** Sekiz adres, dört alana bölünse de sekiz adrestir; her anahtar hâlâ sekizini de görür, çünkü etiketli bağlantı bütün kimlikleri taşır ve bütün kaynak adresleri karşıya geçer. İki alanlı iki rejimin ayrı sonuç vermesi de aynı ayrımdan gelir. Alan sayısı ikisinde de ikidir, ama ulaşan çerçeve birinde **17**, öbüründe **11**'dir. Fark bölütlemenin kabalığından değil **yerleşiminden** doğar: alanlar iki anahtara yayıldığında bir alanın üyeleri dört istasyon olur, alanlar tek anahtarda yerel kaldığında yine dört olur ama bu kez kimin kiminle konuştuğu kabloya bağlanmıştır. Aynı sayıda alan, aynı sayıda üye, ayrı sonuç. Satırı asıl bölen şey bölütleme değil, **etiketli bağlantının ne taşıdığıdır.** Üçüncü rejimde her alan tek bir anahtarda yerel kalır; etiketli bağlantının taşıyacağı ortak kimlik yoktur ve her anahtar yalnız kendi dört adresini öğrenir. Satır **16**'dan **8**'e iner. Bu tek başına bölütlemenin değil, **bölütleme ile yerleşimin birlikte** verdiği sonuçtur. #### Bölütlemenin Ürettiği Kara Delik Kazancın bedeli kara delik sütununda duruyor ve ödenen şey küçük değil. Bölütsüz ağda kırk çerçevenin kırkı da ulaşıyor. İki alana bölündüğünde **23**, yerel bölütlemede **29**, dört alana bölündüğünde **32** çerçeve kara deliğe düşüyor. Kırk çerçevelik kümede son değer **0,800**'dür: bölütleme, trafiğin dörtte üçünden fazlasını durdurmuştur. Bu bir arıza değildir, tanımın kendisidir. Yayın alanını bölmek, o alanların birbirine çerçeve gönderememesi demektir; kazanılan sessizlik ile kaybedilen erişim aynı şeyin iki yüzüdür. Ölçüm bunu bir kader adıyla yazıyor çünkü çerçeve gerçekten ölüyor: anahtar onu kendi alanı içinde taşırıyor, hedef o alanda olmadığı için hiçbir kopya hedefe varmıyor ve kimse bir hata bildirmiyor. Ayrımın nereye kaydığına dikkat edilmelidir. Önceki derste kara delik bir **yanılgıydı** — tablo eskimişti, cihaz yanlış bacağa çıkıyordu. Burada kara delik bir **karardır**: tablo doğrudur, kimlik doğrudur, cihaz tam olarak kendisinden isteneni yapmıştır. Aynı ad, iki ayrı nedenle yazılır ve ikisini ayıran şey tablonun doğru olup olmadığıdır. Kara deliğin bu ikinci türü, alanın sınırının nereye düştüğünü de belirler. Bir yayın alanı, adres çözümlemenin yürüyebildiği en geniş kümedir: bir istasyon ancak kendi alanındaki bir adresi sorabilir, çünkü sorusu bir yayın çerçevesiyle taşınır ve o çerçeve alanın dışına çıkmaz. Bu yüzden yayın alanının sınırı ile adres bloğunun sınırı aynı yere düşer; Ağ Modelleri kursunda kurulan alt ağ hesabı burada tekrarlanmaz, ama bölütleme her yeni alan için ayrı bir blok gerektirir. Kırk çerçevelik kümede **32** kara delik **0,800**'dür ve çözünürlüğün otuz iki katıdır; bu ölçekte iddia kurgunun ayrıntısına değil, bölütlemenin tanımına dayanır. Etiketli sütunu üçüncü bir okumayı veriyor. Bölütsüz ağda **29** çerçeve iki anahtar arasındaki kabloyu kullanıyor; iki alana bölündüğünde **14**'e, yerel bölütlemede **0**'a iniyor. Yerel bölütleme kabloyu tümüyle boşaltır — ama boşalttığı kablo aynı zamanda **29** çerçevenin ölme nedenidir. Bir bağlantının kullanılmaması onun gereksiz olduğunu göstermez. #### Özet - Sanal yerel ağ, kimliği bacağa atar; istasyon kimliği görmez ve çerçevesine hiçbir alan eklenmez. Yayın alanının sınırı fiziksel olmaktan çıkıp bildirimsel olur. - Etiketli bağlantı, kimliği çerçeveye dört baytlık bir alanla yazar; 12 bitlik kimlik alanı 4094 kullanılabilir değer verir ve etiket istasyona çıkarken düşürülür. - Bölütleme taşırma teslimini **280**'den **51**'e ve **8**'e indirir; alan iki istasyona düştüğünde gereksiz kopya **0** olur ve taşırma ile öğrenilmiş iletme aynı şeye dönüşür. - Tablo satırı üç rejimde de **16** kalır: bölütleme adresleri ayırır, yok etmez. Satırı **8**'e indiren şey bölütleme değil, etiketli bağlantının o kimliği hiç taşımamasıdır. - Bedel kara deliktir: **0**, **23**, **29**, **32**. Bu kara delik bir yanılgı değil bir karardır — tablo doğrudur ve cihaz isteneni yapmıştır. #### Sonraki Adım Bu ölçümde iki anahtar arasında tek bir kablo vardı ve taşırılan her çerçeve o kabloyu bir kez geçip bitiyordu. İki anahtar arasına ikinci bir kablo çekilirse durum değişir: taşırılan çerçeve birinci kablodan gidip ikinciden geri döner, geri döndüğünde yeniden taşırılır ve bu kez birinci kablodan çıkar. Çerçeveyi durduracak bir alan yoktur — bağlantı katmanı çerçevesinde bir atlama sayacı bulunmaz. Sonraki ders yedekli bağların bu sonucunu ve onu önleyen protokolün kararını ölçer: hangi bağ engellenir ve engel yeniden hesaplanana kadar geçen turda paketin kaderi ne olur. ### Kapsayan Ağaç Protokolü Source: https://academia.sh/tr/kurslar/anahtarlama-ve-yonlendirme/kapsayan-agac-protokolu Engellenmemiş bir halkada tek bir yayın çerçevesi on iki turda 142 kopya üretir ve durmaz; ağaçta 7 kopyada biter. Ağaç yeniden kurulduğunda tablolar eskiyse 20 paket kara deliğe düşer, tabloları yalnız iki anahtar tazelemişse 10 paket döngüye girer. Önceki ders iki anahtar arasına tek bir kablo koydu ve taşırılan her çerçeve o kabloyu bir kez geçip bitti. Yedeklilik istendiğinde ikinci bir kablo çekilir; iki anahtar iki ayrı yoldan birbirine bağlanır ve biri koptuğunda öbürü ayakta kalır. Bu, ağ tasarımının en eski ve en doğal isteğidir. İstek, taşırma ile bir araya geldiğinde bir arıza üretir. Taşırılan çerçeve birinci kablodan karşıya geçer, karşıdaki anahtar onu geldiği bacak dışındaki bütün bacaklara taşırır — ikinci kablo da bunların içindedir — ve çerçeve ilk anahtara geri döner. Geri döndüğünde ilk anahtar onu yeniden taşırır. Bu dersin sorusu, bu dönüşün nasıl durdurulduğu ve durdurma kararının paketin kaderine ne yaptığıdır. #### Çerçevede Sayaç Yoktur Yukarıdaki dönüşün neden kendiliğinden bitmediğini görmek için çerçeveye bakmak yeter. Bir Ethernet çerçevesinde hedef adresi, kaynak adresi, tür alanı, yük ve denetim dizisi vardır. **Kaç cihazdan geçtiğini sayan bir alan yoktur.** Ağ katmanı paketinde böyle bir alan bulunur ve Ağ Modelleri kursunda kuruldu; bağlantı katmanı çerçevesinde bulunmaz. Sonuç ikili değil, üçlüdür. Birincisi, dolaşan çerçeve hiçbir zaman **yaşlanarak** ölmez. İkincisi, halka üzerindeki her anahtar çerçeveyi her turda **çoğaltır**: gelen bir kopya, giden birden çok kopya doğurur. Üçüncüsü, aynı kaynak adresi farklı bacaklardan görüldüğü için her anahtarın eşleştirme tablosu tur başına yeniden yazılır — tablo, önceki derste ölçülen anlamda eskimiş değil, **kararsızdır.** Bu üçlü, döngünün neden kara delikten daha pahalı olduğunun ilk örneğidir. Kara delikte paket ölür ve iş biter; burada paket ölmez, çoğalır ve ağın taşıma kapasitesini kendisi tüketir. Dışarıdan bakan biri bunu bir tıkanıklık olarak görür. #### Protokolün Kararı Çözüm, fiziksel olarak halka olan bir topolojiyi mantıksal olarak **ağaç** hâline getirmektir. Ağaçta çevrim yoktur; çevrim yoksa dönüş de yoktur. Bunun için bazı bağların **engellenmesi** gerekir: bağ ayakta kalır, kablo takılıdır, ama üzerinden veri çerçevesi geçmez. **Kapsayan ağaç protokolü (spanning tree protocol)** bu ağacı anahtarların kendi aralarında kurmasını sağlar. Karar üç adımdadır. Anahtarlar önce bir **kök** seçer: her anahtarın bir tanımlayıcısı vardır ve en küçük tanımlayıcı kök olur. Sonra her anahtar köke giden en ucuz bacağını **kök bacağı** olarak işaretler. Son olarak her bağ üzerinde, o bağı köke daha ucuz bağlayan uç **atanmış** sayılır; öbür uç **engellenir.** Ağacın kendisinin nasıl kurulduğu bu dersin konusu değildir. Kapsayan ağaç kavramı ve açgözlü kurulumu Algoritmalar kursundaki Minimum Kapsayan Ağaç dersinde kuruldu; burada yeniden türetilmez. Burada ölçülen şey **protokolün kararı** ve o kararın paketlere ne yaptığıdır. ```text # ogretilen dokum, calistirilmamistir topoloji: a-b-c-d-e-f-g-h-a halkasi + b-f kirisi (8 dugum, 9 bag) kok: a bacak rolleri (kok a icin) b: kok bacagi -> a | atanmis -> c, f h: kok bacagi -> a | atanmis -> g c: kok bacagi -> b | atanmis -> d f: kok bacagi -> b | atanmis -> e d: kok bacagi -> c | d-e ENGELLI g: kok bacagi -> h | f-g ENGELLI protokol iletisi (anahtardan anahtara, veri degil) kok tanimlayicisi | koke maliyet | gonderen tanimlayici | bacak ``` Kök seçiminde tanımlayıcının küçüklüğü bir yetenek ölçüsü değildir; yalnızca bütün anahtarların aynı sonuca varmasını sağlayan bir sıralama kuralıdır. Kök nerede olursa olsun ağaç kurulur, ama ağacın **biçimi** köke bağlıdır ve yolların uzunluğu da öyle. #### Ölçümün Varsayımları - **AC22** — Topoloji ortak tanımın topolojisidir: sekiz anahtar, yedi bağdan bir halka (`a–b–c–d–e–f–g–h–a`) ve halkayı kesen `b–f` kirişi; toplam dokuz bağ. Kâhin topolojiyi biz kurduğumuz için bilinir ve her düğüm için her hedefe giden en kısa yolun ilk adımıdır. - **AC23** — Kök `a`'dır ve ağaç kökten enine yürünerek kurulur: her anahtar köke en yakın bacağını tutar, kalan bağlar engellenir. En küçük kapsayan ağaç algoritması burada çalıştırılmaz; ağacın **sonucu** kullanılır. - **AC24** — Taşırma ölçümünde bir yayın çerçevesi kökten çıkar; her düğüm, çerçeveyi geldiği bacak dışındaki her bağa kopyalar. Durduran hiçbir düzenek yoktur çünkü çerçevede atlama sayacı yoktur. Ölçüm tur sınırıyla kesilir; kesilmesi çerçevenin durduğu anlamına gelmez. - **AC25** — Kırk kaynak–hedef çifti tek bir üreteçten, tek bir modülüsle çekilir; kaynağın hedefe eşit olduğu çekiliş atılır. Aynı kırk çift bütün rejimlerde kullanılır. - **AC26** — Kopan bağ `b–f` kirişidir. Kiriş halkanın iki yakasını kısa devre yaptığı için ağacın çoğu ondan geçer; koptuğunda çok sayıda anahtarın kararı değişmek zorundadır. - **AC27** — Beş rejim karşılaştırılır: ağaç kurulu ve kopma yok; bağ koptu ama ne ağaç ne tablo yenilendi; ağaç yenilendi ama tablolar eski; ağaç yenilendi ve tabloyu yalnız iki anahtar tazeledi; ağaç yenilendi ve bütün tablolar temizlendi. - **AC28** — Atlama sınırı 12'dir. Sınırı yakan ya da aynı bağdan ikinci kez geçen paket **döngü**, bir sonraki düğümü tabloda bulunmayan ya da artık komşu olmayan paket **kara delik** sayılır. - **AC29** — Kümenin çözünürlüğü kırk pakettir; ölçülebilen en küçük fark $1/40 = 0{,}025$. #### Ölçüm ```python """Kapsayan agac protokolunun karari: engellenen bag ve paketin kaderi. Agac, kokten enine yurunerek kurulur; en kucuk kapsayan agac algoritmasi Algoritmalar kursunda kuruldu ve burada yeniden turetilmez. """ TOHUM = 20260810 DUGUMLER = ["a", "b", "c", "d", "e", "f", "g", "h"] BAGLAR = [("a", "b"), ("b", "c"), ("c", "d"), ("d", "e"), ("e", "f"), ("f", "g"), ("g", "h"), ("h", "a"), ("b", "f")] KOPAN, KOK, ATLAMA_SINIRI = ("b", "f"), "a", 12 def uretec(tohum): d = tohum % 2147483646 + 1 def r(n): nonlocal d d = (d * 48271) % 2147483647 return d % n return r def komsuluk(baglar): k = {u: set() for u in DUGUMLER} for x, y in baglar: k[x].add(y) k[y].add(x) return k def kahin(baglar): """Her dugum icin her hedefe giden en kisa yolun ilk adimi.""" k, tablo = komsuluk(baglar), {} for kaynak in DUGUMLER: onceki, sira, gorulen = {}, [kaynak], {kaynak} while sira: yeni = [] for u in sira: for v in sorted(k[u]): if v not in gorulen: gorulen.add(v) onceki[v] = u yeni.append(v) sira = yeni for hedef in DUGUMLER: if hedef == kaynak or hedef not in onceki: continue adim = hedef while onceki[adim] != kaynak: adim = onceki[adim] tablo[(kaynak, hedef)] = adim return tablo def agac(baglar, kok=KOK): """Koke en yakin bacak tutulur, kalan bag engellenir.""" k, gorulen, sira, kalan = komsuluk(baglar), {kok}, [kok], [] while sira: yeni = [] for u in sira: for v in sorted(k[u]): if v not in gorulen: gorulen.add(v) kalan.append(tuple(sorted((u, v)))) yeni.append(v) sira = yeni return kalan def ilet(kaynak, hedef, tablolar, baglar): k, u, gecilen, atlama = komsuluk(baglar), kaynak, [], 0 while u != hedef: if atlama >= ATLAMA_SINIRI: return "dongu", atlama sonraki = tablolar.get((u, hedef)) if sonraki is None or sonraki not in k[u]: return "kara delik", atlama if (u, sonraki) in gecilen: return "dongu", atlama gecilen.append((u, sonraki)) u, atlama = sonraki, atlama + 1 return "ulasti", atlama def ciftler(sayi=40): r, liste = uretec(TOHUM), [] while len(liste) < sayi: x, y = DUGUMLER[r(8)], DUGUMLER[r(8)] if x != y: liste.append((x, y)) return liste def olc(tablolar, baglar): sayim, adim = {"ulasti": 0, "dongu": 0, "kara delik": 0}, 0 for x, y in ciftler(): kader, a = ilet(x, y, tablolar, baglar) sayim[kader] += 1 adim += a return sayim, adim def kismi(eski, yeni, guncelleyen): """Yeni agaci yalniz bir kume duymustur; otekiler eskisini surdurur.""" return {(u, h): (yeni if u in guncelleyen else eski)[(u, h)] for (u, h) in eski if (u, h) in yeni} def tasir(baglar, kaynak, tur_siniri): """Yayin cercevesi: her dugum, geldigi bacak disindaki her baga kopyalar.""" k, dalga, kopya = komsuluk(baglar), [(kaynak, None)], 0 for _ in range(tur_siniri): yeni = [] for u, geldigi in dalga: for v in sorted(k[u]): if v != geldigi: kopya += 1 yeni.append((v, u)) dalga = yeni if not dalga: break return kopya, len(dalga) KOPUK = [b for b in BAGLAR if b != KOPAN] ESKI, YENI = agac(BAGLAR), agac(KOPUK) ESKI_KOPUK = [b for b in ESKI if b != KOPAN] print(f"bağ {len(BAGLAR)} | ağaç bağı {len(ESKI)} | eski ağacın engellediği " f"{[b for b in BAGLAR if tuple(sorted(b)) not in ESKI]}") print(f"kopan bağ {KOPAN} | yeni ağacın engellediği " f"{[b for b in KOPUK if tuple(sorted(b)) not in YENI]}") print() print(f"{'tur':>3s} {'halka kopya':>11s} {'ayakta':>6s} {'ağaç kopya':>10s} " f"{'ayakta':>6s}") for tur in (1, 2, 4, 6, 8, 10, 12): k1, a1 = tasir(BAGLAR, KOK, tur) k2, a2 = tasir(ESKI, KOK, tur) print(f"{tur:3d} {k1:11d} {a1:6d} {k2:10d} {a2:6d}") print() print(f"{'rejim':<32s} {'ulaştı':>6s} {'döngü':>6s} {'kara delik':>11s} " f"{'adım':>5s}") for ad, tab, bag in ( ("ağaç kurulu, kopma yok", kahin(ESKI), ESKI), ("bağ koptu, ağaç ve tablo eski", kahin(ESKI), ESKI_KOPUK), ("ağaç yeni, tablolar eski", kahin(ESKI), YENI), ("ağaç yeni, tablo iki anahtarda", kismi(kahin(ESKI), kahin(YENI), {"b", "f"}), YENI), ("ağaç yeni, tablolar temiz", kahin(YENI), YENI)): s, a = olc(tab, bag) print(f"{ad:<32s} {s['ulasti']:6d} {s['dongu']:6d} {s['kara delik']:11d} " f"{a:5d}") ``` ``` bağ 9 | ağaç bağı 7 | eski ağacın engellediği [('d', 'e'), ('f', 'g')] kopan bağ ('b', 'f') | yeni ağacın engellediği [('e', 'f')] tur halka kopya ayakta ağaç kopya ayakta 1 2 2 2 2 2 5 3 5 3 4 14 5 7 0 6 27 7 7 0 8 50 13 7 0 10 85 19 7 0 12 142 33 7 0 rejim ulaştı döngü kara delik adım ağaç kurulu, kopma yok 40 0 0 106 bağ koptu, ağaç ve tablo eski 21 0 19 70 ağaç yeni, tablolar eski 20 0 20 64 ağaç yeni, tablo iki anahtarda 25 10 5 100 ağaç yeni, tablolar temiz 40 0 0 129 ``` #### Engellemenin Karşılığı Üst tablo protokolün var olma nedenini veriyor. Dokuz bağlı halkada tek bir yayın çerçevesi dördüncü turda **14**, sekizinci turda **50**, on ikinci turda **142** kopya üretiyor ve o anda hâlâ **33** kopya yolda. Sayı büyümeyi sürdürüyor; ölçüm turu bitirdiği için duruyor, çerçeve durduğu için değil. Bir tek çerçeve, sekiz anahtarlı bir ağı tek başına doldurur. Ağaçta aynı çerçeve dördüncü turda **7** kopyada biter ve ayakta hiçbir kopya kalmaz. Yedi sayısı ağacın bağ sayısıdır ve tesadüf değildir: ağaçta her bağ tam bir kez, kökten uzağa doğru geçilir. **Taşırma bir ağaçta sonlu, bir çevrimde sonsuzdur** ve aradaki fark iki bağın engellenmesinden ibarettir. Bedel de aynı yerde durur. Dokuz bağın ikisi veri taşımaz; kablolar takılıdır, bacaklar ayaktadır, ama üzerlerinden çerçeve geçmez. Yedeklilik için çekilen kablo, yedeklilik ihtiyacı doğana kadar boş bekler. #### Engel Kalkana Kadar Alt tablo kirişin koptuğu andan yeni ağacın oturmasına kadar geçen süreyi beş adımda okuyor. **Ağaç kuruluyken** kırk paketin kırkı da ulaşıyor, **106** adım harcanıyor. Bu, engellemenin maliyetinin de göstergesidir: aynı kırk çift, bütün bağlar açık olsaydı daha kısa yollardan giderdi. Engelleme yolları uzatır ama hiçbir paketi kaybetmez. **Bağ koptuğunda ve kimse duymadığında** ulaşan **21**'e iner, **19** paket kara deliğe düşer. Adım **70**'e düşüyor — daha az adım, daha az iş değil, **erken ölüm** demektir. Kara deliğe düşen paket ilerlemeyi bırakır; harcamadığı adım, bir kazanç değil bir kayıptır. **Ağaç yeniden kurulup tablolar eski kaldığında** durum bir parça daha kötüdür: ulaşan **20**, kara delik **20**. Protokol topolojiyi düzeltmiştir, ama eşleştirme tabloları hâlâ eski ağacın bacaklarını göstermektedir. Yeni ağaç bir bağı açmış, bir başkasını engellemiştir; tablolar kapanmış bacağı gösterdiği sürece paket komşu olmayan bir yere yollanır ve orada biter. Bu, protokolün neden yalnız ağacı yeniden kurmakla yetinmediğinin gerekçesidir: topoloji değişimi bildirildiğinde tabloların **yaşı da kısaltılır**, böylece eski girdiler hızla düşer. **Tabloyu yalnız iki anahtar tazelediğinde** tablo ilk kez üçüncü kaderi üretiyor: **25** ulaşıyor, **5** kara deliğe düşüyor ve **10** paket **döngüye** giriyor. Adım **64**'ten **100**'e çıkıyor. İki anahtar yeni bacağı gösterirken komşuları eskisini gösterdiği için paket ileri gidip geri dönüyor ve atlama sınırını yakana kadar dolaşıyor. Buradan ortak tanımın ikinci iddiası okunur: **kısmî bilgi, hiç bilgiden daha pahalı bir arıza üretir.** Kimse duymadığında paket hemen ölüyordu; iki anahtar duyduğunda kara delik **20**'den **5**'e indi, ama **10** paket ölmek yerine dolaşmaya başladı ve adım **64**'ten **100**'e çıktı. Kaybedilen paket sayısı azaldı, harcanan iş arttı ve arıza **görünmez** hâle geldi — dolaşan paket bir hata değil, bir tıkanıklık gibi görünür. Üçüncü iddia da aynı satırdan okunur ve yapısaldır. **Hiçbir anahtar tek başına bir paketi döngüye sokamaz.** Döngü için biri paketi ileri, öbürü geri gönderen **en az iki tablo** gerekir; ilk üç rejimde bütün tablolar aynı ağacı gösterdiği için, yanlış olsalar bile döngü doğmadı. Döngü, tablonun yanlışlığından değil **tabloların anlaşmazlığından** doğar. **Bütün tablolar temizlendiğinde** kırk paketin kırkı yeniden ulaşıyor ve adım **129**'a çıkıyor. Kiriş gittiği için yollar uzamıştır; ama **hiçbir paket kaybolmaz.** Yakınsamanın tanımı budur: pahalı ama doğru. #### Özet - Bağlantı katmanı çerçevesinde atlama sayacı yoktur; çevrim içeren bir topolojide taşırılan çerçeve yaşlanarak ölmez, her turda çoğalır ve tabloları kararsız bırakır. - Kapsayan ağaç protokolü bir kök seçer, her anahtarın köke giden bacağını tutar ve kalan bağları engeller; halkada tek bir yayın çerçevesi on ikinci turda **142** kopyaya çıkarken ağaçta **7** kopyada biter. - Engellemenin bedeli boş bekleyen kablo ve uzayan yoldur: ağaçta kırk paket **106** adımda ulaşır, kopma sonrası yeni ağaçta **129** adımda — ama kırkı da ulaşır. - Kopmayı kimse duymadığında **19**, ağaç yenilenip tablolar eski kaldığında **20** paket kara deliğe düşer; adımın **70** ve **64**'e inmesi kazanç değil erken ölümdür. - Tabloyu yalnız iki anahtar tazelediğinde kara delik **5**'e iner ama **10** paket döngüye girer ve adım **100**'e çıkar: kısmî bilgi, hiç bilgiden pahalı bir arıza üretir. - Döngü tek bir tablonun yapabileceği bir şey değildir; en az iki tablonun anlaşmazlığıdır. #### Sonraki Adım Kapsayan ağacın yedekliliğe verdiği yanıt tek yönlüdür: ikinci bağ vardır, ama beklemektedir. Ölçümde iki bağ engellendi ve o iki bağın taşıma kapasitesi kopma anına kadar kullanılmadı. Buradan bir soru doğar: iki bağ aynı anda kullanılabilir mi? Çevrim yasağı bunu yasaklıyor gibi görünür, çünkü iki bağ iki yol demektir ve iki yol taşırılan çerçeveyi geri getirir. Sonraki ders bu yasağın etrafından dolaşan düzeneği ölçer: birden çok bağı **tek bir mantıksal bağ** sayan bir toplama, dağıtım kararının aynı akışı neden bölmediği ve bir bacak düştüğünde kaç akışın taşındığı. ### Bağlantı Toplama Source: https://academia.sh/tr/kurslar/anahtarlama-ve-yonlendirme/baglanti-toplama Akış başına dağıtım hiçbir akışı bölmez ve sırayı bozmaz ama bacak yükünü 0 ile 19 arasına dağıtır; çerçeve başına dağıtım yükü eşitler, 8 akışın 7'sini böler. Bir bacak düştüğünde modülüs yeniden eşlemesi 8 akışın 7'sini taşır, yerinde eşleme yalnız 3'ünü. Önceki ders yedekliliğe verilen ilk yanıtı ölçtü: fazladan bağ çekilir, protokol onu engeller ve engellenen bağ kopma anına kadar bekler. Ölçümde dokuz bağın ikisi hiç veri taşımadı. Kapasitesi vardır, kablosu takılıdır ve boştur. Buradan doğal bir soru çıkar: iki bağ aynı anda kullanılamaz mı? Çevrim yasağı bunu yasaklıyor gibi görünür — iki bağ iki yol demektir, iki yol taşırılan çerçeveyi geri getirir ve döngü doğar. Bu dersin sorusu, yasağın nasıl aşıldığı ve aşmanın hangi yeni kararı gerektirdiğidir. #### Tek Mantıksal Bağ **Bağlantı toplama (link aggregation)**, iki anahtar arasındaki birden çok fiziksel bacağı tek bir mantıksal bağ olarak sunmaktır. Kapsayan ağaç protokolü topolojiyi bu mantıksal bağlar üzerinden görür: dört bacak dört bağ değil, **bir bağdır.** Bunun sonucu doğrudandır. Önceki dersin ölçümünde çevrim, iki anahtar arasındaki iki ayrı bağdan doğuyordu; toplama bu iki bağı bire indirdiği için ağaç bir çevrim görmez ve hiçbirini engellemez. Yasağı çiğneyen bir düzenek değildir; **yasağın konusu olan çevrimi ortadan kaldıran** bir düzenektir. Taşırma da aynı görüntüye uyar. Yayın çerçevesi mantıksal bağa verilir ve yalnız **bir** bacaktan çıkar; karşı anahtar onu tek bir kopya olarak alır. Toplamanın en önemli kuralı burada belirir: gelen bir çerçeve, aynı toplamanın başka bir bacağından geri gönderilmez. Bu kural olmasaydı toplama, önceki dersin ölçtüğü çoğalmayı kendi içinde yeniden üretirdi. Toplamanın kurulduğunun iki uçta da bilinmesi gerekir. Bacaklar bir uçta toplanmış, öbür uçta ayrı ayrı sayılmışsa, bir yanın tek bağ gördüğü yerde öbür yan birden çok bağ görür ve ağacın engelleme kararı iki uçta ayrı çıkar. Bu yüzden toplama, iki uç arasında bir denetim iletisiyle **anlaşılarak** kurulur; anlaşma sağlanamayan bacak toplamaya alınmaz ve ayrı bir bağ olarak bırakılır. #### Dağıtım Kararı Akışa Bakar Toplanmış bir bağa verilen her çerçeve için bir karar gerekir: hangi bacaktan çıkacak? En basit yanıt sırayla dağıtmaktır ve yükü en iyi dengeleyen yanıt da budur. Ama bir sorun vardır. Bacaklar aynı kabloda değildir. Her birinin kendi kuyruğu, kendi uzunluğu, kendi anlık doluluğu vardır; iki bacak arasındaki gecikme farkı sıfır değildir. Aynı akışa ait iki çerçeve iki ayrı bacaktan gönderilirse, ikincisi birincisinden önce varabilir. Bağlantı katmanı bunu düzeltemez. Önceki derste görüldüğü gibi Ethernet çerçevesinde atlama sayacı yoktur; **sıra numarası da yoktur.** Alıcı anahtar, elindeki iki çerçevenin hangisinin önce gönderildiğini bilemez ve onları yeniden sıralayamaz. Sırayı bozmamak, gönderen tarafın kararına kalır. Sırasız teslimin bedeli üst katmanda ödenir. Ağ Modelleri kursundaki TCP dersinde kurulan düzenek sırasız gelen segmentleri yeniden sıralar, ama bunu tampon tutarak ve kimi durumda gereksiz yeniden iletim yaparak yapar; sıralamayı hiç beklemeyen bir uygulama ise veriyi bozulmuş sayar. Bu yüzden yaygın kural şudur: **dağıtım kararı çerçeveye değil akışa bakar.** Aynı akışın bütün çerçeveleri aynı bacaktan çıkar. Akışın ne olduğu bir seçimdir. Yalnız donanım adresi çiftine bakan bir özet, iki anahtar arasındaki bütün trafiği tek bir akış sayar ve toplamayı hükümsüz bırakır; adres çiftine bağlantı noktalarını da katan bir özet akışı inceltir ve dengeyi iyileştirir. Ölçüm en kaba biçimi kullanır, çünkü ölçülen şey özetin inceliği değil kararın **neye baktığıdır.** ```text # ogretilen dokum, calistirilmamistir toplama yapilandirmasi (anahtar 1 <-> anahtar 2) mantiksal bag: t1 bacak 0 anlasti bacak 1 anlasti bacak 2 anlasti bacak 3 anlasti agacin gordugu: TEK bag dagitim karari akis basina : bacak = ozet(kaynak, hedef) mod bacak_sayisi cerceve basina: bacak = sira_no mod bacak_sayisi kural: bir toplamadan gelen cerceve ayni toplamanin baska bir bacagindan geri gonderilmez. ``` #### Ölçümün Varsayımları - **AC30** — Dört bacaklı tek bir toplama vardır. Sekiz akış, ortak topolojinin düğüm adlarından tek bir üreteçle, tek modülüsle çekilir; kırk çerçevenin her biri ayrı bir üreteçle bu sekiz akıştan birine atanır. Kâhin akış–çerçeve eşlemesini biz kurduğumuz için bilinir. - **AC31** — Akış özeti, akışı tanımlayan adların karakter değerlerinin toplamıdır ve bacak numarası bu özetin bacak sayısına göre kalanıdır. Özetin inceliği ölçümün konusu değildir. - **AC32** — Bacak gecikmeleri eşit değildir ve sırasıyla 1, 2, 1, 3 birimdir. Her bacak birim zamanda bir çerçeve işler; bir çerçevenin varış anı, bacağın boşalma anına gecikmenin eklenmesiyle bulunur. - **AC33** — Bir çerçeve, aynı akışın kendisinden **sonra** gönderilmiş bir çerçevesinden sonra varıyorsa **sırasız** sayılır. Sıralama bağlantı katmanında düzeltilemez, çünkü çerçevede sıra numarası yoktur. - **AC34** — İki dağıtım şeması karşılaştırılır: akış başına ve çerçeve başına. Aynı kırk çerçeve ikisinde de kullanılır. - **AC35** — Kopma rejiminde 1 numaralı bacak düşer. Yeniden eşleme iki kuralla denenir: **modülüs**, bacak sayısı azaldığı için bütün akışları yeniden hesaplar; **yerinde**, yalnız düşen bacaktaki akışları taşır ve ötekilere dokunmaz. - **AC36** — Kopma 20. çerçevede olur ve dağıtım eşlemesi beş çerçeve sonra güncellenir. Bu pencerede düşen bacağa yazılmış çerçeveler **kara delik** sayılır: bacak yoktur, çerçeve bir yere varmaz ve kimse bildirmez. - **AC37** — Kümenin çözünürlüğü kırk çerçeve ve sekiz akıştır; çerçeve kümesinde ölçülebilen en küçük fark $1/40 = 0{,}025$, akış kümesinde $1/8 = 0{,}125$'tir. #### Ölçüm ```python """Baglanti toplama: dagitim akisi bolmez, dusen bacak akis tasir.""" TOHUM = 20260810 DUGUMLER = ["a", "b", "c", "d", "e", "f", "g", "h"] BACAK, GECIKME = 4, (1, 2, 1, 3) DUSEN, KOPMA_ANI, PENCERE = 1, 20, 5 def uretec(tohum): d = tohum % 2147483646 + 1 def r(n): nonlocal d d = (d * 48271) % 2147483647 return d % n return r def akislar(sayi=8): r, liste = uretec(TOHUM), [] while len(liste) < sayi: x, y = DUGUMLER[r(8)], DUGUMLER[r(8)] if x != y and (x, y) not in liste: liste.append((x, y)) return liste def cerceveler(A, sayi=40): r = uretec(TOHUM + 1) return [{"no": i, "akis": A[r(8)]} for i in range(sayi)] def ozet(akis): return sum(ord(c) for c in akis[0] + akis[1]) def bacak(c, sema, bacaklar): n = len(bacaklar) return bacaklar[ozet(c["akis"]) % n if sema == "akış" else c["no"] % n] def varis(C): """Her bacak birim zamanda bir cerceve isler; gecikmeler esit degil.""" bos = {} for c in C: basla = max(c["no"], bos.get(c["bacak"], 0)) bos[c["bacak"]] = basla + 1 c["varis"] = basla + 1 + GECIKME[c["bacak"]] return C def sirasiz(C): enson, sayi = {}, 0 for c in sorted(C, key=lambda c: (c["varis"], c["no"])): if c["akis"] in enson and enson[c["akis"]] > c["no"]: sayi += 1 enson[c["akis"]] = max(enson.get(c["akis"], -1), c["no"]) return sayi A, TUM = akislar(), list(range(BACAK)) print(f"akış {len(A)} | çerçeve 40 | bacak {BACAK} | düşen bacak {DUSEN}") print() print(f"{'dağıtım':<8s} {'bacak yükü':>18s} {'en az':>5s} {'en çok':>6s} " f"{'bölünen akış':>12s} {'sırasız':>7s}") for sema in ("akış", "çerçeve"): C = cerceveler(A) for c in C: c["bacak"] = bacak(c, sema, TUM) varis(C) yuk = [sum(1 for c in C if c["bacak"] == b) for b in TUM] bolunen = sum(1 for a in A if len({c["bacak"] for c in C if c["akis"] == a}) > 1) print(f"{sema:<8s} {str(yuk):>18s} {min(yuk):5d} {max(yuk):6d} " f"{bolunen:12d} {sirasiz(C):7d}") print() KALAN = [b for b in TUM if b != DUSEN] C = cerceveler(A) eski = {a: bacak({"akis": a, "no": 0}, "akış", TUM) for a in A} mod = {a: bacak({"akis": a, "no": 0}, "akış", KALAN) for a in A} yerinde = {a: (KALAN[ozet(a) % len(KALAN)] if eski[a] == DUSEN else eski[a]) for a in A} olen = sum(1 for c in C if KOPMA_ANI <= c["no"] < KOPMA_ANI + PENCERE and eski[c["akis"]] == DUSEN) print(f"düşen bacaktaki akış {sum(1 for a in A if eski[a] == DUSEN)} | " f"{PENCERE} çerçevelik pencerede ölen çerçeve {olen}") print() print(f"{'yeniden eşleme':<16s} {'taşınan akış':>12s} {'yerinde kalan':>13s} " f"{'yeni yük':>14s}") for ad, yeni in (("modülüs", mod), ("yerinde", yerinde)): tasinan = sum(1 for a in A if yeni[a] != eski[a]) yuk = [sum(1 for c in C if yeni[c["akis"]] == b) for b in KALAN] print(f"{ad:<16s} {tasinan:12d} {len(A) - tasinan:13d} {str(yuk):>14s}") ``` ``` akış 8 | çerçeve 40 | bacak 4 | düşen bacak 1 dağıtım bacak yükü en az en çok bölünen akış sırasız akış [0, 19, 5, 16] 0 19 0 0 çerçeve [10, 10, 10, 10] 10 10 7 2 düşen bacaktaki akış 3 | 5 çerçevelik pencerede ölen çerçeve 2 yeniden eşleme taşınan akış yerinde kalan yeni yük modülüs 7 1 [26, 14, 0] yerinde 3 5 [13, 11, 16] ``` #### Sıra ile Denge Arasında Üst tablo iki dağıtım şemasını yan yana koyuyor ve ikisi de birer şey kazanıp birer şey kaybediyor. **Akış başına** dağıtım vaadini tam olarak tutuyor: bölünen akış **0**, sırasız varan çerçeve **0**. Sekiz akışın hiçbiri iki bacağa yayılmıyor, bu yüzden bacak gecikmeleri eşit olmasa da sıra hiç bozulmuyor. Sırayı korumak için fazladan hiçbir düzenek gerekmiyor — karar zaten sırayı koruyor. Bedeli yük sütununda duruyor ve küçük değil: bacaklar sırasıyla **0**, **19**, **5** ve **16** çerçeve taşıyor. Dört bacaklı bir toplamada bir bacak hiç kullanılmıyor, bir başkası kırk çerçevenin **19**'unu tek başına çekiyor. Toplamanın vaat ettiği kapasite dörde katlanma değil, akışların özet değerlerinin nereye düştüğüne bağlı bir dağılımdır. **Çerçeve başına** dağıtım yükü tam olarak eşitliyor: her bacak **10** çerçeve. Karşılığında sekiz akışın **7**'si bölünüyor — sekizincisi bölünmüyor çünkü o akışın çerçeveleri zaten tek bir bacağa denk gelmiş. Bölünmenin bedeli **2** sırasız çerçevedir. Bu sayı kırk çerçevelik kümede **0,050**'dir ve çözünürlüğün iki katıdır; ölçüm bandının içindedir ama küçüktür, çünkü bacak gecikmeleri arasındaki en büyük fark iki birimdir. Gecikme farkı büyüdükçe bu sayının büyüyeceği kurgudan okunur, ölçümden değil. Örüntü şudur: **dağıtım kararı ne kadar ince olursa denge o kadar iyi, sıra o kadar kırılgandır.** İkisini birden veren bir kural yoktur, çünkü sırayı koruyan şey akışı bölmemektir ve dengeyi kuran şey bölmektir. #### Kapasite Kimin Yük sütununun okunmasının pratik bir sonucu vardır ve toplama hakkındaki en yaygın yanılgıyı kapatır. Dört bacaklı bir toplamanın toplam kapasitesi dört bacağın toplamıdır, ama **tek bir akışın kapasitesi bir bacaktır.** Akış bölünmediği için bölünemez; özet değeri onu hangi bacağa düşürmüşse, o akışın taşıyabileceği en çok veri o bacağın kapasitesidir. Ölçüm bunu doğrudan gösteriyor: **19** çerçeve taşıyan bacak, tek başına o akışların tavanıdır ve boş duran bacak onlara hiçbir şey katmaz. Toplama, **çok sayıda akışı** olan bir bağı büyütür; **tek bir büyük akışı** olan bir bağı büyütmez. İki anahtar arasındaki trafik tek bir yedekleme aktarımından ibaretse, dört bacak çekmek bir bacak çekmekle aynı sonucu verir. Bunun ikinci yüzü yedekliliktir. Aynı düzenek, aynı kablolarla iki ayrı şey satın alır: akışlar çok olduğunda kapasite, bir bacak düştüğünde ayakta kalma. Hangisinin ağır bastığı akış sayısına bağlıdır ve bu, ölçülebilen bir şeydir. Bacakların hepsinin aynı anda taşıması zorunlu da değildir. **Etkin–bekleyen** düzenlemede bir bacak bütün trafiği taşır, ötekiler yalnız o düştüğünde devreye girer. Bu, dağıtım kararını tümüyle ortadan kaldırır: bölünen akış olmaz, sırasız çerçeve olmaz, denge sorunu olmaz. Karşılığında beklenen bacakların kapasitesi hiç kullanılmaz — önceki dersin engellenmiş bağıyla aynı durum, bu kez ağacın değil toplamanın kararıyla. #### Bir Bacak Düştüğünde Alt bölüm toplamanın asıl gerekçesine bakıyor. Bir bacak düştüğünde mantıksal bağ ayakta kalır; kapsayan ağaç bunu bir topoloji değişimi olarak görmez ve yeniden hesap yapmaz. Önceki derste ölçülen turlar burada hiç harcanmaz. Harcanmayan tur, bedava bir devralma anlamına gelmez. Düşen bacakta **3** akış vardır ve dağıtım eşlemesi güncellenene kadar geçen beş çerçevelik pencerede **2** çerçeve kara deliğe düşer. Bacak yoktur, çerçeve bir yere varmaz, kimse bir hata bildirmez. Pencere uzadıkça bu sayı doğrusal büyür. Asıl fark yeniden eşleme kuralında ortaya çıkıyor. **Modülüs** kuralı bacak sayısını dörtten üçe indirip bütün özetleri yeniden hesaplıyor ve sekiz akışın **7**'sini taşıyor. Oysa taşınması **gereken** akış yalnız **3** tanedir; kalan dördü sağlam bacaklarda duruyordu ve hiçbir gerekçe olmadan yer değiştirdi. Her yer değiştiren akış, karşı taraftaki eşleştirme tablosunda yeni bir bacak demektir ve o tablonun tazelenmesini bekler. **Yerinde** kural yalnız düşen bacaktaki **3** akışı taşıyor, beşini yerinde bırakıyor. Ve sonuç yalnız daha az iş değil, daha iyi bir dağılım: modülüs kuralı yükü **26**, **14**, **0** diye bölerken yerinde kural **13**, **11**, **16** veriyor. Bütün akışları yeniden hesaplamak dengeyi iyileştirmedi, bozdu — çünkü özet değerleri bacak sayısına göre kalan alındığında yeni bir kalıba düşer ve o kalıbın dengeli olacağının hiçbir güvencesi yoktur. Sekiz akışlık kümede **7** ile **3** arasındaki fark **0,500**'dür ve akış kümesinin çözünürlüğü olan **0,125**'in dört katıdır. Sonuç genel bir kurala varır: **bir kaynağın düşmesi, ona bağlı olmayan eşlemeleri değiştirmemelidir.** Değiştirdiğinde ödenen bedel, arıza ile hiç ilgisi olmayan akışların da yeniden yerleşmesidir. #### Özet - Bağlantı toplama, birden çok bacağı **tek bir mantıksal bağ** yapar; kapsayan ağaç bir çevrim görmediği için hiçbir bacağı engellemez ve toplamanın kendi kuralı, gelen çerçevenin aynı toplamadan geri gönderilmesini yasaklar. - Çerçevede sıra numarası yoktur; alıcı sıralayamaz, bu yüzden sırayı koruma yükümlülüğü dağıtım kararına düşer. - Akış başına dağıtım **0** akış böler ve **0** sırasız çerçeve verir, ama yükü **0**, **19**, **5**, **16** diye dağıtır; çerçeve başına dağıtım yükü **10**'a eşitler, **7** akışı böler ve **2** sırasız çerçeve üretir. - Bir bacak düştüğünde ağaç yeniden hesap yapmaz, ama eşleme güncellenene kadar geçen beş çerçevelik pencerede **2** çerçeve kara deliğe düşer. - Modülüs yeniden eşlemesi taşınması gereken **3** akış yerine **7** akışı taşır ve yükü **26**, **14**, **0** yapar; yerinde eşleme **3** akış taşır ve **13**, **11**, **16** verir. #### Sonraki Adım Bu konudaki beş dersin ölçtüğü bütün kararlar tek bir ortak varsayımı paylaşıyordu: kaynak ile hedef **aynı yerel ağın içindeydi.** Anahtar hedefi kendi tablosunda arıyordu çünkü hedefin kendi bacaklarından birinde olması bekleniyordu; taşırma bir işe yarıyordu çünkü taşırılan çerçevenin hedefe ulaşma ihtimali vardı; bölütleme kara delik üretiyordu çünkü hedef başka bir alandaydı ve oraya giden bir yol tanımlanmamıştı. Her durumda hedef, ya doğrudan komşuydu ya da hiç yoktu. Sonraki konu bu varsayımı kaldırır. Hedef başka bir ağdaysa, cihazın tablosunda o hedefin adresi hiçbir zaman bulunmayacaktır — çünkü hedef hiçbir bacağın arkasında değildir. Karar o zaman neye bakar ve bakılan şey hangi tabloda durur? ## Yönlendirme En uzun önek eşlemeden yönlendirme tablosuna, statik ile dinamik seçimin ölçütünden uzaklık vektörü ve bağlantı durumu ailelerinin yakınsamasına, politika tabanlı yönlendirmeden tablo ayrıştırma, etiket anahtarlama ve kaplama ağlarına. ### Yönlendirme Kararı Source: https://academia.sh/tr/kurslar/anahtarlama-ve-yonlendirme/yonlendirme-karari Yönlendirme kararı iletide yazana değil cihazın kendi tablosuna bakılarak alınır; aynı tablo iki farklı kuralla okunduğunda 256 adresin 12'sinde ayrışır ve tablo paylaşılan bir gerçeğin kopyası olduğu için kopma anında 40 paketin 26'sı ulaşır, 14'ü kara deliğe düşer. Buraya kadar verilen bütün kararlar **aynı yerel ağın içinde** verildi. Bir anahtar, çerçevenin hedefini kendi eşleştirme tablosunda arıyordu; bulduğunda çerçeveyi doğrudan o bağlantı noktasından çıkarıyor, bulamadığında taşırıyordu. Hedef her durumda **doğrudan komşuydu**: aynı yayın alanının içinde, bir adım ötede. Hedef başka bir ağdaysa bu kurgu çalışmaz. Doğrudan komşu değildir, tabloda bir bağlantı noktası karşılığı yoktur ve taşırmak bir seçenek değildir — ağların ağı taşırılamaz. Karar artık "hangi bağlantı noktası" sorusuna değil, **"kime vereyim"** sorusuna yanıt vermek zorundadır. Bu dersin sorusu, o yanıtın nereden okunduğudur. #### Karar Neye Bakar Bir yönlendiricinin verdiği karara **yönlendirme kararı (routing decision)** denir ve tek bir çıktısı vardır: **bir sonraki düğüm (next hop)**. Paketin hedef adresi girdidir, komşu düğümlerden biri çıktıdır. Yönlendirici hedefe giden yolun tamamını bilmez, bilmesi de gerekmez; yalnızca **bir adımı** bilir ve paketi oraya verir. Yolun kalanı sonraki düğümün sorunudur. Kararın alındığı yer paketin kendisi değildir. Paket hedef adresini taşır, başka bir şey taşımaz; hangi komşunun o hedefe yaklaştığını söylemez. Bunu söyleyen şey cihazın kendi belleğindeki **yönlendirme tablosudur**. Tablo, hedef adres öneklerini bir sonraki düğümlere eşleyen bir satır kümesidir: ```text # ogretilen dokum, calistirilmamistir yönlendirme tablosu — satırlar yazıldıkları sırada önek uzunluk bir sonraki düğüm 1010 4 kuzey 10110 5 batı 101011 6 doğu (boş) 0 merkez 10101100 8 yerel 10100 5 güney ``` Bu döküm bir belirtim değil, bir cihazın belleğinin okunmuş hâlidir; çalıştırılmamıştır ve buradan bir sayı iddiası çıkmaz. Dikkat edilecek tek şey satırların **sırasıdır**: satırlar zamanla eklenmiştir, uzunluğa göre sıralı değildir. Sonuncu satır ilk satırdan daha uzun bir önek taşır. Boş önek satırı özeldir: uzunluğu sıfırdır ve her adresle eşleşir. Bu satır **varsayılan yol**dur ve tablonun eksiklerini kapatır. Onun sayesinde tablo dünyanın bütün adreslerini saymak zorunda kalmaz. #### En Uzun Önek Eşleme Yukarıdaki tabloda bir adres birden çok satırla eşleşebilir. `10101100` ile başlayan bir adres beş satırın dördüne uyar. Hangisi kazanır? Kural **en uzun önek eşleme (longest prefix match)** adını taşır: eşleşen satırlar arasından öneki en uzun olan seçilir. Gerekçe bilgi miktarıdır. Uzun önek daha dar bir adres kümesini kapsar, dolayısıyla o küme hakkında **daha kesin** bir bildirimdir. Kısa önek ise geniş bir kümeyi kaba bir yaklaşımla toplar. İki bildirim çeliştiğinde kesin olan tercih edilir. Buradaki asıl nokta şudur: **kural tablonun içinde yazmaz.** Tablo yalnız satırları taşır; hangi satırın kazanacağını belirleyen kural cihazın belirtiminde durur. Aynı satır kümesini başka bir kuralla okuyan bir cihaz başka bir karar verir. En yaygın yanlış kural, satırları yazıldıkları sırada tarayıp **ilk eşleşeni** almaktır. #### Tablo Bir Kopyadır Linux Ağ Yönetimi ve Sorun Giderme kursunda yönlendirme tablosu **tek bir makinenin yapılandırması** olarak okunmuştu: bir dosya, bir komut çıktısı, o makineye ait bir gerçek. Burada tablo bir yapılandırma değil, **paylaşılan bir gerçeğin kopyasıdır** — ağın topolojisi tektir, ama her cihaz onun kendi kopyasını tutar ve kararını o kopyadan okur. Kopyalar anlaştığı sürece bu ayrım görünmez. Görünür hâle geldiği an, topolojinin değiştiği ve kopyaların henüz güncellenmediği andır. Bütün kopyaların gerçeğe uyduğu duruma **yakınsama (convergence)** denir; kurs boyunca ölçülen şey yakınsamanın kendisi değil, **yakınsamamış geçen süredir**. O sürede paketin üç kaderi vardır. **Ulaştı**: hedefine vardı. **Kara delik (black hole)**: bir düğümün tablosu artık var olmayan bir komşuyu gösterdi, paket orada öldü. **Döngü**: tablolar paketi birbirine geri gönderdi, paket atlama sınırını yakana kadar dolaştı. Ölçülen ağ sekiz düğümlüdür. Yedi bağ bir halka kurar, sekizinci bağ halkayı kesen bir kiriştir. Kiriş halkanın iki yakasını kısa devre yaptığı için tabloların çoğu ondan geçer; koptuğunda çok sayıda satırın kararı değişmek zorundadır. Gerçeğin kendisi — **kâhin (oracle)** — topolojiyi biz kurduğumuz için bilinir: her düğüm için her hedefe giden en kısa yolun ilk adımıdır. Ölçümün varsayımları: - **YL1** — Ağ sekiz düğümlü, dokuz bağlıdır; yedi bağ halkayı, dokuzuncu bağ halkayı kesen kirişi kurar. Topolojiyi kurgu ürettiği için kâhin bilinir. - **YL2** — Kâhin, her düğüm için her hedefe giden en kısa yolun ilk adımıdır ve ölçüm boyunca değiştirilmez. Gerçek her zaman en kısa yoldur. - **YL3** — Ölçülen kopma yalnız kirişin kaybıdır: bir bağ düşer, düğüm kaybı yoktur ve ağ bölünmez. Kopmadan sonra her hedefe hâlâ bir yol vardır. - **YL4** — Kırk kaynak–hedef çifti sabit bir tohumdan üretilir. Aynı çift birden çok kez çıkabilir ve ölçüm bu tekrarları ayrı paket sayar. - **YL5** — Atlama sınırı 12'dir; sınırı yakan paket döngü sayılır. Sekiz düğümlü ağda en uzun döngüsüz yol yedi adımdır, sınır bunun belirgin biçimde üstündedir. - **YL6** — Önek ölçümünde adres sekiz bitliktir ve uzayın **tamamı** taranır; örnek seçilmez. Tablo satırları yazıldıkları sırada durur. - **YL7** — Kümenin çözünürlüğü ölçüm bandının alt sınırıdır: kırk paketlik kümede ölçülebilen en küçük fark **1/40 = 0,025**, adres uzayında **1/256**'dır. #### Aynı Tablo, İki Kural Önce kuralın kendisi ölçülür. Yukarıdaki altı satırlık tablo iki farklı kuralla okunur ve sekiz bitlik adres uzayının tamamı taranır. ```python """En uzun onek eslemesi: ayni tablo, iki okuma kurali. Satirlar yazildiklari sirada durur, uzunluga gore sirali degildir. Sekiz bitlik adres uzayinin tamami taranir; ornek secilmez. """ TABLO = [("1010", "kuzey"), ("10110", "batı"), ("101011", "doğu"), ("", "merkez"), ("10101100", "yerel"), ("10100", "güney")] DUGUMLER = ("kuzey", "güney", "doğu", "batı", "merkez", "yerel") ADRESLER = [format(a, "08b") for a in range(256)] def en_uzun_onek(adres): secili = None for onek, dugum in TABLO: if adres.startswith(onek) and (secili is None or len(onek) > len(secili[0])): secili = (onek, dugum) return secili def ilk_eslesen(adres): for onek, dugum in TABLO: if adres.startswith(onek): return (onek, dugum) return None ayrisan = [a for a in ADRESLER if en_uzun_onek(a)[1] != ilk_eslesen(a)[1]] print(f"tablo satırı {len(TABLO)} | adres uzayı {len(ADRESLER)} | " f"iki kuralın ayrıştığı adres {len(ayrisan)}") print() print(f"{'bir sonraki düğüm':>18s} {'en uzun önek':>13s} {'ilk eşleşen':>12s}") for dugum in DUGUMLER: print(f"{dugum:>18s} {sum(en_uzun_onek(a)[1] == dugum for a in ADRESLER):13d}" f" {sum(ilk_eslesen(a)[1] == dugum for a in ADRESLER):12d}") print() for a in (ayrisan[0], ayrisan[8], ayrisan[11]): u, i = en_uzun_onek(a), ilk_eslesen(a) print(f" {a} -> en uzun önek {u[1]} ({u[0]}), ilk eşleşen {i[1]} ({i[0]})") ``` ``` tablo satırı 6 | adres uzayı 256 | iki kuralın ayrıştığı adres 12 bir sonraki düğüm en uzun önek ilk eşleşen kuzey 4 16 güney 8 0 doğu 3 0 batı 8 8 merkez 232 232 yerel 1 0 10100000 -> en uzun önek güney (10100), ilk eşleşen kuzey (1010) 10101100 -> en uzun önek yerel (10101100), ilk eşleşen kuzey (1010) 10101111 -> en uzun önek doğu (101011), ilk eşleşen kuzey (1010) ``` İki kural 256 adresin **12**'sinde ayrışıyor. Ayrışmanın yönü tek taraflı: satır sırasına göre okuyan cihaz `kuzey`'e **16** adres gönderiyor, en uzun öneke göre okuyan **4**. Aradaki on iki adresin sekizi `güney`'e, üçü `doğu`'ya, biri `yerel`'e gitmesi gereken adreslerdir. `merkez` sütunu ikisinde de **232**'dir: varsayılan yol her iki kuralda da son çare olarak kalır, çünkü hiçbir uzun önekle eşleşmeyen adresler için tek eşleşme odur. `batı` sütunundaki **8** de ikisinde aynıdır ve bu bir tesadüf değil: `10110` öneki hiçbir kısa önekle çakışmaz, tabloda onu kapsayan başka satır yoktur. **Ayrışma yalnız iç içe geçmiş öneklerde doğar.** Tabloda iç içelik olmasaydı iki kural aynı kararı verirdi ve kuralın belirtimde yazılı olması gerekmezdi. #### Kopmadan Önce ve Sonra Şimdi kural sabitlenir ve **tablo** değişir. Üç kuşak yan yana konur: kopma yokken yakınsamış tablolar, kopma anında hâlâ eski olan tablolar ve kopmadan sonra yeniden yakınsamış tablolar. Kırk paket her üçünde de aynı çiftler arasında yürütülür. ```python """Tablo bir kopyadir: ayni kural, uc tablo kusagi. Sekiz dugum, halkayi kesen b-f kirisi; olculen kopma o kirisin kaybi. """ TOHUM = 20260810 DUGUMLER = ["a", "b", "c", "d", "e", "f", "g", "h"] BAGLAR = [("a", "b"), ("b", "c"), ("c", "d"), ("d", "e"), ("e", "f"), ("f", "g"), ("g", "h"), ("h", "a"), ("b", "f")] KOPUK = [b for b in BAGLAR if b != ("b", "f")] ATLAMA_SINIRI = 12 def uretec(tohum): d = tohum % 2147483646 + 1 def r(n): nonlocal d d = (d * 48271) % 2147483647 return d % n return r def komsuluk(baglar): k = {u: set() for u in DUGUMLER} for x, y in baglar: k[x].add(y) k[y].add(x) return k def kahin(baglar): """Her dugum icin her hedefe giden en kisa yolun ilk adimi.""" k, tablo = komsuluk(baglar), {} for kaynak in DUGUMLER: onceki, sira, gorulen = {}, [kaynak], {kaynak} while sira: yeni = [] for u in sira: for v in sorted(k[u]): if v not in gorulen: gorulen.add(v) onceki[v] = u yeni.append(v) sira = yeni for hedef in DUGUMLER: if hedef == kaynak or hedef not in onceki: continue adim = hedef while onceki[adim] != kaynak: adim = onceki[adim] tablo[(kaynak, hedef)] = adim return tablo def ilet(kaynak, hedef, tablolar, baglar): """Paketi tablolara gore yurutur; kaderini, adimi ve olen dugumu dondurur.""" k, u, gecilen, atlama = komsuluk(baglar), kaynak, [], 0 while u != hedef: if atlama >= ATLAMA_SINIRI: return "dongu", atlama, u sonraki = tablolar.get((u, hedef)) if sonraki is None or sonraki not in k[u]: return "kara delik", atlama, u if (u, sonraki) in gecilen: return "dongu", atlama, u gecilen.append((u, sonraki)) u, atlama = sonraki, atlama + 1 return "ulasti", atlama, None def ciftler(sayi=40, tohum=TOHUM): r, liste = uretec(tohum), [] while len(liste) < sayi: x, y = DUGUMLER[r(8)], DUGUMLER[r(8)] if x != y: liste.append((x, y)) return liste def olc(tablolar, baglar, sayi=40): sayim, adim = {"ulasti": 0, "dongu": 0, "kara delik": 0}, 0 for x, y in ciftler(sayi): kader, a, _ = ilet(x, y, tablolar, baglar) sayim[kader] += 1 adim += a return sayim, adim eski, yeni = kahin(BAGLAR), kahin(KOPUK) print(f"düğüm {len(DUGUMLER)} | bağ {len(BAGLAR)} | tablo satırı {len(eski)} | " f"ölçülen çift {len(ciftler())} | atlama sınırı {ATLAMA_SINIRI}") print() print(f"{'tablo kuşağı':<27s} {'ulaştı':>7s} {'döngü':>6s} {'kara delik':>11s} {'adım':>5s}") for ad, tab, bag in (("yakınsamış, kopma yok", eski, BAGLAR), ("kopma anı, tablolar eski", eski, KOPUK), ("kopma sonrası, yakınsamış", yeni, KOPUK)): s, a = olc(tab, bag) print(f"{ad:<27s} {s['ulasti']:7d} {s['dongu']:6d} {s['kara delik']:11d} {a:5d}") print() degisen = sum(1 for anahtar in eski if eski[anahtar] != yeni[anahtar]) print(f"kopmadan sonra kararı değişmek zorunda olan satır: {degisen}/{len(eski)}") olen = {} for x, y in ciftler(): kader, _, dugum = ilet(x, y, eski, KOPUK) if kader != "ulasti": olen[dugum] = olen.get(dugum, 0) + 1 print("paketin öldüğü düğüm:", dict(sorted(olen.items()))) ``` ``` düğüm 8 | bağ 9 | tablo satırı 56 | ölçülen çift 40 | atlama sınırı 12 tablo kuşağı ulaştı döngü kara delik adım yakınsamış, kopma yok 40 0 0 83 kopma anı, tablolar eski 26 0 14 61 kopma sonrası, yakınsamış 40 0 0 99 kopmadan sonra kararı değişmek zorunda olan satır: 11/56 paketin öldüğü düğüm: {'b': 6, 'f': 8} ``` #### Kopmanın Okunması Üç satır üç ayrı şey söylüyor. **Yakınsamış ağda kırk paketin kırkı da ulaşıyor**, toplam 83 adımla. Bu, tabloların gerçekle uyuştuğu durumdur ve ölçümün taban çizgisidir. Alt satır aynı sonucu kopmadan sonra veriyor: yine **40/40**, ama **99** adımla. Kiriş gidince yollar uzuyor; on altı adımlık fark budur. Ağın kaybettiği şey bağlanabilirlik değil, kısalıktır — **hiçbir paket kaybolmuyor**. Ortadaki satır ise arada geçen süredir. Tablolar hâlâ kirişi gösterirken **26 paket ulaşıyor, 14'ü kara deliğe düşüyor.** Bu on dördü ölçülebilir bir paydır: kırk paketlik kümede **0,350**, bandın alt sınırının on dört katı. Toplam adımın burada **61**'e düşmesi ilk bakışta iyi görünür ve tam da bu yüzden dikkat ister. Adım azaldı çünkü paketlerin üçte biri **yola devam etmedi**: kara deliğe düşen paket hemen ölür, geri kalan adımlarını harcamaz. **Düşük adım sayısı burada bir başarı değil, bir kayıp imzasıdır.** Son iki satır arızanın nerede olduğunu söylüyor. Kopmadan sonra kararı değişmek zorunda olan satır sayısı **11**; tablo elli altı satır taşıyor, yani satırların büyük çoğunluğu doğru kalıyor. Buna karşın on dört paket ölüyor. Sebep, ölen paketlerin **hepsinin** iki düğümde ölmesi: **b**'de altı, **f**'de sekiz. Bunlar kopan kirişin iki ucudur. Buradan çıkan sonuç kursun eksenidir. Bir paketin kaderi **çıktığı düğümün tablosunun doğru olmasına bağlı değildir.** Kaynak düğümün satırı doğru olabilir; paket yolda, tablosu yanlış olan bir düğüme uğrar ve orada ölür. Karar zinciri boyunca **en eski kopya** sonucu belirler. #### Özet - Yönlendirme kararının girdisi paketin hedef adresi, çıktısı bir sonraki düğümdür; yönlendirici yolun tamamını değil yalnız bir adımı bilir. - Karar iletide yazana değil cihazın **kendi tablosuna** bakılarak alınır; kararı belirleyen kural tabloda değil belirtimde durur. - En uzun önek eşleme, eşleşen satırlar arasından en dar kümeyi seçer; satır sırasına göre okuyan bir kural aynı tabloda 256 adresin **12**'sinde başka bir karar verir ve ayrışma yalnız iç içe geçmiş öneklerde doğar. - Tablo bir yapılandırma değil, paylaşılan bir gerçeğin kopyasıdır; yakınsamış ağda kırk paketin kırkı ulaşır, kopmadan önce **83**, kopmadan sonra **99** adımla. - Kopma anında eski tablolarla **26** paket ulaşır, **14**'ü kara deliğe düşer; adımın **61**'e düşmesi kazanç değil, ölen paketlerin adım harcamamasıdır. - Elli altı satırın yalnız **11**'i yanlıştır, ama ölen on dört paketin hepsi kopan bağın iki ucunda ölür: kaderi belirleyen şey kaynağın kopyası değil, yol üzerindeki **en eski** kopyadır. #### Sonraki Adım Bu ölçümde tablolar iki kez elle kuruldu: bir kez kopmadan önceki gerçekten, bir kez kopmadan sonraki gerçekten. Aradaki geçişi kimse yapmadı — ikinci kuşak tablo ölçüme hazır biçimde verildi. Gerçek bir ağda o geçişi birinin yapması gerekir ve iki seçenek vardır: tabloyu bir yönetici yazar, ya da cihazlar birbirine anlatır. Sonraki ders bu iki seçeneği yan yana koyar ve şunu sorar: elle yazılmış bir tablo kopmayı ne zaman öğrenir ve kara delik sayısı zamanla ne yapar? ### Statik ve Dinamik Yönlendirme Source: https://academia.sh/tr/kurslar/anahtarlama-ve-yonlendirme/statik-ve-dinamik-yonlendirme Statik tablo kopmayı hiç duymaz ve kara delik sayısı altı tur boyunca 14'te kalır; haberin yayıldığı dinamik rejimde kayıp iki turda biter, ama haberi yalnız iki düğüm duyduğunda kara delik sıfırlanırken 6 paket döngüye girer ve adım 61'den 94'e çıkar. Önceki ölçümde iki tablo kuşağı vardı ve ikincisi hazır verildi: kopmadan sonraki gerçek hesaplandı, tablolara yazıldı ve paketler öyle yürütüldü. Aradaki geçişi kimse yapmadı. Gerçek bir ağda o geçişi birinin yapması gerekir ve yalnız iki yol vardır. Ya satırları bir yönetici elle yazar — buna **statik yönlendirme** denir — ya da cihazlar bağlarının durumunu birbirine anlatır ve tablolarını kendileri kurar; buna **dinamik yönlendirme** denir. Bu dersin sorusu hangisinin daha iyi olduğu değildir. Soru şudur: kopma olduğunda **kaç tur sonra** doğru tabloya varılır ve varılmıyorsa kayıp zamanla ne yapar? #### Yazmak ve Anlatmak Statik yönlendirmede tablo bir yapılandırma metnidir. Yönetici her düğüm için her hedefin bir sonraki düğümünü yazar; cihaz bu satırları okur ve hiç sorgulamaz. Satırın doğru olup olmadığını denetleyen bir düzenek yoktur, çünkü cihazın karşılaştırabileceği ikinci bir kaynak yoktur. ```text # ogretilen dokum, calistirilmamistir düğüm b için elle yazılmış satırlar hedef bir sonraki düğüm a a c c d c e f f f g f h a ``` Sekiz düğümlü ağda her düğüm için yedi satır yazılır ve `e`, `f`, `g` satırları kirişten geçer. Kiriş koptuğunda bu metin değişmez — dosyada yazan neyse cihaz onu okumaya devam eder. Dinamik yönlendirmede tablo bir yapılandırma değil, bir **anlaşmanın çıktısıdır**. Cihazlar düzenli aralıklarla komşularına bildirimde bulunur, gelen bildirimlerden kendi satırlarını üretir ve bir bağ düştüğünde bunu komşularına söyler. Yöneticinin yazdığı şey satırlar değil, protokolün hangi bağlarda konuşacağıdır. İki rejimin maliyeti farklı yerlere düşer. Statik rejimde maliyet **yazma anındadır**: sekiz düğümlü bir ağda her düğümün yedi hedefi vardır, toplam elli altı satır. Düğüm sayısı $n$ ise satır sayısı $n(n-1)$ ile büyür — otuz düğümde sekiz yüz yetmiş satır. Dinamik rejimde maliyet **çalışma anındadır**: cihazlar bildirim gönderir, gelen bildirimleri işler ve yakınsama boyunca tablolar bir süre yanlış kalır. Yazma maliyetinin bir kısmı önceki dersteki varsayılan yolla kısaltılabilir. Bir düğüm komşularından biri dışındaki her hedefi tek bir boş önek satırına yığabilir; o zaman elle yazılan satır sayısı yediden ikiye iner. Ölçümde bu kısaltma kullanılmaz, çünkü ölçülen şey yazma emeği değil **kararın doğruluğudur**: varsayılan yol satır sayısını azaltır, kopmayı duyma yeteneğini değiştirmez. Kısaltılmış bir tablo da kopan bağı gösteriyorsa paketi yine oraya gönderir. #### Statik Tablonun Kör Noktası Statik bir tablo bir bağın koptuğunu **hiçbir zaman** öğrenmez. Bu bir gecikme değil, bir yokluktur: haberin ulaşacağı bir kanal tanımlanmamıştır. Cihaz kendi bağının düştüğünü görebilir, ama iki adım ötedeki bir bağın düştüğünü göremez ve satırı o bağı gösteriyorsa paketi oraya göndermeye devam eder. Bunun ölçüme yansıyan sonucu şudur: statik rejimde kara delik sayısı **zamanın işlevi değildir**. Birinci turda kaç paket ölüyorsa yüzüncü turda da o kadarı ölür. Kayıp durmaz, **birikir**. Durması için ölçümün dışından bir olay gerekir: bir yöneticinin arızayı fark edip satırları yeniden yazması. Dinamik rejimde ise haberin bir kanalı vardır. Kopan bağın iki ucu bunu doğrudan görür, komşularına söyler, onlar kendi komşularına söyler. Haber ağda bir dalga gibi yayılır ve her tur bir komşuluk adımı ilerler. Aşağıdaki ölçüm tam olarak bu dalgayı modeller. Ölçümün varsayımları: - **YL8** — Ağ, kâhin ve kırk çift önceki derstekiyle aynıdır: sekiz düğüm, dokuz bağ, halkayı kesen kiriş. Ölçülen kopma yine o kirişin kaybıdır. - **YL9** — Statik rejimde tablo ölçüm boyunca hiç değişmez. Yöneticinin arızayı fark edip müdahale etmesi ölçümün dışındadır; ölçülen şey müdahaleye kadar geçen süredir. - **YL10** — Dinamik rejimde haber kopan bağın iki ucundan başlar ve her turda bir komşuluk adımı ilerler. Haberi duyan düğüm tablosunu **doğru** hâline getirir; duymayan düğüm eski tablosunu olduğu gibi sürdürür. - **YL11** — Tur, bir düğümün komşularından bildirim alıp tablosunu güncellemesidir. Tur bir saat birimi değildir; karşılığı protokolün bildirim aralığıdır ve saniye cinsinden değişir. - **YL12** — Aynı kırk çift her turda yeniden yürütülür ve ölçüm turlar arasında bellek tutmaz; her tur o turun tablolarıyla bağımsız ölçülür. - **YL13** — Atlama sınırı 12'dir; sınırı yakan paket döngü sayılır. - **YL14** — Kümenin çözünürlüğü kırk paket üzerinden **1/40 = 0,025**'tir; bundan küçük bir fark iddia edilmez. #### Ölçüm ```python """Statik ve dinamik: kopmayi duymayan tablo ile duyan tablo. Statik rejimde tablo hic degismez. Dinamik rejimde haber kopan bagin iki ucundan baslar ve her turda bir komsuluk adimi ilerler. """ TOHUM = 20260810 DUGUMLER = ["a", "b", "c", "d", "e", "f", "g", "h"] BAGLAR = [("a", "b"), ("b", "c"), ("c", "d"), ("d", "e"), ("e", "f"), ("f", "g"), ("g", "h"), ("h", "a"), ("b", "f")] KOPUK = [b for b in BAGLAR if b != ("b", "f")] ATLAMA_SINIRI = 12 def uretec(tohum): d = tohum % 2147483646 + 1 def r(n): nonlocal d d = (d * 48271) % 2147483647 return d % n return r def komsuluk(baglar): k = {u: set() for u in DUGUMLER} for x, y in baglar: k[x].add(y) k[y].add(x) return k def kahin(baglar): """Her dugum icin her hedefe giden en kisa yolun ilk adimi.""" k, tablo = komsuluk(baglar), {} for kaynak in DUGUMLER: onceki, sira, gorulen = {}, [kaynak], {kaynak} while sira: yeni = [] for u in sira: for v in sorted(k[u]): if v not in gorulen: gorulen.add(v) onceki[v] = u yeni.append(v) sira = yeni for hedef in DUGUMLER: if hedef == kaynak or hedef not in onceki: continue adim = hedef while onceki[adim] != kaynak: adim = onceki[adim] tablo[(kaynak, hedef)] = adim return tablo def ilet(kaynak, hedef, tablolar, baglar): k, u, gecilen, atlama = komsuluk(baglar), kaynak, [], 0 while u != hedef: if atlama >= ATLAMA_SINIRI: return "dongu", atlama sonraki = tablolar.get((u, hedef)) if sonraki is None or sonraki not in k[u]: return "kara delik", atlama if (u, sonraki) in gecilen: return "dongu", atlama gecilen.append((u, sonraki)) u, atlama = sonraki, atlama + 1 return "ulasti", atlama def ciftler(sayi=40, tohum=TOHUM): r, liste = uretec(tohum), [] while len(liste) < sayi: x, y = DUGUMLER[r(8)], DUGUMLER[r(8)] if x != y: liste.append((x, y)) return liste def olc(tablolar, baglar, sayi=40): sayim, adim = {"ulasti": 0, "dongu": 0, "kara delik": 0}, 0 for x, y in ciftler(sayi): kader, a = ilet(x, y, tablolar, baglar) sayim[kader] += 1 adim += a return sayim, adim def kismi(eski, yeni, duyan): """Kopmayi yalniz duyanlar guncelledi; otekiler eski tablosunu surduruyor.""" return {(u, h): (yeni if u in duyan else eski)[(u, h)] for (u, h) in eski} def duyanlar(tur, baglar=KOPUK, kaynak=("b", "f")): """Haber kopan bagin uclarindan baslar, turda bir komsuluk adimi ilerler.""" if tur <= 0: return set() k, kume, sinir = komsuluk(baglar), set(kaynak), set(kaynak) for _ in range(tur - 1): sinir = {v for u in sinir for v in k[u]} - kume kume |= sinir return kume eski, yeni = kahin(BAGLAR), kahin(KOPUK) degisen = [(u, h) for (u, h) in eski if eski[(u, h)] != yeni[(u, h)]] print(f"tablo satırı {len(eski)} | kopmadan sonra elle düzeltilecek satır " f"{len(degisen)} | dokunulacak düğüm {len({u for u, _ in degisen})}") print() print(f"{'tur':>3s} {'duyan':>5s} | {'statik: ulaştı':>14s} {'döngü':>5s} {'k.delik':>7s}" f" {'adım':>4s} | {'dinamik: ulaştı':>15s} {'döngü':>5s} {'k.delik':>7s} {'adım':>4s}") statik_kayip = dinamik_kayip = 0 for tur in range(6): s, sa = olc(eski, KOPUK) kume = duyanlar(tur) d, da = olc(kismi(eski, yeni, kume), KOPUK) statik_kayip += s["dongu"] + s["kara delik"] dinamik_kayip += d["dongu"] + d["kara delik"] print(f"{tur:3d} {len(kume):5d} | {s['ulasti']:14d} {s['dongu']:5d} " f"{s['kara delik']:7d} {sa:4d} | {d['ulasti']:15d} {d['dongu']:5d} " f"{d['kara delik']:7d} {da:4d}") print(f"altı turda hedefine varmayan paket: statik {statik_kayip}, " f"dinamik {dinamik_kayip}") print() print(f"{'duyan küme':<22s} {'ulaştı':>7s} {'döngü':>6s} {'kara delik':>11s} " f"{'adım':>5s} {'tablosu doğruyken ölen':>23s}") for ad, kume in (("kimse", set()), ("yalnız b ve f", {"b", "f"}), ("b, f ve komşuları", duyanlar(2)), ("d dışında herkes", set(DUGUMLER) - {"d"}), ("herkes", set(DUGUMLER))): tab = kismi(eski, yeni, kume) s, a = olc(tab, KOPUK) dogruyken = sum(1 for x, y in ciftler() if ilet(x, y, tab, KOPUK)[0] != "ulasti" and x in kume) print(f"{ad:<22s} {s['ulasti']:7d} {s['dongu']:6d} {s['kara delik']:11d} " f"{a:5d} {dogruyken:23d}") ``` ``` tablo satırı 56 | kopmadan sonra elle düzeltilecek satır 11 | dokunulacak düğüm 6 tur duyan | statik: ulaştı döngü k.delik adım | dinamik: ulaştı döngü k.delik adım 0 0 | 26 0 14 61 | 26 0 14 61 1 2 | 26 0 14 61 | 34 6 0 94 2 6 | 26 0 14 61 | 40 0 0 99 3 8 | 26 0 14 61 | 40 0 0 99 4 8 | 26 0 14 61 | 40 0 0 99 5 8 | 26 0 14 61 | 40 0 0 99 altı turda hedefine varmayan paket: statik 84, dinamik 20 duyan küme ulaştı döngü kara delik adım tablosu doğruyken ölen kimse 26 0 14 61 0 yalnız b ve f 34 6 0 94 1 b, f ve komşuları 40 0 0 99 0 d dışında herkes 40 0 0 99 0 herkes 40 0 0 99 0 ``` #### Düz Çizgi ile İnen Çizgi Statik sütunu altı turun altısında da aynıdır: **26 ulaştı, 14 kara delik, 61 adım.** Bu sabitlik ölçümün en önemli bulgusudur. Kayıp azalmıyor çünkü azalmasını sağlayacak bir olay yok; tablo kopmayı duymadı, duyacağı bir kanal da yok. Altı turda hedefine varmayan paket **84**'e ulaşıyor ve bu sayı turla doğrusal büyümeye devam eder. Dinamik sütunu iki turda kapanıyor: ikinci turda ulaşan **40**'a çıkıyor ve orada kalıyor. Altı turdaki toplam kayıp **20**. Aynı kopma, aynı topoloji, aynı kırk paket — fark yalnız haberin bir kanalı olup olmamasıdır. Elle düzeltme maliyeti üst satırda duruyor. Elli altı satırın **11**'i yanlış hâle geliyor ve bu on bir satır **6** ayrı düğüme dağılmış. Yönetici bir bağın koptuğunu öğrense bile düzeltmesi gereken şey tek bir satır değildir; altı cihaza dokunması, her birinde hangi satırların değişmesi gerektiğini yeniden hesaplaması gerekir. Sekiz düğümlük bir ağda bu iş bir oturumdur, otuz düğümlük bir ağda başka bir şeydir. #### Kısmî Bilginin Bedeli Alt tablo dinamik rejimin **içine** bakıyor ve orada beklenmedik bir şey var. Kimse duymadığında **14 paket kara deliğe** düşüyor, toplam **61** adım harcanıyor. Kopmayı **yalnız b ve f** duyduğunda kara delik **sıfıra** iniyor — ilk bakışta düzelme. Ama ulaşan sayısı 40 değil **34**; kalan **6 paket döngüye** giriyor ve toplam adım **61**'den **94**'e çıkıyor. Bu satır kursun ikinci iddiasını ödüyor: **kısmî bilgi, hiç bilgiden daha pahalı bir arıza üretir.** Gerekçe kaderlerin doğasındadır. Kara deliğe düşen paket **hemen ölür**: bir düğüme varır, orada karşılığı olmayan bir komşu görülür ve paket atılır. Harcadığı kaynak yolun o noktasına kadar attığı adımlardır. Döngüye giren paket ise ölmez; **atlama sınırını yakana kadar ağda dolaşır**, her turda bağ kapasitesi ve işleme kapasitesi tüketir. Ölçüm bunu adım sayısıyla söylüyor. Kayıp paket sayısı 14'ten 6'ya, yani yarıdan fazla inerken **harcanan adım 61'den 94'e çıkıyor**. Az sayıda paket, çok sayıda adım. Arızanın görünümü de değişiyor: kara delik bir kayıp gibi görünür ve bulunması görece kolaydır; döngü **tıkanıklık gibi görünür**, çünkü bağlar doludur ve paketler akmaktadır — yalnızca hiçbiri varmamaktadır. Sağdaki son sütun bunun neden kaçınılmaz olduğunu söylüyor. `yalnız b ve f` satırında **tablosu doğru olan** bir düğümden çıkıp ölen **1** paket var. O düğüm kopmayı duymuştur, satırı gerçeğe uygundur, kararı kusursuzdur — ve paketi yine de kaybeder, çünkü paketi verdiği komşu duymamıştır. Buradan yapısal bir sonuç çıkar: **hiçbir cihaz tek başına bir paketi döngüye sokamaz.** İki tablonun paketi birbirine geri gönderdiği bu duruma **yönlendirme döngüsü (routing loop)** denir; ölçümdeki kader adı kısaca **döngü**dür. Bir cihazın kararının doğruluğu kendi tablosuna değil, **komşusununkine** bağlıdır. Son iki satır bir başka şeyi gösteriyor. **d dışında herkes** duyduğunda sonuç **40/40** — hiç duymayan bir düğüm kaldığı hâlde. Sebep, ölçülen kırk çiftin hiçbirinin `d`'nin değişen satırlarına uğramaması. Kısmî bilgi her zaman arıza üretmez; arıza, **eksik kalan bilginin paketin yoluna düşmesiyle** doğar. #### Ölçütle Seçim İki rejim arasındaki seçim bu ölçümden okunabilir bir ölçüte dayanır ve ölçüt "hangisi daha gelişkin" değildir. Statik yönlendirme, **hedefe giden yol tekse** doğru seçimdir. Tek çıkışı olan bir uç ağda alternatif yol yoktur; bir dinamik protokol koşsa bile keşfedeceği ikinci bir yol bulunmadığından kopma anında yapabileceği hiçbir şey yoktur. Böyle bir yerde protokolün bildirim trafiği ve durum tutması karşılıksız bir maliyettir. Dinamik yönlendirme, **yol sayısı birden çoksa** karşılığını verir. Ölçümdeki halka tam da budur: kiriş koptuğunda her hedefe hâlâ bir yol vardır ve dinamik rejim onu iki turda bulur. Statik rejimin bulamamasının nedeni yolun yokluğu değil, yolu arayan bir düzeneğin yokluğudur. İkisinin karışımı da bir seçenektir ve yaygındır: uç ağlara statik satır, çekirdeğe dinamik protokol. Ölçüt her iki durumda da aynıdır — bir bağ koptuğunda **kaç turda** doğru tabloya varıldığı ve o turlarda kaç paketin hedefine varmadığı. Bu ölçüt statik rejim için de tanımlıdır, ama karşılığı protokolde değil insandadır. Statik bir ağın yakınsama süresi, arızanın fark edilmesiyle satırların yeniden yazılması arasında geçen süredir; ölçüm bunu **YL9** ile dışarıda bıraktı. Dışarıda bırakılmasının nedeni, sürenin protokolden okunamamasıdır: bir bildirim aralığı gibi bir üst sınırı yoktur ve arızanın ne kadar sonra görüleceğine bağlıdır. Ölçümdeki düz çizgi tam olarak bu belirsizliği temsil eder — o çizgi kendiliğinden inmez. #### Özet - Statik tabloyu yönetici yazar ve maliyeti yazma anındadır; satır sayısı $n(n-1)$ ile büyür ve sekiz düğümde elli altı satırdır. - Statik tablo kopmayı hiç duymaz: kara delik sayısı altı turun altısında da **14**'te kalır ve altı turdaki toplam kayıp **84** pakete ulaşır, dinamik rejimde **20**. - Elle düzeltme tek satırlık bir iş değildir; elli altı satırın **11**'i **6** ayrı düğümde yanlış hâle gelir. - Kopmayı yalnız iki düğüm duyduğunda kara delik **0**'a iner ama **6 paket döngüye** girer ve adım **61**'den **94**'e çıkar: kısmî bilgi, hiç bilgiden daha pahalı ve daha zor görülen bir arıza üretir. - Tablosu doğru olan bir düğümden çıkan **1** paket bile ölür; hiçbir cihaz tek başına bir paketi döngüye sokamaz, döngü en az iki tablonun anlaşmazlığıdır. - Seçim ölçütü yol sayısıdır: tek yollu uç ağda statik satır yeterlidir, birden çok yollu ağda dinamik protokolün bulduğu turlar karşılığını verir. #### Sonraki Adım Bu ölçümde haberin **taşınması** modellenmedi. Duyan küme dışarıdan verildi ve duyan her düğüm doğru tabloya bir anda vardı; sanki bağ koptuğu an gerçeğin tamamı elindeymiş gibi. Gerçekte bir düğümün komşusundan duyacağı şey topolojinin tamamı değildir. En yalın protokol ailesi komşudan yalnız tek bir şey duyar: **komşunun her hedefe kaç adım uzakta olduğunu.** Sonraki ders bu tek sayının nasıl yayıldığını, doğru tabloya kaç turda vardığını ve bu yalınlığın hangi kusuru getirdiğini ölçer. ### Uzaklık Vektörü Protokolleri Source: https://academia.sh/tr/kurslar/anahtarlama-ve-yonlendirme/uzaklik-vektoru-protokolleri Komşudan yalnız bir uzaklık dizisi duyulur; soğuk başlangıçtan doğru tabloya dört turda varılır ve tur başına ulaşan paket 0, 9, 20, 32, 40 olur. Kötü haberi öğrenebilmek için gereken tek ödün sonsuza saymayı doğurur: bir hedef erişilemez olduğunda on iki turluk pencerede 60 paketin altmışı da döngüye girer. Önceki ölçümde haberin taşınması modellenmedi: duyan küme dışarıdan verildi ve duyan düğüm doğru tabloya bir anda vardı. Gerçekte bir düğümün komşusundan duyacağı şey topolojinin tamamı değildir; kimse komşusuna "ağ şöyle bağlı" diye bir harita göndermez. En yalın protokol ailesi komşudan tek bir şey duyar: **komşunun her hedefe kaç adım uzakta olduğunu.** Bu ailenin adı **uzaklık vektörü (distance vector)** ailesidir ve bu dersin sorusu, bu tek sayının doğru tabloyu kurmaya yetip yetmediğidir. #### Komşudan Duyulan Tek Şey Bir düğüm komşularına bir liste gönderir: her hedef için bir **yol maliyeti**. Yol maliyeti burada adım sayısıdır. Liste komşunun kim olduğunu, hangi yoldan gidildiğini ya da ağın nasıl bağlı olduğunu söylemez — yalnız uzaklığı söyler. ```text # ogretilen dokum, calistirilmamistir düğüm c, komşularına gönderdiği bildirim hedef maliyet a 3 b 1 d 1 e 2 f 2 g 3 h 4 ``` Bildirimi alan düğüm iki adım atar. Gelen her yol maliyetine **bir ekler** — komşuya ulaşmanın maliyeti bir adımdır. Sonra kendi tablosundaki yol maliyetiyle karşılaştırır ve **daha küçük olanı** alır; aldığında bir sonraki düğüm alanına o komşunun adını yazar. Buradaki bilgi kısıtı ailenin tanımıdır. Düğüm `c`'nin bildirimini alan `b`, `a`'ya üç adımda gidildiğini öğrenir; **hangi düğümlerden geçilerek** gidildiğini öğrenmez. Bu, hesabı ucuzlatır: alınan bildirim topoloji değil, komşunun **çoktan çiğnenmiş** kararıdır. Düğüm kendi hesabını yapmaz, komşusunun hesabına bir ekler. #### Yakınsama Burada Ne Demek Kurs boyunca ölçülen şey **yakınsamadır** ve bu karşılık Sistem Tasarımına Giriş kursunda da kullanılmıştı. Orada yakınsayan şey **kopya veri değerleriydi**: aynı kaydın kopyaları bir süre farklı okunur, sonunda aynı değere varır ve gözlenen şey **okunan değerdir**. Burada yakınsayan şey veri değil **yönlendirme tablosudur**, gözlenen şey de okunan değer değil **paketin kaderidir**. Karşılık aynıdır, duyu ayrıdır; ikisi karıştırılmaz. #### Yalnız İyileşmeyi Kabul Eden Kural Kuralın ilk biçimi en yalınıdır: **düğüm yalnız daha kısa bir yol duyduğunda tablosunu değiştirir.** Gelen yol maliyeti elindekinden büyükse bildirimi atar. Bu kural sezgiseldir ve bir şeyi kesin olarak sağlar — tablo asla kötüleşmez. Ölçümün ilk bölümü bu kuralı **soğuk başlangıçtan** izler: hiçbir düğümün elinde hiçbir şey yoktur, herkes yalnız kendi komşularını bilir ve tablolar turlarla dolar. Ölçümün varsayımları: - **YL15** — Ağ, kâhin ve kırk çift önceki derslerdekiyle aynıdır. Birinci ve üçüncü bölümde kopan bağ yine halkayı kesen kiriştir. - **YL16** — Birinci bölümde başlangıç **soğuktur**: her düğümün kendine uzaklığı sıfır, ötekilere 99'dur ve hiçbir tablo satırı yoktur. Ölçülen şey sıfırdan kuruluş turudur. - **YL17** — Tur, bütün düğümlerin komşularından bildirim alıp tablolarını bir kez güncellemesidir; bildirimler eşzamanlı kabul edilir. Bir turun saniye karşılığı yoktur. - **YL18** — Yol maliyeti adım sayısıdır, her bağın maliyeti birdir. Yol maliyetinin tavanı **16**'dır ve bu tavana varan girdi **erişilemez** sayılır; tavan sonsuzun sonlu karşılığıdır. - **YL19** — İkinci bölümde ölçülen kopma başkadır: `d` düğümüne giden iki bağ birden düşer ve `d` ağdan kopar. Geri kalan yedi düğüm birbirine bağlı kalır. Başlangıç bu bölümde soğuk değil, kopma öncesi gerçeğe yakınsamış tablodur. - **YL20** — Bekletme penceresi altı turdur ve yalnız bir girdi **erişilemez** hâle geldiğinde açılır; pencere boyunca o girdi için hiçbir bildirim kabul edilmez. - **YL21** — Kümenin çözünürlüğü kırk paket üzerinden **1/40 = 0,025**'tir. İkinci bölümün penceresi on iki tur ve turda beş pakettir; oradaki küme altmış pakettir. #### Ölçüm ```python """Uzaklik vektoru: komsudan yalniz bir sayi duyulur. Bolum 1 - soguk baslangic; dugum yalniz DAHA IYI bir yolu kabul eder. Bolum 2 - kotu haber de kabul edilir; sonsuza sayma ve iki daraltma. """ TOHUM = 20260810 DUGUMLER = ["a", "b", "c", "d", "e", "f", "g", "h"] BAGLAR = [("a", "b"), ("b", "c"), ("c", "d"), ("d", "e"), ("e", "f"), ("f", "g"), ("g", "h"), ("h", "a"), ("b", "f")] KOPUK = [b for b in BAGLAR if b != ("b", "f")] YALITIK = [b for b in BAGLAR if b not in (("c", "d"), ("d", "e"))] ATLAMA_SINIRI, SONSUZ, PENCERE = 12, 16, 12 def uretec(tohum): d = tohum % 2147483646 + 1 def r(n): nonlocal d d = (d * 48271) % 2147483647 return d % n return r def komsuluk(baglar): k = {u: set() for u in DUGUMLER} for x, y in baglar: k[x].add(y) k[y].add(x) return k def kahin(baglar): k, tablo = komsuluk(baglar), {} for kaynak in DUGUMLER: onceki, sira, gorulen = {}, [kaynak], {kaynak} while sira: yeni = [] for u in sira: for v in sorted(k[u]): if v not in gorulen: gorulen.add(v) onceki[v] = u yeni.append(v) sira = yeni for hedef in DUGUMLER: if hedef == kaynak or hedef not in onceki: continue adim = hedef while onceki[adim] != kaynak: adim = onceki[adim] tablo[(kaynak, hedef)] = adim return tablo def ilet(kaynak, hedef, tablolar, baglar): k, u, gecilen, atlama = komsuluk(baglar), kaynak, [], 0 while u != hedef: if atlama >= ATLAMA_SINIRI: return "dongu", atlama sonraki = tablolar.get((u, hedef)) if sonraki is None or sonraki not in k[u]: return "kara delik", atlama if (u, sonraki) in gecilen: return "dongu", atlama gecilen.append((u, sonraki)) u, atlama = sonraki, atlama + 1 return "ulasti", atlama def ciftler(sayi=40, tohum=TOHUM): r, liste = uretec(tohum), [] while len(liste) < sayi: x, y = DUGUMLER[r(8)], DUGUMLER[r(8)] if x != y: liste.append((x, y)) return liste def olc(tablolar, baglar, sayi=40): sayim = {"ulasti": 0, "dongu": 0, "kara delik": 0} for x, y in ciftler(sayi): sayim[ilet(x, y, tablolar, baglar)[0]] += 1 return sayim def yalniz_iyilesme(baglar, tur): """Komsunun uzaklik dizisi duyulur; yalniz daha kisa yol kabul edilir.""" k = komsuluk(baglar) uzak = {(u, h): (0 if u == h else 99) for u in DUGUMLER for h in DUGUMLER} ilk = {} for _ in range(tur): yeni_uzak, yeni_ilk = dict(uzak), dict(ilk) for u in DUGUMLER: for v in sorted(k[u]): for h in DUGUMLER: if uzak[(v, h)] + 1 < yeni_uzak[(u, h)]: yeni_uzak[(u, h)] = uzak[(v, h)] + 1 yeni_ilk[(u, h)] = v uzak, ilk = yeni_uzak, yeni_ilk return uzak, ilk def yeniden_hesap(baglar, tur, basla, geri_bildirmeme=False, bekletme=0): """Tablo her turda komsu bildirimlerinden yeniden kurulur; kotu haber de alinir.""" k, izleme = komsuluk(baglar), [] uzak, ilk = dict(basla[0]), dict(basla[1]) donmus = {anahtar: 0 for anahtar in uzak} for _ in range(tur): yeni_uzak, yeni_ilk = dict(uzak), dict(ilk) for u in DUGUMLER: for h in DUGUMLER: if u == h or donmus[(u, h)] > 0: continue en_iyi, secim = (1, h) if h in k[u] else (SONSUZ, None) for v in sorted(k[u]): if geri_bildirmeme and ilk.get((v, h)) == u: continue maliyet = min(uzak[(v, h)] + 1, SONSUZ) if maliyet < en_iyi: en_iyi, secim = maliyet, v if en_iyi >= SONSUZ > uzak[(u, h)]: donmus[(u, h)] = bekletme yeni_uzak[(u, h)], yeni_ilk[(u, h)] = en_iyi, secim for anahtar in donmus: donmus[anahtar] = max(0, donmus[anahtar] - 1) uzak, ilk = yeni_uzak, yeni_ilk izleme.append((dict(uzak), dict(ilk))) return izleme dogru = kahin(KOPUK) print("Bölüm 1 — soğuk başlangıç, yalnız daha kısa yol kabul edilir") print(f"{'tur':>3s} {'ulaştı':>7s} {'döngü':>6s} {'kara delik':>11s} {'kâhinle aynı satır':>19s}") for tur in range(6): ilk = yalniz_iyilesme(KOPUK, tur)[1] s = olc(ilk, KOPUK) esit = sum(1 for anahtar in dogru if ilk.get(anahtar) == dogru[anahtar]) print(f"{tur:3d} {s['ulasti']:7d} {s['dongu']:6d} {s['kara delik']:11d}" f" {esit:16d}/{len(dogru)}") basla = yalniz_iyilesme(BAGLAR, 8) d_hedefli = [(x, y) for x, y in ciftler() if y == "d"] print() print(f"Bölüm 2 — d yalıtıldı, {PENCERE} turluk pencere, turda {len(d_hedefli)} paket") print(f"{'daraltma':<28s} {'tavan turu':>10s} {'döngü':>6s} {'kara delik':>11s} " f"{'adım':>5s} {'tepe maliyet':>12s}") for etiket, gb, bk in (("yok", False, 0), ("bekletme", False, 6), ("geri bildirmeme", True, 0), ("geri bildirmeme + bekletme", True, 6)): dongu = kara = adim = tepe = 0 tavan = None for i, (uzak, ilk) in enumerate(yeniden_hesap(YALITIK, PENCERE, basla, gb, bk), 1): for x, y in d_hedefli: kader, a = ilet(x, y, ilk, YALITIK) dongu += kader == "dongu" kara += kader == "kara delik" adim += a tepe = max(tepe, max(uzak[(u, "d")] for u in DUGUMLER if u != "d")) if tavan is None and all(uzak[(u, "d")] >= SONSUZ for u in DUGUMLER if u != "d"): tavan = i print(f"{etiket:<28s} {tavan if tavan else '>' + str(PENCERE):>10} {dongu:6d} " f"{kara:11d} {adim:5d} {tepe:12d}") print() print("Bölüm 3 — kiriş koptu, her hedef erişilebilir kalıyor") print(f"{'daraltma':<28s} {'yakınsama turu':>14s}") for etiket, gb, bk in (("yok", False, 0), ("bekletme", False, 6), ("geri bildirmeme", True, 0), ("geri bildirmeme + bekletme", True, 6)): tur_sayisi = None for i, (uzak, ilk) in enumerate(yeniden_hesap(KOPUK, 20, basla, gb, bk), 1): if all(ilk.get(anahtar) == dogru[anahtar] for anahtar in dogru): tur_sayisi = i break print(f"{etiket:<28s} {tur_sayisi if tur_sayisi else '>20':>14}") ``` ``` Bölüm 1 — soğuk başlangıç, yalnız daha kısa yol kabul edilir tur ulaştı döngü kara delik kâhinle aynı satır 0 0 0 40 0/56 1 9 0 31 16/56 2 20 0 20 32/56 3 32 0 8 48/56 4 40 0 0 56/56 5 40 0 0 56/56 Bölüm 2 — d yalıtıldı, 12 turluk pencere, turda 5 paket daraltma tavan turu döngü kara delik adım tepe maliyet yok >12 60 0 202 13 bekletme >12 60 0 202 13 geri bildirmeme >12 5 55 59 16 geri bildirmeme + bekletme 6 5 55 41 16 Bölüm 3 — kiriş koptu, her hedef erişilebilir kalıyor daraltma yakınsama turu yok 2 bekletme 2 geri bildirmeme 3 geri bildirmeme + bekletme 7 ``` #### Dört Tur Birinci bölüm ailenin temel sayısını veriyor. Soğuk başlangıçtan doğru tabloya **dört turda** varılıyor ve tur başına ulaşan paket **0, 9, 20, 32, 40** oluyor. Sıfırıncı turda hiçbir paket ulaşmıyor: tablo boş olduğu için her paket ilk düğümde ölüyor, kırk kara delik. Uzaklık vektörü ağa **hiçbir şey bilmeden** başlar; komşusunun kim olduğunu bile tabloya yazmamıştır. Sonraki turlarda kâhinle aynı olan satır sayısı **16, 32, 48, 56** diye ilerliyor: her tur tam on altı satır düzeliyor. Düzenlilik tesadüf değil, bildirimin doğasıdır. Bir turda bilgi tam olarak bir komşuluk adımı ilerler; birinci turda bir adımlık hedefler, ikinci turda iki adımlık hedefler doğru yazılır. Ağın çapı kaçsa yakınsama turu odur. Ulaşan paket sayısının satır sayısından hızlı büyümemesi de anlamlıdır: bir paketin ulaşması için **yol üzerindeki bütün** satırların doğru olması gerekir. Otuz iki satır doğruyken bile sekiz paket ölür, çünkü o sekizinin yolunda henüz dolmamış bir satır vardır. #### Kötü Haberi Öğrenmek Birinci bölümün kuralı bir şeyi yapamaz: **kötü haberi öğrenemez.** Yalnız daha kısa yolu kabul eden bir düğüm, bir yolun uzadığını ya da yok olduğunu asla duyamaz — çünkü o haber tanımı gereği daha büyük bir yol maliyetiyle gelir ve kural onu atar. Bu yüzden gerçek protokoller bir ödün verir: **bir sonraki düğüm olarak seçilmiş komşudan gelen bildirim, kötü olsa bile kabul edilir.** Ödün zorunludur; onsuz önceki dersteki statik rejimin körlüğü geri gelir. Sonsuza sayma tam bu ödünden doğar. Bir hedef erişilemez olduğunda düğümler birbirinin eski yol maliyetini duyar, bir ekler ve yazar; komşusu da onunkini duyar, bir ekler ve yazar. Yol maliyeti turdan tura **birer birer** büyür ve tavana ulaşana kadar hiçbir düğüm hedefin gerçekten kaybolduğunu anlamaz. Bu davranışın adı **sonsuza sayma (count to infinity)**dır. #### Sonsuza Sayma ve İki Daraltma İkinci bölüm bu davranışı ölçüyor. `d` düğümü ağdan koptuğunda, daraltmasız kuralda tepe maliyet on iki turda ancak **13**'e çıkıyor — tavan olan 16'ya bile varamıyor. O pencerede `d` hedefli **60 paketin altmışı da döngüye** giriyor ve **202** adım harcanıyor. Kara delik sayısı **0**: hiçbir paket ölmüyor, hepsi dolaşıyor. Önceki derste kurulan okuma burada en saf hâliyle görünüyor — **arıza kaybolan paket değil, dolan bağlardır.** Birinci daraltma **geri bildirmeme (split horizon)** adını taşır ve tek bir kuraldır: bir düğüm, bir hedefe giden yolu **o yolun ilk adımı olan komşuya bildirmez**. Gerekçe açıktır — o komşu zaten kendisi üzerinden gidiyordur, ona kendi yolunu geri satmak bir bilgi değil bir yankıdır. Ölçüm kazancı doğruluyor: döngü **60**'tan **5**'e, adım **202**'den **59**'a iniyor. Kara delik **55**'e çıkıyor, yani paketlerin çoğu artık dolaşmak yerine hemen ölüyor. Bu bir kayıp değildir. İki kaderde de paket hedefine varmaz, ama biri **bir adımda** ölür, öteki **on iki adım** ağ kaynağı harcar; adım sütunundaki düşüş bunu ölçüyor. Geri bildirmeme yine de yetmiyor. `tavan turu` sütunu on iki turda hâlâ tamamlanmadığını söylüyor: iki düğümlü döngüleri kesiyor, ama halkanın kurduğu **daha uzun** döngüleri kesmiyor. Bir düğüm tavana varıyor, sonra henüz varmamış bir komşusundan eski bir yol maliyeti duyup geri iniyor. İkinci daraltma **bekletme (hold-down)** budur: bir girdi erişilemez hâle geldiğinde düğüm o girdiyi bir pencere boyunca dondurur ve o hedef için hiçbir bildirimi kabul etmez. Pencere boyunca komşuların eski yol maliyetleri süzülüp gider. Ölçümde etkisi nettir: tavana varılan tur **6**, adım **59**'dan **41**'e iniyor. Ama bekletme **tek başına** hiçbir şey yapmıyor — ikinci satır daraltmasız satırla birebir aynı: 60 döngü, 202 adım. Sebep şudur: bekletme yalnız bir girdi **erişilemez** olduğunda açılır ve daraltmasız kuralda hiçbir girdi tavana varmadığı için pencere hiç açılmaz. Tetikleyicisi oluşmayan bir daraltma yoktur. Üçüncü bölüm bedeli veriyor. Hedeflerin erişilebilir kaldığı sıradan bir kopmada daraltmasız kural **2 turda**, geri bildirmeme **3 turda**, ikisi birlikte **7 turda** yakınsıyor. Bekletme burada iki kez zarar veriyor: geri bildirmeme geçici olarak bir girdiyi erişilemez gösteriyor, bekletme bu geçici bilgiyi doğru sanıp altı tur donduruyor. **Kötü haberi hızlandıran her daraltma, iyi haberi yavaşlatır.** #### Özet - Uzaklık vektörü ailesinde düğüm komşusundan yalnız bir yol maliyeti dizisi duyar; topolojiyi değil, komşusunun çoktan alınmış kararını öğrenir ve ona bir ekler. - Soğuk başlangıçtan doğru tabloya **dört turda** varılır; tur başına ulaşan paket **0, 9, 20, 32, 40**, doğru satır sayısı **0, 16, 32, 48, 56**'dır — her tur bir komşuluk adımı ilerler. - Yalnız daha kısa yolu kabul eden kural kötü haberi öğrenemez; bunu öğrenebilmek için verilen ödün sonsuza saymayı doğurur. - Bir hedef erişilemez olduğunda daraltmasız kuralda on iki turluk pencerede **60 paketin altmışı da döngüye** girer, **202** adım harcanır ve yol maliyeti tavana bile varamaz. - Geri bildirmeme döngüyü **5**'e, adımı **59**'a indirir; bekletme eklendiğinde tavana **6.** turda varılır ve adım **41**'e iner, ama bekletme tek başına hiçbir şey yapmaz çünkü tetikleyicisi oluşmaz. - Daraltmaların bedeli sıradan kopmada ödenir: yakınsama turu **2**'den **3**'e, ikisi birlikteyken **7**'ye çıkar. #### Sonraki Adım Bütün bu kusurların tek bir kaynağı var: düğüm komşusunun **kararını** duyuyor, komşusunun **gördüğünü** değil. Yol maliyeti tek bir sayıya sıkıştığı için o sayının hangi yolu özetlediği kayboluyor; düğüm kendi adının o yolun içinde geçip geçmediğini bilemiyor ve daraltmalar bu bilgisizliği dışarıdan kapatmaya çalışıyor. Sonraki ders ödünü tersine çevirir: komşular birbirine karar değil **ham bağ bilgisi** gönderirse ve her düğüm en kısa yolu kendi hesaplarsa, kaç turda yakınsanır? ### Bağlantı Durumu Protokolleri Source: https://academia.sh/tr/kurslar/anahtarlama-ve-yonlendirme/baglanti-durumu-protokollari Komşuya karar değil ham bağ bilgisi gönderilir; her düğüm topoloji veritabanını kendi kurar ve en kısa yolu kendi hesaplar. Doğru tabloya üç turda varılır ve her turda uzaklık vektörünün önündedir: 9, 20, 32, 40'a karşı 0, 9, 20, 32. Önceki dersin bütün kusurları tek bir yerden geliyordu: düğüm komşusunun **kararını** duyuyordu, komşusunun **gördüğünü** değil. Uzaklık dizisindeki bir sayı, komşunun kendi komşusundan duyduğu bir sayıya bir eklenerek üretilmişti; o sayının hangi yoldan geçtiği sıkıştırma sırasında kaybolmuştu. **Bağlantı durumu (link state)** ailesi ödünü tersine çevirir. Komşuya gönderilen şey bir karar değil, **ham bir olgudur**: "şu bağ var ve ölçüsü şudur." Olgu taşınırken değiştirilmez, özetlenmez, üzerine bir eklenmez. Her düğüm kendisine ulaşan olguları biriktirir ve en kısa yolu **kendi hesaplar**. Bu dersin sorusu, bu değiş tokuşun kaç tur kazandırdığı ve kazancın nereden geldiğidir. #### Komşuya Gönderilen Şey Uzaklık vektöründe bir düğüm sekiz satırlık bir ölçü dizisi gönderiyordu: her hedef için bir sayı. Bağlantı durumunda gönderilen şey çok daha küçüktür — düğüm yalnız **kendi bağlarını** bildirir. ```text # ogretilen dokum, calistirilmamistir düğüm c'nin bildirimi bildiren c komşu b ölçü 1 komşu d ölçü 1 düğüm c'nin bildirimi, iki tur sonra elinde biriken veritabanı a–b b–c c–d d–e e–f f–g g–h h–a ``` Fark bildirimin boyutunda değil, **kimin adına konuştuğundadır**. Uzaklık vektöründe `c`, `h`'ye dört adımda gidildiğini söylüyordu — bu `c`'nin kendi kararıydı ve `h` hakkında `c`'nin bilmediği bir şey içeriyordu. Bağlantı durumunda `c` yalnız kendi gördüğü iki bağı bildirir; `h` hakkında hiçbir şey söylemez, çünkü `h` hakkında hiçbir şey görmez. #### Taşırma ve Topoloji Veritabanı Bildirim komşuda durmaz. Alan düğüm onu kendi komşularına **olduğu gibi** iletir; Ağ Modelleri ve Protokoller kursunda kurulan **taşırma** düzeneğinin buradaki karşılığı budur. İletirken bildirimi değiştirmez, ölçüsüne bir eklemez, kendi adını yazmaz. Bildirim ağın içinde yayılırken **aynı bildirim** kalır. Her düğüm gelen bildirimleri biriktirir. Biriken şeye **topoloji veritabanı** denir ve sonunda ağın bağ listesinden başka bir şey değildir. Veritabanı tamamlandığında düğümün elinde topolojinin kendisi vardır — kimsenin özetlemediği, kimsenin çiğnemediği hâliyle. Bundan sonrası bir çizge hesabıdır. Düğüm kendisini kaynak alarak her hedefe giden en kısa yolu bulur ve yolun **ilk adımını** tablosuna yazar. Bu hesabın kendisi Algoritmalar müfredatındaki Çizge Algoritmaları kursunda kuruldu ve burada yeniden türetilmez; burada önemli olan hesabın **nerede** yapıldığıdır. Uzaklık vektöründe hesap dağıtıktı ve her düğüm komşusunun hesabının üstüne inşa ediyordu. Burada hesap **yereldir**: her düğüm aynı girdiden aynı sonucu bağımsız olarak çıkarır. Bunun doğrudan bir sonucu vardır. Yanlış bir tablo artık yanlış bir hesaptan gelemez — hesap her yerde aynıdır. Yanlış tablo yalnız **eksik girdiden** gelir: veritabanı henüz dolmamıştır. Ölçüm bu eksikliği sayar. #### Veritabanının Bedeli Bu düzenek bedava değildir ve bedeli iki yerde toplanır. Birincisi boyuttur. Uzaklık vektöründe bir düğümün tuttuğu şey hedef sayısı kadar satırdır; bağlantı durumunda tuttuğu şey **ağın tamamıdır**. Ölçülen ağda bu sekiz bağ demektir, ama bağ sayısı büyüdükçe her düğümün belleği ve her değişiklikte yaptığı hesap onunla büyür. Büyük ağların topolojiyi bölgelere ayırıp her bölgenin veritabanını kendi içinde tutmasının nedeni budur: hesabın girdisi küçültülür. İkincisi tazeliktir. Bildirim değiştirilmeden taşındığı için, ağda dolaşan **eski** bir bildirim yeni bir bildirimle karışabilir ve bir düğüm geçmişteki bir bağı bugünkü sanabilir. Bu yüzden her bildirim bir **sıra numarası** ve bir **yaş** taşır; düğüm aynı bildirenin iki bildirimini gördüğünde büyük numaralıyı tutar, yaşı dolanı düşürür. Bu iki alan, kopyaların anlaşmazlığını protokolün kendi içinde çözen tek düzenektir. Ölçümün varsayımları: - **YL22** — Ağ, kâhin ve kırk çift önceki derslerdekiyle aynıdır; ölçülen kopma yine halkayı kesen kirişin kaybıdır ve iki aile aynı topolojide ölçülür. - **YL23** — Bağlantı durumu ailesinde düğümün başlangıç bilgisi **kendi bağlarıdır**. Bu bilgi bir komşudan duyulmaz, doğrudan gözlenir; bağın ucundaki cihaz kendi arayüzünü görür. - **YL24** — Tur, her düğümün elindeki bağ kümesini bütün komşularına iletmesi ve gelenleri kendi kümesine katmasıdır. Bildirim taşınırken **değiştirilmez**. - **YL25** — Düğüm elindeki bağ kümesinden en kısa yolu kâhinle **aynı yordamla** hesaplar. Yordam her düğümde aynıdır; farklı çıkan tek şey girdidir. Eksik girdiyle çıkan tablo yanlış olur, yordam değil. - **YL26** — Uzaklık vektörü tarafı önceki dersin soğuk başlangıçlı kuralıdır: düğüm komşusunun ölçü dizisini duyar ve yalnız daha kısa yolu alır. - **YL27** — Taşınan girdi sayımında uzaklık vektörü her komşuya sekiz hedeflik dizisini, bağlantı durumu bildiği bağ kümesini gönderir. Model **her turda** taşırma yapar; gerçek protokoller değişiklik olmadıkça taşırmaz, bu yüzden sayım yalnız yakınsama penceresi için anlamlıdır. - **YL28** — Kümenin çözünürlüğü kırk paket üzerinden **1/40 = 0,025**'tir. #### Ölçüm ```python """Baglanti durumu: komsuya karar degil ham bag bilgisi gonderilir. Bolum 1 - iki ailenin tur basina paket kaderi yan yana. Bolum 2 - dogru satir, bilinen bag ve o tura dek tasinan girdi. """ TOHUM = 20260810 DUGUMLER = ["a", "b", "c", "d", "e", "f", "g", "h"] BAGLAR = [("a", "b"), ("b", "c"), ("c", "d"), ("d", "e"), ("e", "f"), ("f", "g"), ("g", "h"), ("h", "a"), ("b", "f")] KOPUK = [b for b in BAGLAR if b != ("b", "f")] ATLAMA_SINIRI = 12 def uretec(tohum): d = tohum % 2147483646 + 1 def r(n): nonlocal d d = (d * 48271) % 2147483647 return d % n return r def komsuluk(baglar): k = {u: set() for u in DUGUMLER} for x, y in baglar: k[x].add(y) k[y].add(x) return k def kahin(baglar): k, tablo = komsuluk(baglar), {} for kaynak in DUGUMLER: onceki, sira, gorulen = {}, [kaynak], {kaynak} while sira: yeni = [] for u in sira: for v in sorted(k[u]): if v not in gorulen: gorulen.add(v) onceki[v] = u yeni.append(v) sira = yeni for hedef in DUGUMLER: if hedef == kaynak or hedef not in onceki: continue adim = hedef while onceki[adim] != kaynak: adim = onceki[adim] tablo[(kaynak, hedef)] = adim return tablo def ilet(kaynak, hedef, tablolar, baglar): k, u, gecilen, atlama = komsuluk(baglar), kaynak, [], 0 while u != hedef: if atlama >= ATLAMA_SINIRI: return "dongu", atlama sonraki = tablolar.get((u, hedef)) if sonraki is None or sonraki not in k[u]: return "kara delik", atlama if (u, sonraki) in gecilen: return "dongu", atlama gecilen.append((u, sonraki)) u, atlama = sonraki, atlama + 1 return "ulasti", atlama def ciftler(sayi=40, tohum=TOHUM): r, liste = uretec(tohum), [] while len(liste) < sayi: x, y = DUGUMLER[r(8)], DUGUMLER[r(8)] if x != y: liste.append((x, y)) return liste def olc(tablolar, baglar, sayi=40): sayim = {"ulasti": 0, "dongu": 0, "kara delik": 0} for x, y in ciftler(sayi): sayim[ilet(x, y, tablolar, baglar)[0]] += 1 return sayim def uzaklik_vektoru(baglar, tur): """Komsudan ozetlenmis olcu duyulur; yalniz daha kisa yol alinir.""" k = komsuluk(baglar) uzak = {(u, h): (0 if u == h else 99) for u in DUGUMLER for h in DUGUMLER} ilk = {} for _ in range(tur): yeni_uzak, yeni_ilk = dict(uzak), dict(ilk) for u in DUGUMLER: for v in sorted(k[u]): for h in DUGUMLER: if uzak[(v, h)] + 1 < yeni_uzak[(u, h)]: yeni_uzak[(u, h)] = uzak[(v, h)] + 1 yeni_ilk[(u, h)] = v uzak, ilk = yeni_uzak, yeni_ilk return ilk def baglanti_durumu(baglar, tur): """Ham bag bilgisi degistirilmeden tasinir; dugum kendi hesaplar.""" k = komsuluk(baglar) bilinen = {u: {(u, v) for v in k[u]} for u in DUGUMLER} tasinan = 0 for _ in range(tur): tasinan += sum(len(bilinen[u]) * len(k[u]) for u in DUGUMLER) yeni = {u: set(bilinen[u]) for u in DUGUMLER} for u in DUGUMLER: for v in k[u]: yeni[u] |= bilinen[v] bilinen = yeni tablolar = {} for u in DUGUMLER: yerel = kahin([tuple(sorted(b)) for b in bilinen[u]]) for (x, h), adim in yerel.items(): if x == u: tablolar[(u, h)] = adim return tablolar, bilinen, tasinan dogru = kahin(KOPUK) k_kopuk = komsuluk(KOPUK) uv_tur_girdi = sum(len(DUGUMLER) * len(k_kopuk[u]) for u in DUGUMLER) print(f"düğüm {len(DUGUMLER)} | kopma sonrası bağ {len(KOPUK)} | tablo satırı " f"{len(dogru)} | ölçülen paket {len(ciftler())}") print() print(f"{'tur':>3s} | {'uzaklık vektörü: ulaştı':>23s} {'döngü':>6s} {'k.delik':>8s}" f" | {'bağlantı durumu: ulaştı':>23s} {'döngü':>6s} {'k.delik':>8s}") for tur in range(6): uv = olc(uzaklik_vektoru(KOPUK, tur), KOPUK) bd = olc(baglanti_durumu(KOPUK, tur)[0], KOPUK) print(f"{tur:3d} | {uv['ulasti']:23d} {uv['dongu']:6d} {uv['kara delik']:8d}" f" | {bd['ulasti']:23d} {bd['dongu']:6d} {bd['kara delik']:8d}") print() print(f"{'tur':>3s} {'UV doğru satır':>14s} {'BD doğru satır':>14s} " f"{'BD bilinen bağ':>14s} {'BD taşınan':>11s} {'UV taşınan':>11s}") for tur in range(6): uv = uzaklik_vektoru(KOPUK, tur) bd, bilinen, tasinan = baglanti_durumu(KOPUK, tur) bag = {len({tuple(sorted(b)) for b in bilinen[u]}) for u in DUGUMLER} print(f"{tur:3d} {sum(1 for a in dogru if uv.get(a) == dogru[a]):11d}/56" f" {sum(1 for a in dogru if bd.get(a) == dogru[a]):11d}/56" f" {min(bag):8d}/{len(KOPUK):<5d} {tasinan:11d} {uv_tur_girdi * tur:11d}") ``` ``` düğüm 8 | kopma sonrası bağ 8 | tablo satırı 56 | ölçülen paket 40 tur | uzaklık vektörü: ulaştı döngü k.delik | bağlantı durumu: ulaştı döngü k.delik 0 | 0 0 40 | 9 0 31 1 | 9 0 31 | 20 0 20 2 | 20 0 20 | 32 0 8 3 | 32 0 8 | 40 0 0 4 | 40 0 0 | 40 0 0 5 | 40 0 0 | 40 0 0 tur UV doğru satır BD doğru satır BD bilinen bağ BD taşınan UV taşınan 0 0/56 16/56 2/8 0 0 1 16/56 32/56 4/8 32 128 2 32/56 48/56 6/8 128 256 3 48/56 56/56 8/8 288 384 4 56/56 56/56 8/8 512 512 5 56/56 56/56 8/8 768 640 ``` #### Her Turda Önde Üst tablo iki aileyi aynı kopmada, aynı kırk paketle yan yana koyuyor. Bağlantı durumu doğru tabloya **üç turda** varıyor, uzaklık vektörü **dört turda**. Ve fark yalnız bitiş noktasında değil: bağlantı durumu **her turda** öndedir. Sıfırıncı turda **9**'a karşı **0**, birinci turda **20**'ye karşı **9**, ikinci turda **32**'ye karşı **20**. Sıfırıncı tur en çok şey söyleyen satırdır. Hiçbir bildirim henüz gönderilmemiştir ve bağlantı durumu yine de **9 paketi ulaştırır**. Sebep varsayım YL23'tür: düğümün kendi bağları bir komşudan duyulmaz, doğrudan görülür. Bağın ucundaki cihaz o bağın var olduğunu protokolsüz bilir. Uzaklık vektöründe bu bilgi de bir turluk bildirim bekler, çünkü orada tabloya yazılan şey **duyulan** bir ölçüdür. Döngü sütunu her iki ailede de baştan sona **0**'dır. Bu bir tesadüf değil, soğuk başlangıcın sonucudur: iki kural da yalnız daha kısa yolu kabul ediyor ve hiçbir tablo satırı yanlış bir komşuyu göstermiyor — henüz **hiçbir şey** göstermiyor. Yanlış yön için önce bir yön yazılmış olması gerekir; boş satır kara delik üretir, döngü üretmez. #### Fark Nerede Alt tablo kazancın kaynağını arıyor ve ilk bakışta beklenen yanıtı vermiyor. Doğru satır sütunları her iki ailede de **turda tam on altı satır** ilerliyor: uzaklık vektörü 0, 16, 32, 48, 56; bağlantı durumu 16, 32, 48, 56. **Artış hızı aynı.** İki aile de turda bir komşuluk adımı ilerliyor, çünkü bilgi ikisinde de bir turda bir bağ geçiyor. Ne bağlantı durumu daha hızlı yayılıyor, ne uzaklık vektörü daha yavaş. İki dizi arasındaki tek fark **başlangıç noktasıdır**. Bağlantı durumunun dizisi uzaklık vektörünün dizisinin **bir tur kaydırılmış** hâlidir. Kazanılan tur, kazanılan hız değil, kazanılan **baş**tır. Taşınan girdi sütunları da beklenenin tersini söylüyor. Bağlantı durumu kendi yakınsama turunda (üçüncü tur) **288** girdi taşımış; uzaklık vektörü kendi yakınsama turunda (dördüncü tur) **384**. Yani daha erken yakınsayan aile **daha az** bilgi taşımış. Bilinen bağ sütunu bunu doğruluyor: bağlantı durumu düğümünün taşıdığı en büyük yük **sekiz bağdır** ve orada durur, çünkü ağın tamamı sekiz bağdır. Uzaklık vektörü ise her turda her komşuya sekiz hedeflik dizisini yeniden gönderir ve bu yük hiç azalmaz. Dördüncü okuma buradan çıkar: **fark bilgi miktarında değil, bilginin ne kadar uzaktan taşındığındadır.** Uzaklık vektöründe bir düğümün `h` hakkında bildiği sayı, `h`'den başlayıp aradaki her düğümde yeniden hesaplanarak gelmiştir; her durakta bir toplama yapılmış ve o duraktan öncesi silinmiştir. Bağlantı durumunda `h`'nin bağları, `h`'nin ağzından çıktığı biçimde gelir; aradaki düğümler taşıyıcıdır, yorumcu değil. Yorumlanmayan bilgi, taşındığı mesafeden bağımsız olarak aynı bilgidir. Beşinci tur satırı da dürüstlük gerektiriyor. Orada bağlantı durumunun taşıdığı girdi **768**'e çıkıp uzaklık vektörünü geçiyor. Bu, YL27'de yazılan model kısıtının sonucudur: ölçüm her turda taşırma yapıyor. Gerçek protokoller yakınsadıktan sonra bir değişiklik olmadıkça taşırmaz; sayım bu yüzden yalnız yakınsama penceresi için okunur. #### İki Ailenin Ortak Vardığı Yer Bütün bu farklara karşın iki aile aynı yere varıyor. Dördüncü turdan sonra her iki sütun da **56/56** doğru satır ve **40/40** ulaşan paket veriyor. Tablolar yalnız eşit derecede doğru değil, **birbirinin aynısı**: ikisi de kâhinin tablosudur. Bunun nedeni yapısaldır. İki aile de aynı şeyi arıyor — **en kısa yolu**. Uzaklık vektörü onu komşularının ölçülerini toplayarak, bağlantı durumu topolojiyi kurup kendi hesaplayarak buluyor; ama aranan ölçüt tek. Ölçütü tek olan bir aramanın sonucu da tektir ve bu yüzden iki ailenin ayrıldığı yer sonuç değil, sonuca varış süresi ve o süredeki paketin kaderidir. #### Özet - Bağlantı durumu ailesinde komşuya karar değil ham bağ bilgisi gönderilir; bildirim taşınırken değiştirilmez ve her düğüm en kısa yolu kendi hesaplar. - Yanlış tablo yanlış hesaptan gelemez, çünkü hesap her düğümde aynıdır; yanlış tablo yalnız **eksik girdiden** gelir. - Doğru tabloya **üç turda** varılır ve her turda uzaklık vektörünün önündedir: ulaşan paket **9, 20, 32, 40**'a karşı **0, 9, 20, 32**. Sıfırıncı turdaki 9 paket, düğümün kendi bağlarını protokolsüz bilmesinden gelir. - Doğru satır artışı iki ailede de **turda on altıdır**; bağlantı durumunun dizisi uzaklık vektörünün **bir tur kaydırılmış** hâlidir. Kazanılan şey hız değil baştır. - Yakınsama turunda taşınan girdi bağlantı durumunda **288**, uzaklık vektöründe **384**: erken yakınsayan aile daha az bilgi taşır. Fark bilgi miktarında değil, bilginin ne kadar uzaktan **yorumlanmadan** taşındığındadır. - İki aile de dördüncü turdan sonra **56/56** doğru satıra ve **40/40** ulaşan pakete varır; tablolar birbirinin aynısıdır, çünkü ikisi de aynı ölçütü arar. #### Sonraki Adım Son bölümün bulgusu şudur: iki aile de **en kısa yolu** arıyordu ve ikisi de sonunda **aynı tabloya** vardı. Ölçüt tek olduğu için sonuç da tekti; aralarındaki bütün fark o sonuca varana kadar geçen turlara sıkışmıştı. Bu, ölçütün kendisinin hiç tartışılmadığı anlamına gelir — kısalık, sorgulanmadan iyi sayıldı. Oysa bir yol yalnız uzunluğuyla değerlendirilmez: kimin ağından geçtiği, kimin hattını doldurduğu ve kime ne kadara mal olduğu da yolun nitelikleridir. Sonraki ders şunu sorar: ya en kısa yol **istenmiyorsa** — tablo neye göre kurulur ve uzayan yol bir kusur mudur? ### Sınır Ağ Geçidi Protokolü Source: https://academia.sh/tr/kurslar/anahtarlama-ve-yonlendirme/sinir-ag-gecidi-protokolu Otonom sistem sınırında karar en kısa yola değil politikaya bakar: transit yasağı kırk paketin kırkını da hedefine ulaştırır ama toplam adımı 83'ten 92'ye çıkarır, sınır duyurusu kapandığında 14 paket kara deliğe düşer, tek bir düğümün yol sızıntısı ise adımı 83'e geri indirip 7 paketi sözleşme dışı yoldan geçirir. Önceki iki ders iki yönlendirme ailesini yan yana koydu. Uzaklık vektörü komşusunun uzaklık dizisini öğreniyordu, bağlantı durumu topolojinin kendisini taşıyordu; turları farklıydı, ama ikisi de aynı şeyi arıyordu ve sonunda **aynı tabloya** varıyordu: her hedefe giden **en kısa yolun** ilk adımı. Bu dersin sorusu tam buradan başlar. Ya en kısa yol **istenmiyorsa**? Bir ağ, komşusunun trafiğini taşımak zorunda değildir; taşıdığında bunun bir bedeli ve bir sözleşmesi vardır. Sınır ağ geçidi protokolünün ölçüsü bu yüzden en kısa yol değil **izin verilen yoldur** ve izin verilen yol çoğu zaman daha uzundur. #### Sınır Bir Karar Sınırıdır Otonom sistem kavramı **İnternet Nasıl Çalışır** kursunda kuruldu; tanımı burada tekrarlanmaz. Burada önemli olan şu ayrımdır: bir otonom sistemin **içinde** tablo bir **ölçüye** göre kurulur — adım sayısı, bağ maliyeti, gecikme. Sınırın **ötesinde** ölçünün yerini **sözleşme** alır. Sınırdan geçen şey bir uzaklık değil bir **duyurudur**. Duyuru üç şey söyler: hangi hedefe gidildiği, o hedefe hangi otonom sistemler üzerinden gidildiği ve **bir sonraki düğümün** kim olduğu. Komşu bu duyuruyu kabul edebilir, değiştirebilir ya da atabilir. Kabul ederse kendi tablosuna bir satır yazar; atarsa o hedefe giden bir yolu hiç öğrenmemiş olur. Ve duyuruyu **doğrulayan hiçbir şey yoktur**. Uygulama Katmanı Protokolleri kursu bunu iletide yazan için söylemişti; sınırda aynı boşluk duyuru için geçerlidir. Komşu ne bildirirse tablo onu yazar. Duyurunun **yolu** taşıması iki işi birden görür. Birincisi politikadır: alan taraf yolun ara konumuna bakarak duyuruyu kabul eder ya da atar; bu dersin ölçtüğü şey budur. İkincisi döngü saptamasıdır ve kursun üçüncü iddiasıyla doğrudan ilgilidir. Kurs boyunca döngü **en az iki tablonun anlaşmazlığı** olarak sayıldı; hiçbir cihaz tek başına bir paketi döngüye sokamıyordu, çünkü hiçbir cihaz kendi tablosundan öteye bakamıyordu. Sınırda durum değişir: duyuru yolun kendisini taşıdığı için bir otonom sistem, gelen duyurunun yolunda **kendi adını** görebilir. Gördüğü an duyuruyu atar. Döngünün tek bir tabloya bakılarak saptanabildiği yer burasıdır ve içeride karşılığı yoktur — uzaklık vektörü ailesinin sonsuza sayma kusuru tam olarak bu bilginin eksikliğinden doğar. #### Kurgu: Üç Otonom Sistem Kursun sekiz düğümlü ağı üç otonom sisteme bölünür. Bölünme fiziksel bağları değiştirmez; yalnızca hangi bağın **sınır bağı** olduğunu belirler. ```text # ogretilen dokum, calistirilmamistir otonom sistem düğümler iç bağlar sınır bağları kuzey a b c d a-b b-c c-d d-e (orta), b-f (orta), h-a (güney) orta e f e-f d-e (kuzey), b-f (kuzey), f-g (güney) güney g h g-h f-g (orta), h-a (kuzey) güney -> kuzey duyurusu kuzey -> güney duyurusu hedef g hedef c yol güney yol kuzey bir sonraki düğüm h bir sonraki düğüm a orta -> kuzey duyurusu (güney'den öğrenilmiş, transit yasağıyla iletilmez) hedef g yol orta güney bir sonraki düğüm f ``` Üçüncü duyuru dersin çekirdeğidir. Orta otonom sistemi güney'e giden bir yolu biliyor ve kuzey'e duyurabilir. Duyurursa kuzey ile güney arasındaki trafiği **taşımayı** üstlenmiş olur. Taşımayacaksa duyuruyu iletmez ve kuzey o yolu hiç öğrenmez. #### İzin Verilen Yol Bir yolun otonom sistem dizisi, düğüm dizisinin otonom sistemlere çevrilip yinelemelerin sıkıştırılmış hâlidir. `g-f-b-c` yolunun dizisi `güney orta kuzey`, `g-h-a-b-c` yolununki `güney kuzey`'dir. **Kural tek satırdır:** bir otonom sistem transit taşımayacağını bildirdiğinde, dizinin **ara konumunda** onun bulunduğu her yol elenir. Baştaki ve sondaki otonom sistem ara konumda sayılmaz — kendi trafiğini taşımak transit değildir. Sonuç `g`'den `c`'ye giden pakette görünür. En kısa yol `g-f-b-c`, üç adımdır ve ortadan geçer. Orta transit taşımıyorsa bu yol elenir; geriye kalan en kısa **izin verilen** yol `g-h-a-b-c`, dört adımdır. **Yol bir adım uzadı, paket yine ulaştı.** Ölçülen şey budur. Ölçümün varsayımları: - **YL61** — Sekiz düğüm, dokuz bağ: yedisi `a–b–c–d–e–f–g–h–a` halkasını kurar, sekizincisi halkayı kesen `b–f` kirişidir. Topoloji kurs boyunca aynıdır. - **YL62** — Düğümler üç otonom sisteme bölünür: kuzey `a b c d`, orta `e f`, güney `g h`. Otonom sistemler numarayla değil kurgu adlarla anılır. - **YL63** — Politika tek kuraldan ibarettir: **transit yasağı**. Kaynağın ve hedefin kendi otonom sistemi ara konumda sayılmaz. - **YL64** — Kâhin değişmez; gerçek her zaman **en kısa yolun** ilk adımıdır. Politika tablosu ayrı bir tablodur ve ölçülen şey ikisinin farkıdır. - **YL65** — Kırk kaynak–hedef çifti kurs çekirdeğinin üretecinden gelir. Aynı çift birden çok kez çıkabilir ve her çıkışı **ayrı bir pakettir**. Atlama sınırı 12. - **YL66** — Sızıntı **tek bir düğümün** yasağı tutmamasıdır: `f`, orta otonom sisteminin transit taşımama sözüne karşın duyuruyu iletir. Öteki orta düğümü `e` sözü tutar. - **YL67** — Kırk paketlik kümede ölçülebilen en küçük fark `1/40 = 0,025`'tir; bundan küçük bir fark iddia edilmez. #### Ölçüm ```python """Politika tabanli yonlendirme: en kisa yol degil izin verilen yol.""" TOHUM = 20260810 DUGUMLER = "abcdefgh" BAGLAR = [("a", "b"), ("b", "c"), ("c", "d"), ("d", "e"), ("e", "f"), ("f", "g"), ("g", "h"), ("h", "a"), ("b", "f")] OS = {"a": "kuzey", "b": "kuzey", "c": "kuzey", "d": "kuzey", "e": "orta", "f": "orta", "g": "guney", "h": "guney"} ATLAMA_SINIRI = 12 def uretec(tohum): d = tohum % 2147483646 + 1 def r(n): nonlocal d d = (d * 48271) % 2147483647 return d % n return r def ciftler(sayi=40): r, liste = uretec(TOHUM), [] while len(liste) < sayi: x, y = DUGUMLER[r(8)], DUGUMLER[r(8)] if x != y: liste.append((x, y)) return liste def komsuluk(baglar): k = {u: set() for u in DUGUMLER} for x, y in baglar: k[x].add(y) k[y].add(x) return k def tablo(tasimayan=(), kapali=(), sizdiran=()): """Her dugum icin her hedefe giden en kisa IZIN VERILEN yolun ilk adimi.""" kom, t = komsuluk(BAGLAR), {} for u in DUGUMLER: for h in DUGUMLER: if u == h: continue yasak = {v for v in DUGUMLER if OS[v] in tasimayan and OS[v] not in (OS[u], OS[h]) and v not in sizdiran} onceki, sira, gorulen = {}, [u], {u} while sira: yeni = [] for x in sira: for v in sorted(kom[x]): if tuple(sorted((x, v))) in kapali or v in gorulen: continue if v in yasak and v != h: continue gorulen.add(v) onceki[v] = x yeni.append(v) sira = yeni if h not in onceki: continue adim = h while onceki[adim] != u: adim = onceki[adim] t[(u, h)] = adim return t def ilet(kaynak, hedef, t): kom, u, yol, gecilen = komsuluk(BAGLAR), kaynak, [kaynak], [] while u != hedef: if len(yol) > ATLAMA_SINIRI: return "dongu", yol s = t.get((u, hedef)) if s is None or s not in kom[u]: return "kara delik", yol if (u, s) in gecilen: return "dongu", yol gecilen.append((u, s)) u = s yol.append(u) return "ulasti", yol def olc(t, tasimayan): sayim, adim, disi = {"ulasti": 0, "dongu": 0, "kara delik": 0}, 0, 0 for x, y in ciftler(): kader, yol = ilet(x, y, t) sayim[kader] += 1 adim += len(yol) - 1 if {OS[v] for v in yol[1:-1]} & (set(tasimayan) - {OS[x], OS[y]}): disi += 1 return sayim, adim, disi REJIM = (("politikasız", (), (), ()), ("orta taşımaz", ("orta",), (), ()), ("orta taşımaz, sınır kapalı", ("orta",), (("a", "h"),), ()), ("orta taşımaz, f sızdırıyor", ("orta",), (), ("f",))) print(f"{'rejim':<28s} {'satır':>5s} {'ulaştı':>7s} {'döngü':>6s} " f"{'kara delik':>11s} {'adım':>5s} {'politika dışı':>14s}") for ad, tas, kap, siz in REJIM: t = tablo(tas, kap, siz) s, a, d = olc(t, tas) print(f"{ad:<28s} {len(t):5d} {s['ulasti']:7d} {s['dongu']:6d} " f"{s['kara delik']:11d} {a:5d} {d:14d}") temel, dar, sizan = tablo(), tablo(("orta",)), tablo(("orta",), (), ("f",)) print() print(f"56 satırın politikayla ayrışanı " f"{sum(1 for k in temel if temel[k] != dar.get(k))}, " f"sızıntıyla ayrışanı {sum(1 for k in temel if temel[k] != sizan.get(k))}") print(f"{'çift':>7s} {'paket':>6s} {'politikasız':>12s} {'politikalı':>11s}" f" {'sızıntıda':>10s}") for x, y in sorted(set(ciftler())): y0, y1, y2 = (''.join(ilet(x, y, t)[1]) for t in (temel, dar, sizan)) if y0 == y1 == y2: continue n = sum(1 for c in ciftler() if c == (x, y)) print(f"{x+'->'+y:>7s} {n:6d} {y0:>12s} {y1:>11s} {y2:>10s}") ``` ``` rejim satır ulaştı döngü kara delik adım politika dışı politikasız 56 40 0 0 83 0 orta taşımaz 56 40 0 0 92 0 orta taşımaz, sınır kapalı 40 26 0 14 48 0 orta taşımaz, f sızdırıyor 56 40 0 0 83 7 56 satırın politikayla ayrışanı 5, sızıntıyla ayrışanı 1 çift paket politikasız politikalı sızıntıda b->g 2 bfg bahg bfg g->b 1 gfb ghab gfb g->c 2 gfbc ghabc gfbc g->d 2 gfed ghabcd gfed ``` #### Uzayan Yol Bir Kusur Değildir İkinci satır dersin ana ölçüsüdür. Transit yasağı yürürlüğe girdiğinde tablo yine **56 satırdır**, kırk paketin **kırkı da ulaşır**, döngü **0**, kara delik **0**. Değişen tek şey toplam adımdır: **83'ten 92'ye**, dokuz adım. Alt tablo dokuz adımın nereden geldiğini gösteriyor. Elli altı satırın yalnız **5**'i ayrışıyor ve ölçülen kırk pakette bu ayrışma **dört çifte**, toplam **yedi pakete** dokunuyor. `g->d` yolu üç adımdan beşe çıkıyor, `g->c` üçten dörde, `b->g` ve `g->b` ikiden üçe. Öteki otuz üç paket politikayı hiç görmüyor, çünkü yolları zaten ara konumda ortadan geçmiyordu. Bu ders kursun ölçü ekseniyle birlikte okunmalıdır. Ekseni belirleyen şey **paketin kaderidir**: ulaştı, döngü, kara delik. Politika bu üç sayının hiçbirini değiştirmedi. Kırk paketlik kümede ölçülebilen en küçük fark `0,025`'tir ve buradaki kader farkı tam olarak **sıfırdır**. Adım, kaderin değil bedelin ölçüsüdür. Bunun tersini söylemek de doğrudur: **en kısa yol bir hedef değildir.** Kiriş üzerinden geçen yol iki adım kısaydı, ama o kirişin iki ucu iki ayrı otonom sisteme aitti ve aradaki trafiği taşımanın bir bedeli vardı. Dokuz adım, o bedeli ödememenin karşılığıdır. #### Politika Fazla Dar Kurulursa Üçüncü satır ayrımı keskinleştiriyor. Bu rejimde transit yasağı duruyor ve buna ek olarak kuzey ile güney arasındaki `h–a` sınır bağı duyurulmuyor — iki komşu birbirine hiçbir hedef bildirmiyor. Tablo **56 satırdan 40 satıra** iniyor. Eksik kalan on altı satır için **izin verilen yol yoktur**: kuzey'den güney'e giden her yol ya ortadan geçer (yasak) ya da `h–a`'dan geçer (duyurulmuyor). Ölçümde bu **14 kara delik** olarak görünüyor; kırk paketten yalnız **26**'sı ulaşıyor. Adım sayısının 92'den **48**'e inmesi bir iyileşme değildir. Ölen paket adım harcamayı bırakır; düşük adım burada tam olarak **kaybın** göstergesidir. Aynı sayının iki rejimde iki ayrı şey söylemesi, tek bir sayaca bakmanın neden yetmediğinin de yanıtıdır. Ayrım şudur: **yolu uzatan politika bir kusur değildir; hedefi ulaşılamaz kılan politika kusurdur.** İkisi de aynı dille yazılır, ikisinin de sözdizimi doğrudur, ikisi de hatasız yürürlüğe girer. Farkı yalnız ölçüm gösterir. #### Yol Sızıntısı ve Daraltmalar Dördüncü satır bir yapılandırma kusurunu ölçüyor. **Yol sızıntısı**, bir otonom sistemin bir komşusundan öğrendiği duyuruyu, sözleşmesi gereği iletmemesi gerekirken başka bir komşusuna iletmesidir. Burada `f` düğümü orta otonom sisteminin transit yasağını tutmuyor; `e` tutuyor. Yasağı bozan **tek bir düğümdür**. Sonuç şaşırtıcı biçimde temiz görünüyor: **56 satır, 40 ulaştı, 0 döngü, 0 kara delik.** Toplam adım **92'den 83'e** iniyor. Elli altı satırın yalnız **1**'i politikasız tablodan ayrılıyor — yani sızıntı, tabloyu bir satır kala **politikasız hâline geri döndürüyor**. Ve **7 paket** ara konumda ortadan geçiyor: alt tablonun sağ sütunu bu yolları veriyor, `bfg`, `gfb`, `gfbc`, `gfed`. Bu bir saldırı değil bir **yapılandırma kusurudur**: kural yazılmış, sözdizimi doğru, oturum ayakta, hiçbir alarm çalmıyor. Saldırı tarafı **Ağ Güvenliği** kursunun konusudur ve buraya taşınmaz. Sayılan yüzeyler ve her birini kapatan daraltma şunlardır. **Birinci yüzey — sözleşme dışı taşınan trafik.** Yedi paket, taşınmayacağı bildirilmiş bir otonom sistemden geçiyor. **Daraltma:** bir komşudan öğrenilen duyurunun başka bir komşuya iletilmesi, komşu başına yazılmış bir **önek süzgeciyle** sınırlanır; süzgeçte olmayan önek duyurulmaz. İkinci daraltma, komşu başına **duyuru sayısı üst sınırıdır** — sızıntı çoğu kez duyuru sayısında ani bir artışla gelir ve sınır aşıldığında oturum kendiliğinden kapanır. **İkinci yüzey — sızıntının iyileşme gibi görünmesi.** Adım 92'den 83'e indi, kaybolan paket yok, tablo satırı 56'da kaldı. Gecikmeye bakan bir sayaç **iyileşme** bildirir. **Daraltma:** izlenen şey adım değil **otonom sistem dizisi** olmalıdır; `g->c` yolunun dizisi `güney kuzey` beklenirken `güney orta kuzey` çıkıyor. Bu fark tabloda görünür, sayaçta görünmez. **Üçüncü yüzey — duyurunun doğrulanmaması.** Duyuru "şu hedefe benden gidilir" der ve bunu doğrulayan bir şey yoktur. **Daraltma:** önekin sahibi ile duyurmaya yetkili otonom sistemi eşleştiren **imzalı bir kayıt düzeni** ve duyuruyu bu kayda karşı sınayan süzgeç. İkinci daraltma, **kendi otonom sistemini yolunda taşıyan duyuruların reddedilmesidir** — geri dönen duyuru bir döngü belirtisidir. **Dördüncü yüzey — fazla dar politika.** Üçüncü rejimin 14 kara deliği bir yapılandırma kusurudur ve sızıntının tersidir. **Daraltma:** politika değişikliği yürürlüğe alınmadan önce her hedef için **izin verilen yol sayısının sayılması**; sayı sıfıra düşen hedef varsa değişiklik yayına alınmaz. #### Özet - Otonom sistem sınırında karar ölçüden politikaya geçer; sınırdan geçen şey uzaklık değil **duyurudur** ve duyuruyu doğrulayan hiçbir şey yoktur. - Bir yol, otonom sistem dizisinin **ara konumunda** transit taşımayan bir otonom sistem bulunduğunda elenir; kaynağın ve hedefin kendi otonom sistemi ara konumda sayılmaz. - Transit yasağı kırk paketin kırkını da ulaştırır ve toplam adımı **83'ten 92'ye** çıkarır; 56 satırın **5**'i ayrışır, ayrışma **dört çifte** ve **yedi pakete** dokunur. **Uzayan yol bir kusur değildir.** - Sınır duyurusu kapandığında tablo **40 satıra** iner ve **14 paket** kara deliğe düşer; adımın 48'e inmesi kayıp göstergesidir, iyileşme değil. - Tek bir düğümün yol sızıntısı tabloyu politikasız hâline **bir satır kala** geri döndürür: adım 83'e iner, **7 paket** sözleşme dışı yoldan geçer ve hiçbir sayaç bunu bildirmez. #### Sonraki Adım Bu derste politika **tek bir tablonun** içinde uygulandı: her düğümün bir tablosu vardı ve bir hedefin o tabloda tek bir satırı. Politika, o satırın hangi bir sonraki düğümü göstereceğini değiştirdi. Peki aynı cihazın **birden çok tablosu** olsaydı? Sonraki ders aynı adresin aynı cihazda iki ayrı karara gitmesini ölçer: tablo ayrıştırıldığında hangi paket hangi tabloya düşer, ayrı tablolar aynı bağları paylaştığında ne olur ve örnek sayısı tutulan satır sayısını nasıl büyütür. ### Yönlendirme Örnekleri Source: https://academia.sh/tr/kurslar/anahtarlama-ve-yonlendirme/yonlendirme-ornekleri Aynı cihazda birden çok yönlendirme tablosu tutulduğunda aynı hedef iki ayrı bir sonraki düğüme gider: üç örnek kırk paketi 83, 99 ve 91 adımda taşır, 56 satırın 18'i ayrışır, örnekler tek tabloya indirgendiğinde 14 paket kara deliğe düşer. Önceki ders politikayı **tek bir tablonun** içinde uyguladı. Her düğümün bir tablosu vardı, her hedefin o tabloda tek bir satırı ve politika o satırın hangi bir sonraki düğümü göstereceğini değiştirdi. Sınır ağ geçidi protokolü tabloyu yeniden yazdı ama tablonun sayısını değiştirmedi. Bu dersin sorusu şudur: aynı cihaz **birden çok tablo** tutarsa ne olur? O zaman bir hedef adresi tek bir karara değil, kaç tablo varsa o kadar karara karşılık gelir — ve kararlar birbirini bilmez. Ölçülen şey bu ayrışmadır. #### Bir Cihaz, Birden Çok Tablo **Yönlendirme örneği (routing instance)**, tek bir cihazın içinde tutulan bağımsız bir yönlendirme tablosudur. Üç parçası vardır: cihazın hangi bağlarını kullanabileceğini söyleyen bir **bağ kümesi**, o bağ kümesinden hesaplanmış bir **tablo** ve gelen paketin hangi örneğe düşeceğini belirleyen bir **bağlantı noktası eşlemesi**. Üçüncü parça dersin en kolay atlanan yeridir. **Paketin hangi örneğe düştüğü adresinden okunmaz.** Adres iki örnekte de aynıdır; ayrımı yapan şey paketin **hangi bağlantı noktasından girdiğidir**. Cihaz önce örneği seçer, sonra o örneğin tablosunda en uzun önek eşlemesini yapar. İki adım ayrıdır ve ikincisi birincisinden habersizdir. ```text # ogretilen dokum, calistirilmamistir b düğümünün yönlendirme örnekleri örnek bağlantı noktası hedef bir sonraki düğüm yonetim 1 2 e f yonetim 1 2 f f olcum 3 4 e c olcum 3 4 f a konuk 5 e f konuk 5 f f gelen paketin örneğe düşmesi bağlantı noktası 1 -> yonetim örneği -> hedef e için bir sonraki düğüm f bağlantı noktası 3 -> olcum örneği -> hedef e için bir sonraki düğüm c hedef adresi ikisinde de aynıdır ve seçime hiç girmez ``` Ayrıştırmanın gerekçesi kapsamdır. Ölçüm trafiğinin yönetim trafiğiyle aynı yolu kullanması gerekmez; konuk trafiğinin kimi bağa hiç çıkmaması istenebilir. Bunu adres planıyla yapmak her düğümde ayrı bir süzgeç yazmak demektir; örnekle yapmak, **bağ kümesini** daraltıp tablonun kendisini hesaplatmak demektir. #### Aynı Adres, İki Karar Kurgu üç örnek kurar. `yonetim` cihazın bütün bağlarını kullanır. `olcum` kirişi (`b–f`) kullanmaz — o bağ bu örneğe eşlenmemiştir. `konuk` ise `d–e` bağını kullanmaz. Üç örnek de aynı sekiz düğümü, aynı hedefleri ve aynı en uzun önek eşleme kuralını kullanır; ayrıldıkları tek yer bağ kümesidir. Sonuç `b` düğümünde görünür. Hedef `e` için `yonetim` örneği `f`'yi, `olcum` örneği `c`'yi gösterir. **Aynı cihaz, aynı hedef, iki ayrı bir sonraki düğüm.** İki karar da doğrudur; ikisi de kendi bağ kümesinin en kısa yoludur. Yanlış olan, birini ötekinin yerine kullanmaktır. Ölçümün varsayımları: - **YL68** — Topoloji kurs boyunca aynıdır: sekiz düğüm, `a–b–c–d–e–f–g–h–a` halkası ve halkayı kesen `b–f` kirişi. - **YL69** — Üç yönlendirme örneği kurulur ve yalnız **bağ kümeleriyle** ayrılırlar: `yonetim` dokuz bağın tümü, `olcum` kirişsiz sekiz bağ, `konuk` `d–e` bağı olmadan sekiz bağ. Örnek adları kurgudur. - **YL70** — Her örneğin tablosu kendi bağ kümesinden hesaplanır ve kâhinle aynı kuraldır: her hedefe giden **en kısa yolun ilk adımı**. Kâhin değiştirilmez. - **YL71** — Paket girdiği örneği bırakmaz. Bir örnekte iletilen paket, yolu boyunca yalnız o örneğin bağlarını ve yalnız o örneğin tablolarını görür. - **YL72** — Kırk kaynak–hedef çifti kurs çekirdeğinin üretecinden gelir; aynı çift birden çok kez çıkabilir ve her çıkışı ayrı bir pakettir. Atlama sınırı 12. - **YL73** — Tek tabloya indirgeme, `yonetim` örneğinin tablosunun ötekilerin **bağ kümesinde** kullanılmasıdır; bağ kümeleri indirgemede birleşmez, çünkü bir bağın bir örneğe eşlenmemesi fiziksel değil yönetimsel bir karardır. #### Ölçüm ```python """Yonlendirme ornekleri: ayni adres, ayni cihaz, iki ayri karar.""" TOHUM = 20260810 DUGUMLER = "abcdefgh" BAGLAR = [("a", "b"), ("b", "c"), ("c", "d"), ("d", "e"), ("e", "f"), ("f", "g"), ("g", "h"), ("h", "a"), ("b", "f")] ORNEK = {"yonetim": BAGLAR, "olcum": [b for b in BAGLAR if b != ("b", "f")], "konuk": [b for b in BAGLAR if b != ("d", "e")]} ATLAMA_SINIRI = 12 def uretec(tohum): d = tohum % 2147483646 + 1 def r(n): nonlocal d d = (d * 48271) % 2147483647 return d % n return r def ciftler(sayi=40): r, liste = uretec(TOHUM), [] while len(liste) < sayi: x, y = DUGUMLER[r(8)], DUGUMLER[r(8)] if x != y: liste.append((x, y)) return liste def komsuluk(baglar): k = {u: set() for u in DUGUMLER} for x, y in baglar: k[x].add(y) k[y].add(x) return k def kahin(baglar): """Her dugum icin her hedefe giden en kisa yolun ilk adimi.""" kom, t = komsuluk(baglar), {} for kaynak in DUGUMLER: onceki, sira, gorulen = {}, [kaynak], {kaynak} while sira: yeni = [] for u in sira: for v in sorted(kom[u]): if v not in gorulen: gorulen.add(v) onceki[v] = u yeni.append(v) sira = yeni for hedef in DUGUMLER: if hedef == kaynak or hedef not in onceki: continue adim = hedef while onceki[adim] != kaynak: adim = onceki[adim] t[(kaynak, hedef)] = adim return t def ilet(kaynak, hedef, t, baglar): kom, u, yol, gecilen = komsuluk(baglar), kaynak, [kaynak], [] while u != hedef: if len(yol) > ATLAMA_SINIRI: return "dongu", yol s = t.get((u, hedef)) if s is None or s not in kom[u]: return "kara delik", yol if (u, s) in gecilen: return "dongu", yol gecilen.append((u, s)) u = s yol.append(u) return "ulasti", yol def olc(t, baglar): sayim, adim = {"ulasti": 0, "dongu": 0, "kara delik": 0}, 0 for x, y in ciftler(): kader, yol = ilet(x, y, t, baglar) sayim[kader] += 1 adim += len(yol) - 1 return sayim, adim T = {ad: kahin(bag) for ad, bag in ORNEK.items()} print(f"{'örnek':<9s} {'bağ':>4s} {'satır':>6s} {'ulaştı':>7s} {'döngü':>6s} " f"{'kara delik':>11s} {'adım':>5s}") for ad, bag in ORNEK.items(): s, a = olc(T[ad], bag) print(f"{ad:<9s} {len(bag):4d} {len(T[ad]):6d} {s['ulasti']:7d} " f"{s['dongu']:6d} {s['kara delik']:11d} {a:5d}") print() print(f"{'karşılaştırma':<20s} {'ayrışan satır':>14s} {'ilk adımı ayrışan paket':>24s}") for x, y in (("yonetim", "olcum"), ("yonetim", "konuk"), ("olcum", "konuk")): satir = sum(1 for k in T[x] if T[x][k] != T[y][k]) paket = sum(1 for c in ciftler() if T[x][c] != T[y][c]) print(f"{x + ' – ' + y:<20s} {satir:14d} {paket:24d}") print() print("b düğümünün yönlendirme satırları") print(f"{'hedef':>6s} {'yonetim':>8s} {'olcum':>6s} {'konuk':>6s} durum") for h in DUGUMLER: if h == "b": continue v = [T[ad][("b", h)] for ad in ORNEK] print(f"{h:>6s} {v[0]:>8s} {v[1]:>6s} {v[2]:>6s} " f"{'ayrışıyor' if len(set(v)) > 1 else 'aynı'}") print() for n in (1, 2, 3): secili = list(ORNEK)[:n] ayri = sum(1 for k in T["yonetim"] if len({T[ad][k] for ad in secili}) > 1) print(f"örnek {n}: tutulan satır {n * 56}, en az iki örneğin ayrıştığı " f"satır {ayri}") print() print("tek tabloya indirgeme (yonetim tablosu kazanır)") for ad in ("olcum", "konuk"): s, a = olc(T["yonetim"], ORNEK[ad]) print(f" {ad} bağ kümesinde: ulaştı {s['ulasti']}, döngü {s['dongu']}, " f"kara delik {s['kara delik']}, adım {a}") ``` ``` örnek bağ satır ulaştı döngü kara delik adım yonetim 9 56 40 0 0 83 olcum 8 56 40 0 0 99 konuk 8 56 40 0 0 91 karşılaştırma ayrışan satır ilk adımı ayrışan paket yonetim – olcum 11 12 yonetim – konuk 7 6 olcum – konuk 18 18 b düğümünün yönlendirme satırları hedef yonetim olcum konuk durum a a a a aynı c c c c aynı d c c c aynı e f c f ayrışıyor f f a f ayrışıyor g f a f ayrışıyor h a a a aynı örnek 1: tutulan satır 56, en az iki örneğin ayrıştığı satır 0 örnek 2: tutulan satır 112, en az iki örneğin ayrıştığı satır 11 örnek 3: tutulan satır 168, en az iki örneğin ayrıştığı satır 18 tek tabloya indirgeme (yonetim tablosu kazanır) olcum bağ kümesinde: ulaştı 26, döngü 0, kara delik 14, adım 61 konuk bağ kümesinde: ulaştı 32, döngü 0, kara delik 8, adım 72 ``` #### Ayrışmanın Ölçüsü Üst tablo üç örneği yan yana koyuyor. Üçünde de kırk paketin **kırkı ulaşıyor**, döngü **0**, kara delik **0**. Ayrılan tek şey adımdır: `yonetim` **83**, `konuk` **91**, `olcum` **99**. Kirişin çıkarılması `d–e` bağının çıkarılmasından pahalıdır, çünkü kiriş halkanın iki yakasını kısa devre yapan bağdır. İkinci tablo ayrışmayı satır ve paket düzeyinde sayıyor. `yonetim` ile `olcum` **56 satırın 11**'inde ayrışıyor ve bu ayrışma ölçülen kırk paketin **12**'sinin ilk adımını değiştiriyor. `yonetim` ile `konuk` arasında sayılar **7** ve **6**. En büyük ayrışma iki daraltılmış örnek arasındadır: `olcum` ile `konuk` **18 satırda** ve **18 pakette** ayrışıyor — hiçbiri ötekinin kullandığı bağı kullanmıyor. Üçüncü tablo `b` düğümünün yedi satırını veriyor. Dördü üç örnekte de aynı: `a`, `c`, `d` ve `h` hedefleri için karar bağ kümesinden bağımsızdır. Üçü ayrışıyor. `e` hedefinde `yonetim` ve `konuk` `f` derken `olcum` `c` diyor; `f` hedefinde `olcum` **`a`** diyor, yani paketi halkanın öteki yakasından dolaştırıyor. Ayrışmanın bir sonucu daha var. Bir bağ koptuğunda yakınsama yalnız o bağı **kullanan** örneklerde başlar. Kiriş koparsa `yonetim` örneğinin tablosu yeni tabloya, yani `olcum` örneğinin tablosuna dönmek zorundadır; ikisi arasındaki fark ölçülmüş durumda ve **11 satırdır**. Aynı kopmada `olcum` örneği **sıfır satır** değiştirir, çünkü o bağ zaten kümesinde yoktur. Aynı cihaz aynı anda bir örnekte yakınsama turu harcarken öteki örnekte hiç harcamaz; ayrıştırma tabloyu ayırmadan önce **arızanın kapsamını** ayırır. Buradaki gözlem kursun ölçü ekseninin bir başka biçimidir. Kurs boyunca tablolar **anlaşmazlığa düştüğünde** paketin başına gelen şey sayıldı; burada tablolar **anlaşmıyor ve bu bir arıza değil.** Ayrışma tasarımın kendisidir. Arıza, ayrışmanın kaldırıldığı yerde başlar. #### Örnek Sayısının Bedeli Dördüncü tablo satır sayısını veriyor. Sekiz düğüm ve yedi hedef, örnek başına **56 satır** eder; iki örnek **112**, üç örnek **168**. Satır sayısı örnek sayısıyla **doğrusal** büyür. Ayrışan satır aynı hızla büyümüyor. Tek örnekte **0**, iki örnekte **11**, üç örnekte **18**. Üçüncü örnek tabloya 56 satır daha ekliyor ama ayrışmayı yalnız yedi satır artırıyor. Ters yönden okunduğunda: 56 satırın **38**'i (56 eksi 18) üç örnekte de aynıdır ve 168 satırın **114**'ü, aynı kararın üç kez yazılmış kopyasıdır. Bedel budur. Ayrıştırma, kararı gerçekten ayrışan **18 satır** için yapılır; kalan satırlar ayrıştırmanın taşıma masrafıdır. Bu masraf düğüm sayısıyla değil, **hedef sayısı çarpı örnek sayısı** ile büyür ve iki çarpanın ikisi de tasarım kararıdır. #### Çakışan Adresler ve Paylaşılan Satırlar Kurguda örnekleri ayıran şey bağ kümesidir. Çalışan ağlarda asıl gerekçe **adresin kendisidir**: iki örnek aynı adres öbeğini taşıyabilir ve o öbek iki ayrı yere gidebilir. Tek tablolu bir cihazda bu olanaksızdır, çünkü en uzun önek eşlemesi tek bir sonuç verir ve aynı önek iki satıra yazılamaz. Örnekler kısıtı kaldırır, çünkü eşleme **örnek seçildikten sonra** yapılır. Kurgunun düğüm adları çakışmıyor; çakışsalardı ölçüm değişmezdi, zaten örnek seçimi adrese hiç bakmıyor. Bunun ikinci sonucu, bir satırın iki örnek arasında **kasıtlı olarak** paylaşılabilmesidir. Bütün örneklerden erişilmesi istenen ortak bir hizmet varsa, o hizmetin satırı ikinci örneğe kopyalanır ve ayrışma bir satır azalır. Son ölçüm bu işlemin sınırını veriyor: kopyalanan satırda **bir sonraki düğümün o örnekte komşu olduğu** doğrulanmazsa, kopyalanan her satır bir kara delik satırıdır. Bölütlemenin bağlantı katmanındaki karşılığı kursun ağ cihazları konusunda kuruldu: **sanal yerel ağ** yayın alanını böler ve çerçeveyi etiketle ayırır. Ayrım tek cümleyle yazılabilir: sanal yerel ağ **aynı yayın alanına kimin gireceğini**, yönlendirme örneği ise **hangi tablonun okunacağını** belirler. Biri çerçevenin dolaştığı alanı, öteki paketin bakacağı satırı ayırır. İkisi bir arada kullanıldığında bir bağlantı noktası hem bir sanal yerel ağa hem bir yönlendirme örneğine eşlenir; eşlemelerden biri eksikse paket ya yanlış alana ya yanlış tabloya düşer. #### Tek Tabloya İndirgeme Son ölçüm masraftan kaçmayı deniyor: üç tablo yerine tek tablo tutulsa, `yonetim` örneğinin tablosu ötekilerin bağ kümesinde ne yapar? `olcum` bağ kümesinde **26 paket ulaşıyor, 14'ü kara deliğe düşüyor**, toplam adım 61. Gerekçe `b` düğümünün satırında yazılı: birleşik tablo hedef `f` için `f`'yi gösteriyor, ama `f` bu örnekte `b`'nin komşusu değil. Bir sonraki düğüm tabloda var, komşulukta yok — kursun kara delik tanımı tam olarak budur. `konuk` bağ kümesinde sayılar **32** ve **8**. Adımın 83'ten 61'e inmesi burada da bir iyileşme değildir: ölen paket adım harcamayı bırakır ve düşük adım kaybın göstergesi olur. Bu, ayrıştırmanın neden tabloyla birlikte **bağ kümesini de** ayırdığının yanıtıdır. Tabloyu paylaştırıp bağ kümesini ayrı tutmak, her düğümde bir sonraki düğümün var olduğunu ama erişilemediğini bildiren satırlar üretir. Tablo küçülür, paket ölür. #### Özet - Yönlendirme örneği üç parçadır: **bağ kümesi**, ondan hesaplanan **tablo** ve gelen paketi örneğe düşüren **bağlantı noktası eşlemesi**. Paketin hangi örneğe düştüğü adresinden okunmaz. - Aynı cihazda aynı hedef iki ayrı karara gider: `b` düğümü hedef `e` için `yonetim` örneğinde `f`'yi, `olcum` örneğinde `c`'yi gösterir; ikisi de kendi bağ kümesinin en kısa yoludur. - Üç örnek kırk paketin kırkını da ulaştırır ve toplam adım sırasıyla **83**, **99** ve **91**'dir; ayrışma `yonetim`–`olcum` arasında **11 satır** ve **12 paket**, `olcum`–`konuk` arasında **18 satır** ve **18 pakettir**. - Tutulan satır örnek sayısıyla doğrusal büyür (**56**, **112**, **168**) ama ayrışan satır büyümez (**0**, **11**, **18**); 168 satırın **114**'ü aynı kararın kopyasıdır. - Örnekler tek tabloya indirgendiğinde `olcum` bağ kümesinde **14 paket** kara deliğe düşer: bir sonraki düğüm tabloda vardır ama o örnekte komşu değildir. #### Sonraki Adım Üç örnekte de karar **her düğümde yeniden alındı**. Paket `b`'ye geldi, `b` tablosuna baktı; `c`'ye geldi, `c` tablosuna baktı. Örnek sayısını üçe çıkarmak tutulan satırı üçe katladı ama bakış sayısını hiç değiştirmedi: kırk paket kaç adım attıysa o kadar arama yapıldı. Sonraki ders bu tekrarı ölçer. Karar yol boyunca her düğümde yeniden alınmak zorunda mıdır, yoksa **bir kez alınıp paketin üzerinde taşınabilir mi** ve taşındığında kaç arama ile kaç satır arasında nasıl bir takas doğar. ### MPLS ve Etiket Anahtarlama Source: https://academia.sh/tr/kurslar/anahtarlama-ve-yonlendirme/mpls-ve-etiket-anahtarlama Karar her düğümde yeniden alındığında kırk paket 83 tam tablo bakışı üretir; karar bir kez kenarda alınıp etiketle taşındığında sayı 40 tam bakışa ve 43 etiket bakışına iner, etiketle kurulan yol kirişin yükünü 14 paketten 0'a indirir ve tutulan satır 56'dan 110'a çıkar. Önceki ders aynı cihazda üç yönlendirme örneği kurdu ve tutulan satırı 56'dan 168'e çıkardı. Değişmeyen bir şey vardı: karar **her düğümde yeniden alınıyordu**. Paket `b`'ye geldi, `b` hedefe baktı ve kendi tablosundan bir satır okudu; `c`'ye geldi, `c` aynı işi baştan yaptı. Örnek sayısı satırı üçe katladı ama bu tekrarı hiç değiştirmedi. Bu dersin sorusu tekrarın kendisidir. Yakınsamış bir ağda yol boyunca alınan kararların hepsi **aynı yolu** verir; aynı sonuç beş düğümde beş kez hesaplanır. Karar bir kez alınıp paketin üzerinde taşınabilir mi ve taşındığında ne kazanılır, ne ödenir? #### Kararın Alındığı Yer Her düğümde karar alan bir ağda işlem üç adımdır: paketin hedef adresini oku, tablodaki önekler arasında **en uzun önek eşlemesini** yap, çıkan satırdaki bir sonraki düğüme ilet. Üç adım da her düğümde yinelenir ve üçüncü adımın girdisi her seferinde aynıdır. **Etiket anahtarlama (label switching)** bu yinelemeyi kaldırır. Yolun **giriş** düğümü kararı bir kez alır ve sonucu pakete kısa bir **etiket** olarak ekler. Ara düğümler hedef adresine hiç bakmaz; yalnız gelen etikete bakar, kendi etiket tablosundan çıkan etiketi ve bir sonraki düğümü okur, etiketi **takas eder** ve paketi iletir. Çıkış düğümü etiketi çıkarır ve paketi hedefine teslim eder. Etiketin iki özelliği kritiktir. Etiket **hedefi adlandırmaz, yolu adlandırır**: aynı hedefe giden iki ayrı yolun iki ayrı etiketi olabilir. Ve etiket **bağ başına anlamlıdır**: `17` değerinin `b–c` bağındaki anlamı ile `c–d` bağındaki anlamı arasında hiçbir bağ yoktur, bu yüzden her düğüm etiketi takas etmek zorundadır. ```text # ogretilen dokum, calistirilmamistir giriş düğümü (b) ara düğüm (c) çıkış düğümü (d) hedef d gelen etiket 17 gelen etiket 9 yol b-c-d çıkan etiket 9 işlem çıkar ve teslim et işlem etiket ekle bir sonraki d etiket 17 işlem takas c düğümünün etiket tablosu c düğümünün yönlendirme tablosu gelen çıkan bir sonraki hedef bir sonraki 17 9 d a b 23 41 b d d 44 6 b e d ``` Sağdaki iki tablo dersin takasını gösteriyor. Yönlendirme tablosu **hedef başına** satır tutar; etiket tablosu **yol başına** satır tutar. Bir düğümden geçen yol sayısı hedef sayısından büyükse etiket tablosu yönlendirme tablosundan büyür. Etiket tek bir değer olmak zorunda değildir. Pakete **birden çok etiket** yazılabilir; etiketler bir yığın oluşturur ve ara düğüm yalnız **en dıştaki** etikete bakar. Bu, önceki dersle doğrudan birleşir: dıştaki etiket **yolu**, içteki etiket paketin hangi **yönlendirme örneğine** ait olduğunu adlandırır. Ara düğümler örnekleri hiç bilmez; yalnız çıkış düğümü dış etiketi çıkarıp içtekine bakar ve paketi doğru örneğin tablosuna düşürür. Bir ağın ortasındaki düğümler böylece taşıdıkları trafiğin kaç örneğe ayrıldığını bilmeden onu taşıyabilir. Ölçüm yığının derinliğini saymaz; saydığı şey en dıştaki etiketin ürettiği bakıştır. #### Yolun Kenardan Kurulması Karar bir kez alındığında, o kararın **en kısa yol olma zorunluluğu ortadan kalkar**. Giriş düğümü etiketi hangi yola karşılık getireceğini seçebilir; ara düğümler zaten hedefe bakmadığı için seçimi sorgulamaz. **Yol mühendisliği (traffic engineering)** budur: yolu maliyet değil, yönetim seçer. Kurguda bunun karşılığı kirişten kaçınmaktır. Kiriş halkanın iki yakasını kısa devre yaptığı için en kısa yolların çoğu ondan geçer ve tek bir bağ üzerinde yığılır. Etiket yolları kirişsiz halkanın en kısa yollarından kurulursa kiriş fiziksel olarak durmayı sürdürür, ama üzerinden paket geçmez. Ölçümün varsayımları: - **YL74** — Topoloji kurs boyunca aynıdır: sekiz düğüm, `a–b–c–d–e–f–g–h–a` halkası ve halkayı kesen `b–f` kirişi. - **YL75** — İki rejim karşılaştırılır. Birincisinde her düğüm hedefe bakıp kendi tablosundan karar alır; ikincisinde yalnız giriş düğümü hedefe bakar, ara düğümler etikete bakar. **Yol ikisinde de aynı tablodan türetilir**; ayrılan tek şey kararın alındığı yerdir. - **YL76** — Bakış sayımı: her düğümde karar alan rejimde paketin attığı **her adım** bir tam tablo bakışıdır. Kenarda karar alan rejimde paket başına **bir** tam tablo bakışı ve kalan adım sayısı kadar **etiket bakışı** sayılır. - **YL77** — Yol mühendisliği rejiminde etiket yolları kirişsiz halkanın en kısa yollarından kurulur. Kiriş **fiziksel olarak durur**; yalnız hiçbir etiket yolu onu kullanmaz. - **YL78** — Etiket satırı sayımı: elli altı yolun her biri için yolun **son düğümü dışındaki** her düğümde bir satır tutulur. Yönlendirme tablosu ise düğüm başına yalnız hedef sayısı kadar satır tutar. - **YL79** — Son rejimde kiriş kopar ve etiket yolları **yenilenmez**; giriş düğümü eski kararını sürdürür, ara düğümler zaten hedefi bilmedikleri için hiçbir şey düzeltemez. - **YL80** — Kırk kaynak–hedef çifti kurs çekirdeğinin üretecinden gelir, her çıkış ayrı bir pakettir, atlama sınırı 12 ve kümenin çözünürlüğü `1/40 = 0,025`'tir. #### Ölçüm ```python """Etiket anahtarlama: karar her dugumde mi, bir kez kenarda mi alinir.""" TOHUM = 20260810 DUGUMLER = "abcdefgh" BAGLAR = [("a", "b"), ("b", "c"), ("c", "d"), ("d", "e"), ("e", "f"), ("f", "g"), ("g", "h"), ("h", "a"), ("b", "f")] KOPUK = [b for b in BAGLAR if b != ("b", "f")] ATLAMA_SINIRI = 12 def uretec(tohum): d = tohum % 2147483646 + 1 def r(n): nonlocal d d = (d * 48271) % 2147483647 return d % n return r def ciftler(sayi=40): r, liste = uretec(TOHUM), [] while len(liste) < sayi: x, y = DUGUMLER[r(8)], DUGUMLER[r(8)] if x != y: liste.append((x, y)) return liste def komsuluk(baglar): k = {u: set() for u in DUGUMLER} for x, y in baglar: k[x].add(y) k[y].add(x) return k def kahin(baglar): """Her dugum icin her hedefe giden en kisa yolun ilk adimi.""" kom, t = komsuluk(baglar), {} for kaynak in DUGUMLER: onceki, sira, gorulen = {}, [kaynak], {kaynak} while sira: yeni = [] for u in sira: for v in sorted(kom[u]): if v not in gorulen: gorulen.add(v) onceki[v] = u yeni.append(v) sira = yeni for hedef in DUGUMLER: if hedef == kaynak or hedef not in onceki: continue adim = hedef while onceki[adim] != kaynak: adim = onceki[adim] t[(kaynak, hedef)] = adim return t def yol(kaynak, hedef, t, baglar): kom, u, y, gecilen = komsuluk(baglar), kaynak, [kaynak], [] while u != hedef: if len(y) > ATLAMA_SINIRI: return "dongu", y s = t.get((u, hedef)) if s is None or s not in kom[u]: return "kara delik", y if (u, s) in gecilen: return "dongu", y gecilen.append((u, s)) u = s y.append(u) return "ulasti", y def olc(t, baglar, kenar): """kenar=False: her dugumde tam tablo bakisi. kenar=True: bir kez kenarda.""" sayim = {"ulasti": 0, "dongu": 0, "kara delik": 0} adim = tam = etiket = kiris = 0 for x, y in ciftler(): kader, iz = yol(x, y, t, baglar) k = len(iz) - 1 sayim[kader] += 1 adim += k tam += 1 if kenar else k etiket += max(k - 1, 0) if kenar else 0 kiris += sum(1 for i in range(k) if tuple(sorted((iz[i], iz[i + 1]))) == ("b", "f")) return sayim, adim, tam, etiket, kiris TAM, MUH = kahin(BAGLAR), kahin(KOPUK) REJIM = (("düğüm başına karar", TAM, BAGLAR, False), ("kenarda karar", TAM, BAGLAR, True), ("kenarda karar, yol mühendisliği", MUH, BAGLAR, True), ("kiriş koptu, etiket eski", TAM, KOPUK, True), ("kiriş koptu, düğüm başına karar", TAM, KOPUK, False)) print(f"{'rejim':<32s} {'ulaştı':>7s} {'döngü':>6s} {'kara delik':>11s} " f"{'adım':>5s} {'tam bakış':>10s} {'etiket bakışı':>14s} {'kiriş':>6s}") for ad, t, bag, kenar in REJIM: s, a, tm, et, kr = olc(t, bag, kenar) print(f"{ad:<32s} {s['ulasti']:7d} {s['dongu']:6d} {s['kara delik']:11d} " f"{a:5d} {tm:10d} {et:14d} {kr:6d}") print() print(f"{'tablo':<26s} {'toplam satır':>13s} {'düğüm başına en çok':>21s}") print(f"{'yönlendirme (hedef başına)':<26s} {len(TAM):13d} " f"{max(sum(1 for u, h in TAM if u == x) for x in DUGUMLER):21d}") for ad, t in (("etiket, en kısa yol", TAM), ("etiket, mühendislik yolu", MUH)): satir = {u: 0 for u in DUGUMLER} for u in DUGUMLER: for h in DUGUMLER: if u == h: continue for v in yol(u, h, t, BAGLAR)[1][:-1]: satir[v] += 1 print(f"{ad:<26s} {sum(satir.values()):13d} {max(satir.values()):21d}") ``` ``` rejim ulaştı döngü kara delik adım tam bakış etiket bakışı kiriş düğüm başına karar 40 0 0 83 83 0 14 kenarda karar 40 0 0 83 40 43 14 kenarda karar, yol mühendisliği 40 0 0 99 40 59 0 kiriş koptu, etiket eski 26 0 14 61 40 26 0 kiriş koptu, düğüm başına karar 26 0 14 61 61 0 0 tablo toplam satır düğüm başına en çok yönlendirme (hedef başına) 56 7 etiket, en kısa yol 110 23 etiket, mühendislik yolu 128 18 ``` #### Bakışın Yeri Değişti, Sayısı Değişmedi İlk iki satır aynı yolu iki ayrı biçimde yürütüyor. Kırk paket her ikisinde de **83 adım** atıyor, kırkı da ulaşıyor, kiriş yükü ikisinde de **14 pakettir**. Yol tıpatıp aynıdır ve bu kasıtlıdır: karşılaştırılan şey yol değil, kararın alındığı yerdir. Değişen şey bakışın dağılımıdır. Her düğümde karar alan rejim **83 tam tablo bakışı** yapar. Kenarda karar alan rejim **40 tam tablo bakışı** ve **43 etiket bakışı** yapar. Toplam bakış sayısı ikisinde de 83'tür; **etiket bakış sayısını azaltmaz.** Kazanç bakışın **türündedir**. Tam tablo bakışı hedef adresini okumayı, önekler arasında en uzun eşlemeyi aramayı ve yedi satırlık bir tabloda gezinmeyi gerektirir. Etiket bakışı tek bir değerin doğrudan aranmasıdır; sıralama yoktur, önek yoktur, uzunluk karşılaştırması yoktur. İkinci ve daha önemli kazanç kursun ölçü eksenindedir. Her düğümde karar alan rejimde yol boyunca **k ayrı tablo** kararı verir ve bu tabloların anlaşması gerekir. Kenarda karar alan rejimde yolu belirleyen **tek bir tablodur**; ara düğümlerin tabloları yolu değil, yalnız etiketin karşılığını taşır. Kursun üçüncü iddiası döngünün **en az iki tablonun anlaşmazlığı** olduğunu söylüyordu; etiket, anlaşması gereken tablo sayısını bire indirir. #### Yükün Dağıtılması Üçüncü satır yol mühendisliğini ölçüyor. Etiket yolları kirişten kaçındığında kırk paketin kırkı yine ulaşıyor, ama toplam adım **83'ten 99'a** çıkıyor ve kirişten geçen paket sayısı **14'ten 0'a** iniyor. Takas açıktır: on altı fazladan adıma karşılık, tek bir bağ üzerindeki on dört paketlik yığılmanın kaldırılması. Bu kararı maliyet veremez, çünkü maliyetin bildiği tek şey yol uzunluğudur; kirişin kapasitesini, bedelini ya da paylaşıldığı başka trafiği bilmez. Bir önceki derste politikanın yolu uzatması bir kusur değildi; burada da değildir ve gerekçesi aynıdır: **en kısa yol bir hedef değil, bir varsayılan değerdir.** #### Tablonun Bedeli Alt tablo kararın kenara taşınmasının faturasını veriyor. Yönlendirme tabloları elli altı düğüm–hedef satırı tutuyor ve hiçbir düğümde **7**'den fazla satır yok. Etiket tabloları aynı elli altı yol için **110 satır** tutuyor ve en yüklü düğümde **23 satır** birikiyor. Örüntü tablodaki iki satırda okunur. Yönlendirme durumu **hedef sayısıyla** büyür; etiket durumu **yol sayısıyla** büyür ve yol sayısı hedef sayısından çok daha hızlı artar. Karar kenara taşındı, ama kararın **durumu** araya yayıldı. Mühendislik yolları bu faturayı ilginç biçimde bölüyor: toplam satır 110'dan **128**'e çıkıyor, ama düğüm başına en çok satır 23'ten **18**'e iniyor. Kiriş, üzerinden geçen bütün yolları iki düğümde yığıyordu; kirişten kaçınmak yolları uzatıp sayıyı büyütürken yükü de durumu da dağıtıyor. Bir bağdan kaçınmanın yalnız trafiği değil **tablo yükünü** de dengelediği yer burasıdır. #### Kenarda Alınan Karar Kenarda Yenilenir Son satır kopmayı ölçüyor. Kiriş koptuğunda ve etiket yolları yenilenmediğinde kırk paketin **26**'sı ulaşıyor, **14**'ü kara deliğe düşüyor, toplam adım **61**'e iniyor. Tam tablo bakışı yine **40**, etiket bakışı **26**'ya iniyor — ölen paket bakış da harcamayı bırakır. Beşinci satır aynı kopmayı her düğümde karar alan rejimde ölçüyor ve kader sayıları birebir aynı çıkıyor: **26 ulaştı, 14 kara delik, 61 adım**. Şaşırtıcı değildir, çünkü iki rejim de aynı eski tabloyu ve aynı kopuk bağ kümesini kullanıyor. Ayrılan tek sütun bakış sütunudur: eski karar her düğümde yeniden alındığında **61 tam bakış**, kenarda bir kez alındığında **40 tam bakış** ve **26 etiket bakışı**. Kaderler aynı olsa da onarım aynı değildir. Her düğümde karar alan bir ağda tablolar birkaç yakınsama turunda kendini düzeltir ve düzeltme **kopmanın yakınında** başlar. Etiket yolunda ara düğümlerin düzeltebileceği hiçbir şey yoktur: hedefi bilmiyorlar, yalnız etiketin karşılığını biliyorlar. Onarım **girişte** olmak zorundadır ve giriş, kopmadan en uzak düğüm olabilir. Kursun ölçü ekseni burada tersine döner. Kararı tek bir yere toplamak, o yerin anlaşmazlığını **bütün yola** yayar. Etiket, anlaşması gereken tablo sayısını bire indirir; karşılığında o tek tablonun eskimesi paketin tek arıza nedeni olur. #### Özet - Etiket anahtarlamada karar **giriş düğümünde bir kez** alınır ve pakete etiket olarak yazılır; ara düğümler hedefe hiç bakmaz, etiketi takas eder. Etiket hedefi değil **yolu** adlandırır ve **bağ başına** anlamlıdır. - Bakış sayısı değişmez: aynı yol her düğümde karar alan rejimde **83 tam tablo bakışı**, kenarda karar alan rejimde **40 tam bakış** ve **43 etiket bakışı** üretir. Değişen şey bakışın türü ve yolu belirleyen tablo sayısıdır. - Etiket yolu en kısa olmak zorunda değildir: kirişten kaçan yollar adımı **83'ten 99'a** çıkarır ve kirişten geçen paketi **14'ten 0'a** indirir. - Tutulan satır **56**'dan **110**'a çıkar; yönlendirme durumu hedef sayısıyla, etiket durumu yol sayısıyla büyür. Mühendislik yolları toplamı **128**'e çıkarırken düğüm başına en çok satırı **23**'ten **18**'e indirir. - Kiriş koptuğunda ve etiket yolu yenilenmediğinde **14 paket** kara deliğe düşer. Aynı kopmada her düğümde karar alan rejim de **26** ulaştırıp **14**'ünü kaybeder; ayrılan tek şey bakış dağılımı (**61 tam bakışa** karşı **40 tam** ve **26 etiket**) ve onarımın nerede başladığıdır — ara düğüm hedefi bilmediği için onarım **girişte** olmak zorundadır. #### Sonraki Adım Etiket kararı kenara taşıdı, ama yol hâlâ ağın kendi bağlarından geçiyordu: `b`'den `c`'ye giden etiketli paket gerçekten `b–c` bağını kullandı. Peki iki düğüm arasındaki bağ fiziksel bir bağ değil de, başka bir ağın üzerinden kurulmuş **mantıksal** bir bağ olsaydı? Sonraki ders tünellerle kurulan mantıksal topolojiyi ölçer: böyle bir ağda tablo iki katmanda birden tutulur, iki katman ayrı ayrı yakınsar ve paketin kaderi ikisinin **birden** anlaşmasına bağlıdır. ### Kaplama Ağları Source: https://academia.sh/tr/kurslar/anahtarlama-ve-yonlendirme/kaplama-aglari Tünellerle kurulan mantıksal topoloji kendi tablosunu tutar ve altındaki tabloyu görmez: alt ağ düzeni koptuğunda kaplamanın tek satırı değişmez ama alt ağ düzeni adımı 188'den 211'e çıkar, alt ağ düzeninin tabloları eskidiğinde kaplamanın doğru tablosuyla 21 paket ölür, kaplama tablolarının kısmî bilgisi ise alt ağ düzeninde tek bir yanlış karar olmadan 12 paketi döngüye sokar. Önceki ders kararı kenara taşıdı, ama yol hâlâ ağın kendi bağlarından geçiyordu: `b`'den `c`'ye giden etiketli paket gerçekten `b–c` bağını kullandı. Etiket yolu adlandırıyordu ve adlandırdığı yol fizikseldi. Bu dersin sorusu şudur: iki düğüm arasındaki bağ fiziksel bir bağ değil de, **başka bir ağın üzerinden kurulmuş** mantıksal bir bağ olsaydı ne olurdu? O zaman ortada tek bir tablo değil **iki tablo** olur, ikisi ayrı ayrı yakınsar ve paketin kaderi ikisinin **birden** anlaşmasına bağlanır. Kursun ölçü ekseninin en uç biçimi budur. #### Kaplama ve Alt Ağ Düzeni **Kaplama ağı (overlay network)**, tünellerle kurulan mantıksal bir topolojidir. Kaplamanın bir bağı, iki düğüm arasında doğrudan bir kablo olduğu anlamına gelmez; o iki düğümün birbirini **komşu sayması** anlamına gelir. Kaplamanın üzerinde durduğu gerçek bağ kümesine **alt ağ düzeni (underlay)** denir. (`alt ağ` tek başına adres öbeğini bölen kavram için ayrılmıştır; buradaki kavramın adı **alt ağ düzenidir** ve ikisi karıştırılmaz.) Konteynerler kursu konteyner ağlarının kaplamasını kurmuştu; o yordam burada tekrarlanmaz. Burada kaplama bir **mantıksal topoloji** olarak ölçülür: kendi tablosu, kendi komşuluğu, kendi yakınsaması ve kendi atlama sayacı vardır. ```text # ogretilen dokum, calistirilmamistir kaplama bağı alt ağ düzenindeki yol anlamı a-c a-b-c a ile c kaplamada komşudur a-e a-b-f-e a ile e kaplamada komşudur c-f c-b-f c ile f kaplamada komşudur tünellenmiş paket dış başlık kaynak a hedef c <- alt ağ düzeni yalnız bunu okur iç başlık kaynak a hedef g <- kaplama yalnız bunu okur yük ... a düğümünün iki tablosu kaplama tablosu alt ağ düzeni tablosu hedef bir sonraki hedef bir sonraki g e c b d d e b ``` Sağdaki iki tablo dersin tamamıdır. `a` düğümü kaplamada `g` hedefi için `e`'yi gösterir; `e` kaplamada komşudur ama alt ağ düzeninde üç adım uzaktadır. Paket `a`'dan çıkarken alt ağ düzeni tablosuna göre `b`'ye gider ve kaplama bunu hiç görmez. İki tablo aynı cihazın içindedir ve **birbirini okumaz**. Bunun doğrudan bir sonucu vardır: **bir kaplama adımı, alt ağ düzeninde birkaç adımdır.** İki katmanın sayaçları ayrıdır ve ayrı sayılmak zorundadır. Ölçümün varsayımları: - **YL81** — Alt ağ düzeni kurs boyunca aynıdır: sekiz düğüm, `a–b–c–d–e–f–g–h–a` halkası ve halkayı kesen `b–f` kirişi. - **YL82** — Kaplama dokuz tünelden kurulur ve tünellerin **hiçbiri** alt ağ düzeninin bir bağıyla aynı değildir; her tünel alt ağ düzeninde iki ile dört adım arasında bir yola karşılık gelir. - **YL83** — İki katmanın tabloları ayrı hesaplanır ve birbirini görmez. Kural ikisinde de aynıdır: her hedefe giden **en kısa yolun ilk adımı**. Kâhin değiştirilmez. - **YL84** — Her katmanın kendi atlama sayacı vardır ve ikisinin sınırı 12'dir. Bir kaplama adımı içinde harcanan alt ağ düzeni adımları kaplama sayacına **eklenmez**. - **YL85** — Bir kaplama adımı ancak tünel alt ağ düzeninde teslim edildiyse atılmış sayılır; tünel teslim edilemezse paketin kaderi tünelin kaderidir. - **YL86** — Son iki rejimde kalkan kaplama bağı `a–c` tünelidir. Dördüncüsünde kalkışı yalnız `a` ve `c` duyar; öteki yedi düğüm eski kaplama tablosunu sürdürür. - **YL87** — Son iki rejimde alt ağ düzeninin tablosu **kâhinin kendisidir**: alt ağ düzeninde tek bir yanlış karar yoktur ve tek bir tünel teslim edilemez değildir. - **YL88** — Kırk kaynak–hedef çifti kurs çekirdeğinin üretecinden gelir, her çıkış ayrı bir pakettir ve kümenin çözünürlüğü `1/40 = 0,025`'tir. #### Ölçüm ```python """Kaplama agi: kaplamanin tablosu ile alt ag duzeninin tablosu anlasmazsa.""" TOHUM = 20260810 DUGUMLER = "abcdefgh" BAGLAR = [("a", "b"), ("b", "c"), ("c", "d"), ("d", "e"), ("e", "f"), ("f", "g"), ("g", "h"), ("h", "a"), ("b", "f")] KOPUK = [b for b in BAGLAR if b != ("b", "f")] KAPLAMA = [("a", "c"), ("a", "d"), ("a", "e"), ("b", "d"), ("b", "g"), ("c", "f"), ("d", "h"), ("e", "g"), ("f", "h")] ATLAMA_SINIRI = 12 def uretec(tohum): d = tohum % 2147483646 + 1 def r(n): nonlocal d d = (d * 48271) % 2147483647 return d % n return r def ciftler(sayi=40): r, liste = uretec(TOHUM), [] while len(liste) < sayi: x, y = DUGUMLER[r(8)], DUGUMLER[r(8)] if x != y: liste.append((x, y)) return liste def komsuluk(baglar): k = {u: set() for u in DUGUMLER} for x, y in baglar: k[x].add(y) k[y].add(x) return k def kahin(baglar): """Her dugum icin her hedefe giden en kisa yolun ilk adimi.""" kom, t = komsuluk(baglar), {} for kaynak in DUGUMLER: onceki, sira, gorulen = {}, [kaynak], {kaynak} while sira: yeni = [] for u in sira: for v in sorted(kom[u]): if v not in gorulen: gorulen.add(v) onceki[v] = u yeni.append(v) sira = yeni for hedef in DUGUMLER: if hedef == kaynak or hedef not in onceki: continue adim = hedef while onceki[adim] != kaynak: adim = onceki[adim] t[(kaynak, hedef)] = adim return t def ilet(kaynak, hedef, t, baglar): """Tek katmanda yurutur; kaderi ve attigi adimi dondurur.""" kom, u, gecilen, atlama = komsuluk(baglar), kaynak, [], 0 while u != hedef: if atlama >= ATLAMA_SINIRI: return "dongu", atlama s = t.get((u, hedef)) if s is None or s not in kom[u]: return "kara delik", atlama if (u, s) in gecilen: return "dongu", atlama gecilen.append((u, s)) u, atlama = s, atlama + 1 return "ulasti", atlama def kaplama_ilet(kaynak, hedef, ust, ust_bag, alt, alt_bag): """Her kaplama adimi bir tuneldir ve alt agda ayrica yurutulur.""" kom, u, gecilen, ust_adim, alt_adim = komsuluk(ust_bag), kaynak, [], 0, 0 while u != hedef: if ust_adim >= ATLAMA_SINIRI: return "kaplama dongusu", ust_adim, alt_adim s = ust.get((u, hedef)) if s is None or s not in kom[u]: return "kaplama kara deligi", ust_adim, alt_adim if (u, s) in gecilen: return "kaplama dongusu", ust_adim, alt_adim kader, a = ilet(u, s, alt, alt_bag) alt_adim += a if kader != "ulasti": return "tunel " + kader, ust_adim, alt_adim gecilen.append((u, s)) u, ust_adim = s, ust_adim + 1 return "ulasti", ust_adim, alt_adim def kismi(eski, yeni, duyan): """Kaplama bagininin kalktigini yalniz bir kume duymustur.""" return {(u, h): (yeni if u in duyan else eski)[(u, h)] for (u, h) in eski if (u, h) in yeni} def olc(ust, ust_bag, alt, alt_bag): sayim = {"ulasti": 0, "kaplama dongusu": 0, "kaplama kara deligi": 0, "tunel kara delik": 0, "tunel dongu": 0} ua = aa = 0 for x, y in ciftler(): kader, u_, a_ = kaplama_ilet(x, y, ust, ust_bag, alt, alt_bag) sayim[kader] += 1 ua += u_ aa += a_ return sayim, ua, aa UST, ALT, ALT_YENI = kahin(KAPLAMA), kahin(BAGLAR), kahin(KOPUK) EKSIK = [b for b in KAPLAMA if b != ("a", "c")] UST_YENI = kahin(EKSIK) REJIM = (("iki katman da yakınsamış", UST, KAPLAMA, ALT, BAGLAR), ("alt ağ düzeni koptu, yakınsadı", UST, KAPLAMA, ALT_YENI, KOPUK), ("alt ağ düzeni koptu, tablo eski", UST, KAPLAMA, ALT, KOPUK), ("tünel kalktı, iki uç duydu", kismi(UST, UST_YENI, {"a", "c"}), EKSIK, ALT, BAGLAR), ("tünel kalktı, hepsi duydu", UST_YENI, EKSIK, ALT, BAGLAR), ("iki katman birden eski", kismi(UST, UST_YENI, {"a", "c"}), EKSIK, ALT, KOPUK)) OLCUM = [(ad, olc(ust, ubag, alt, abag)) for ad, ust, ubag, alt, abag in REJIM] print(f"{'rejim':<32s} {'ulaştı':>7s} {'kaplama döngüsü':>16s} " f"{'tünel kara deliği':>18s}") for ad, (s, ua, aa) in OLCUM: print(f"{ad:<32s} {s['ulasti']:7d} {s['kaplama dongusu']:16d} " f"{s['tunel kara delik']:18d}") print() print(f"{'rejim':<32s} {'kaplama adımı':>14s} {'alt ağ düzeni adımı':>20s}") for ad, (s, ua, aa) in OLCUM: print(f"{ad:<32s} {ua:14d} {aa:20d}") print() print("tünelin alt ağ düzenindeki uzunluğu") print(f"{'tünel':>6s} {'yakınsamış':>11s} {'kopma sonrası':>14s} {'eski tabloyla':>14s}") for x, y in KAPLAMA: _, a0 = ilet(x, y, ALT, BAGLAR) k1, a1 = ilet(x, y, ALT_YENI, KOPUK) k2, a2 = ilet(x, y, ALT, KOPUK) print(f"{x + '-' + y:>6s} {a0:11d} {a1:14d} " f"{('kara delik' if k2 != 'ulasti' else str(a2)):>14s}") ``` ``` rejim ulaştı kaplama döngüsü tünel kara deliği iki katman da yakınsamış 40 0 0 alt ağ düzeni koptu, yakınsadı 40 0 0 alt ağ düzeni koptu, tablo eski 19 0 21 tünel kalktı, iki uç duydu 28 12 0 tünel kalktı, hepsi duydu 40 0 0 iki katman birden eski 17 3 20 rejim kaplama adımı alt ağ düzeni adımı iki katman da yakınsamış 74 188 alt ağ düzeni koptu, yakınsadı 74 211 alt ağ düzeni koptu, tablo eski 40 124 tünel kalktı, iki uç duydu 77 205 tünel kalktı, hepsi duydu 97 264 iki katman birden eski 41 134 tünelin alt ağ düzenindeki uzunluğu tünel yakınsamış kopma sonrası eski tabloyla a-c 2 2 2 a-d 3 3 3 a-e 3 4 kara delik b-d 2 2 2 b-g 2 3 kara delik c-f 2 3 kara delik d-h 4 4 4 e-g 2 2 2 f-h 2 2 2 ``` #### Kaplama Kopmayı Görmez İlk iki rejim kirişin kopmasını ölçüyor. Kırk paketin kırkı iki rejimde de ulaşıyor ve **kaplama adımı ikisinde de 74**. Kaplamanın tablosunda **tek bir satır değişmedi**; kaplama için hiçbir şey olmadı. Alt ağ düzeni adımı **188'den 211'e** çıkıyor. Üçüncü tablo yirmi üç fazladan adımın nereden geldiğini söylüyor: `a-e` tüneli üç adımdan dörde, `b-g` ve `c-f` tünelleri ikişer adımdan üçer adıma çıkıyor. Kirişi kullanan tüneller bunlardı; kiriş gidince alt ağ düzeni onları halkanın öteki yakasından kurdu. Bu, kaplamanın en çok reklam edilen özelliğidir ve ölçüm onu doğruluyor: **alt ağ düzeni kendini onardığı sürece kaplama kopmayı hiç görmez.** Ama ölçüm bedeli de veriyor. Kaplamayı izleyen bir gözlemci yirmi üç fazladan adımı **göremez**, çünkü kendi sayacında hiçbir şey değişmemiştir. Katman, arızayı gizlerken maliyeti de gizler. #### Doğru Tablo, Ölü Paket Üçüncü rejim aynı kopmayı alt ağ düzeni **yakınsamadan** ölçüyor. Kaplamanın tablosu yine değişmedi, yine doğrudur; kırk paketin yalnız **19**'u ulaşıyor ve **21**'i tünel kara deliğine düşüyor. Üçüncü tablonun son sütunu üç tüneli adlandırıyor: `a-e`, `b-g` ve `c-f` eski alt ağ düzeni tablosuyla teslim edilemiyor. Kaplama bu üç bağı hâlâ ayakta sayıyor ve paketleri onlara yolluyor. İki katmanlı anlaşmazlığın ilk biçimi budur: **üstteki tablo kusursuzdur ve paket ölür.** Kaplamanın kendi ölçüsüne bakan bir denetim hiçbir arıza bildirmez — kaplama komşulukları tam, kaplama yolları geçerli, kaplama adımı beklenenden bile düşük (**40**, çünkü ölen paket adım harcamayı bırakır). Arıza bir katman aşağıdadır ve yukarısı ona bakamaz. #### Alt Ağ Kusursuz, Kaplama Döngüde Dördüncü rejim anlaşmazlığı ters çeviriyor. Bu rejimde alt ağ düzeninin tablosu kâhinin kendisidir: **alt ağ düzeninde tek bir yanlış karar yoktur** ve dokuz tünelin dokuzu da teslim edilebilir. Değişen tek şey kaplamadadır — `a-c` tüneli kalkmıştır ve bunu yalnız `a` ile `c` duymuştur. Sonuç: kırk paketin **28**'i ulaşıyor, **12**'si **kaplama döngüsüne** giriyor. Kara delik **sıfır**. Beşinci rejim aynı tünel kalkışını herkes duyduğunda ölçüyor: **40 ulaşıyor**, kaplama adımı 97'ye, alt ağ düzeni adımı 264'e çıkıyor. Kursun ikinci iddiası burada bir katman yukarıda yeniden ödeniyor. **Kısmî bilgi, tam bilgisizlikten pahalı bir arıza üretir:** herkes duyduğunda kırk paket ulaşıyor, yalnız iki uç duyduğunda on iki paket ağda dolaşıyor. Ve üçüncü iddia da ikinci kez ödeniyor: on iki paketin hiçbirini tek bir tablo döngüye sokmadı. Döngü, **iki kaplama tablosunun anlaşmazlığıdır** — `a` tünelin kalktığını bilir, `d` bilmez ve paketi geri gönderir. En keskin nokta şudur: **alt ağ düzeni bu döngüyü göremez.** Alt ağ düzeninin gördüğü şey, her biri ayrı ayrı geçerli olan tünel teslimleridir. `a`'dan `d`'ye giden tünel teslim edildi, `d`'den `a`'ya giden tünel de teslim edildi; ikisi de doğru. Döngü ancak iki teslimi **yan yana koyan** bir gözden görünür ve alt ağ düzeninde öyle bir göz yoktur. #### İki Katman Birden Altıncı rejim iki anlaşmazlığı üst üste koyuyor: `a-c` tüneli kalkmış ve bunu yalnız iki uç duymuş, **aynı anda** kiriş kopmuş ve alt ağ düzeninin tabloları eskimiş. Kırk paketin **17**'si ulaşıyor — tek başına alt ağ düzeni arızasından (**19**) da, tek başına kaplama arızasından (**28**) da az. Asıl gözlem kaderlerin dağılımındadır. Kaplama döngüsü **12**'den **3**'e, tünel kara deliği **21**'den **20**'ye iniyor. Döngüye girecek paketlerin çoğu daha ilk turda bir tünel kara deliğine düşüp ölüyor: **alttaki arıza üsttekini gizliyor.** Kaplamayı izleyen bir göz döngü sayısının düştüğünü görür ve bunu bir iyileşme sanabilir. Adım sayıları da aynı yöne işaret ediyor — kaplama **77**'den **41**'e, alt ağ düzeni **205**'ten **134**'e. Ağın en kötü durumu, bütün sayaçların en sakin göründüğü durumdur. #### İki Sayaç, İki Tanı Sayaçların ayrılığı tanıyı da ayırıyor. Döngüye giren rejimde kaplama **77 adım**, alt ağ düzeni **205 adım** harcıyor: kaplamadaki her adım alt ağ düzeninde ortalama iki buçuk adımın üzerindedir ve kaplama katmanındaki bir döngü alt ağ düzeninde bu katsayıyla büyür. İki gözlemci iki ayrı şey görür. Kaplamayı izleyen sayaç döngüyü **döngü olarak** görür: paketler dolaşıyor, atlama sınırı yanıyor. Alt ağ düzenini izleyen sayaç yalnız **yük artışı** görür: bağlar üzerinde beklenenden çok paket var, hiçbir teslim başarısız değil. Ortak tanımın "döngü tıkanıklık gibi görünür" saptaması, iki katmanlı bir ağda **hangi katmandan bakıldığına** göre değişen bir saptamadır. Bu, kaplamayı kullanmamak için bir gerekçe değildir; kaplamanın iki katmanı birden izlemeden kullanılamayacağı için bir gerekçedir. Tek katmanlı bir ağda tablo ile bağ kümesi aynı yerde durur ve arıza ikisinde birden görünür. Kaplamada ölçülen altı rejimin **üçünde** paket ölür ve üçünün belirtisi başkadır: biri yalnız kara delik, biri yalnız döngü, biri ikisi birden. #### Özet - Kaplama ağı tünellerle kurulan mantıksal bir topolojidir; kaplamanın bir bağı komşuluk bildirir, kablo bildirmez. Altındaki gerçek bağ kümesinin adı **alt ağ düzenidir** ve iki katmanın tabloları aynı cihazda dursa da birbirini okumaz. - Alt ağ düzeni kendini onardığında kaplama kopmayı **hiç görmez**: kaplama adımı **74**'te kalır, alt ağ düzeni adımı **188'den 211'e** çıkar. Katman arızayı gizlerken maliyeti de gizler. - Alt ağ düzeni yakınsamadan kaplama doğru tablosuyla çalışırsa **21 paket** tünel kara deliğine düşer; kirişi kullanan `a-e`, `b-g` ve `c-f` tünelleri teslim edilemez. Üstteki tablo kusursuzdur ve paket ölür. - Alt ağ düzeninde tek bir yanlış karar yokken kaplama tablolarının kısmî bilgisi **12 paketi döngüye** sokar; herkes duyduğunda kırk paketin kırkı ulaşır. Döngü **iki kaplama tablosunun anlaşmazlığıdır** ve alt ağ düzeni onu göremez. - Kaplamadaki 77 adım alt ağ düzeninde 205 adımdır; kaplamayı izleyen sayaç döngü görür, alt ağ düzenini izleyen sayaç yalnız yük artışı görür. - İki katman birden eskidiğinde ulaşan paket **17**'ye iner ama döngü **3**'e düşer: alttaki kara delik üstteki döngüyü gizler ve en kötü durum sayaçlarda en sakin görünür. #### Sonraki Adım Buraya kadar bütün ölçümlerde topoloji **verilmişti**. Sekiz düğüm, dokuz bağ ve halkayı kesen bir kiriş baştan konmuştu; ölçülen şey hep ona verilen yanıttı — hangi tablo kaç turda yakınsıyor, hangi politika yolu ne kadar uzatıyor, hangi katman kopmayı görüyor. Topolojinin kendisi hiç sorgulanmadı. Oysa topoloji de bir seçimdir: hangi düğümün hangi düğüme bağlanacağı, kaç yedek yol bırakılacağı, bir kopmanın kaç düğümün tablosunu değiştireceği yazılırken kararlaştırılır. Sonraki konu bu seçimi ölçer ve seçimin doğrudan yakınsama turuna dokunduğunu gösterir. ## Topoloji Tasarımı Katmanlı kurumsal düzenler, doğu–batı trafiği için omurga–yaprak, ağ geçidi yedekliliği ve devralma, ve büyüyen ağda sürdürülebilir adres ile ad planı. ### Katmanlı Tasarım Source: https://academia.sh/tr/kurslar/anahtarlama-ve-yonlendirme/katmanli-tasarim Katman sayısı adım sayısını ve yakınsama turunu birlikte belirler: aynı dokuz erişim anahtarında düz zincir 121, iki katmanlı tasarım 80, üç katmanlı tasarım 138 adım harcar ve bağlantı durumu ailesi sırasıyla 7, 1 ve 3 turda yakınsar. Buraya kadar topoloji **verilmişti**. Sekiz düğüm, dokuz bağ, halkayı kesen bir kiriş — bunlar kurgunun sabitiydi ve ölçülen şey topolojiye verilen yanıttı: hangi aile kaç turda yakınsıyor, kısmî bilgi hangi kaderi üretiyor, kaplama kendi tablosuyla alttakiyle nasıl çelişiyor. Topolojinin kendisi de bir seçimdir. Seçim yakınsama turunu, adım sayısını ve kopmanın kaç satırı değiştirdiğini birlikte belirler. Bu dersin sorusu şudur: aynı erişim anahtarlarını üç ayrı düzende bağladığımızda paketin ödediği şey nasıl değişir? #### Katmanın Taşıdığı Karar **Katmanlı tasarım (layered design)** cihazları rolüne göre ayırır ve her role tek bir karar verdirir. **Erişim katmanı (access layer)** konakların bağlandığı yerdir. Kararı yereldir: çerçeve bu anahtarın bir bağlantı noktasına mı gidiyor, yoksa yukarı mı? **Dağıtım katmanı (distribution layer)** bir bina, kat ya da bölütün tamamını toplar; kararı bloğun sınırındadır ve blok dışına giden her şey ondan geçer. **Çekirdek katmanı (core layer)** yalnız blokları birbirine bağlar; hiçbir konak ona bağlanmaz ve kararı en dar olandır. İki katmanlı düzende dağıtım ile çekirdek aynı cihazda birleşir; bu birleşmenin adı **çöken çekirdek (collapsed core)** düzenidir. Katmansız düzen ise bir seçim değil, seçimin yokluğudur: yeni anahtar bir öncekine takılır ve ağ bir zincir olarak büyür. Ölçüm için üç düzen kurulur. Üçünde de **dokuz erişim anahtarı** vardır ve konaklar yalnız onlara bağlıdır; değişen tek şey aralarındaki düzendir. ```text # ogretilen dokum , calistirilmamistir düz zincir — 1 katman erişim: e1 - e2 - e3 - e4 - e5 - e6 - e7 - e8 - e9 çöken çekirdek — 2 katman çekirdek: c1 - c2 erişim: e1..e9, her biri hem c1'e hem c2'ye üç katmanlı — 3 katman çekirdek: c1 - c2 dağıtım: d1 d2 | d3 d4 | d5 d6, her biri hem c1'e hem c2'ye erişim: e1 e2 e3 -> d1 d2 e4 e5 e6 -> d3 d4 e7 e8 e9 -> d5 d6 ``` #### Katmanın Söz Verdiği ve Vermediği Katmanlı tasarımın gerekçesi çoğu zaman "daha hızlı" diye özetlenir ve bu özet yanlıştır. Katman eklemek yolu **uzatır**: her yeni katman, bloklar arası her paketin geçmek zorunda olduğu iki cihaz daha demektir. Katmanın söz verdiği başka bir şeydir: bir bloğun içindeki değişiklik blokta kalır. Söz **adımda** değil, **tabloda ve kopmanın yayılımındadır**. Ölçüm sözün iki yakasını da sayar. Ölçümün dayandığı varsayımlar: - **TP1** — Üç tasarımın da dokuz erişim anahtarı aynıdır ve kırk paket yalnız bu dokuzun arasında üretilir. Karşılaştırılan şey konak sayısı değil, aradaki düzendir. - **TP2** — Kâhin topolojiyi biz kurduğumuz için bilinir ve her düğüm için her hedefe giden en kısa yolun ilk adımıdır. Eşit uzunluktaki yollarda düğüm adının sırası belirler. - **TP3** — Bütün bağların maliyeti birdir; ölçülen şey bant genişliği değil **adımdır**. - **TP4** — Yakınsama sayacı **soğuk başlangıçtan** işler: sıfırıncı turda her düğüm yalnız kendi bağlarını bilir. Uzaklık vektörü ailesinde tur, komşunun uzaklık dizisinin öğrenilmesidir; bağlantı durumu ailesinde komşunun bildiği bağların öğrenilmesidir. - **TP5** — Kesilen bağ elle seçilmez: kırk paketin en kısa yollarını taşıyan **en yoğun bağ** sayılarak bulunur. Üç tasarımda da aynı ölçüt uygulanır. - **TP6** — Atlama sınırı 12'dir; bu sınırı yakan paket döngü sayılır. - **TP7** — Tablo satırı, bir düğümün bir hedef için tuttuğu tek bir kayıttır; üç tasarımın satır sayısı düğüm sayısıyla birlikte büyür. - **TP8** — Kırk paketlik kümede ölçülebilen en küçük fark 1/40 = 0,025'tir; bundan küçük bir fark iddia edilmez. #### Ölçüm ```python """Katmanli tasarim: katman sayisinin adima ve yakinsama turuna etkisi. Bolum 1 - uc tasarim yakinsamis halde: adim, tablo satiri, en uzun yol. Bolum 2 - soguk baslangictan yakinsama turu. Bolum 3 - en yogun bag koptugunda paketin kaderi ve yeniden yakinsama. """ TOHUM = 20260810 ATLAMA_SINIRI = 12 ERISIM = [f"e{i}" for i in range(1, 10)] BLOK = {"d1": ERISIM[0:3], "d2": ERISIM[0:3], "d3": ERISIM[3:6], "d4": ERISIM[3:6], "d5": ERISIM[6:9], "d6": ERISIM[6:9]} TASARIM = { "düz zincir": (ERISIM, [(f"e{i}", f"e{i + 1}") for i in range(1, 9)]), "iki katmanlı": (ERISIM + ["c1", "c2"], [(e, c) for e in ERISIM for c in ("c1", "c2")] + [("c1", "c2")]), "üç katmanlı": (ERISIM + sorted(BLOK) + ["c1", "c2"], [(e, d) for d, es in BLOK.items() for e in es] + [(d, c) for d in sorted(BLOK) for c in ("c1", "c2")] + [("c1", "c2")]), } def uretec(tohum): d = tohum % 2147483646 + 1 def r(n): nonlocal d d = (d * 48271) % 2147483647 return d % n return r def komsuluk(dugumler, baglar): k = {u: set() for u in dugumler} for x, y in baglar: k[x].add(y) k[y].add(x) return k def kahin(dugumler, baglar): """Her dugum icin her hedefe giden en kisa yolun ilk adimi.""" k, tablo = komsuluk(dugumler, baglar), {} for kaynak in dugumler: onceki, sira, gorulen = {}, [kaynak], {kaynak} while sira: yeni = [] for u in sira: for v in sorted(k[u]): if v not in gorulen: gorulen.add(v) onceki[v] = u yeni.append(v) sira = yeni for hedef in dugumler: if hedef == kaynak or hedef not in onceki: continue adim = hedef while onceki[adim] != kaynak: adim = onceki[adim] tablo[(kaynak, hedef)] = adim return tablo def ilet(kaynak, hedef, tablolar, dugumler, baglar): k, u, gecilen, atlama = komsuluk(dugumler, baglar), kaynak, [], 0 while u != hedef: if atlama >= ATLAMA_SINIRI: return "dongu", atlama sonraki = tablolar.get((u, hedef)) if sonraki is None or sonraki not in k[u]: return "kara delik", atlama if (u, sonraki) in gecilen: return "dongu", atlama gecilen.append((u, sonraki)) u, atlama = sonraki, atlama + 1 return "ulasti", atlama def ciftler(sayi=40, tohum=TOHUM): r, liste = uretec(tohum), [] while len(liste) < sayi: x, y = ERISIM[r(9)], ERISIM[r(9)] if x != y: liste.append((x, y)) return liste def olc(tablolar, dugumler, baglar): sayim, adim, en_uzun = {"ulasti": 0, "dongu": 0, "kara delik": 0}, 0, 0 for x, y in ciftler(): kader, a = ilet(x, y, tablolar, dugumler, baglar) sayim[kader] += 1 adim += a if kader == "ulasti": en_uzun = max(en_uzun, a) return sayim, adim, en_uzun def uzaklik_vektoru(dugumler, baglar, tur): """Her turda dugum yalniz komsusunun uzaklik dizisini ogrenir.""" k = komsuluk(dugumler, baglar) uzak = {(u, h): (0 if u == h else 99) for u in dugumler for h in dugumler} ilk = {} for _ in range(tur): yeni_uzak, yeni_ilk = dict(uzak), dict(ilk) for u in dugumler: for v in sorted(k[u]): for h in dugumler: if uzak[(v, h)] + 1 < yeni_uzak[(u, h)]: yeni_uzak[(u, h)] = uzak[(v, h)] + 1 yeni_ilk[(u, h)] = v uzak, ilk = yeni_uzak, yeni_ilk return ilk def baglanti_durumu(dugumler, baglar, tur): """Turlarda topoloji tasinir; tam topolojiyi alan dugum dogru hesaplar.""" k = komsuluk(dugumler, baglar) bilinen = {u: {tuple(sorted((u, v))) for v in k[u]} for u in dugumler} for _ in range(tur): yeni = {u: set(bilinen[u]) for u in dugumler} for u in dugumler: for v in k[u]: yeni[u] |= bilinen[v] bilinen = yeni tablolar = {} for u in dugumler: gor = sorted({x for b in bilinen[u] for x in b}) for (x, h), adim in kahin(gor, sorted(bilinen[u])).items(): if x == u: tablolar[(u, h)] = adim return tablolar def en_yogun(dugumler, baglar): t, say = kahin(dugumler, baglar), {} for x, y in ciftler(): u = x while u != y: v = t[(u, y)] say[tuple(sorted((u, v)))] = say.get(tuple(sorted((u, v))), 0) + 1 u = v return max(say, key=say.get) print(f"{'tasarım':<14s} {'katman':>6s} {'düğüm':>5s} {'bağ':>4s} " f"{'tablo satırı':>12s} {'ulaştı':>6s} {'adım':>5s} {'en uzun':>7s}") for i, (ad, (D, B)) in enumerate(TASARIM.items()): t = kahin(D, B) s, a, u = olc(t, D, B) print(f"{ad:<14s} {i + 1:6d} {len(D):5d} {len(B):4d} {len(t):12d} " f"{s['ulasti']:6d} {a:5d} {u:7d}") print() print(f"{'tur':>3s}" + "".join(f"{ad:>17s}" for ad in TASARIM)) print(f"{'':>3s}" + f"{'uv bd':>17s}" * 3) for tur in range(0, 9): satir = f"{tur:3d}" for ad, (D, B) in TASARIM.items(): uv = olc(uzaklik_vektoru(D, B, tur), D, B)[0]["ulasti"] bd = olc(baglanti_durumu(D, B, tur), D, B)[0]["ulasti"] satir += f"{uv:12d}{bd:5d}" print(satir) print() print(f"{'tasarım':<14s} {'kesilen':>9s} {'kopma anı':>18s} " f"{'yakınsamış':>18s} {'uv/bd turu':>10s} {'değişen satır':>13s}") print(f"{'':<14s} {'':>9s} {'ulaştı kara delik':>18s} {'ulaştı kara delik':>18s}") for ad, (D, B) in TASARIM.items(): kes = en_yogun(D, B) kopuk = [b for b in B if tuple(sorted(b)) != kes] eski, yeni = kahin(D, B), kahin(D, kopuk) s0 = olc(eski, D, kopuk)[0] s1 = olc(yeni, D, kopuk)[0] tur_bd = next(t for t in range(12) if olc(baglanti_durumu(D, kopuk, t), D, kopuk)[0] == s1) tur_uv = next(t for t in range(12) if olc(uzaklik_vektoru(D, kopuk, t), D, kopuk)[0] == s1) degisen = sum(1 for a in eski if a in yeni and eski[a] != yeni[a]) print(f"{ad:<14s} {kes[0] + '–' + kes[1]:>9s} {s0['ulasti']:11d}" f"{s0['kara delik']:7d} {s1['ulasti']:11d}{s1['kara delik']:7d} " f"{f'{tur_uv}/{tur_bd}':>10s} {f'{degisen}/{len(eski)}':>13s}") ``` ``` tasarım katman düğüm bağ tablo satırı ulaştı adım en uzun düz zincir 1 9 8 72 40 121 8 iki katmanlı 2 11 19 110 40 80 2 üç katmanlı 3 17 31 272 40 138 4 tur düz zincir iki katmanlı üç katmanlı uv bd uv bd uv bd 0 0 13 0 0 0 0 1 13 22 0 40 0 11 2 22 26 40 40 11 11 3 26 29 40 40 11 40 4 29 34 40 40 40 40 5 34 37 40 40 40 40 6 37 38 40 40 40 40 7 38 40 40 40 40 40 8 40 40 40 40 40 40 tasarım kesilen kopma anı yakınsamış uv/bd turu değişen satır ulaştı kara delik ulaştı kara delik düz zincir e5–e6 19 21 19 21 3/2 0/72 iki katmanlı c1–e7 26 14 40 0 2/1 18/110 üç katmanlı c1–d3 20 20 40 0 4/3 24/272 ``` #### Adım Sayısı Katmanla Birlikte Artmaz Üst tablo katmanın söz vermediği şeyi doğrudan gösteriyor. **İki katmanlı** düzen kırk paketi **80** adımda taşıyor ve en uzun yol **2**: her paket yukarı çıkıp aşağı iniyor, hepsi bu. **Üç katmanlı** düzen aynı kırk paket için **138** adım harcıyor ve en uzun yol **4**'e çıkıyor. Üçüncü katman, iki katmanlı düzenin üstüne **58 adım** ekliyor. Şaşırtıcı olan üst satırdır: **düz zincir 121 adımda bitiriyor** ve üç katmanlı düzenden **daha az** adım harcıyor. Nedeni dağılımdadır: zincirde komşu anahtarlar arasındaki paket tek adımda varır ve kırk paketin on üçü böyledir. Zincirin en uzun yolu **8** adımdır, yani en kötü durumu üç katmanlının iki katıdır; toplam adımı düşük tutan şey en kötü durum değil, ucuz yakın komşulardır. Buradan çıkan kural şudur: **katman sayısı adım sayısını iyileştirmez.** İki katmanlı düzenin 80'i bir alt sınırdır, çünkü herhangi iki erişim anahtarı arasında zaten en az iki adım vardır. Üçüncü katman bu sayıyı yalnız büyütebilir. #### Yakınsama Turu Katmanla Birlikte Küçülür Orta tablo aynı üç düzeni soğuk başlangıçtan izliyor ve buradaki sıralama tersine dönüyor. **Düz zincirde** bağlantı durumu ailesi kırk paketin kırkını **7. turda** ulaştırıyor, uzaklık vektörü ailesi **8. turda**. Bilgi zincir boyunca komşudan komşuya sürünüyor: e1'in e9'u öğrenmesi için haberin sekiz bağ geçmesi gerekiyor. **İki katmanlı** düzende bağlantı durumu ailesi **1. turda** bitiriyor — bir erişim anahtarının komşusu çekirdektir ve çekirdek herkesi tanır, dolayısıyla tek tur bütün topolojiyi taşımaya yetiyor. **Üç katmanlı** düzen **3. turda** yakınsıyor: haberin erişimden dağıtıma, dağıtımdan çekirdeğe ve oradan geri inmesi gerekiyor. Sıfırıncı tur satırı ayrıca okunmalıdır. Düz zincirde bağlantı durumu ailesi **13** paketi daha ilk anda ulaştırıyor, çünkü o on üç paketin hedefi zaten komşudur ve düğüm kendi bağlarını baştan bilir. İki ve üç katmanlı düzenlerde aynı hücre **0**'dır: katmanlı bir tasarımda hiçbir erişim anahtarı bir başkasının komşusu değildir. Katmanlaşmanın ilk bedeli budur — sıfırıncı turda hiçbir paket ulaşmaz. İki aile arasındaki bir turluk fark üç düzende de sürüyor: bağlantı durumu ailesi her tasarımda uzaklık vektörü ailesinden **bir tur önce** bitiriyor. #### Kopmanın Ödettiği Alt tablo en yoğun bağı kesiyor ve üç düzenin verdiği yanıt birbirinden tamamen ayrı. **Düz zincirde** kesilen bağ `e5–e6` ve sonuç kalıcıdır: **21 paket kara deliğe** düşer ve tablolar yakınsadıktan sonra da **21** kalır. Zincirde alternatif yol yoktur; kopma ağı iki parçaya ayırır ve doğru tablo hesaplamak bir işe yaramaz. Değişen satır sayısı **0/72** bunu söylüyor: hesaplanacak yeni bir yol yok. Zincirin ucuz adım sayısı buraya kadardır. **İki katmanlı** düzende kesilen bağ `c1–e7`'dir. Kopma anında eski tablolarla **26 paket ulaşır, 14'ü kara deliğe düşer**; tablolar yakınsadığında **40/40**'a dönülür ve toplam adım yine **80**'dir — kaybedilen hiçbir şey yoktur, çünkü e7'nin c2 üzerinden ikinci bir yolu vardır. Bağlantı durumu ailesi bunu **1 turda** onarır. Bedel **110 satırın 18'inin** değişmesidir. **Üç katmanlı** düzende kesilen bağ `c1–d3`'tür; kopma anında **20 ulaşır, 20 kara deliğe düşer**, yakınsama **3 tur** alır ve sonuç yine **40/40**. Asıl fark en sağdaki sütundadır: değişen satır **272'nin 24'ü**, yani **yüzde 9**. İki katmanlı düzende aynı oran **110'un 18'i**, yani **yüzde 16**. Üçüncü katmanın satın aldığı şey budur: kopma daha çok satır içeren bir tabloda **daha az satırı** kıpırdatır, çünkü değişiklik bloğun sınırında durur. Takas böylece açıktır. Katman eklemek adım, yakınsama turu ve tablo satırı ekler; karşılığında verdiği tek şey **değişikliğin dar kalmasıdır**. Dokuz erişim anahtarında bu takas üçüncü katmanı haklı çıkarmaz; çekirdeğin dokuz yerine doksan dokuz komşusu olduğunda çıkarır. #### Özet - Katmanlı tasarım cihazları role ayırır: erişim konağı toplar, dağıtım bloğu toplar, çekirdek yalnız blokları bağlar; iki katmanlı düzende son iki rol aynı cihazda birleşir. - Aynı dokuz erişim anahtarında düz zincir **121**, iki katmanlı düzen **80**, üç katmanlı düzen **138** adım harcar; katman eklemek adım sayısını **iyileştirmez**. - Yakınsama turu ters yönde çalışır: bağlantı durumu ailesi zincirde **7**, iki katmanlıda **1**, üç katmanlıda **3** turda yakınsar ve her tasarımda uzaklık vektörü ailesinden bir tur öndedir. - Katmanlı düzende sıfırıncı turda hiçbir paket ulaşmaz; zincirde **13** paket ulaşır, çünkü hedefleri zaten komşudur. - En yoğun bağ koptuğunda zincir **21 paketi kalıcı olarak** kaybeder; iki ve üç katmanlı düzenler **40/40**'a döner, ama değişen satır oranı sırasıyla **18/110** ve **24/272**'dir — üçüncü katmanın satın aldığı şey dar kalan değişikliktir. #### Sonraki Adım Üç tasarımın da örtük bir kabulü vardı: paket erişimden yukarı çıkar, bir yerde döner ve aşağı iner. Kırk paketin kaynağı da hedefi de erişim anahtarlarındaydı, ama düzen yukarı çıkmaya göre kurulmuştu. Üç katmanlı düzende bunun bedeli göründü — bloklar arası her paket dört adım harcadı, blok içindekiler ise iki. Aynı iki uç arasındaki adım sayısı, uçların hangi bloğa düştüğüne bağlıydı. Sonraki ders trafiğin çoğunun yukarı değil **yana** aktığı durumu ele alır: her yaprağın her omurgaya bağlandığı bir düzende iki yaprak arasındaki adım sayısı sabit kalır ve bu sabitliğin tablo satırına ödettiği ayrı ayrı sayılır. ### Omurga–Yaprak Tasarımı Source: https://academia.sh/tr/kurslar/anahtarlama-ve-yonlendirme/omurga-yaprak-tasarimi Her yaprağın her omurgaya bağlandığı düzende iki yaprak arası adım sayısı omurga sayısından, yaprak çiftinden ve kopmadan bağımsız olarak 2'de sabit kalır; sabitliğin bedeli tablo satırıdır ve dört omurgada tek yol satırı 90'dan 156'ya, çok yol satırı 90'dan 468'e çıkar. Önceki ders üç düzeni aynı dokuz erişim anahtarı üzerinde ölçtü ve üç katmanlı düzende bir tutarsızlık bıraktı: aynı iki uç arasındaki adım sayısı, uçların hangi bloğa düştüğüne bağlıydı. Blok içindeki paket iki adım, bloklar arasındaki paket dört adım harcadı. Katmanlı düzenin örtük kabulü, trafiğin çoğunun **yukarı** akmasıydı — konaktan çıkıp ağın dışına giden, kuzey–güney yönlü trafik. O kabul doğruyken bloklar arası dört adım seyrek ödenir. Kabul her zaman doğru değildir. Bir konağın konuştuğu şey ağın dışı değil, aynı ağdaki başka bir konaksa trafik yukarı değil **yana** akar. Bu dersin sorusu şudur: trafiğin çoğu yaprakla yaprak arasındaysa hangi düzen adım sayısını uçların yerinden bağımsız kılar ve bunun bedeli nedir? #### Doğu–Batı Trafiği Ağdaki iki uç arasında, ağın dışına çıkmadan akan trafiğe **doğu–batı trafiği (east–west traffic)** denir. Karşıtı **kuzey–güney trafiğidir**: konaktan çıkıp çekirdeği aşan, ağın dışına giden akış. Katmanlı tasarım kuzey–güney için kurulur. Bloğun dağıtım çifti, bloğun bütün trafiğini toplayıp çekirdeğe verir; çekirdek onu dışarıya taşır. Bu düzende doğu–batı trafiği bir istisna gibi işlenir: iki blok arasındaki her paket kendi dağıtım çiftine çıkar, çekirdeğe tırmanır, öteki dağıtım çiftine iner ve oradan yaprağa ulaşır. Ölçüm bunu önceki derste dört adım olarak saymıştı. Sorun yalnız adım sayısı değildir. Blok içi paket iki, bloklar arası paket dört adım harcadığında **iki uç arasındaki maliyet uçların nereye takıldığına bağlı** olur. Bir konağı başka bir yaprağa taşımak, kimseyle konuşmasını değiştirmeden gecikmesini değiştirir. #### Omurga ve Yaprak **Omurga–yaprak (spine–leaf)** düzeni bu bağımlılığı yapısal olarak kaldırır. İki tür cihaz vardır. **Yaprak** konakların bağlandığı anahtardır. **Omurga** yalnız yaprakları bağlar ve hiçbir konak ona takılmaz. Kural tektir: **her yaprak her omurgaya bağlanır, omurgalar birbirine bağlanmaz, yapraklar birbirine bağlanmaz.** Bu kuralın doğrudan sonucu şudur: bir yapraktan bir başka yaprağa giden her yol tam olarak **iki** adımdır — yaprak, omurga, yaprak. Başka uzunlukta bir yol yoktur, çünkü başka bir bağ yoktur. ```text # ogretilen dokum , calistirilmamistir omurga–yaprak, 3 omurga omurga: o1 o2 o3 yaprak: y1 y2 y3 y4 y5 y6 y7 y8 y9 kural: her y, her o'ya bağlı (9 x 3 = 27 bağ) o–o bağı yok, y–y bağı yok y3 -> y8 için yollar: y3-o1-y8 y3-o2-y8 y3-o3-y8 hepsi 2 adım, hepsi eşit maliyetli ``` Üç yol da eşit uzunlukta olduğu için yaprak birini seçmek zorundadır. Seçim **eşit maliyetli çoklu yol (equal-cost multipath)** kuralıyla yapılır: yaprak, hedefe giden bütün eşit maliyetli bir sonraki düğümleri tablosunda tutar ve her akış için birini seçer. Aynı akışın bütün paketleri aynı seçimi alır. Akışın bölünmemesi kuralı **Bağlantı Toplama** dersinde kurulmuştu; orada seçim bir bağ demetinin bacakları arasındaydı, burada aynı kural **yol** üzerinde işler. Ölçümün dayandığı varsayımlar: - **TP9** — Dokuz yaprak (`y1`–`y9`) önceki dersin dokuz erişim anahtarıdır; kırk çift yalnız bunların arasında üretilir. Ölçülen şey bu yüzden tümüyle doğu–batı trafiğidir. - **TP10** — Omurga sayısı 1, 2, 3 ve 4 olarak denenir; her denemede yaprak sayısı sabittir. Karşılaştırma satırı olarak önceki dersin üç katmanlı düzeni aynı dokuz yaprakla yeniden kurulur. - **TP11** — Kâhin her hedef için en kısa yolun **bütün** ilk adımlarını verir; eşit maliyetli yollar teke indirilmez. - **TP12** — Akış seçimi akış numarasının eşit maliyetli aday sayısına bölümünden kalanla yapılır. Gerçek düzenekte seçim başlık alanlarının karmasıyla yapılır; ölçümde önemli olan seçimin **akış başına sabit** ve yollar arasında **düzgün dağılmış** olmasıdır. - **TP13** — Bütün bağların maliyeti birdir; ölçülen şey adımdır. - **TP14** — "Tek yol satırı" her hedef için bir kayıt sayar, "çok yol satırı" her eşit maliyetli bir sonraki düğüm için ayrı kayıt sayar. İkisi aynı tablonun iki muhasebesidir. - **TP15** — Kopma her düzende aynı biçimde uygulanır: bir yaprağın ilk omurgaya giden bağı kesilir (`y7–o1`). Üç katmanlı düzende karşılığı aynı yaprağın dağıtım bağıdır (`d5–y7`). - **TP16** — Kırk paketlik kümede ölçülebilen en küçük fark 1/40 = 0,025'tir; atlama sınırı 12'dir. #### Ölçüm ```python """Omurga-yaprak: iki yaprak arasindaki adimin sabitligi ve tablo satirina bedeli. Bolum 1 - omurga sayisi degisirken adim, bag ve tablo satiri. Bolum 2 - bir yaprak-omurga bagi koptugunda kopma ani ve yakinsamis hal. """ TOHUM = 20260810 ATLAMA_SINIRI = 12 YAPRAK = [f"y{i}" for i in range(1, 10)] BLOK = {"d1": YAPRAK[0:3], "d2": YAPRAK[0:3], "d3": YAPRAK[3:6], "d4": YAPRAK[3:6], "d5": YAPRAK[6:9], "d6": YAPRAK[6:9]} UC_KATMANLI = (YAPRAK + sorted(BLOK) + ["c1", "c2"], [(y, d) for d, ys in BLOK.items() for y in ys] + [(d, c) for d in sorted(BLOK) for c in ("c1", "c2")] + [("c1", "c2")]) def uretec(tohum): d = tohum % 2147483646 + 1 def r(n): nonlocal d d = (d * 48271) % 2147483647 return d % n return r def komsuluk(dugumler, baglar): k = {u: set() for u in dugumler} for x, y in baglar: k[x].add(y) k[y].add(x) return k def uzakliklar(dugumler, baglar): k, uzak = komsuluk(dugumler, baglar), {} for kaynak in dugumler: gorulen, sira, d = {kaynak}, [kaynak], 0 uzak[(kaynak, kaynak)] = 0 while sira: d, yeni = d + 1, [] for u in sira: for v in sorted(k[u]): if v not in gorulen: gorulen.add(v) uzak[(kaynak, v)] = d yeni.append(v) sira = yeni return uzak def kahin(dugumler, baglar): """Her hedef icin en kisa yolun ilk adimlarinin tamami (esit maliyetli).""" k, uzak, tablo = komsuluk(dugumler, baglar), uzakliklar(dugumler, baglar), {} for u in dugumler: for h in dugumler: if u == h or (u, h) not in uzak: continue tablo[(u, h)] = [v for v in sorted(k[u]) if uzak.get((v, h), 99) == uzak[(u, h)] - 1] return tablo def ilet(akis, kaynak, hedef, tablolar, dugumler, baglar): """Esit maliyetli yollardan biri akis numarasina gore secilir.""" k, u, gecilen, atlama = komsuluk(dugumler, baglar), kaynak, [], 0 while u != hedef: if atlama >= ATLAMA_SINIRI: return "dongu", atlama aday = [v for v in tablolar.get((u, hedef), []) if v in k[u]] if not aday: return "kara delik", atlama sonraki = aday[akis % len(aday)] if (u, sonraki) in gecilen: return "dongu", atlama gecilen.append((u, sonraki)) u, atlama = sonraki, atlama + 1 return "ulasti", atlama def ciftler(sayi=40, tohum=TOHUM): r, liste = uretec(tohum), [] while len(liste) < sayi: x, y = YAPRAK[r(9)], YAPRAK[r(9)] if x != y: liste.append((x, y)) return liste def olc(tablolar, dugumler, baglar): sayim, adim, uzunluk = {"ulasti": 0, "dongu": 0, "kara delik": 0}, 0, [] for i, (x, y) in enumerate(ciftler()): kader, a = ilet(i, x, y, tablolar, dugumler, baglar) sayim[kader] += 1 adim += a if kader == "ulasti": uzunluk.append(a) return sayim, adim, (min(uzunluk), max(uzunluk)) if uzunluk else (0, 0) def yuk(tablolar, dugumler, baglar): """Kirk akisin her bagi kac kez kullandigi; en yuklu bag dondurulur.""" k, say = komsuluk(dugumler, baglar), {} for i, (x, y) in enumerate(ciftler()): u, atlama = x, 0 while u != y and atlama < ATLAMA_SINIRI: aday = [v for v in tablolar.get((u, y), []) if v in k[u]] if not aday: break v = aday[i % len(aday)] bag = tuple(sorted((u, v))) say[bag] = say.get(bag, 0) + 1 u, atlama = v, atlama + 1 return max(say.values()) def omurga_yaprak(omurga): o = [f"o{i}" for i in range(1, omurga + 1)] return YAPRAK + o, [(y, s) for y in YAPRAK for s in o] DUZEN = {f"omurga–yaprak, {s} omurga": omurga_yaprak(s) for s in (1, 2, 3, 4)} DUZEN["üç katmanlı (01. ders)"] = UC_KATMANLI print(f"{'düzen':<24s} {'düğüm':>5s} {'bağ':>4s} {'ulaştı':>6s} {'adım':>5s} " f"{'aralık':>6s} {'en yüklü bağ':>12s} {'tek yol':>7s} {'çok yol':>7s}") for ad, (D, B) in DUZEN.items(): t = kahin(D, B) s, a, (mn, mx) = olc(t, D, B) print(f"{ad:<24s} {len(D):5d} {len(B):4d} {s['ulasti']:6d} {a:5d} " f"{f'{mn}–{mx}':>6s} {yuk(t, D, B):12d} {len(t):7d} " f"{sum(len(v) for v in t.values()):7d}") print() print(f"{'düzen':<24s} {'kesilen':>7s} {'kopma anı':>18s} {'yakınsamış':>18s} " f"{'adım':>5s}") print(f"{'':<24s} {'':>7s} {'ulaştı kara delik':>18s} {'ulaştı kara delik':>18s}") for ad, (D, B) in DUZEN.items(): kes = ("y7", "o1") if "omurga" in ad else ("d5", "y7") kopuk = [b for b in B if tuple(sorted(b)) != tuple(sorted(kes))] eski, yeni = kahin(D, B), kahin(D, kopuk) s0 = olc(eski, D, kopuk)[0] s1, a1, _ = olc(yeni, D, kopuk) print(f"{ad:<24s} {kes[0] + '–' + kes[1]:>7s} {s0['ulasti']:11d}" f"{s0['kara delik']:7d} {s1['ulasti']:11d}{s1['kara delik']:7d} {a1:5d}") ``` ``` düzen düğüm bağ ulaştı adım aralık en yüklü bağ tek yol çok yol omurga–yaprak, 1 omurga 10 9 40 80 2–2 14 90 90 omurga–yaprak, 2 omurga 11 18 40 80 2–2 9 110 198 omurga–yaprak, 3 omurga 12 27 40 80 2–2 6 132 324 omurga–yaprak, 4 omurga 13 36 40 80 2–2 5 156 468 üç katmanlı (01. ders) 17 31 40 138 2–4 11 272 500 düzen kesilen kopma anı yakınsamış adım ulaştı kara delik ulaştı kara delik omurga–yaprak, 1 omurga y7–o1 26 14 26 14 52 omurga–yaprak, 2 omurga y7–o1 38 2 40 0 80 omurga–yaprak, 3 omurga y7–o1 38 2 40 0 80 omurga–yaprak, 4 omurga y7–o1 39 1 40 0 80 üç katmanlı (01. ders) d5–y7 38 2 40 0 138 ``` #### Adım Sabittir `aralık` sütunu dört omurga–yaprak satırında da **2–2** yazıyor: kırk paketin en kısası da en uzunu da iki adım. Toplam adım dört düzende de **80**'dir ve omurga sayısıyla hiç değişmiyor. Bu sabitlik üç ayrı boyutta geçerlidir ve üçü de tabloda okunur. **Yaprak çiftinden bağımsız:** kırk çift dokuz yaprak arasından üretildi ve hiçbiri ikiden uzun bir yol bulamadı. **Omurga sayısından bağımsız:** bir omurgadan dört omurgaya çıkarken bağ sayısı dokuzdan otuz altıya çıktı, adım aynı kaldı. **Kopmadan bağımsız:** alt tabloda `y7–o1` kesildikten sonra yakınsamış adım toplamı yine **80**'dir. Karşılaştırma satırı farkı veriyor. Üç katmanlı düzen aynı kırk paketi **138** adımda taşıyor ve aralığı **2–4**. Aradaki 58 adımın tamamı bloklar arası trafiğin çekirdeğe tırmanmasından geliyor. Doğu–batı trafiği için katmanlı düzen yalnız daha yavaş değil, **öngörülemezdir**: maliyeti uçların hangi bloğa düştüğü belirler. Sabitliğin kaynağı bir eniyileme değil, bir yokluktur. Omurgalar birbirine bağlanmadığı ve yapraklar birbirine bağlanmadığı için üç adımlık bir yol **kurulamaz**. Düzen kısa yolu seçmiyor; uzun yolu var etmiyor. #### Sabitliğin Bedeli Tablo Satırıdır Sağdaki iki sütun bedeli veriyor ve ikisi ayrı ayrı okunmalıdır. **Tek yol satırı** her hedef için bir kayıt sayar: bir omurgada **90**, iki omurgada **110**, üç omurgada **132**, dört omurgada **156**. Artış düğüm eklemekten gelir; her yeni omurga hem kendisi bir hedef olur hem de herkesin tablosuna bir satır ekler. **Çok yol satırı** asıl bedeldir. Yaprak, hedefe giden eşit maliyetli bütün bir sonraki düğümleri tutmak zorundadır; iki omurgada her uzak hedefin iki, dört omurgada dört kaydı olur. Sayı **90**'dan **468**'e çıkıyor — omurga sayısı dörde katlanırken satır **5,2 katına** çıkıyor. Adım hiç değişmediği hâlde. Kural şudur: **omurga–yaprak düzeninde ölçek adımla değil satırla ödenir.** Katmanlı tasarımda büyüme adımı uzatır ve tabloyu bloğun sınırında keser; omurga–yaprakta büyüme adımı hiç değiştirmez ve her yaprağın tablosunu genişletir. İki tasarım aynı kaynağı iki ayrı hesaba yazar. Karşılaştırma satırı burada omurga–yaprağın lehinedir: üç katmanlı düzen **272** tek yol ve **500** çok yol satırı tutuyor, iki omurgalı düzen **110** ve **198**. Üç katmanlı düzenin fazlası ara katmanın kendi düğümlerinden gelir — altı dağıtım ve iki çekirdek cihazı, hepsi birbirinin tablosunda. #### Omurga Sayısı Neyi Değiştirir Adım değişmiyorsa ikiden fazla omurga niye kurulur? Yanıt `en yüklü bağ` sütunundadır. Kırk akışın en çok yüklediği bağ, bir omurgada **14** akış taşıyor; iki omurgada **9**, üç omurgada **6**, dört omurgada **5**. Omurga eklemek gecikmeyi değil **yoğunluğu** düşürür; akışlar paralel yollara dağılır. İkinci yanıt alt tablodadır. **Tek omurgalı düzen bir tasarım değildir:** `y7–o1` kesildiğinde 14 paket kara deliğe düşer ve tablolar yakınsadıktan sonra da **14** kalır, çünkü `y7`'nin başka yolu yoktur. İki omurgadan itibaren aynı kopma yakınsamadan sonra **0** kara delik bırakır; kopma anında kalan **2** paket, o anda `o1`'i seçmiş olan akışlardır. Dört omurgada bu sayı **1**'e iner: kopan bağı kullanan akış oranı omurga sayısıyla azalır. Bir uyarı gereklidir. Ölçüm bütün bağların maliyetini bir sayar ve bant genişliğini hiç görmez. Gerçek bir düzende yaprağın aşağı bakan toplam kapasitesi, yukarı bakan toplam kapasitesinden büyük olabilir; o durumda `en yüklü bağ` sütunu akış sayısını değil, akışların sığmadığı yeri gösterir. Bu ders o hesabı yapmaz; yalnız akışın kaç bağa dağıldığını sayar. #### Özet - Doğu–batı trafiği ağın içinde kalan trafiktir; katmanlı tasarım kuzey–güney için kurulur ve doğu–batı paketini çekirdeğe tırmandırır. - Omurga–yaprak düzeninde her yaprak her omurgaya bağlanır, omurgalar ve yapraklar kendi aralarında bağlanmaz; bu yüzden iki yaprak arası her yol **2** adımdır. - Sabitlik üç boyutta geçerlidir: yaprak çiftinden, omurga sayısından ve kopmadan bağımsız olarak toplam **80** adım; üç katmanlı düzen aynı kırk paket için **138** adım ve **2–4** aralık verir. - Bedel tablo satırıdır: bir omurgadan dört omurgaya çıkarken tek yol satırı **90**'dan **156**'ya, çok yol satırı **90**'dan **468**'e çıkar. - Omurga eklemek adımı değil yoğunluğu düşürür — en yüklü bağ **14** akıştan **5** akışa iner; tek omurgalı düzende kopma **14 paketi kalıcı olarak** kaybettirir, iki omurgadan itibaren kayıp yakınsamayla **0**'a iner. #### Sonraki Adım Omurga–yaprak düzeninde yedeklilik yapısaldır: hiçbir cihaz tek başına bir yolun sahibi değildir ve bir omurganın kaybı yalnız akışların dağılımını değiştirir. Ama yaprağa bağlı konak, ağın dışına giden paketini bir yola değil bir **adrese** yollar — varsayılan ağ geçidinin adresine. O adres tek bir cihazın üstünde durur ve o cihaz düştüğünde yedeklilik yapısal olmaktan çıkıp bir **devralmaya** dönüşür: adresin sahibi değişmelidir ve değişimi herkesin duyması gerekir. Sonraki ders devralma penceresinde paketin kaderini sayar ve kısmî bilginin döngü ürettiğini ikinci kez ölçer. ### Yedeklilik ve Devralma Source: https://academia.sh/tr/kurslar/anahtarlama-ve-yonlendirme/yedeklilik-ve-devralma Ağ geçidi yedekliliğinde devralma penceresi ölçülür: yukarı bağ koptuğunda ve kimse duymadığında kırk akışın kırkı bir adım sonra kara deliğe düşer, geçit devrettiğinde kara delik sıfırlanır ama eş bağı kırk geçiş taşır, iki geçit birbirini etkin sandığında kırk akış döngüye girer ve eş bağı seksen geçiş taşır. Omurga–yaprak düzeninde yedeklilik yapısaldı: hiçbir cihaz bir yolun tek sahibi değildi ve bir omurganın kaybı yalnız akışların dağılımını değiştiriyordu. Konak tarafında durum böyle değildir. Konak, ağın dışına giden paketini bir yola değil bir **adrese** yollar — varsayılan ağ geçidinin adresine. Adres tekildir ve bir anda tek bir cihazın üstünde durur. Bu tekillik yedekliliği yapısal olmaktan çıkarır. Cihaz düştüğünde ikinci bir cihazın adresi **devralması** ve devralmayı herkesin duyması gerekir. Bu dersin sorusu, duymanın sürdüğü o kısa aralıkta paketin başına ne geldiğidir. #### Sanal Adres ve İki Rol **Ağ geçidi yedekliliği (gateway redundancy)** iki cihazı tek bir adresin arkasına koyar. Bu adrese **sanal adres** denir; konaklar onu varsayılan ağ geçidi olarak bilir ve iki cihazın varlığından haberdar değildir. Cihazlardan biri **etkin**, öteki **yedektir**. Etkin olan sanal adresi yanıtlar ve paketleri yukarı iletir; yedek olan sessizce dinler. Etkin olanın düzenli aralıklarla gönderdiği duyurular kesildiğinde yedek olan bir süre bekler ve sonra adresi devralır. ```text # ogretilen dokum , calistirilmamistir ağ geçidi çifti sanal adres tek adres, konakların varsayılan ağ geçidi g1 öncelik 110 etkin -> sanal adresi yanıtlar, yukarı iletir g2 öncelik 100 yedek -> sessiz dinler, duyuru bekler eş bağı g1 - g2, duyuruların ve durum bilgisinin taşındığı bağ zamanlama duyuru aralığı etkin olan her aralıkta bir kez duyurur ölü sayacı yedek olan bu süre boyunca duyuru duymazsa devralır devralma anı yedek olan sanal adresi yanıtlamaya başlar yaprak tablosu (uzak ağlar için) hedef bir sonraki düğüm u1 u2 u3 sanal adresin o an bulunduğuna inanılan geçit ``` Servis düzeyindeki devralma kalıpları — sağlık sınaması, yeniden deneme, devre kesici — **Dayanıklılık Kalıpları** kursunda kuruldu ve burada tekrarlanmaz. Orada devralan şey bir servis örneğiydi ve ölçülen şey isteğin akıbetiydi; burada devralan şey **ağ geçididir** ve ölçülen şey paketin kaderidir. #### Pencere Nedir Devralma anlık değildir. Ölü sayacı dolana kadar geçen süre, yedek olanın adresi ilan etmesi ve yol üzerindeki anahtarların adresin yerini yeniden öğrenmesi — bunların toplamına **devralma penceresi** denir. Pencere boyunca cihazlar sanal adresin nerede olduğu konusunda anlaşmaz. Pencerede iki ayrı soru vardır. Birincisi: **sanal adresi kim yanıtlıyor?** İkincisi: **yanıtlayan cihaz paketi iletebiliyor mu?** Ölçüm tam bu ayrımı sayar: yukarı bağı kopmuş bir geçit, adresi tuttuğu sürece paketleri toplamayı sürdürür. Ölçümün dayandığı varsayımlar: - **TP17** — Dokuz yaprak (`y1`–`y9`) bir ağ geçidi çiftine (`g1`, `g2`) bağlıdır; çift çekirdeğe (`c`), çekirdek üç uzak ağa (`u1`, `u2`, `u3`) bağlıdır. Kırk akışın kaynağı bir yaprak, hedefi bir uzak ağdır; ölçülen trafik tümüyle kuzey–güney yönlüdür. - **TP18** — Ölçülen arıza `g1–c` **yukarı bağının** kopmasıdır. `g1` sağdır, yapraklara bağlıdır ve sanal adresi tutmayı sürdürebilir. - **TP19** — Her yaprağın bir **inancı** vardır: sanal adresin `g1`'de mi `g2`'de mi olduğu. Duyan yaprak `g2` der, duymayan `g1` der. - **TP20** — Her geçidin de bir inancı vardır. Kendini etkin sanan geçit paketi yukarı iletir; eşini etkin sanan geçit paketi **eş bağından** eşine verir. - **TP21** — Kâhin kurguyu biz kurduğumuz için bilinir: `g1–c` koptuktan sonra uzak ağlara giden tek yol `g2`'nin üstündedir. - **TP22** — Rejimler yalnız inançta ayrılır; topoloji `g1–c` bağının varlığı dışında değişmez. Böylece ölçülen fark bilgi farkıdır, yapı farkı değil. - **TP23** — "Eş bağı" sütunu kırk akışın `g1–g2` bağını toplam kaç kez geçtiğini sayar. Bu bağ denetim trafiği için boyutlandırılır; kullanıcı trafiği taşıması bir belirtidir. - **TP24** — Bir paket aynı bağdan ikinci kez geçtiğinde ya da atlama sınırını (12) yaktığında **döngü** sayılır; bir sonraki düğümü artık komşu olmayan paket **kara delik** sayılır. - **TP25** — Adım sütunu yalnız harcanan adımı sayar; kara deliğe düşen paket öldüğü yere kadarki adımı harcamış olur. - **TP26** — Kırk akışlık kümede ölçülebilen en küçük fark 1/40 = 0,025'tir. #### Ölçüm ```python """Ag gecidi yedekliligi: devralma penceresinde paketin kaderi. Bolum 1 - rejimler: yakinsamis, pencere, yukari bag izleme, ikiye bolunme. Bolum 2 - duyan yaprak sayisi artarken kaderin degisimi. """ TOHUM = 20260810 ATLAMA_SINIRI = 12 YAPRAK = [f"y{i}" for i in range(1, 10)] UZAK = ["u1", "u2", "u3"] DUGUMLER = YAPRAK + ["g1", "g2", "c"] + UZAK BAGLAR = ([(y, g) for y in YAPRAK for g in ("g1", "g2")] + [("g1", "g2"), ("g1", "c"), ("g2", "c")] + [("c", u) for u in UZAK]) KOPUK = [b for b in BAGLAR if b != ("g1", "c")] def uretec(tohum): d = tohum % 2147483646 + 1 def r(n): nonlocal d d = (d * 48271) % 2147483647 return d % n return r def komsuluk(baglar): k = {u: set() for u in DUGUMLER} for x, y in baglar: k[x].add(y) k[y].add(x) return k def tablolar(yaprak_inanci, g1_inanci, g2_inanci): """Her dugumun uzak aglar icin tuttugu bir sonraki dugum.""" t = {} for y in YAPRAK: for u in UZAK: t[(y, u)] = yaprak_inanci[y] for g, es, inanc in (("g1", "g2", g1_inanci), ("g2", "g1", g2_inanci)): for u in UZAK: t[(g, u)] = "c" if inanc == g else es for u in UZAK: t[("c", u)] = u return t def ilet(kaynak, hedef, tab, baglar): k, u, gecilen, atlama = komsuluk(baglar), kaynak, [], 0 while u != hedef: if atlama >= ATLAMA_SINIRI: return "dongu", atlama sonraki = tab.get((u, hedef)) if sonraki is None or sonraki not in k[u]: return "kara delik", atlama if (u, sonraki) in gecilen: return "dongu", atlama gecilen.append((u, sonraki)) u, atlama = sonraki, atlama + 1 return "ulasti", atlama def ciftler(sayi=40, tohum=TOHUM): r, liste = uretec(tohum), [] while len(liste) < sayi: liste.append((YAPRAK[r(9)], UZAK[r(3)])) return liste def es_gecisi(tab, baglar): """Kirk akisin g1-g2 es bagini kac kez gectigi.""" k, say = komsuluk(baglar), 0 for x, y in ciftler(): u, gecilen, atlama = x, [], 0 while u != y and atlama < ATLAMA_SINIRI: v = tab.get((u, y)) if v is None or v not in k[u] or (u, v) in gecilen: break if {u, v} == {"g1", "g2"}: say += 1 gecilen.append((u, v)) u, atlama = v, atlama + 1 return say def olc(tab, baglar): sayim, adim = {"ulasti": 0, "dongu": 0, "kara delik": 0}, 0 for x, y in ciftler(): kader, a = ilet(x, y, tab, baglar) sayim[kader] += 1 adim += a return sayim, adim def inanc(duyan): return {y: ("g2" if y in duyan else "g1") for y in YAPRAK} HEPSI, HIC = set(YAPRAK), set() REJIM = [ ("yakınsamış, g1 etkin", BAGLAR, inanc(HIC), "g1", "g1"), ("yukarı bağ koptu, kimse duymadı", KOPUK, inanc(HIC), "g1", "g1"), ("g1 devretti, yapraklar duymadı", KOPUK, inanc(HIC), "g2", "g2"), ("g1 devretti, dört yaprak duydu", KOPUK, inanc(set(YAPRAK[:4])), "g2", "g2"), ("g1 devretti, hepsi duydu", KOPUK, inanc(HEPSI), "g2", "g2"), ("ikisi de kendini etkin sanıyor", BAGLAR, inanc(set(YAPRAK[:5])), "g1", "g2"), ("ikisi de eşini etkin sanıyor", BAGLAR, inanc(set(YAPRAK[:5])), "g2", "g1"), ] print(f"{'rejim':<32s} {'ulaştı':>6s} {'döngü':>6s} {'kara delik':>10s} " f"{'adım':>5s} {'eş bağı':>7s}") for ad, bag, yi, a1, a2 in REJIM: tab = tablolar(yi, a1, a2) s, a = olc(tab, bag) print(f"{ad:<32s} {s['ulasti']:6d} {s['dongu']:6d} {s['kara delik']:10d} " f"{a:5d} {es_gecisi(tab, bag):7d}") print() print(f"{'duyan yaprak':>12s} {'g1 devretmedi':>30s} {'g1 devretti':>30s}") print(f"{'':>12s} {'ulaştı kara delik adım eş':>30s}" f" {'ulaştı kara delik adım eş':>30s}") for n in range(0, 10): yi, sutun = inanc(set(YAPRAK[:n])), [] for g1i in ("g1", "g2"): tab = tablolar(yi, g1i, "g2") s, a = olc(tab, KOPUK) sutun.append(f"{s['ulasti']:9d}{s['kara delik']:11d}{a:5d}" f"{es_gecisi(tab, KOPUK):5d}") print(f"{n:12d} {sutun[0]} {sutun[1]}") print() print(f"düğüm {len(DUGUMLER)}, bağ {len(BAGLAR)}, akış 40, " f"atlama sınırı {ATLAMA_SINIRI}") ``` ``` rejim ulaştı döngü kara delik adım eş bağı yakınsamış, g1 etkin 40 0 0 120 0 yukarı bağ koptu, kimse duymadı 0 0 40 40 0 g1 devretti, yapraklar duymadı 40 0 0 160 40 g1 devretti, dört yaprak duydu 40 0 0 146 26 g1 devretti, hepsi duydu 40 0 0 120 0 ikisi de kendini etkin sanıyor 40 0 0 120 0 ikisi de eşini etkin sanıyor 0 40 0 120 80 duyan yaprak g1 devretmedi g1 devretti ulaştı kara delik adım eş ulaştı kara delik adım eş 0 0 40 40 0 40 0 160 40 1 4 36 48 0 40 0 156 36 2 7 33 54 0 40 0 153 33 3 9 31 58 0 40 0 151 31 4 14 26 68 0 40 0 146 26 5 18 22 76 0 40 0 142 22 6 24 16 88 0 40 0 136 16 7 29 11 98 0 40 0 131 11 8 34 6 108 0 40 0 126 6 9 40 0 120 0 40 0 120 0 düğüm 15, bağ 24, akış 40, atlama sınırı 12 ``` #### Yanıtlamak İletmek Değildir İkinci satır dersin en önemli sayısıdır. `g1–c` koptuğunda ve kimse duymadığında kırk akışın kırkı **kara deliğe** düşer. Harcanan adım **40**'tır — akış başına bir adım. Paket yaprağı terk eder, sanal adresi tutan geçide varır ve orada ölür. Arızanın biçimi budur: cihaz ayaktadır, bağlantı noktaları çalışır, sanal adres yanıtlanır ve konak varsayılan ağ geçidini erişilebilir bulur. Yalnız paket yukarı çıkmaz. **Sanal adresin sahibi ile paketi iletebilen ayrı sorulardır** ve konak yalnız birincisini sorabilir. #### Devretmek Kara Deliği Eş Bağına Çevirir Üçüncü satır arızayı kapatıyor: `g1` yukarı bağının koptuğunu fark edip devrettiğinde kırk akışın kırkı **ulaşır**, kara delik **0**'a iner. Yapraklar hâlâ hiçbir şey duymamıştır; `g1` onların paketini alıp eşine verir. Bedel iki sütunda birden görünür. Adım **120**'den **160**'a çıkar — akış başına bir fazladan adım. Ve `eş bağı` sütunu **0**'dan **40**'a çıkar: denetim trafiği için kurulmuş olan bağ, kullanıcı trafiğinin tamamını taşır. Alt tablo bu bedelin nasıl eridiğini gösteriyor. Duyan yaprak sayısı sıfırdan dokuza çıkarken, `g1 devretti` sütununda ulaşan **40**'ta sabit kalıyor; değişen şey adımın **160**'tan **120**'ye, eş bağı geçişinin **40**'tan **0**'a inmesidir. Devralma penceresi paketleri kaybettirmiyor; onları **eş bağı üzerinden** taşıtıyor ve pencere kapandıkça bu yük kalkıyor. Sol sütun aynı pencereyi devretme olmadan gösteriyor: duyan yaprak sayısı arttıkça ulaşan **0**'dan **40**'a, kara delik **40**'tan **0**'a doğrusal olarak akıyor. Sekiz yaprak duymuşken bile **6 akış** hâlâ ölü geçide gidiyor. #### Kısmî Bilgi Yine Döngü Üretiyor Son satır kursun ikinci iddiasını ikinci kez ödüyor. `g1` ve `g2` **birbirini etkin sandığında** kırk akışın kırkı **döngüye** girer: kara delik **0**, ulaşan **0**. Bu durum uydurma değildir. `g1` düşerken "artık etkin olan eşimdir" bilgisini almıştır; `g2`, `g1` döndüğünde "önceliği yüksek olan eşimdir" bilgisini almıştır. **İkisi de doğru bir şey duydu, ama farklı anlarda.** Yanlış olan ikisinin **birlikte** söylediğidir. İki sayı karşılaştırılmalıdır. Hiç bilginin olmadığı rejimde (`kimse duymadı`) kırk paket kara deliğe düşer, **40 adım** harcanır ve eş bağı **0** geçiş taşır: arıza ucuzdur ve bellidir. Kısmî bilginin olduğu rejimde kırk paket döngüye girer, **120 adım** harcanır ve eş bağı **80** geçiş taşır — akış başına iki geçiş. **Döngü kara delikten üç kat pahalıdır ve kara delik gibi değil, tıkanıklık gibi görünür:** yönetici boş bir bağ değil, dolu bir eş bağı görür. Üçüncü iddia da burada okunur. Döngüye giren kırk akışın yaprakları iki gruba ayrılmıştı; beşi `g1`'e, dördü `g2`'ye yolluyordu. Hangi grupta olduğu **hiç fark etmedi** — kırkı da döngüye girdi. Yaprağın tablosu doğruydu ve paketi öldü. **Hiçbir cihaz tek başına bir paketi döngüye sokamaz;** döngü çiftin ortak ürünüdür. Altıncı satır bir uyarı taşır. **İkisi de kendini etkin sandığında** — yani sanal adres iki cihazda birden yanıtlandığında — kader tablosu tertemiz görünür: **40 ulaştı, 0 döngü, 0 kara delik, 120 adım.** Bu ölçü **ikiye bölünmeyi göremez**, çünkü paketler gerçekten varır. Görülebileceği yer başka bir tablodadır: aynı adres iki bağlantı noktasından duyulduğunda eşleştirme tablosu iki kayıt arasında salınır. O tablo **Eşleştirme Tabloları** dersinin konusudur ve burada tekrarlanmaz. #### Sayılan Yüzeyler ve Daraltmaları Bu bölüm arızaların nasıl **göründüğünü** ve nasıl **daraltıldığını** yazar; bir yordam vermez. Saldırı tarafı **Kablosuz Ağlar ve Ağ Güvenliği** kursuna aittir. **Birinci yüzey — pencerenin uzunluğu.** Ölçümde devretme olmadan sekiz yaprak duymuşken hâlâ **6 akış** ölüyor. **Daraltma:** duyuru aralığının ve ölü sayacının kısaltılması pencereyi daraltır; bedeli, geçici bir aksamanın gereksiz bir devralma başlatmasıdır. İkinci daraltma yedek yolun **önceden** hesaplanmış olmasıdır: tablo devralma anında hesaplanmaz, hazır bekletilir. **İkinci yüzey — yanıtlayan ama iletemeyen geçit.** Ölçümde **40 kara delik** ve akış başına tek adım. **Daraltma: yukarı bağ izleme** — geçidin önceliği, yukarı bağının durumuna bağlanır; bağ düşünce öncelik düşer ve eş devralır. Ölçüm bu daraltmanın tam kazancını veriyor: kara delik **40**'tan **0**'a iner, karşılığında eş bağı **40** geçiş taşır. **Üçüncü yüzey — iki geçidin birbirini etkin sanması.** Ölçümde **40 döngü** ve eş bağında **80** geçiş. **Daraltma:** önceliklerin kesin ve eşitsiz sıralanması ve **önceliğin geri alınmasının (preemption)** kapatılması — dönen cihaz adresi geri istemezse iki taraflı bekleyiş doğmaz. Ayrıca atlama sınırı döngüyü sonlandırır, ama sınır bir çözüm değil bir tavandır: bedeli ölçümde **120 adım** olarak durur. **Dördüncü yüzey — eş bağının tek olması.** Eş bağı hem duyuruyu hem devralma sırasında bütün kullanıcı trafiğini taşır; ölçümde bu yük **40** geçiş. Bağ koptuğunda iki cihaz birbirini göremez ve ikiye bölünme doğar. **Daraltma:** eş bağının kendisinin yedeklenmesi ve eşin sağlığının **ikinci bir yoldan** doğrulanması — tek bir bağın sessizliği ölüm kanıtı sayılmaz. **Beşinci yüzey — duyuruların doğrulanmadan kabul edilmesi.** Devralma duyurusu bir bildirimdir; bildirimi doğrulayan bir şey yoksa geçidi hangi cihazın devraldığı bildirene kalır. **Daraltma:** duyuruların kimlik doğrulamasına bağlanması ve yalnız geçit çiftinin bulunduğu bağlantı noktalarında kabul edilmesi. #### Özet - Ağ geçidi yedekliliği iki cihazı tek bir sanal adresin arkasına koyar; konak adresi bilir, cihazları bilmez ve yalnız "adres yanıtlıyor mu" sorusunu sorabilir. - Yukarı bağ koptuğunda ve kimse duymadığında kırk akışın kırkı bir adım sonra kara deliğe düşer: **yanıtlamak iletmek değildir.** - Geçit devrettiğinde kara delik **0**'a iner ama adım **120**'den **160**'a, eş bağı geçişi **0**'dan **40**'a çıkar; duyan yaprak sayısı arttıkça ikisi de geri iner. - İki geçit birbirini etkin sandığında kırk akış döngüye girer: **120 adım** ve eş bağında **80** geçiş — hiç bilginin olduğu rejimin **üç katı** ve tıkanıklık görünümlü. - Yaprakların yarısı bir geçide, yarısı ötekine yollarken kırkı da döngüye girdi; döngü çiftin ortak ürünüdür ve **ikisi de kendini etkin sandığında** ölçü hiçbir şey göremez. #### Sonraki Adım Buraya kadarki üç ders topolojiyi bir çizge olarak ölçtü: düğümler, bağlar, adımlar, turlar. Tablo satırı sayısı her ölçümde bir sütun olarak göründü ve her seferinde topolojiden çıktı — üç katmanlı düzende 272, dört omurgalı düzende 468. Ama satır sayısını belirleyen ikinci bir şey daha vardır ve topolojiyle hiç ilgisi yoktur: hedeflerin **nasıl adlandırıldığı**. Aynı topolojide, adresleri bir düzene göre dağıtan bir plan ile büyüme sırasına göre dağıtan bir plan aynı tabloyu farklı sayıda satırla doldurur. Sonraki ders bu farkı sayar ve kursu kapatır. ### Adres ve Ad Planlaması Source: https://academia.sh/tr/kurslar/anahtarlama-ve-yonlendirme/adres-ve-ad-planlamasi Aynı topolojide özetlenebilir plan alt ağ sayısı dokuzdan otuz altıya çıkarken tablo satırını 73'te sabit tutar, büyüme sırasına göre dağıtılan plan aynı yolda 90 satırdan 335 satıra çıkar; taşınan tek bir ağ özeti sahip olmadığı adresi duyurur duruma sokar ve iki paket kara deliğe düşer. Önceki üç ders topolojiyi bir çizge olarak ölçtü ve tablo satırı her ölçümde bir sütun olarak göründü: üç katmanlı düzende 272, dört omurgalı düzende 468. Her seferinde satır sayısını belirleyen şey topolojiydi. Satır sayısını belirleyen ikinci bir şey daha vardır ve topolojiyle hiç ilgisi yoktur: hedeflerin **nasıl adlandırıldığı**. Aynı cihazlarda, aynı bağlarla, aynı sayıda alt ağla iki ayrı adres planı aynı tabloyu bambaşka sayıda satırla doldurur. Bu dersin sorusu, planın tabloya ne yaptığıdır. #### Planın Tek Koşulu Bir yönlendirme tablosu, komşu adresleri **tek bir satırda** özetleyebilir. Buna **yol özetleme** denir ve tek bir koşulu vardır: özetlenen aralıktaki bütün adresler **aynı bir sonraki düğümden** ulaşılabilir olmalıdır. Aralık hizalı olmalı ve içine başka bir yöne giden bir adres düşmemelidir. Alt ağ maskesi, hizalama ve blok adımı hesabı **Alt Ağlara Bölme** ve **Değişken Uzunluklu Alt Ağlar** derslerinde kuruldu; burada tekrarlanmaz. Ölçülen şey hesabın kendisi değil, hesabın **tablo satırına** etkisidir. Bir plan bu koşulu ya sağlar ya sağlamaz. Sağlayan plan adres uzayını topolojiyle aynı biçimde böler: her bloğa hizalı bir aralık, her aralığın içinde her yaprağa hizalı bir alt aralık ve her ikisinde **büyüme payı**. Sağlamayan plan adresleri tek bir havuzdan yaratılma sırasına göre dağıtır. ```text # ogretilen dokum , calistirilmamistir hizalı plan — 64 yuvalık uzay, dört blok, üçü kullanılıyor blok 0 yuva 0-15 y1: 0-3 y2: 4-7 y3: 8-11 12-15 büyüme payı blok 1 yuva 16-31 blok 2 yuva 32-47 blok 3 48-63 ayrılmış c1'in tablosu: 0-15 -> d1 16-31 -> d3 32-47 -> d5 büyüme sırasına göre plan — tek havuz, yaratılma sırası yuva 0 -> y1 yuva 1 -> y2 yuva 2 -> y3 yuva 3 -> y4 ... ardışık iki yuva ayrı bloklara düşer; özetlenecek aralık doğmaz ``` Ölçümün dayandığı varsayımlar: - **TP27** — Topoloji birinci dersin üç katmanlı düzenidir: dokuz yaprak, üç blok, altı dağıtım ve iki çekirdek düğümü. Topoloji iki planda da aynıdır; değişen tek şey plandır. - **TP28** — Adres uzayı 64 yuvadır ve yuva bir alt ağı temsil eder. Hizalı planda her blok 16, her yaprak 4 yuva alır; yaprak başına `k` yuva kullanılır, kalanı büyüme payıdır. - **TP29** — Satır sayısı, bir düğümün tablosunu kaplayan **en az sayıda hizalı önek** olarak sayılır. Boş yuva bir öneğin içine düşebilir; başka yöne giden bir yuva düşemez. - **TP30** — Kâhin topolojiyi biz kurduğumuz için bilinir ve her düğüm için her yaprağa giden en kısa yolun ilk adımıdır. Paket en uzun önek eşlemeyle yürütülür. - **TP31** — Ad bölgesi sayısı, adlar plandaki sırayla dizildiğinde blok değiştirmeden sayılabilen en az aralık sayısıdır. Ad çözümlemenin kendisi **Alan Adı Sistemi** dersinin konusudur ve burada tekrarlanmaz. - **TP32** — Kırk paketlik kümede ölçülebilen en küçük fark 1/40 = 0,025'tir. #### Ölçüm ```python """Adres ve ad plani: planin tablo satir sayisina etkisi. Bolum 1 - hizali plan ile buyume sirasina gore plan, yaprak basina 1-4 alt ag. Bolum 2 - ozetin sahip olmadigi adresi duyurmasi. """ TOHUM = 20260810 YUVA = 64 YAPRAK = [f"y{i}" for i in range(1, 10)] BLOK = {0: YAPRAK[0:3], 1: YAPRAK[3:6], 2: YAPRAK[6:9]} DAGITIM = {"d1": 0, "d2": 0, "d3": 1, "d4": 1, "d5": 2, "d6": 2} DUGUMLER = YAPRAK + sorted(DAGITIM) + ["c1", "c2"] BAGLAR = ([(y, d) for d, b in DAGITIM.items() for y in BLOK[b]] + [(d, c) for d in sorted(DAGITIM) for c in ("c1", "c2")] + [("c1", "c2")]) def uretec(tohum): d = tohum % 2147483646 + 1 def r(n): nonlocal d d = (d * 48271) % 2147483647 return d % n return r def komsuluk(): k = {u: set() for u in DUGUMLER} for x, y in BAGLAR: k[x].add(y) k[y].add(x) return k def kahin(): """Her dugum icin her hedefe giden en kisa yolun ilk adimi.""" k, tablo = komsuluk(), {} for kaynak in DUGUMLER: onceki, sira = {}, [kaynak] while sira: yeni = [] for u in sira: for v in sorted(k[u]): if v != kaynak and v not in onceki: onceki[v] = u yeni.append(v) sira = yeni for h in onceki: adim = h while onceki[adim] != kaynak: adim = onceki[adim] tablo[(kaynak, h)] = adim return tablo def hizali(k): """Her blok 16, her yaprak 4 yuva; k tanesi dolu, kalani buyume payi.""" return {16 * b + 4 * j + i: y for b, yapraklar in BLOK.items() for j, y in enumerate(yapraklar) for i in range(k)} def buyume_sirasi(k): """Alt aglar yaratilma sirasina gore tek havuzdan verilir.""" return {n: YAPRAK[n % 9] for n in range(9 * k)} def onekler(u, plan, bas=0, boy=YUVA): """u dugumunun tablosunu kaplayan en az sayida hizali onek.""" ic = {("yerel" if y == u else T[(u, y)]) for yuva, y in plan.items() if bas <= yuva < bas + boy} if len(ic) < 2: return [(bas, boy, ic.pop())] if ic else [] return (onekler(u, plan, bas, boy // 2) + onekler(u, plan, bas + boy // 2, boy // 2)) def ilet(kaynak, yuva, onek, komsu, gercek): """En uzun onek eslemeyle yurutur; varis gercek eve bakilarak sinanir.""" u, atlama = kaynak, 0 while atlama < 12: aday = [o for o in onek[u] if o[0] <= yuva < o[0] + o[1]] if not aday: return "kara delik" v = min(aday, key=lambda o: o[1])[2] if v == "yerel": return "ulasti" if gercek.get(yuva) == u else "kara delik" if v not in komsu[u]: return "kara delik" u, atlama = v, atlama + 1 return "dongu" def ciftler(sayi=40, tohum=TOHUM): r, liste = uretec(tohum), [] while len(liste) < sayi: x, y = YAPRAK[r(9)], YAPRAK[r(9)] if x != y: liste.append((x, y)) return liste def bolge(plan): """Ad dizisinde blok degistirmeden sayilabilen en az bolge sayisi.""" onceki, say = None, 0 for _, y in sorted(plan.items()): b = next(i for i, ys in BLOK.items() if y in ys) if b != onceki: say, onceki = say + 1, b return say def olc(plan, hedef=None, gercek=None): """Satirlar plandan, hedefler adres planindan, varis gercek evden.""" hedef, gercek = hedef or plan, gercek or plan komsu = komsuluk() onek = {u: onekler(u, plan) for u in DUGUMLER} ilk, sayim = {}, {"ulasti": 0, "dongu": 0, "kara delik": 0} for yuva, y in sorted(hedef.items()): ilk.setdefault(y, yuva) for x, y in ciftler(): sayim[ilet(x, ilk[y], onek, komsu, gercek)] += 1 return sum(len(o) for o in onek.values()), len(onek["c1"]), sayim T = kahin() print(f"{'plan':<14s} {'yaprak başına':>13s} {'alt ağ':>6s} " f"{'toplam satır':>12s} {'c1':>3s} {'ad bölgesi':>10s} {'ulaştı':>6s}") for ad, kur in (("hizalı", hizali), ("büyüme sırası", buyume_sirasi)): for k in (1, 2, 3, 4): plan = kur(k) satir, c1, s = olc(plan) print(f"{ad:<14s} {k:13d} {len(plan):6d} {satir:12d} {c1:3d} " f"{bolge(plan):10d} {s['ulasti']:6d}") print() ev = hizali(4) tasinan = {yuva: ("y1" if y == "y9" else y) for yuva, y in ev.items()} print(f"{'durum':<32s} {'toplam satır':>12s} {'c1':>3s} {'ulaştı':>6s} " f"{'kara delik':>10s}") for ad, plan, ger in (("plan yerinde", ev, None), ("taşındı, özet güncellenmedi", ev, tasinan), ("taşındı, ayrı satır eklendi", tasinan, tasinan)): satir, c1, s = olc(plan, ev, ger) print(f"{ad:<32s} {satir:12d} {c1:3d} {s['ulasti']:6d} " f"{s['kara delik']:10d}") ``` ``` plan yaprak başına alt ağ toplam satır c1 ad bölgesi ulaştı hizalı 1 9 73 3 3 40 hizalı 2 18 73 3 3 40 hizalı 3 27 73 3 3 40 hizalı 4 36 73 3 3 40 büyüme sırası 1 9 90 6 3 40 büyüme sırası 2 18 171 12 6 40 büyüme sırası 3 27 249 17 9 40 büyüme sırası 4 36 335 24 12 40 durum toplam satır c1 ulaştı kara delik plan yerinde 73 3 40 0 taşındı, özet güncellenmedi 73 3 38 2 taşındı, ayrı satır eklendi 76 4 40 0 ``` #### Satır Sayısı Alt Ağ Sayısından Bağımsız Olabilir Üst tablonun ilk dört satırı dersin tamamıdır. Hizalı planda alt ağ sayısı **9**'dan **36**'ya çıkarken toplam tablo satırı **73**'te kalıyor. Dört katına çıkan bir ağ, tablosuna **tek bir satır** eklemiyor. Çekirdeğin tablosu **3** satırda duruyor: blok başına bir önek. Alt dört satır aynı topolojiyi büyüme sırasına göre dağıtılmış adreslerle gösteriyor. Toplam satır **90**, **171**, **249**, **335** diye tırmanıyor — alt ağ sayısıyla doğrusal. Otuz altı alt ağda fark **73**'e karşı **335**, yani **4,6 kat**. Çekirdeğin tablosu **3** yerine **24** satır tutuyor. Aradaki farkın kaynağı tek bir koşuldur. Hizalı planda bir bloğun bütün adresleri aynı bir sonraki düğümden ulaşılır, bu yüzden tek önek hepsini kaplar. Büyüme sırasına göre dağıtılan planda ardışık iki adres ayrı bloklara düşer; kaplanabilecek hiçbir aralık kalmaz ve tablo adres başına bir satıra iner. `ad bölgesi` sütunu aynı hesabı adlarda tekrarlıyor. Hizalı planda adlar plandaki sırayla dizildiğinde **3** aralık çıkıyor — blok başına bir bölge. Büyüme sırasına göre dizilen adlarda sayı **3**, **6**, **9**, **12** diye büyüyor. Ad planı ayrı bir tasarım değildir; adres planının aynı sorusudur ve aynı hesapla ölçülür. Bir şey değişmiyor: `ulaştı` sütunu sekiz satırın sekizinde de **40**. Plan paketi kaybettirmez, yalnız tabloyu büyütür. Planın bedeli gecikmede değil, **taşınan durumdadır.** #### Özetin Sahip Olmadığı Adres Alt tablo özetin tek zayıf noktasını ölçüyor. `y9`'a bağlı ağlar başka bir yaprağa taşınmış ve adresleri değişmemişse tablolar hiç değişmez — toplam satır yine **73**, çekirdek yine **3**. Ama kırk paketin **2**'si kara deliğe düşer. Sebep şudur: çekirdeğin `32-47 -> d5` satırı artık **sahip olmadığı bir adresi** duyuruyor. Özet, kapsadığı her adresin o yönde olduğunu söyler; taşınan ağ o yönde değildir. Özet yanlış değil, **fazla kapsayıcıdır** — ve fazla kapsayan bir doğru, bir yanlıştır. Onarım son satırdadır. Taşınan ağ için ayrı ve daha dar bir satır eklenirse kırk paketin kırkı ulaşır; bedeli toplam **73**'ten **76**'ya, çekirdekte **3**'ten **4**'e çıkan satırdır. Üç satır küçük görünür, ama kural bellidir: **her istisna bir satırdır ve istisnalar birikir.** Plan, tabloyu büyümekten koruyan tek şeydir; korumayı sürdürmenin yolu ise taşınan ağı yeniden numaralandırmaktır. #### Özet - Yol özetlemenin tek koşulu, özetlenen aralıktaki bütün adreslerin **aynı bir sonraki düğümden** ulaşılabilir olmasıdır; plan bu koşulu ya sağlar ya sağlamaz. - Hizalı planda alt ağ sayısı **9**'dan **36**'ya çıkarken toplam satır **73**'te, çekirdeğin tablosu **3**'te kalır. - Büyüme sırasına göre dağıtılan planda aynı topoloji **90**, **171**, **249**, **335** satır tutar; otuz altı alt ağda fark **4,6 kattır**. - Ad planı ayrı bir tasarım değildir: ad bölgesi sayısı hizalı planda **3**'te kalır, büyüme sırasına göre dizilen adlarda **3**'ten **12**'ye çıkar. - Taşınan tek bir ağ özeti sahip olmadığı adresi duyurur hâle getirir ve **2** paket kara deliğe düşer; ayrı satır eklemek onarır ama satırı **73**'ten **76**'ya çıkarır. #### Kurs Kapanışı Kurs tek bir soruyla açıldı: karar iletide yazandan değil cihazın **kendi tablosundan** okunuyorsa ve o tablo paylaşılan bir gerçeğin **kopyasıysa**, kopyalar anlaşmadığı sürede pakete ne olur? On yedi ders bu soruyu on yedi ayrı anlaşmazlıkla sordu ve hepsinde aynı üç kaderi saydı. | ders | ölçülen anlaşmazlık | ulaşan | döngü ya da kara delik | |---|---|---|---| | Yineleyici, Hub ve Anahtar | tablonun hiç olmaması | 40 çerçeve, 280 teslim | yok; 240 gereksiz kopya, 34 çakışma | | Eşleştirme Tabloları | girdinin yaşı | 110 teslim, ömür kısalınca 278 | 3 kara delik, ömür kısalınca 0 | | Sanal Yerel Ağlar | bölütün sınırı ile tablonun kapsamı | taşırma teslimi 280, 51, 8 | kara delik 0, 23, 29, 32 | | Kapsayan Ağaç Protokolü | ağaç yenilendi, tablolar eski | ağaçta 40/40, 106 ve 129 adım | 19 ve 20 kara delik; iki anahtar tazeleyince 10 döngü | | Bağlantı Toplama | bacak eşlemesi ile bacağın durumu | 8 akış bölünmeden dağıtılır | beş çerçevelik pencerede 2 kara delik | | Yönlendirme Kararı | kopyanın yaşı ve okuma kuralı | yakınsamış 40/40, 83 ve 99 adım | kopma anında 14 kara delik | | Statik ve Dinamik Yönlendirme | statik tablo kopmayı hiç duymaz | dinamikte iki turda 40 | statikte 14 kara delik altı tur sabit; iki düğüm duyunca 6 döngü | | Uzaklık Vektörü Protokolleri | komşunun kararının yaşı | 0, 9, 20, 32, 40 — dört tur | erişilemez hedefte 60 paketin altmışı döngü; geri bildirmeme 5'e indirir | | Bağlantı Durumu Protokolleri | veritabanının eksik girdisi | 9, 20, 32, 40 — üç tur | döngü yok; yanlış tablo yalnız eksik girdiden | | Sınır Ağ Geçidi Protokolü | politika ile en kısa yol | transit yasağında 40/40, 92 adım | duyuru kapanınca 14 kara delik; sızıntıda 7 paket sözleşme dışı | | Yönlendirme Örnekleri | aynı hedefin iki örnekteki iki kararı | üç örnekte 40/40, 83, 99, 91 adım | tek tabloya indirgenince 14 kara delik | | MPLS ve Etiket Anahtarlama | etiket yolu ile alttaki bağın durumu | 40 tam bakış ve 43 etiket bakışı | kiriş kopup yol yenilenmeyince 14 kara delik | | Kaplama Ağları | kaplamanın tablosu ile alt ağ düzeninin tablosu | iki katman yakınsamışken 40/40, kaplama 74 adım | alt ağ düzeni eskiyken 21 tünel kara deliği; tünel kalkıp iki uç duyunca 12 kaplama döngüsü | | Katmanlı Tasarım | soğuk başlangıç ve en yoğun bağın kopması | üç tasarımda 40/40; 121, 80, 138 adım | düz zincirde 21 kalıcı kara delik | | Omurga–Yaprak Tasarımı | bir yaprak–omurga bağının kaybı | 40/40, 80 adım, her yol 2 adım | tek omurgada 14 kalıcı kara delik, ikiden itibaren 0 | | Yedeklilik ve Devralma | sanal adresin kimde olduğu | devretme varken 40/40 | kimse duymayınca 40 kara delik; ikisi de eşini etkin sanınca 40 döngü | | Adres ve Ad Planlaması | özetin kapsadığı ile sahip olduğu | 73 satırla 40/40 | taşınan ağda 2 kara delik | Tablo üç şeyi tekrar tekrar söylüyor. **Kısmî bilgi, hiç bilgiden pahalı bir arıza üretir:** kimsenin duymadığı kopma kara delik verir ve arıza bellidir; birkaç düğümün duyduğu kopma döngü verir ve tıkanıklık gibi görünür. **Hiçbir cihaz tek başına bir paketi döngüye sokamaz:** döngü en az iki tablonun anlaşmazlığıdır ve tablosu doğru olan bir düğümden çıkan paket de ölebilir. Ve **yakınsama bir hız değil bir tur sayısıdır:** kaç turda bittiği, bilginin ne kadar uzaktan taşındığına bağlıdır. Bütün bu ölçümlerin ortak bir sessiz kabulü vardı. Bir bağ ya vardır ya yoktur; komşu ya duyar ya duymaz; çerçeve ya iletilir ya iletilmez. İki cihaz arasında bir kablo varsa o kablonun taşıdığı şey karşı tarafa **ulaşır** — kurs boyunca kopma dışında bunun tersi hiç düşünülmedi. Sonraki kurs bu kabulü kaldırır: kablosuz bir bağda iletilen çerçevenin varması bir kesinlik değil bir **olasılıktır**, ortam paylaşılır ve dinleyenin kim olduğu bilinmez. Kablolu bağın verili saydığı her şey orada yeniden sorulacak.