Masaüstünde bir uygulamanın ikonuna çift tıklıyoruz ve birkaç saniye içinde karşımıza çalışan bir program çıkıyor.

Günlük kullanımda bu hareket o kadar sıradan ki, aslında arka planda neler olduğunu çoğu zaman düşünmüyoruz.

Oysa çift tıklamak, diskte duran bir dosyayı doğrudan işlemciye vermek anlamına gelmiyor.

İşletim sistemi önce çalıştırılabilir dosyanın yapısını inceliyor, ardından uygulama için bir Process oluşturuyor, sanal adres alanını hazırlıyor, ihtiyaç duyduğu DLL’leri eşliyor, ilgili Runtime altyapısını devreye sokuyor ve sonunda uygulamanın başlangıç kodunun CPU üzerinde çalışmasını sağlıyor.

Yani bir programın açılması, tek bir işlemden çok daha fazlası.

Bu süreci anlamanın en kolay yolu, diskteki .exe dosyasından başlayıp çalışan uygulamaya kadar ilerleyen zinciri adım adım takip etmek.

Diskteki .EXE Dosyası Aslında Nedir?

Bir uygulamanın .exe dosyasını diskte gördüğümüzde, onu çalışan programın kendisi olarak düşünmek kolaydır.

Fakat diskte duran executable henüz çalışan bir uygulama değildir.

O dosya, içerisinde programın kodlarını, verilerini ve çalıştırılması için gerekli yapısal bilgileri barındıran statik bir veri ve talimat bütünüdür.

Windows dünyasında çalıştırılabilir dosyalar Portable Executable (PE) formatında yapılandırılır.

Bu yapı, işletim sistemine dosyanın içeriğinin nasıl ele alınması gerektiği konusunda gerekli bilgileri sağlar.

Dolayısıyla işletim sistemi .exe dosyasını rastgele bir veri yığını gibi okuyup çalıştırmaz.

Önce onun nasıl yapılandırıldığını anlaması gerekir.

İlk Adım: PE Yapısının İncelenmesi

Programı çalıştırma isteği geldiğinde Windows’un yükleyici mekanizması executable dosyanın başlık bilgilerini inceler.

PE yapısı içerisinde dosyanın nasıl belleğe eşleneceği konusunda ihtiyaç duyulan bilgiler bulunur.

Örneğin hedef mimari, görüntü boyutu ve hizalama bilgileri ile bağımlı kütüphaneler hakkında bilgiler bu yapının bir parçasıdır.

Dosyanın içerisinde kod, veri ve kaynaklar gibi farklı bölümler de bulunur.

Bu nedenle .exe dosyasını basitçe:

“İçinde programın kodu var, CPU bunu okuyup çalıştırıyor.”

şeklinde düşünmek eksik kalır.

Executable aynı zamanda işletim sistemi için bir çalıştırma planıdır.

Dosyanın kendisi henüz çalışan bir program değildir; işletim sistemine bu programın nasıl hazırlanması gerektiği konusunda gerekli yapısal bilgileri sunar.

Executable’dan Process’e

PE yapısı incelendikten sonra artık programın çalışması için gerekli çalışma ortamının oluşturulması gerekir.

Burada Process kavramı devreye girer.

Windows yeni bir Process bağlamı oluşturur ve executable’ın görüntüsünü bu bağlama eşlemeye başlar.

Bu Process’e benzersiz bir PID (Process ID) atanır.

Artık elimizde yalnızca diskte duran statik bir dosya yoktur.

İşletim sistemi tarafından yönetilen, kendisine ait kaynakları ve adres alanı bulunan bir çalışma bağlamı oluşmuştur.

Bu ayrım oldukça önemlidir:

EXE dosyası diskteki statik yapıdır. Process ise o programın işletim sistemi tarafından çalıştırılmak üzere oluşturulan canlı çalışma bağlamıdır.

Sanal Bellek: Program Gerçekte RAM’i Nasıl Görüyor?

Process oluşturulduktan sonra sıradaki önemli aşamalardan biri sanal adres alanının hazırlanmasıdır.

Her Process için özel bir Virtual Address Space, yani sanal adres alanı bulunur.

Bu alanı programın kendi dünyası gibi düşünebiliriz.

Program belleğe erişirken doğrudan fiziksel RAM adresleriyle çalışmak zorunda değildir. İşletim sistemi ve işlemcinin bellek yönetim mekanizmaları, programın kullandığı sanal adresleri fiziksel bellekle eşleştirir.

Burada çok önemli bir ayrım vardır:

Sanal bellek ile fiziksel RAM aynı şey değildir.

Programın gördüğü adres alanı ile bilgisayardaki gerçek RAM hücreleri arasında bir eşleme mekanizması bulunur.

Sayfa Tabloları ve MMU

