İşletim sistemi
Genel özellikler
İşlem yönetimi Kesmeler Bellek yönetimi Dosya sistemi Aygıt sürücüsü Bilgisayar ağı Bilgisayar güvenliği G/Ç
g t d

Ana belleğin işlemler arasında paylaştırılmasına ana bellek yönetimi ya da bellek yönetimi (Memory Management) adı verilir.^[1][1] İşletim sisteminin bu amaçla oluşturulan kesimine de bellek yöneticisi (memory Manager) adı verilir.

Bellek yöneticisinin görevi, belleğin hangi parçalarının kullanımda olduğunu, hangi parçalarının kullanılmadığını izlemek, süreçlere bellek tahsis etme (allocate), tahsis edilen belleği geri almak ve bellek ile disk arasındaki takas işlemlerini gerçekleştirmektir.^[2] Bellek yönetimi dendiğinde genellikle belleğin yığın (heap) alanında tahsis edilmiş olan bellek alanlarının yönetimi kastedilir.

İşletim sisteminde yürütülen programlar ya da gömülü sistem yazılımları kendi içlerinde bellek yönetimi sergileyebilirler. IBM OS/360 ve ardıllarında bellek işletim sistemi tarafından yönetilirken, Unix ve benzeri işletim sistemlerinde bellek uygulama tarafından yönetilir.

Yazılım geliştirmede, bellek yönetimi ilk anlardan beri önemli bir konu olmuştur. Programlama dili teorisi alanında yaşanan gelişme ve iyileştirmeler, yazılım geliştiricilerin farklı yaklaşımları ve ihtiyaçları nedeniyle bellek yönetimi konusunda pek çok yöntem ortaya çıkmıştır. Bu yöntemler genellikle otomatik bellek yönetimi ve manuel bellek yönetimi olacak şekilde ikiye ayrılmaktadır.

Tahsis edilmiş bellekler serbest bırakılana kadar tekrar tahsis edilemezler. Bu nedenle artık kullanılmayan bir bellek tahsisinin serbest bırakılması önemlidir. Tahsis edilen bellekler artık ihtiyaç duyulmadığı takdirde serbest bırakılmazlarsa, bellek sızıntısına (memory leak) neden olurlar.

Amaçlar[değiştir | kaynağı değiştir]

Bir işletim sisteminin bellek yönetiminin sonuçları şunlardır:

• Bellekteki herhangi bir işlemi başka bir yere aktarabilmelidir.
• Birden fazla işlem veya kullanıcı olduğunda bir kullanıcını diğer kullanıcını alanlarına girmeleri önlenmelidir.
• Kullanıcılar arası kaynak paylaşımını sağlamalıdır.
• Belleğin mantıksal alanlara bölünmesini sağlayarak bilgiye erişimi kolaylaştırmalıdır.
• Belleğin yetmediği durumlarda fiziksel başka bellek alanlarını yani hard diskleri kullanabilmelidir.

Manuel Bellek Yönetimi[değiştir | kaynağı değiştir]

Bir yazılım çalışma zamanında (runtime) bellek tahsisi (allocation) gerçekleştirmek istediğinde çekirdek (kernel) ile iletişim halindedir. Tahsis yöntemi farklılık göstermekle birlikte işletim sisteminin bellek yöneticisi tarafından ayrılan tahsisin konumu önceden bilinmediğinden bir referans (işaretçi / pointer) ile erişilir. Program tarafından tahsis edilen bu alanlar programın kendi içerisinde sergilediği bellek yönetimine kalmaktadır. Program tahsis ettiği alanları artık ihtiyacı kalmadığı durumlarda serbest bırakarak (deallocation) belleği geri kazandırır ve belleğin ilgili bölümleri artık tahsis edilebilir hale gelir. Bu tahsisler geliştirici tarafından manuel bir şekilde gerçekleştirilir ve serbest bırakılır.

Geliştirici ne zaman bellek tahsis etmesi ve serbest bırakması gerektiğine kendisi karar vermelidir. Geliştiricilerin bellek yönetimini verimli ve doğru bir şekilde gerçekleştirmemeleri çeşitli bellek sorunlarına yol açabilir. Örneğin C programlama dilinde artık kullanılmadığından serbest bırakılması gereken tahsisler serbest bırakılmadığında bellek sızıntısına (memory leak) neden olabilir. Bu nedenle geliştirici tahsisleri sürekli olarak gözetmeli ve doğru konumlarda artık serbest bırakmaya özen göstermelidir.

