
Go Çalışma Zamanı: Goroutine Zamanlayıcı ve Çöp Toplayıcı Mimarisi
Go dilinin GMP iş parçacığı modeli, work-stealing mekanizması, mcache bellek yönetimi ve concurrent mark-sweep çöp toplayıcı mimarisi analizi.
Eşzamanlılık mimarisi kurarken doğrudan işletim sistemi iş parçacıklarıyla (thread) uğraşmak yüksek bellek ve bağlam geçişi (context switch) yükü getirir. Go derleyicisinin ürettiği her çalıştırılabilir dosya, arka planda gelişmiş bir çalışma zamanı (runtime) katmanı barındırır. Bu çalışma zamanı, binlerce goroutine yapısını az sayıda işletim sistemi iş parçacığı üzerinde koşturur, bellek tahsisatını yönetir ve kullanılmayan nesneleri temizler. Süreç soyut bir sihir değildir. Doğrudan Linux çekirdeği sistem çağrıları ve bellek sayfaları üzerinde çalışan planlı bir yazılım mimarisidir.
İncelemenin odağında Go 1.14 ile Go 1.24 sürümleri arasındaki temel çalışma zamanı bileşenleri yer almaktadır. Yazı boyunca goroutine zamanlayıcısının GMP modeli, iş çalma (work-stealing) algoritması, sysmon arka plan izleyicisi, asenkron kesinti mekanizması, TCMalloc esintili bellek havuzları ve hibrit yazma bariyerine sahip üç renkli çöp toplayıcı mekanik düzeyde ele alınacaktır. Cgo çağrılarının iç ABI ayrıntıları ve derleyicinin SSA optimizasyon adımları kapsam dışındadır.
GMP Modeli: Goroutine, Machine ve Processor Ayrımı
Zamanlayıcı katmanı M:N iş parçacığı modelini uygular. Bu yapıda M adet kullanıcı seviyesi goroutine, N adet işletim sistemi iş parçacığına dağıtılır. Çekirdek kaynak kodundaki runtime/proc.go dosyasında bu döngü üç temel yapı taşıyla tanımlanır:
- G (Goroutine): Yürütülen bağımsız bir iş parçacığıdır. İşletim sistemi iş parçacıklarının megabaytlar düzeyindeki sabit yığın alanı yerine 2 KB başlangıç yığınıyla oluşturulur. İhtiyaç halinde yığın boyutu dinamik biçimde büyütülür veya küçültülür. G yapısı program sayacını (PC), yığın sınırlarını ve yürütme durumunu (
_Grunnable,_Grunning,_Gwaiting,_Gsyscall) bünyesinde saklar. - M (Machine): İşletim sisteminin doğrudan çekirdek seviyesinde oluşturduğu standart iş parçacığıdır (Linux üzerinde
cloneveyapthread_createçıktısı). Bir M, Go kodunu tek başına yürütemez. Kod koşturmak için bir mantıksal işlemciye (P) bağlanması gerekir. - P (Processor): Mantıksal işlemciyi temsil eder. Sistemdeki işlem gücünü ve kaynak hakkını simgeler. Toplam P sayısı
GOMAXPROCSparametresi ile sınırlandırılmıştır ve varsayılan olarak makinenin CPU çekirdek sayısına eşittir. P yapısı, üzerinde çalıştırılacak goroutine kuyruklarını ve yerel bellek önbelleğini barındırır.
Bir M çekirdekte çalışırken tek bir P ile eşleşir. P bağlantısı olmadan M yalnızca işletim sistemi sistem çağrısında veya Cgo kodunda bekleyebilir.
Yerel Kuyruklar ve Work-Stealing Algoritması
Klasik sistemlerde tüm iş parçacıkları tek bir merkezi kuyruktan iş çeker. Merkezi kuyruk yoğun trafikte kilit çekişmesine (lock contention) yol açar. Go zamanlayıcısı bu sorunu kuyrukları işlemcilere dağıtarak çözer.
Her P yapısı 256 eleman kapasiteli dairesel bir yerel çalıştırma kuyruğuna (local runqueue) sahiptir. Bu dairesel diziye erişim yalnızca o P'ye bağlı olan M tarafından yapıldığı için kilit korumasına gerek duyulmaz. Ayrıca P üzerinde runnext adı verilen tek elemanlık özel bir öncelik yuvası bulunur. Yeni oluşturulan veya bir kanaldan uyandırılan goroutine doğrudan runnext yuvasına yerleştirilir. Veri yerelliği (cache locality) korunur. İşlem hızlanır.
+-----------------------------------------------------------------+
| KÜRESEL KUYRUK (sched.runq) |
| (Kilit korumalı: sched.lock) |
+-----------------------------------------------------------------+
^ ^
| (Her 61 çevrimde bir) | (Taşma / Çalma)
v v
+------------------+ +------------------+
| İşlemci (P 0) | | İşlemci (P 1) |
| runnext: [ G ] | | runnext: [ G ] |
| Yerel: [256 G] | | Yerel: [256 G] |
| mcache havuzu | | mcache havuzu |
+------------------+ +------------------+
| |
v (1:1 Bağlantı) v (1:1 Bağlantı)
+------------------+ +------------------+
| OS Thread (M 0) | | OS Thread (M 1) |
| Yürütülen: G 1 | | Yürütülen: G 2 |
+------------------+ +------------------+
Bir P yerel kuyruğundaki işleri bitirdiğinde durmaz. Zamanlayıcının findrunnable fonksiyonu devreye girer ve iş arama protokolünü şu sıralamayla yürütür:
- Öncelikli yuva ve yerel kuyruk kontrolü: Kendi
runnextyuvası ve 256 elemanlık yerel dairesel dizisi taranır. - Küresel kuyruk kontrolü: Açlık (starvation) durumunu engellemek amacıyla
schedule()döngüsü her 61 zamanlayıcı çevriminde bir (sched.tick % 61 == 0) yerel kuyruğu atlayıp doğrudan küresel kuyruktan (sched.runq) bir goroutine alır. Boşta kalan P de yerel işi yoksa küresel kuyruğu kontrol eder. - Ağ poller (netpoller) kontrolü: Ağ soketlerinden veya dosya tanımlayıcılarından yanıt bekleyen goroutine olup olmadığı epoll benzeri mekanizmalar üzerinden incelenir.
- İş çalma (Work-Stealing): Sistemdeki diğer P yapıları rastgele taranır. Kurban olarak seçilen dolu bir P'nin yerel kuyruğundaki goroutine sayısının yarısı çalınarak (
runqsteal) boş işlemcinin kuyruğuna aktarılır. - Uyku modu: Dört rastgele arama denemesinden sonra iş bulunamazsa M işletim sistemi iş parçacığı uykuya alınır (
stopm) ve P boşta (idle) listesine eklenir.
Dağıtık kuyruk tasarımı, CPU çekirdekleri arasındaki iş yükünü dengelerken kilit bekleme maliyetlerini azaltır.
sysmon Arka Plan İzleyicisi ve Asenkron Preemption
Kullanıcı kodundan bağımsız çalışan özel bir işletim sistemi iş parçacığı mevcuttur. Bu iş parçacığı sysmon (system monitor) olarak adlandırılır. Çalışmak için bir P mantıksal işlemcisine ihtiyaç duymaz. Doğrudan çekirdek seviyesinde çalışır. Uyku periyodu sistem yüküne göre 20 mikrosaniyeden 10 milisaniyeye kadar dinamik olarak değişir.
İzleme birimi olan sysmon çalışma zamanında iki temel görevi yerine getirir:
- Sistem çağrısı kurtarma (handoffp): Bir goroutine engellenen bir sistem çağrısı (
syscall) yaptığında bağlı olduğu M iş parçacığı çekirdekte beklemeye başlar. Eğer bu sistem çağrısı 10 milisaniyeden uzun sürerse veya kuyrukta bekleyen başka işler varsa,sysmondevreye girerek P yapısını o M'den ayırır (handoffp). Boşa çıkan P, başka bir M iş parçacığına bağlanarak kuyruğundaki diğer goroutine yapılarını çalıştırmaya devam eder. Sistem çağrısı tamamlanan eski M ise yeni bir P bulmaya çalışır, bulamazsa goroutine yapısını küresel kuyruğa bırakıp uykuya dalar. - Asenkron preemption tetikleme: Go 1.14 öncesinde zamanlayıcı işbirlikçi (cooperative) yapıdaydı. Bir goroutine yalnızca fonksiyon girişlerinde derleyici tarafından yerleştirilen yığın kontrol noktalarında (
morestack) kesintiye uğrayabiliyordu. Fonksiyon çağrısı içermeyen sıkı bir döngü (for {}), üzerinde çalıştığı M iş parçacığını tekeline alarak zamanlayıcının diğer işleri yürütmesini engelleyebiliyordu.
Geliştiricilerin yaşadığı bu kilitlenme sorunu Go 1.14 sürümünde sinyal tabanlı asenkron preemption ile çözüldü. Eğer bir goroutine kesintisiz olarak 10 milisaniyeden uzun süre tek bir P üzerinde çalışırsa, sysmon o M iş parçacığına işletim sistemi seviyesinde SIGURG sinyali gönderir. İş parçacığının sinyal yakalayıcısı (sighandler) devreye girer. Sinyal anında işlemci yazmaçları (registers) güvenli biçimde kaydedilir ve yığına bir asyncPreempt çağrısı enjekte edilir. Goroutine yürütmesi güvenli bir noktada durdurularak küresel kuyruğa taşınır. İşlemci serbest kalır.
TCMalloc Esinli Bellek Mimarisi: mcache, mcentral ve mheap
Bellek yönetimi Google tarafından tasarlanan TCMalloc mimarisinden esinlenmiştir. Amaç, çok çekirdekli sistemlerde bellek ayırma çağrılarının tek bir merkezi kilit üzerinde yığılmasını önlemektir. Bellek tahsisatı hiyerarşik üç ana katmandan oluşur:
+---------------------------------------------------------------+
| mheap (Sayfa Düzeyi Bellek) |
| (Linux mmap ile alınan sanal bellek, radix tree index) |
+---------------------------------------------------------------+
^
| mspan isteği
v
+---------------------------------------------------------------+
| mcentral (Boyut Sınıfı Havuzu) |
| (67 boyut sınıfı, partial ve full listeleri) |
+---------------------------------------------------------------+
^ ^
| mspan yükleme | mspan yükleme
v v
+-----------------------+ +-----------------------+
| mcache (İşlemci 0) | | mcache (İşlemci 1) |
| (136 mspan, kilit yok) | | (136 mspan, kilit yok) |
| tiny allocator | | tiny allocator |
+-----------------------+ +-----------------------+
- mcache (İşlemciye Özel Önbellek): Her P yapısının kendine ait bağımsız bir
mcachealanı vardır. Bir goroutine bellek tahsis etmek istediğinde bağlı olduğu P'nin yerelmcachehavuzuna başvurur. Aynı anda tek bir P üzerinde yalnızca tek bir M çalışabildiğinden bu işlemde kilit kullanılmaz.mcache, 8 bayttan 32 KB'a kadar değişen 67 farklı boyut sınıfına (size class) bölünmüştür. Her boyut sınıfı işaretçi içeren (scan) ve işaretçi içermeyen (noscan) olmak üzere ikiye ayrılır. Böylece toplam 136 adetmspanyapısı tutulur. Ayrıca 16 bayttan küçük ve işaretçi içermeyen nesneler içintiny allocatorkullanılır. Birden fazla küçük değişken tek bir 16 baytlık blok içinde birleştirilerek iç parçalanma azaltılır. - mcentral (Merkezi Boyut Havuzu): Bir
mcacheiçinde belirli bir boyut sınıfına ait boş yer tükendiğinde, merkezimcentralhavuzundan yeni birmspantalep edilir.mcentraltüm işlemciler tarafından paylaşıldığı için kilit mekanizmasına (mcentral.lock) sahiptir. Her boyut sınıfı için iki bağlı liste tutulur: boş yuvaları olan bloklar (partial) ve dolu bloklar (full). - mheap (Küresel Bellek Yığını): Merkezi havuzda da boş span kalmadığında sistem
mheapkatmanına başvurur.mheap, belleği 8 KB boyutundaki sayfalar (pages) halinde yönetir. Sayfa tahsisatı için radix tree tabanlı sayfa arayıcısı (page allocator) kullanılır. Fiziksel bellek işletim sistemindenmmapsistem çağrısıyla talep edilir. Kullanılmayan boş sayfalarsysmontarafından belirli aralıklarlamadvise(MADV_DONTNEED)çağrısıyla işletim sistemi çekirdeğine geri bırakılır.
Eşzamanlı Tri-Color Mark & Sweep Çöp Toplayıcı
Çöp toplayıcı mimarisi eşzamanlı (concurrent) çalışan üç renkli işaretle ve süpür algoritmasını kullanır. Algoritma nesneleri işaretleme aşamasında üç soyut renk kümesine ayırır:
- Beyaz: Henüz ulaşılmamış ve taranmamış nesnelerdir. İşaretleme döngüsünün başında tüm nesneler beyaz kabul edilir. Döngü bittiğinde beyaz kalan nesneler ulaşılamaz kabul edilerek bellekten temizlenir.
- Gri: Kendisine kök nesnelerden (stack, global değişkenler, register'lar) ulaşılmış ancak işaret ettiği alt nesneler henüz taranmamış ara nesnelerdir. Gri nesneler bir çalışma kuyruğunda (
gcWork) tutulur. - Siyah: Kendisi taranmış ve işaret ettiği tüm alt referanslar gri kuyruğuna eklenmiş canlı nesnelerdir. Siyah nesneler doğrudan beyaz bir nesneye referans veremez.
Çöp toplayıcının yaşam döngüsü dört ana evrede tamamlanır:
[Mark Setup] ---> [Concurrent Mark] ---> [Mark Termination] ---> [Concurrent Sweep]
(STW: ~20µs) (CPU %25 ayrılır) (STW: ~30µs) (Arka planda)
(Yazma bariyeri (Gri nesneler taranır, (Yazma bariyeri (Beyaz span'ler
açılır) kullanıcı kodu sürer) kapatılır) temizlenir)
- Mark Setup (STW): Çöp toplayıcı döngüsü başladığında tüm işlemciler kısa süreliğine durdurulur (Stop-the-World). Bu duraklama sırasında yazma bariyeri (write barrier) etkinleştirilir. STW süresi genellikle 10 ile 30 mikrosaniye arasındadır.
- Concurrent Marking: Dünya yeniden başlatılır ve kullanıcı goroutine'leri çalışmaya devam eder. Toplam CPU kapasitesinin varsayılan olarak yüzde 25'i işaretleme goroutine'lerine tahsis edilir. Gri kuyruğundaki nesneler taranarak siyah yapılır, işaret ettikleri beyaz nesneler griye dönüştürülür. Eğer kullanıcı kodu tahsisat hızını çok artırırsa, çalışma zamanı o goroutine'i işaretleme işine yardım etmeye zorlar (
mark assist). - Mark Termination (STW): İşaretleme tamamlandığında ikinci bir duraklama yapılır. Kök nesnelerin son durumu teyit edilir ve yazma bariyeri devre dışı bırakılır. Bu faz genellikle 20 ile 50 mikrosaniye sürer.
- Concurrent Sweep: STW sonlandırılır. Süpürme işlemi kullanıcı koduyla eşzamanlı yürütülür. Canlı nesne barındırmayan
mspanblokları boşa çıkarılarak yeniden kullanılmak üzeremcentralhavuzuna teslim edilir.
Hibrit Yazma Bariyeri (Hybrid Write Barrier) ve Ek Yükü
Eşzamanlı çöp toplamanın teknik riski, kullanıcı kodunun (mutator) işaretleme sürerken nesne ilişkilerini değiştirebilmesidir. Eğer siyah bir nesne yeni bir beyaz nesneye referans verirse ve o beyaz nesneye olan gri referans silinirse, çöp toplayıcı beyaz nesneyi gözden kaçırır. Bu durum canlı bir nesnenin yanlışlıkla silinmesine ve bellek bozulmasına yol açar.
Bahsedilen veri kaybı riskini ortadan kaldırmak için Go 1.8 sürümünde Dijkstra (ekleme bariyeri) ve Yuasa (silme bariyeri) yaklaşımlarını birleştiren hibrit yazma bariyeri (hybrid write barrier) devreye alınmıştır.
// Çalışma zamanındaki hibrit yazma bariyeri mantığı (runtime/mbarrier.go)
func gcWriteBarrier(dst *uintptr, src uintptr) {
slot := *dst
if slot != 0 {
shade(slot) // Silinen eski referansı griye boya (Yuasa stili)
}
shade(src) // Eklenen yeni referansı griye boya (Dijkstra stili)
*dst = src
}
Hibrit yazma bariyerinin getirdiği en somut kazanım yığın taraması üzerindedir. Klasik modellerde yığın üzerindeki yazmalara da bariyer koymak gerekirdi veya Mark Termination sırasında tüm yığınların baştan taranması (stack rescan) için uzun STW duraklamaları yapılırdı. Go hibrit bariyerinde goroutine yığınları işaretleme başında taranır ve doğrudan siyah kabul edilir. Yığın içi yazmalarda bariyer çalıştırılmaz. Bariyer yalnızca heap üzerindeki işaretçi güncellemelerinde devreye girer. Böylece STW süreleri milisaniyelerden mikrosaniyelere indirilmiştir.
Fakat yazma bariyerinin belirgin bir işlemci maliyeti bulunur. İşaretleme fazı boyunca her heap işaretçi güncellemesinde ek dallanma ve bellek erişimi yapılır. Bellek tahsisatı yoğun uygulamalarda CPU kullanımı artar.
Üretim Ortamı Yapılandırması ve Çalışma Zamanı İzleme
Çalışma zamanının varsayılan ayarları genel iş yükleri için dengelenmiştir ancak yüksek verimli sistemlerde ince ayar gerektirir:
- GOMEMLIMIT (Go 1.19+): Go bellek sınırını belirlemek için kullanılır. Konteyner ortamlarında (Kubernetes) pod sınırının yüzde 85-90 seviyesine ayarlandığında, OOM (Out of Memory) sebebiyle uygulamanın öldürülmesini engeller ve çöp toplayıcının agresifleşerek belleği vaktinde geri vermesini sağlar.
- GOGC: Çöp toplayıcının ne zaman tetikleneceğini belirleyen yüzde oranıdır (varsayılan 100). Canlı bellek miktarı iki katına çıktığında GC başlar.
GOMEMLIMITile birlikte kullanıldığında gereksiz GC döngülerini azaltır. - İzleme Araçları: Çalışma zamanının davranışını incelemek için iki ortam değişkeni telemetri sunar:
GODEBUG=gctrace=1: Her çöp toplama döngüsünün STW süresini, kullanılan bellek miktarını ve CPU yüzdesini standart hata çıktısına yazar.GODEBUG=schedtrace=1000: Her 1000 milisaniyede bir zamanlayıcının durumunu, kaç adet M ve P olduğunu, kuyruk uzunluklarını döker.
Çalışma zamanı mimarisini bilmek, kilit kullanımından kaçınmayı, heap yerine yığın tahsisatını tercih edecek kod yapıları kurmayı ve üretim ortamında öngörülebilir gecikme değerleri elde etmeyi sağlar.
Yazıyı Değerlendir
0 tepkiFikirlerinizi tek tıkla paylaşarak geri bildirim bırakın.
Ali Purtaş
@alipurtas • Hey, This is Ali!
Kendi halinde yazılım geliştiren bir öğrenci. Sistemler kuruyor, deniyor, bozuyor ve öğrendiği gerçek çözümleri burada belgeliyor.
Konu Kümesi & Önerilen Yazılar
copy_file_range ile Blok Katmanında Reflink Tabanlı Dosya Klonlama
copy_file_range sistem çağrısı, Btrfs ve XFS reflink mekanizması, blok seviyesinde anlık dosya klonlama ve gigabaytlarca veriyi kopyalamadan çoğaltma rehberi.
Linux sendfile ve splice Çağrılarıyla Çekirdek İçi Veri Aktarımı
Geleneksel G/Ç kopyalama maliyetleri, sendfile ve splice sistem çağrıları, boru tamponları üzerinden kullanıcı alanına inmeden sokete veri aktarma mimarisi.
Bellek Bariyerleri: x86 TSO ile ARM Zayıf Bellek Düzeni Farkları
x86 TSO modeli ile ARM gevşek bellek mimarisi karşılaştırması, hafıza bariyeri komutları ve lock-free kodların Graviton işlemcilerde çökme nedenleri analizi.
Tartışma & Yorumlar
0Tartışmaya katılmak ve soru sormak için oturum açmalısınız.
Giriş Yap