Sanal bellek adresleri fiziksel belleğe doğrudan bağlanmaz.

Arada Page Table, yani sayfa tabloları bulunur.

Sanal bellek sayfaları, sayfa tabloları üzerinden fiziksel bellek bölgeleriyle eşleştirilir.

Bu işlemin donanım tarafında önemli bir parçası da MMU (Memory Management Unit)‘dir.

Basitleştirerek zinciri şöyle düşünebiliriz:

Sanal adres → Sayfa tablosu → MMU → Fiziksel RAM

Böylece uygulama kendi sanal adres alanında çalışırken, işletim sistemi ve işlemci bu adreslerin fiziksel bellekte nereye karşılık geldiğini yönetir.

Her Process Kendi Bellek Alanını Görüyor

Sanal adres alanının bir başka önemli görevi de izolasyondur.

Her Process kendi sanal adres alanını görür.

Bir Process’in başka bir Process’e ait bellek bölgelerine rastgele erişmesi engellenir; bellek erişimleri uygun izinler üzerinden kontrol edilir.

Örneğin iki farklı uygulama aynı sanal adres değerini kullanıyor olabilir.

Bu, bu iki uygulamanın aynı fiziksel RAM hücresini kontrol ettiği anlamına gelmez.

Her Process’in kendi adres alanı vardır ve işletim sistemi bu alanların birbirinden izole edilmesini sağlar.

Bu izolasyon, sistemin kararlılığının temel parçalarından biridir.

Program Neden Tek Başına Yeterli Değil? DLL’ler Devreye Giriyor

Uygulamaların ihtiyaç duyduğu her işlevi kendi executable dosyasının içerisine koyması gerekmez.

İşletim sistemi ve diğer yazılım bileşenleri tarafından sağlanan ortak kütüphanelerden yararlanabilirler.

İşte burada DLL (Dynamic Link Library) mekanizması devreye girer.

Bir uygulama pencere yönetimi, sistem işlevleri veya farklı platform hizmetleri için çeşitli API’lerden yararlanabilir.

Bu işlevlerin önemli bir bölümü ortak kütüphaneler tarafından sağlanır.

Örneğin Windows ortamında uygulamaların kullandığı çeşitli sistem API’leri ilgili DLL’ler üzerinden sunulabilir.

Bu yaklaşım, aynı işlevlerin her uygulamanın içerisine tekrar tekrar gömülmesi yerine ortak kütüphanelerden kullanılmasına olanak tanır.

Import Address Table Ne İşe Yarıyor?

Executable içerisindeki Import Address Table (IAT), uygulamanın dışarıdan ihtiyaç duyduğu fonksiyonlarla ilgili önemli bir yapıdır.

Windows yükleyicisi gerekli DLL’leri bulduğunda bunları Process’in sanal adres alanına eşler.

Ardından uygulamanın ihtiyaç duyduğu fonksiyonların adreslerinin çözülmesi ve ilgili çağrıların doğru adreslere yönlendirilmesi sağlanır.

Bu sürece dynamic linking, yani dinamik bağlama denir.

Böylece uygulamanın kodu ile dışarıdaki kütüphaneler arasında gerekli bağlantılar kurulmuş olur.

Bu aşama tamamlanmadan uygulamanın ihtiyaç duyduğu bütün çalışma ortamı hazır hale gelmiş sayılmaz.

DLL Eksikse Ne Olur?

Uygulamanın ihtiyaç duyduğu bir DLL bulunamaz veya yüklenemezse başlangıç süreci başarısız olabilir.

Bu durumda Windows bir DLL yükleme hatası gösterebilir.

Çünkü uygulamanın ihtiyaç duyduğu bağımlılıklardan biri eksikken programın çalışması için gereken mimari tamamlanamamıştır.

Bu da bize executable dosyasının tek başına her zaman yeterli olmadığını gösterir.

Bir uygulamanın çalışması için executable’ın yanında ihtiyaç duyduğu dış kütüphanelerin de doğru şekilde hazırlanması gerekebilir.

Runtime: Uygulamanın Çalışma Altyapısı

DLL’lerin yüklenmesiyle birlikte uygulamanın çalışma ortamındaki bir başka katman daha önem kazanır:

Runtime.

Runtime, kullanılan programlama platformuna bağlı olarak uygulamanın çalışması sırasında ihtiyaç duyduğu çalışma zamanı hizmetlerini sağlar.

Burada önemli bir nokta var:

Her programlama platformunun Runtime yapısı aynı değildir.

Örneğin .NET uygulamalarında CLR, C++ tarafında CRT ve Java dünyasında JVM farklı çalışma zamanı altyapıları sunar.

Dolayısıyla Runtime’ı yalnızca tek bir teknolojiye özgü bir yapı olarak düşünmemek gerekir.

