IAli
Tüm Yazılar
POSIX Paylaşılan Bellek shm_open ile Süreçler Arası Hızlı IPC

POSIX Paylaşılan Bellek shm_open ile Süreçler Arası Hızlı IPC

shm_open ve mmap ile süreçler arası kopyalamasız veri aktarımı, POSIX semaforlar, atomik işaretçiler ve kilitlenmesiz dairesel halka kuyruğu mimarisi.

Mikrosaniye altı (sub-microsecond) gecikmeyle çalışan yüksek frekanslı ticaret (HFT) sistemlerinde, telemetry toplayıcılarında veya yerel makine mikroservislerinde süreçler arası iletişim (IPC) en büyük performans darboğazıdır.

Geleneksel borular (pipes), UNIX domain soketleri veya TCP loopback arayüzleri veriyi iletmek için çekirdeğin bellek tamponlarını kullanır. Gönderici süreci veriyi kullanıcı alanından çekirdek alanına kopyalar, alıcı süreci ise veriyi çekirdek alanından kendi belleğine kopyalar. Bu iki adımlı kopyalama ve aradaki sistem çağrısı bağlam değişimleri, mesaj başına yüzlerce nanosaniye gecikme ekler.

POSIX Paylaşılan Bellek (shm_open) mekanizması ise işletim sistemi çekirdeğini aradan tamamen çıkarır. İki bağımsız sürecin sanal adres uzayına aynı fiziksel RAM sayfalarını eşleyerek kopyalamasız (zero-copy) bir iletişim kanalı açar. Bu rehberde shm_open, mmap, atomik işaretçiler ve isimsiz semaforlarla kilitlenmesiz bir dairesel kuyruk (ring buffer) mimarisini inceliyoruz.

TEXT
POSIX Paylaşılan Bellek Mimarisi (Kopyalamasız Veri Paylaşımı):

Süreç A (Yazıcı - Producer)               Süreç B (Okuyucu - Consumer)
Sanal Bellek: 0x7fff1000                  Sanal Bellek: 0x7fff8000
        │                                         │
        │ mmap() ile Eşlendi                     │ mmap() ile Eşlendi
        ▼                                         ▼
┌───────────────────────────────────────────────────────────────┐
│              FİZİKSEL RAM (Ortak /dev/shm Alanı)              │
│                                                               │
│ [ Başlık: head (atomic), tail (atomic), semafor ]             │
│ [ Dairesel Veri Halkası (Ring Buffer): 64 MB Slot ]           │
└───────────────────────────────────────────────────────────────┘
  (ARADA ÇEKİRDEK KOPYALAMASI YOK - DOĞRUDAN DRAM ERİŞİMİ)

1. /dev/shm ve shm_open Mekanizması

Linux sistemlerinde POSIX paylaşılan bellek nesneleri /dev/shm dizini altında sanal bir tmpfs dosya sistemi üzerinde yaşar. Bu dosyalar diskte yer kaplamaz, doğrudan çekirdeğin sayfa önbelleğinde (RAM) barınır.

Geleneksel System V IPC (shmget, shmat) arayüzüne kıyasla POSIX standardı (shm_open, mmap) dosya tanımlayıcısı (file descriptor) semantiğiyle çalışır:

  1. shm_open("/my_shm", O_CREAT | O_RDWR, 0666): /dev/shm/my_shm nesnesini oluşturur ve bir dosya tanıtıcısı döner.
  2. ftruncate(fd, SIZE): Bellek bölgesinin büyüklüğünü (örneğin 64 MB) belirler.
  3. mmap(NULL, SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0): Bu fiziksel bellek sayfalarını sürecin kendi sanal adres uzayına bağlar. Bu yapı Linux 4 Seviyeli Sayfa Tablosu hiyerarşisinde PTE seviyesinde aynı fiziksel sayfa çerçevelerini (page frames) işaret eder.

Her iki süreç de aynı bellek işaretçisine (pointer) sahip olduğunda, Süreç A'nın bir değişkene yazdığı değer Süreç B tarafından aynı anda donanım hızında okunabilir.

2. Kilit Çekişmesini Önleme: Lock-Free Halka Kuyruğu

Paylaşılan bellekte geleneksel pthread_mutex_t kilidi kullanmak, kilit çekişmesi anında süreçlerin çekirdeğe inmesine ve futex sistem çağrılarıyla uyumasına yol açar.

En yüksek başarım için Tek Üretici Tek Tüketici (Single-Producer Single-Consumer - SPSC) kilitlenmesiz dairesel halka kuyruğu tasarımı tercih edilir. Kuyrukta iki atomik indeks bulunur:

  • head: Tüketicinin okuduğu son indeksi gösterir. Yalnızca tüketici tarafından güncellenir.
  • tail: Üreticinin yazdığı son indeksi gösterir. Yalnızca üretici tarafından güncellenir.