#include <stdio.h>
#include <stdlib.h>

int main() {
    int n = 20;
    
    // n tane int tutabilecek bir bellek alanı tahsisi
    int *list = (int*)(malloc(n*sizeof(int)));
    
    /*
        programın işevi
    */
    
    // Tahsis edilen belleğin serbest bırakılması
    free(list);
    list = NULL;

    return EXIT_SUCCESS;
}

Olumlu Yönleri[değiştir | kaynağı değiştir]

Manuel bellek yönetiminde programın bellek yönetimi üstünde yazılım geliştirici tam yetkilidir. Ne zaman tahsis edileceğine ve serbest bırakılacağına tamamen kendisi karar verebilir. Bu nedenle bellek tahsisleri konusunda istediği şekilde yönetim sergileyebilir.

Manuel bellek yönetiminde yazılım geliştirici tarafından tahsis yönetimi yapıldığından, genellikle bellek tahsis etmek, serbest bırakmak ve yeniden boyutlandırmak gibi temel işlevler kullanılır, bu işlevler çoğu uygulamada (implementation) ara algoritmalar yoktur ve yalnızca işlevler görevini yaparlar. Bu nedenle manuel bellek yönetimi performansı en düşük oranda etkileyen bellek yönetimi yöntemlerinden biridir.

Olumsuz Yönleri[değiştir | kaynağı değiştir]

Bellek tahsislerinin yazılım geliştiriciler tarafından yönetilmesi gerektiğinden çeşitli güvenlik sorunlarına yol açabilecek hatalar yapılabilir. Örneğin tahsis edilen belleğin gözden kaçarak serbest bırakılmaması sonucu bellek sızıntısı meydana gelebilir ya da tahsis edilen belleğin doğru kullanılmamasından kaynaklı olarak çeşitli bellek hataları yapılabilir.

Bu yöntem yazılım geliştirme sürecinde önemli bir efor gerektirebilir, geliştirme ve test sürecini uzatabilir.

Otomatik Bellek Yönetimi[değiştir | kaynağı değiştir]

Otomatik bellek yönetimi, bellek yönetimini otomatik hale getiren yöntemlere verilen genel isimdir. Pek çok modern programlama dilinde otomatik bellek yönetimi yaklaşımına rastlanmaktadır. Çalışma zamanında programın bellek yönetiminin kendi içerisinde otomatik bir şekilde gerçekleştirilmesine dayanır. Bu yaklaşımın yaygın örneklerinde geliştiricinin bellek yönetimini düşünmesi gerekmemektedir. Otomatik bellek yönetimi içerisindeki tekniklerin mantığına dayanan ancak birebir aynı olmayan uygulamaları (implementation) bulunmaktadır.

Olumlu Yönleri[değiştir | kaynağı değiştir]

Yazılım geliştiriciyi bellek yönetimini düşünmekten büyük oranda ya da tamamen kurtarır. Yazılım geliştirme sürecindeki belek yönetimi kaynaklı hataları azaltır, maliyeti ve geliştirme zamanını düşürür. Bellek yönetimi kolay hale geldiğinden ilgili programlama dilini kullanarak geliştirme yapmak daha kolay hale gelir, bu nedenle teorik olarak daha fazla geliştirici tarafından kullanılabilir.

Olumsuz Yönleri[değiştir | kaynağı değiştir]

Yazılım geliştiricinin yazılımın bellek yönetimi konusundaki yetki alanlarını sınırlandırır ve kontrolünü azaltır. Çoğu durumda, belleğin incelikle yazılım geliştirici tarafından yönetilmesi gereken senaryolarda iyi bir seçenek değildir.

Performans açısından kritik yazılımlar için olumsuz etki doğurabilir. Çöp toplama tekniğine göre programın çalışma zamanında (runtime) büyük oranda çöp toplama yükü bulunabilir, ayrıca yönteme göre daha fazla bellek kullanımı gibi sorunlara yol açabilir.

Çöp toplama genellikle otomatik olarak derleyici (compiler) tarafından uygulanan bir derleyici özelliği olduğundan, derleyici kaynaklı bir bellek yönetimi hatası meydana gelmesi durumunda yazılım geliştirici bu sorunun çözümü için daha eski derleyici sürümleri kullanmak zorunda ya da daha yeni sürümleri beklemek zorundadır.

Çöp Toplama (Garbage Collection)[değiştir | kaynağı değiştir]

Çöp toplama (Garbage Collection), program tarafından tahsis edilen ve artık kullanılamayan/erişilemeyen tahsislerin serbest bırakılmasına dayanan bir otomatik bellek yönetimi biçimidir, artık ihtiyaç duyulmayan bellek tahsislerine çöp (garbage) denir. Çöp toplama bir programın toplam çalışma süresinin önemli bir bölümünü oluşturabilir ve performansa olumsuz etki edebilir. Çöp toplamanın yürütülmesi öngörülemez olabilir, bu da yapılan performans testlerinde çöp toplama kaynaklı değişken sonuçlar elde edilmesine yol açabilir. Bununla birlikte programda dağılmış olarak önemli duraklamalar meydana gelebilir, bu duraklamalar çöp toplayıcı yürütüldüğü esnasında programın yürütülmesinin kilitlenmesinden kaynaklanmaktadır.

Çöp toplama kullanan dillere çöp toplanmış diller (Garbage Collected Languages) denir. Bir dilin ana tasarımı birden fazla bellek yönetim biçimini barındırabilmektedir. Örneğin bazı derleyiciler çöp toplama ve manuel bellek yönetimi arasında geliştiriciye bir seçim yapma imkânı sunmaktadır. Bir dilin çöp toplama sergiliyor olması için çöp toplamanın dilin ana tasarımına dahil olması ya da bir derleyici özelliği olması gerekmemektedir. Örneğin manuel bellek yönetimi sunan C ve C++ programlama dilleri için çeşitli çöp toplama uygulamaları (implementation) (Bkz. Boehm Garbage Collector) geliştirilmiştir.

Çöp toplama için referans sayımı ya da sahiplik gibi farklı yöntemler geliştirilmiştir.

İzleme (Tracing Garbage Collection)[değiştir | kaynağı değiştir]

Çöp toplama tekniği yaygın olarak çöp toplama takibi (Tracing Garbage Collection) ile gerçekleştirilir. Bu o kadar yaygın bir uygulamadır ki genellikle çöp toplama dendiğinde çöp toplama takibi kastedilmektedir. Çöp toplama izleme program içerisinde gerçekleştirilen tahsislerin kullanımlarını analiz eden ve kullanımda olmayan tahsisleri, bu tahsislere çöp (garbage) denir, tespit edip serbest bırakan bir çöp toplama tekniğidir.

Çöp izlemenin gerçekleştirilmesi için bazı izleme verilerinin çalışma zamanında depolanması gerekmektedir, bu da bir ek yük olarak yansımakta ve yazılımın bellek ayak izini artırmaktadır. Bu izlemenin gerçekleştirilmesi için kullanılan pek çok algoritma bulunmaktadır. Çöp toplama takibi bir derleyici özelliği olabilir ve derleyici tarafından çalışma zamanının bir parçası olarak sunulabilir. Örneğin C# ve Java programlama dillerinde çöp toplama takibi kullanılmaktadır ve bu yaklaşım çalışma zamanında tamamen otomatik bir şekilde yürütülür. Oluşturulan ilgili nesneler otomatik olarak çöp toplama takibine dahil edilir. Bir diğer yöntemde ise çöp toplama takibine dahil edilecek tahsislerin geliştirici tarafından bildirilmesi gerekir.