Runtime’ın görevi, kullanılan platforma bağlı olarak uygulamanın çalışması için gereken altyapıyı sağlamaktır.

.NET Örneğinde Runtime

Örneğin .NET tarafında CLR, uygulamanın çalışma ortamında çeşitli hizmetlerin yürütülmesinde rol oynar.

Bunlar arasında bellek yönetimi, istisna yönetimi ve Garbage Collector gibi mekanizmalar bulunur.

Bu nedenle bir uygulamanın çalışması yalnızca kendi yazdığımız koddan ibaret değildir.

Kullandığımız platformun sağladığı çalışma zamanı altyapısı da uygulamanın çalışma modelinin önemli bir parçasıdır.

İlk Thread Nasıl Devreye Giriyor?

CPU Zamanı Geldiğinde Uygulama Çalışmaya Başlıyor

Thread’in çalışması için CPU zamanı alması gerekir.

Scheduler tarafından CPU üzerinde çalıştırılmasına izin verildiğinde uygulamanın başlangıç kodu yürütülmeye başlar.

Uygulama kendi başlangıç işlemlerini gerçekleştirir ve gerekli hazırlıkları yaptıktan sonra ilk penceresini oluşturabilir.

Böylece kullanıcının gördüğü uygulama arayüzü ortaya çıkar.

Masaüstünde yalnızca bir pencerenin açıldığını görürüz.

Fakat perde arkasında çok daha uzun bir hazırlık zinciri tamamlanmıştır.

Bir Programın Açılış Zincirinin Tamamı

Bütün süreci tek bir model içerisinde toplarsak, bir programın açılışını şu şekilde düşünebiliriz:

1. Executable okunur

.exe dosyasının PE yapısı incelenir ve çalıştırılabilir dosyanın nasıl ele alınacağına ilişkin bilgiler alınır.

2. Process bağlamı oluşturulur

Windows uygulama için bir Process çalışma bağlamı oluşturur ve executable görüntüsünü bu bağlama eşlemeye başlar.

3. Sanal bellek alanı hazırlanır

Process için sanal adres alanı oluşturulur ve sanal adreslerin fiziksel bellekle eşlenmesi için gerekli bellek yönetim yapıları kullanılır.

4. DLL’ler yüklenir ve bağlanır

Uygulamanın ihtiyaç duyduğu dış kütüphaneler bulunur, Process’in adres alanına eşlenir ve gerekli fonksiyon adresleri çözülür.

5. Runtime ve başlangıç Thread’i devreye girer

Kullanılan platforma bağlı Runtime altyapısı hazırlanır, initial thread üzerinden başlangıç kodları yürütülür ve uygulamanın giriş noktasına ulaşılır.

Sonrasında thread CPU zamanı alır ve uygulamanın kendi kodu çalışmaya başlar.

Asıl Ayrım: Dosya mı, Process mi?

Bütün bu sürecin sonunda başlangıçtaki basit görünen sorunun cevabı ortaya çıkıyor:

Bir programa çift tıkladığımızda aslında ne oluyor?

Çift tıkladığımız şey diskte duran bir .exe dosyasıdır.

Fakat çalışan şey o dosyanın kendisi değildir.

İşletim sistemi bu statik dosyadan yola çıkarak Process bağlamını oluşturur, sanal bellek alanını hazırlar, gerekli bağımlılıkları eşler, Runtime altyapısını devreye sokar ve başlangıç thread’i üzerinden uygulamanın kodunu yürütmeye başlar.

Bu yüzden şu ayrım akılda tutulmalı:

Diskteki EXE statik bir dosyadır; bellekte yaşayan ve kaynakları yöneten çalışan varlık ise Process’tir.

Bir program ikonuna çift tıklamak aslında bir dosyayı “açmak”tan çok daha fazlasıdır.

İşletim sistemi, diskteki statik bir çalıştırılabilir dosyayı alıp onu CPU üzerinde çalışabilecek canlı bir çalışma ortamına dönüştürür.

Ve ekranda gördüğümüz uygulama penceresi, bu zincirin sonunda ortaya çıkar.

Bir Sonraki Soru

Buraya kadar bir programın nasıl çalışmaya başladığını gördük.

Peki zaman içerisinde bellekte onlarca Process ve yüzlerce Thread oluştuğunda sistem bunları nasıl yönetiyor?

Daha da önemlisi, bilgisayarı kapatıp yeniden açtığımızda bu çalışan süreçlerin, açık kaynakların ve sistem durumunun neden ortadan kalktığını hiç düşündünüz mü?

Bir sonraki adımda bu kez bilgisayarı kapatıp açmanın arka planda sistemi nasıl yeniden başlattığını incelemek gerekiyor.

By mgm

Bir yanıt yazın

E-posta adresiniz yayınlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir