Bellek Hizalama (Memory Alignment), Padding ve Yalancı Paylaşım (False Sharing) Sorunları
Çok çekirdekli bir işlemcide iki farklı iş parçacığı (thread) tamamen birbirinden bağımsız değişkenler üzerinde işlem yaparken bile işlemci çekirdeklerinin birbirini kilitlediğini ve performansın tek çekirdeğin bile altına düştüğünü görebilirsiniz. İlk bakışta hiçbir mantığa sığmayan bu durumun adı Yalancı Paylaşım (False Sharing) problemidir.
Bu rehberde; derleyicinin bellek hizalama (Memory Alignment) ve dolgu (Padding) kurallarını, çok çekirdekli mimarilerde önbellek tutarlılığı (Cache Coherence – MESI) protokolünün nasıl çalıştığını ve C++17 ile gelen alignas çözümlerini inceliyoruz.
1. Veri Yapısı Dolgusu (Struct Padding) Neden Vardır?
Modern 64-bit işlemciler, bellek adresleri kendi boyutunun katlarına hizalanmış verileri çok daha hızlı okur:
- 4 baytlık bir
int, 4’ün katı bir adreste olmalıdır. - 8 baytlık bir
doubleveya işaretçi, 8’in katı bir adreste olmalıdır.
Eğer değişken sıralamasına dikkat etmezseniz, derleyici bu hizalamayı sağlayabilmek için değişkenlerin arasına görünmez boşluklar (Padding Baytları) ekler:
// Kötü Sıralama: Toplam 24 Bayt!
struct BadLayout {
char a; // 1 Bayt
// [3 Bayt Boş Dolgu - Padding]
int b; // 4 Bayt
char c; // 1 Bayt
// [7 Bayt Boş Dolgu - Padding]
double d; // 8 Bayt
};
// Optimize Edilmiş Sıralama (Büyükten Küçüğe): Toplam 16 Bayt!
struct GoodLayout {
double d; // 8 Bayt
int b; // 4 Bayt
char a; // 1 Bayt
char c; // 1 Bayt
// [2 Bayt Dolgu]
};
Sadece değişkenlerin tanımlanma sırasını değiştirerek aynı nesnenin RAM tüketimini 24 bayttan 16 bayta düşürebilirsiniz. Milyonlarca nesne barındıran bir dizide bu fark yüzlerce megabaytlık RAM tasarrufu ve daha az Cache Miss anlamına gelir.
2. Yalancı Paylaşım (False Sharing) Nedir?
Bir önceki yazıda belirttiğimiz gibi işlemciler belleği 64 baytlık Cache Line blokları halinde taşır. Çok çekirdekli sistemlerde her çekirdeğin kendi L1/L2 önbelleği vardır.
Eğer iki bağımsız değişken bellekte birbirine çok yakınsa (aynı 64 baytlık Cache Line içinde kalıyorsa):
64 Baytlık Cache Line:
[ Core 0'ın Sayacı: sayac_A (8 Bayt) ] [ Core 1'in Sayacı: sayac_B (8 Bayt) ] ... [ Boş ]
- Core 0
sayac_Adeğişkenini artırdığında, donanımsal önbellek tutarlılığı protokolü (MESI – Modified, Exclusive, Shared, Invalid) devreye girer. - Core 0, bu 64 baytlık bloğu değiştirdiğini diğer tüm çekirdeklere anons eder.
- Core 1’in L1 önbelleğindeki kopya Geçersiz (Invalid) ilan edilir.
- Core 1 kendi bağımsız
sayac_Bdeğişkenini güncellemek istediğinde kendi önbelleği geçersiz olduğu için L3 veya ana belleğe gitmek zorunda kalır!
Sonuç: İki iş parçacığı birbirinin değişkenine asla dokunmadığı halde, donanım seviyesinde sürekli birbirinin önbelleğini çöpe atarak devasa bir otobüs (bus) trafiği ve kilitlenme yaratır.
3. False Sharing Benchmark Örneği
#include <thread>
#include <vector>
#include <iostream>
#include <chrono>
// Hatalı: İki sayaç aynı 64 baytlık alanda yan yana
struct FalseSharingData {
uint64_t count1 = 0; // Core 0 burayı yazar
uint64_t count2 = 0; // Core 1 burayı yazar
};
FalseSharingData g_bad_data;
void worker1() {
for (uint64_t i = 0; i < 1'000'000'000; ++i) {
g_bad_data.count1++;
}
}
void worker2() {
for (uint64_t i = 0; i < 1'000'000'000; ++i) {
g_bad_data.count2++;
}
}
Bu iki iş parçacığını çalıştırdığınızda işlem süresi tek bir iş parçacığının iki katı sürebilir!
4. Modern C++ Çözümü: alignas
C++17 ile birlikte bu sorunu çözmek için taşınabilir standart bir sabit tanıtıldı: std::hardwaredestructiveinterference_size.
Her değişkeni bağımsız bir 64 baytlık önbellek satırına hizalamak (izole etmek) için:
#include <new>
// Optimize: Her sayaç kendi bağımsız Cache Line'ında yaşar
struct SafeData {
alignas(64) uint64_t count1 = 0;
alignas(64) uint64_t count2 = 0;
};
SafeData g_safe_data;
alignas(64) belirteci, derleyiciye bu değişkenin bellekte mutlaka 64’ün katı olan yeni bir adreste başlatılmasını ve araya gerekli dolgunun otomatik konmasını emreder.
Sonuç Farkı:
Aynı milyar adımlık döngü test edildiğinde:
- False Sharing Olan Durum: ~2.8 saniye
alignas(64)ile İzolasyon: ~0.45 saniye (Yaklaşık 6 kat hız artışı!)
5. Çıkarımlar
Çok iş parçacıklı yüksek frekanslı sistemlerde (örneğin HFT ticaret botları veya oyun sunucuları), paylaşılan nesnelerin bellekteki yerleşimine dikkat etmek hayati önem taşır. Eğer her thread’in kendi yazma alanı varsa, aralarına mutlaka en az 64 baytlık (alignas) güvenlik mesafesi koyulmalıdır.
Bir sonraki bölümde, kilit mekanizmalarını (std::mutex) tamamen ortadan kaldıran Kilitsiz (Lock-Free) Programlama ve std::atomic Bellek Düzenlerini inceleyeceğiz.