Nesne sonuçlandırma (object finalization) zamanlamasında çöp toplama takibi deterministik değildir. Çöp toplamaya tabii olabilecek duruma gelen her nesne eninde sonunda serbest bırakılacaktır lakin bunun gerçekleşme durumu öngörülemez. Çöp toplamanın ne zaman gerçekleşeceğine ya da gerçekleşmeyeceğine dair hiçbir garanti yoktur. Çöp toplama işlemi programın asıl algoritmasından kaynaklanmayan gecikmelere ve duraklamalara neden olup yürütme zamanının oldukça değişken bir hale gelmesine yol açabilir. Deterministik olmayan yapısı nedeniyle yeni bir nesne tahsis etmek bazen yalnızca nesnenin tahsis edilmesi şeklinde gerçekleşirken bazen uzun bir çöp toplama döngüsünün yürütülmesini tetikleyebilir.

package main

import "fmt"

type Car struct {
    Brand string
    Model string
}

func main() {
    // ptr heap tahsisli bir Car barındırmaktadır
    // tahsisin izlenmesi ve serbest bırakılmasını çöp toplayıcı üstlenmektedir
    ptr := &Car{"Ferrari", "330 P3"}

    fmt.Println(ptr.Brand, "-", ptr.Model)
}

Referans Sayımı (Reference Counting)[değiştir | kaynağı değiştir]

Referans sayma ilgili tahsise yapılan her bir referansın sayılması ve referansların hepsinin sıfıra ulaşması durumunda tahsisin serbest bırakılmasına dayanır. Bu teknikte her referans kendisine referans eden bir sayma verisi bulundurur. Bu sayma verisi referans her kopyalandığında artırılır ve kopya her yok edildiğinde azaltılır. Referans sayma verisi sıfıra ulaştığında tahsisi kullanan bir program noktası olmadığından serbest bırakılır.

Referans sayma çöp toplama takibinde olduğu gibi doğrudan derleyici tarafından otomatik bir şekilde gerçekleştirilebilir ya da yazılım geliştirici tarafından ilgili bölümlerde referans sayma gerçekleştirilebilir.

Referans sayma deterministik bir çöp toplama performansı sergiler. Bunun nedeni program yürütülürken bir referansın oluşturulma, kopyalama ve serbest bırakılma noktaları her zaman sabit olduğundan referansın serbest bırakılma işlemi her zaman aynı algoritma adımında gerçekleşir.

Referans sayma için kullanılan sayma verisi çalışma zamanında ek bellek ayak izi anlamına gelir. Bununla birlikte referans sayma işlemi algoritmaya göre önemli miktarda çalışma zamanı yükü oluşturabilir. Bununla birlikte bazı problemlere sahiptir, bu problemlerin yok edilmesi amacıyla çeşitli yöntemler uygulanmaktadır ve bu yöntemler performansa olumsuz etki edebilmektedir.

Referans saymanın atomiklik (atomicity) sergilemesi gerekmektedir. Çok iş parçacıklı bir ortamda bir referansın aynı anda kopyalanması durumunda referans sayma doğru bir şekilde gerçekleşmeyebilir, bunu önlemek için referans sayma atomik bir şekilde gerçekleştirilmelidir. Bu atomiklik çok iş parçacıklı bir senaryo olmadığı durumlarda dahi küçük de olsa bir çalışma zamanı ek yükü oluşturur.

Referansın sayma verisi üstünde işlem gerektirecek herhangi bir durumun iş parçacıkları tarafından çok fazla tekrarlanması bu atomikliğin programın toplam çalışma süresinin önemli bir bölümünü oluşturmasına neden olabilir.

Referans saymanın diğer bir sorunu döngüselliktir. Örneğin iki referansın birbirlerine referans vermesi durumunda referans sayısının asla sıfırlanmadığı bir döngü oluşturulabilir, bu önlemek için çeşitli döngü algılama algoritmaları vardır.

Referans sayma çeşitli şekillerde uygulanabilir ve bu uygulamaların kendilerine has dezavantajları olabilir. Bazı referans sayma uygulamalarında referans sayma verisi sıfırlandığında tahsisin direkt serbest bırakılması yerine serbest bırakılmayı bekleyen tahsislerin bulunduğu bir bölümde listelenebilir ve periyodik olarak bu listedeki tahsisler serbest bırakılabilir.

Bir referans sayma verisinin sıfıra ulaşılması durumunda yok edilen tahsis de bir referans ise, bu sıralı bir referans sayma başlatabilir ve belirli durumlarda pek çok referansın sayma verisi sıfıra ulaştığından sıralı ve uzun bir serbest bırakmanın tetiklenmesine yol açabilir.