İndeksler güncellenirken C11/C++ atomik bellek modelleri (memory_order_release ve memory_order_acquire) kullanılarak veri bayraklarının işlemci önbelleklerinde doğru sırada görünür olması sağlanır.

3. C Dili ile Uygulama Örneği

Aşağıdaki kod parçası paylaşılan bellek üzerinde çalışan bir kuyruk veri yapısını tanımlar:

C
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>
#include <stdatomic.h>
#include <semaphore.h>

#define SHM_NAME "/telemetry_queue"
#define QUEUE_CAPACITY 1024
#define MSG_SIZE 256

struct Message {
    uint64_t timestamp;
    char payload[MSG_SIZE];
};

struct SharedQueue {
    atomic_uint head;
    atomic_uint tail;
    sem_t sem_items;
    struct Message messages[QUEUE_CAPACITY];
};

int init_shared_memory(int is_creator) {
    int flags = O_RDWR;
    if (is_creator) {
        flags |= O_CREAT | O_EXCL;
    }

    int fd = shm_open(SHM_NAME, flags, 0660);
    if (fd == -1) {
        perror("shm_open");
        return -1;
    }

    if (is_creator) {
        if (ftruncate(fd, sizeof(struct SharedQueue)) == -1) {
            perror("ftruncate");
            return -1;
        }
    }

    void *addr = mmap(NULL, sizeof(struct SharedQueue),
                      PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    close(fd);

    if (addr == MAP_FAILED) {
        perror("mmap");
        return -1;
    }

    struct SharedQueue *q = (struct SharedQueue *)addr;
    if (is_creator) {
        atomic_init(&q->head, 0);
        atomic_init(&q->tail, 0);
        /* 2. arguman 1: surecler arasi paylasimli semafor */
        sem_init(&q->sem_items, 1, 0);
    }

    return 0;
}

4. Olay Bildirimi: POSIX İsimsiz Semaforlar

Sürekli meşgul bekleme (busy waiting / spinning) CPU çekirdeklerini yüzde 100 kullanır ve enerji israfına yol açar. Tüketici kuyrukta yeni mesaj olmadığını gördüğünde CPU'yu serbest bırakmalıdır.

Bunun için sem_init(&sem, 1, 0) çağrısıyla başlatılan süreçler arası isimsiz semafor kullanılır:

  • İkinci parametrenin 1 olması, semaforun iş parçacıkları arasında değil, farklı süreçler arasında paylaşıldığını gösterir.
  • Üretici mesajı kuyruğa yazdıktan sonra sem_post() çağırır.
  • Tüketici mesaj beklerken sem_wait() çağırarak çekirdek seviyesinde uykuya dalar.

Bu model, kopyalamasız veri taşıma avantajını verimli işlemci kullanımıyla birleştirir. Süreçler arası dosya tanıtıcı devri gerektiren durumlar için ise UNIX Domain Soketleri ve SCM_RIGHTS mimarisi tamamlayıcı bir rol üstlenir.

5. Üretim İçin Dikkat Edilmesi Gereken Sınır Koşulları

Paylaşılan bellek kullanılırken şu mimari detaylara özen gösterilmelidir:

  1. Önbellek Çakışması (False Sharing): head ve tail atomik sayaçları aynı 64 baytlık CPU önbellek satırına düşmemelidir. Her iki değişken arasına en az 64 baytlık boşluk (padding) bırakılmalıdır.
  2. Süreç Çöküşlerinde Belleğin Kalması: Normal dosyaların aksine, süreci öldürseniz dahi /dev/shm içindeki bellek alanı sistem yeniden başlayana kadar RAM'de kalır. Süreç kapanışlarında mutlaka shm_unlink() çağrılmalıdır.
  3. Güvenlik İzinleri: /dev/shm üzerindeki dosya izinleri varsayılan olarak kısıtlanmalıdır (0660). Aksi halde aynı sunucudaki yetkisiz diğer kullanıcılar paylaşılan belleği okuyabilir.

Bu mimari tasarım uygulandığında süreçler arası mesaj iletim gecikmesi onlarca mikrosaniyeden 50 nanosaniye bandına iner.

Yazıyı Değerlendir

0 tepki

Fikirlerinizi tek tıkla paylaşarak geri bildirim bırakın.

Bu teknik notu çevrenizle paylaşın

Ali Purtaş

@alipurtas • Hey, This is Ali!

İletişime Geç

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

İç Bağlantılı Mimari
Yorumlar yükleniyor...