#include <iostream>
#include <string>
#include <memory>

struct Car {
    std::string brand;
    std::string model;
};

int main() {
    {
        // ptr heap tahsisli bir Car sınıfı üstünde referans sayımı gerçekleştiriyor
        // tahsis ptr ile birlikte 1 referansa sahip
        std::shared_ptr<Car> ptr(new Car{"Ford", "GT40"});
        
        {
            // ptr2 artık ptr'nin tahsisine işaret ediyor
            // tahsisin referans sayısı 2'ye ulaştı
            std::shared_ptr<Car> ptr2{ ptr };

            std::cout << ptr2->brand << " - " << ptr2->model << std::endl;

        } // ptr2 kapsam dışı kaldığından referans bir eksildi lakin serbest bırakılmadı
          // halen bir referans daha var, ptr tahsise işaret ediyor

    } // ptr kapsam dışı kaldı, referans sayısı 0 olduğundan tahsis serbest bırakıldı

    return EXIT_SUCCESS;
}

Sahiplik (Ownership)[değiştir | kaynağı değiştir]

Sahiplik Rust programlama dilinin tasarımında benimsenen bir bellek yönetimi tekniğidir. Bu teknik çalışma zamanında çöp toplama amacıyla ek bellek ayak izi oluşturmaz, deterministik çalışır ve manuel bellek yönetimine ek olarak bir performans yükü yoktur. Manuel bellek yönetimi ile tamamen aynı çalışma zamanı maliyetine sahiptir.

Sahiplik kuralları derleyici tarafından kontrol edilir ve yönetilir. Bu da bellek yönetimi kurallarının ihlal edilmesi sonucunda derleyici tarafından hata belgelenmesine yol açacaktır. Bu sayede manuel bellek yönetiminde yazılım geliştirici tarafından yapılabilecek bellek yönetimi hatalarının engellenmesi ve tekniğin olumlu yönlerini korurken olumsuz yönlerinin ortaya çıkmasının engellenmesi amaçlanmaktadır.

Sahipliğin kuralları;^[3]

• Bir tahsisin her zaman bir sahibi olmalıdır.
• Bir tahsisin yalnızca tek bir sahibi olabilir.
• Sahibi olmayan bir tahsis kapsam (scope) dışına çıktığında serbest bırakılır.

Bu kuralları irdelemek gerekirse en önemli temel kural bir tahsisin her zaman bir sahibinin olması gerektiğidir. Bu kural sahiplik yaklaşımın kök kuralıdır. Sahibi olan bir tahsis farklı bir sahibe atandığında önceki sahip sahipliğini kaybeder zira aynı anda yalnızca tek bir sahip olma kuralı vardır.

Derleyicinin hata belgeleyeceği yerlerden birisi sahipliğin yanlış kullanımıdır. Sahipliğini kaybetmiş bir değişkeni kullanmak açıkça derleme hatasına neden olacaktır. Bu derleme zamanında gerçekleştirilen bir bellek güvenliği yaklaşımıdır.

Sahiplik tekniği bu noktaya kadar C programlama dilinde yapılan manuel bellek yönetiminden çok farklı değildir. Bir tahsis gerçekleştirildi ve yazılım geliştirici bir işaretçi ile bu tahsisin konumuna sahiptir, bu işaretçiyi farklı bir işaretçiye atayabilir ve bu bir sorun teşkil etmez. C ile geliştirilmiş bir programın tahsisin ne zaman boşaltılacağını anlamak gibi bir amacı yoktur. Bu nedenle yazılım geliştirici serbest bırakana kadar istediği gibi kullanmakta özgürdür lakin sonrasında yapılan bellek yönetimi hataları sonucunda çeşitli bellek sorunları ile karşılaşılabilir.

Rust, C programlama dilinin aksine derleme zamanında tahsisin nerede gerçekleşeceğini bilmek ister. Bunun için yalnızca tek bir sahip olmalıdır. O sahip izlenebilir ve yok edildiği durumda tahsisin serbest bırakılması gerektiği anlaşılmış olur. Tam olarak bu nedenden bir tahsisin tek sahibi vardır.

Sahipliği elinde tutan bir örnek yok edildiğinde, eğer halen elinde bulunduruyorsa doğal olarak başka bir noktada farklı bir sahip olamayacağından tahsisin serbest bırakılması gerçekleşir. Bu yaklaşım manuel bellek yönetiminin güvenli bir şekilde gerçekleştirilmiş olması için derleme zamanında (compile time) teşvik edilen bir türevi olarak düşünülebilir.

fn main() {
    let a = String::from("Merhaba sahiplik!");
    let b = a; // a artık kullanılamaz zira a'nın tahsisinin sahibi b'dir.
    let c = b; // b artık kullanılamaz zira b'nın tahsisinin sahibi c'dir.
    let d = c; // c artık kullanılamaz zira c'nın tahsisinin sahibi d'dir.
    println!("{}", d); // "Merhaba sahiplik!" yazar.
} // kapsam sonunda d yok edileceğinden, sahip olduğu tahsis serbest bırakılır.

Özellikler[değiştir | kaynağı değiştir]

Çok görevli işletim sistemlerinde bellek yönetim sistemleri genellikle aşağıdaki konuları içerir.

Yer değiştirme (relocation)[değiştir | kaynağı değiştir]

Sanal bellekli sistemlerde bellekteki programların farklı zamanlarda, belleğin farklı yerlerinde bulunabilmesi gerekir. Bunun temel nedeni, programın bir süreliğine bellekten dışarı götürülmesinin ardından tekrar geri getirildiğinde her zaman aynı bellek bölgesine yerleştirilmesinin mümkün olmamasıdır. Bu yüzden işletim sisteminin bellek yönetimi bellekte programların yerini değiştirebilmeli ve bu yer değiştirme sonrasında program kodu içindeki referansları doğru şekilde ayarlayarak her zaman bellekte doğru yeri işaret etmesini sağlayabilmelidir.

Koruma (protection)[değiştir | kaynağı değiştir]

Süreçler (process), başka süreçler için ilgili sürecin izni olmadan bellek başvurusu yapmamalıdır. Bellek koruması adı verilen bu mekanizma ile programdaki kötü niyetli ya da hatalı işleyen bir kodun diğer programların çalışmasını etkilemesi engellenir.

Paylaşma (sharing)[değiştir | kaynağı değiştir]

Farklı süreçler arasındaki bellek her ne kadar koruma altında olmuş olsa da uygun durumda farklı sürecin farklı bellek alanına erişip bilgiyi paylaşması mümkün olmalıdır.

Mantıksal yapılanma (logical organization)[değiştir | kaynağı değiştir]

Programlar genelde modüller şeklinde yapılandırılmıştır. Bu modüllerin bir kısmı gerek sadece okuma, gerekse veri değiştirme şeklinde başka programlar tarafından da kullanılabilir. Bellek yönetimi doğrusal fiziksel alanından farklı olan bu mantıksal yapılanmanın düzenlenmesinden sorumludur. Bunu sağlamanın yöntemlerinden birisi kesimlemedir (segmentation).

Fiziksel yapılanma (physical organization)[değiştir | kaynağı değiştir]

Bellek genellikle hızlı birincil depo ve yavaş ikincil depo şeklinde bölümlenmiştir (örneğin rastgele erişimli bellek RAM ve sabit disk gibi). İşletim sistemlerindeki bellek yönetimi bilginin bu bellek katmanları arasında taşınmasından sorumludur [4].

Ayrıca bakınız[değiştir | kaynağı değiştir]

• Sanal bellek (virtual memory)
• Sayfalama (paging)
• Bellek yönetim birimi (Memory Management Unit)

Kaynakça[değiştir | kaynağı değiştir]

Dış bağlantılar[değiştir | kaynağı değiştir]

• [1] http://yunus.hacettepe.edu.tr/~yurdugul/3/indir/isletim.pdf 5 Ekim 2011 tarihinde Wayback Machine sitesinde arşivlendi.
• [2] https://web.archive.org/web/20090419033658/http://www3.itu.edu.tr/~bkurt/Courses/os/lecture7.pdf
• [3] http://www.bote.gazi.edu.tr/boteabd/bto303/Notlar/Hafta6.pdf^{[ölü/kırık bağlantı]}