İşletim Sistemleri (Operating Systems)

Process’ler Arası Etkileşim

Prosesler Arasında Paylaşma Yoluyla İşbirliği Prosesler arasında kaynakları paylaşma yoluyla işbirliği yapılabilir. Paylaşılan kaynaklar : değişken, dosya, veri tabanı, gibi…. Process’ler birbirlerinin ürettiği verileri kullanabilir. Bu durumda; Karşılıklı dışlama gerekli Paylaşılan kaynaklara iki tür erişim yapılır: Yazma ve Okuma Yazmada karşılıklı dışlama olmalı Okuma için karşılıklı dışlama gereksiz

Prosesler Arasında Paylaşma Yoluyla İşbirliği Karşılıklı dışlama : Kritik bölge : Program kodunun, paylaşılan kaynaklar üzerinde işlem yapılan kısmı. Belirli bir anda sadece tek bir process kritik bölgesindeki kodu yürütebilir.

Karşılıklı Dışlama KB: Kritik Bölge İkiden fazla process de aynı kaynaklar üzerinde çalışıyor olabilir.

Karşılıklı Dışlama Çözümleri Özel Donanım Desteği Gerektirmeyen Çözümler Donanıma Dayalı Çözümler Yazılım ve Donanıma Dayalı Çözümler

Özel Donanım Desteği Gerektirmeyen Çözümler Kesmelerin Aktif ve Pasif Yapılması Bir process kritik bölgesine girince sistem kesmelere(interrupt) karşı kapatılarak diğer process’lerin ilgili kritik bölgesine girmesi engellenebilir ve kritik bölge tamamlanınca da tekrar kesmelere açılabilir. Böylece process kritik kısmını bitirene kadar CPU’yu kullanır ve başka bir process’in CPU’dan faydalanmasını engeller. Process 1 . . . kesmeler_pasif; toplam=toplam + degisim; kesmeler_aktif; Process 2 . . . kesmeler_pasif; toplam=toplam - degisim; kesmeler_aktif;

Kesmelerin Aktif ve Pasif Yapılması di; saniye1 = saniye; dakika1 = dakika; saat1 = saat; ei; di; saat = 0; dakika = 0; saniye = 0; ei; di : kesme devre dışı, ei : kesme kullanılabilir.

Özel Donanım Desteği Gerektirmeyen Çözümler Kesmelerin Aktif ve Pasif Yapılması Bu yöntemin en önemli sakıncası, kesme düzeneğinin denetimini sistemde çalışan çok sayıda process’e, özellikle çekirdek katmanı dışındaki process’lere de dağıtmasıdır. Kesme düzeneğinin tutarlı yönetimi güvenli bir işletim için vazgeçilmez bir gerekliliktir. Sistemin kesmelere açılıp kapatılması gibi temel bir aracı her düzeyden (ayrıcalıklı ve sıradan) process’in insiyatifine bırakmak, kesmelerin yönetimini bu process’lerle paylaşmak anlamına gelir. Kritik kesimlerin kesilmelere kapalı olarak işletilmesi CPU’nun tüm dış uyarılara kapatılması anlamına gelir. Bu da sistemin genel başarımını olumsuz yönde etkiler. Bu yöntem işlemcinin birden fazla process’i zaman paylaşımlı olarak çalıştırma özelliğine müdahaledir. Bu gerekçelere dayalı olarak kesme düzeneğinin karşılıklı dışlama için kullanılması, geçerli bir yol olarak benimsenemez.

Özel Donanım Desteği Gerektirmeyen Çözümler Dekker Algoritması : Dekker algoritması karşılıklı dışlama için icat edilmiş ilk algoritmalardandır. 1964'te T. J. Dekker tarafından geliştirilmiştir. İki proses için geliştirilmiş bir metottur. Yani ikiden fazla sayıda proses varsa uygulanabilirliği yoktur.

Dekker Algoritması ve Gelişim Süreci

Dekker Algoritması ve Gelişim Süreci: Birinci Aşama : Sıralı Çalışma (Strict Alternation) : ‘sira’, paylaşılan global bir değişken olsun. ‘sira’ 0 iken Process1 kritik kısmına girer, Process2 bekler. Process1 kritik bölgeyi terk ederken ‘sira’ değişkeni 1 yaparak Process2’nin kritik bölgeye girmesine olanak tanır. Process1’in tekrar kritik bölgeye girmesi Process2’nin kritik bölge işlemini tamamlaması ile mümkün olur. Shared int sira=0; Process 1 . . . while (sira!=0); //kritik kesim; sira=1; Process 2 . . . while (sira!=1); //kritik kesim; sira=0; Bu yaklaşım karşılıklı dışlamayı sağlar ancak bazı aksaklıkları vardır: Process’ler sıra ile çalışmak zorundadır.

Dekker Algoritması ve Gelişim Süreci: Birinci Aşama : Sıralı Çalışma (Strict Alternation) Problemler: Process’ler farklı hızlarda çalışabilecek olmalarına rağmen ancak sıralı şekilde çalışmak zorundadır. Gereksiz yere bekleme problemine sebep vermektedir. Bekleme blok durumda gerçekleşmediğinden CPU’nun kullanılmamasına sebep olur. Bu da kaynak israfıdır. Eğer process’lerden birisi biterse diğer process en fazla bir iterasyon sonunda boş beklemede sonsuz döngüye girer.

Dekker Algoritması ve Gelişim Süreci: Birinci Aşama : Sıralı Çalışma (Strict Alternation) Problemler: Bu algoritma ile process’ler kritik kesimlerine “bir o bir bu” diye nitelenebilen değişmez bir sırada erişebilmektedirler. Bir process kritik kesiminden çıkışta erişim sırasını diğer process yada process’lere bırakmakta, bu process’ler kritik kesimlerine girmedikleri sürece bir daha kritik kesimine girme hakkı kullanamamaktadır. Bu da, bir process’in kritik kesiminin dışında olmasına karşın diğer process’lerin kritik kesimlerine girmelerini engelleyen bir durum oluşturmaktadır.

Dekker Algoritması ve Gelişim Süreci: İkinci Aşama: Process’leri ortak kaynağa değişmez bir sırada erişmeye zorlayan bir önceki yaklaşımın aşılması amacıyla, sıra değişkeni yerine kaynağın kullanım durumunu gösteren ikili bir değişkenin kullanılması düşünülebilir. Bu durumda, sözkonusu değişkenin sıfır değerini içermesi kaynağın kullanılmakta olduğunu, bir değerini içermesi ise kaynağın serbest olduğunu simgeler. Ortak kaynağa erişmek isteyen process’ler kritik kesimlerine girmeden önce bu değişkeni sınarlar. Değişken içeriğinin 0 (sıfır) bulunması durumunda, kritik kesim girişinde bekleme sürdürülür. Değişken içeriğinin 1 (bir) bulunması durumunda ise içerik sıfırlanarak kritik kesime girilir. Kritik kesim çıkışında değişken içeriği kurularak (birlenerek) diğer process’lerin kaynağa erişebilmesi sağlanır.

Dekker Algoritması ve Gelişim Süreci: İkinci Aşama: Bu yaklaşım da karşılıklı dışlama şartını sağlamamaktadır. Proses1 ‘while’ döngüsünde ‘durum’ değişkenini ‘1’ olarak, daha sonrada Proses2 ‘durum’ değişkenini ‘1’ olarak tespit ederse, heriki process’de kritik kesimine girecektir. Process 1 Process 2 while(durum==0);/*bekle*/ while(durum==0);/*bekle*/ durum=0; durum=0; kritik-kesim-1(); kritik-kesim-2(); durum=1; durum=1;

Dekker Algoritması int kosul1, kosul2, sira; Process-1() Process-2() { { kosul1=true; kosul2=true; while (kosul2==false) while (kosul1==false) if (sira==2) if (sira==1) kosul1=false; kosul2=false; while (sira==2); while (sıra==1); } } ……. ……. Kritik Kesim 1 Kritik Kesim 2 ………. …….. sira=2; sira=1; koşul1=false; kosul2=false; ……….. ………. Diğer İşlemler-1 Diğer İşlemler-2 Eğer iki process aynı anda kritik bölgeye girmeye çalışırsa, Dekker algoritması o anki sıraya göre hangi process’in sırasıysa, sadece o process’in kritik bölgeye girmesine izin verir. Eğer bir process zaten kritik bölgedeyse, diğer process yoğun beklemede ilk process’in kritik bölgeden çıkmasını bekler. Bu algoritmaya göre birlikte çalışan iki process’in kritik kesimlerine eşzamanlı olarak girmeleri, kosul1 yada kosul2'nin, ilgili process’in kritik kesimine girmesinden önce mutlaka false olmasından dolayı olanaksızdır. koşul1 ve kosul2 kritik bölgeye girme amacını belirtirken, bir sıra değişkeni (sira) sayesinde iki process arasında hangisinin öncelikli olduğu belirtilir.

Özel Donanım Desteği Gerektirmeyen Çözümler Dekker Algoritması : İki proses için geliştirilmiş bir metottur. Yani ikiden fazla sayıda proses varsa uygulanabilirliği yoktur. Dekker Algoritması matematiksel yönden tam doğru olmakla birlikte en çok iki process’in zaman uyumlamasında kullanılabilmekte, yalın bir biçimde ikiden çok göreve genelleştirilememektedir. Bu önemli kısıtlamadan dolayı pratikte uygulanamamıştır.

Peterson Algoritması Dekker’in algoritması karşılıklı dışlama problemini çözmüştür. Ancak program oldukça karmaşıktır. Peterson’un çözümünün anlaşılması daha kolaydır. Peterson‘un orijinal algoritması sadece iki procees ile çalışır. Bu algoritma ikiden fazla process için genelleştirilebilir. Bu yöntemde de bir dizi oluşturulur ve her process için dizide bir eleman tutulur. Her process dizide kendisi için tutulan değişkeni 1 veya 0 yapar. Örneğin Process1 kritik alana girdiğinde dizideki değişkenini 1 yapar. Process2 de diziye girememiş olur. Process1'in değişkeni sıfır olmadan Process2 kendi değişkenini 1 yapamaz. Shared boolean flag[2]={False, False}; Shared int turn; Process 1 . . . flag[0]=True; turn=1; while(flag[1] && turn = = 1); //kritik kesim; flag[0]=False; Process 2 . . . flag[1]=True; turn=0; while(flag[0] && turn = = 0); //kritik kesim; flag[1]=False;

Peterson Algoritması Peterson algoritması da doğru bir şekilde kullanılabilir fakat bu metot yoğun beklemeyi yani işlemcinin boşuna kullanılmasını gerektirir. Bir process değişken değerini değiştirip, beklemede olan diğer process’in çalışabileceği sinyalini verirken aslında kendisinin çalışamayacağını da kodlamış olur. Ayrıca yoğun olarak bekleyen process, kritik bölgede çalışan bir process’den daha öncelikli olabilir. Bu durumda zamanlayıcı (scheduler) her zaman yoğun bekleyen sürece çalışma hakkı verebilir, bu şekilde sonsuza kadar iki process de bekler. Peterson'un algoritması gibi yazılım tabanlı çözümlerin modern bilgisayar mimarilerinde çalışmasının garantisi yoktur.

Donanım Desteği Gerektiren Çözümler

Semaforlar (Semaphore) Özellikle karşılıklı dışlama kapsamında yazılımsal yaklaşımlarda process’ler, kaynağın serbest olup olmadığını sürekli olarak sınamak suretiyle CPU’yu gereksiz yere meşgul ediyorlardı. 1965 yılında Edsger Dijkstra’nın process’ler arasındaki senkronizasyonu sağlamak için geliştirdiği semafor yapısıyla bu problem ortadan kalkmıştır. Semaforlar kullanım alanları ve tasarımları itibariyle ikiye ayrılır: ikili semaforlar (binary semaphores) tam sayı semaforları (integer semaphores) ikili semaforlar sadece iki process arasında eşleme (Synchronization) sağlar ve üçüncü bir iş için tasarlanmamıştır. Tam sayı semaforları ise istenilen miktarda process’i kontrol edebilir.

Semaforlar (Semaphore) Dijkstra çalışmasında, Almanca ‘Proberen : test et’ manasına gelen P operatörünü ve ‘Verhogen : arttır’ manasına gelen V operatörünü pozitif tamsayı tipinde değişken olan ‘s’ semoforu üzerinde uygulamıştır. V(s) : < s = s+1 > P(s) : < while(s < = 0) {bekle}; s = s-1 > Uygulamada; P() yerine wait(), V() yerine signal() kullanılır signal() semaforu arttırır , wait() azaltır.

Semaforlar (Semaphore) Semaforlar positif tamsayı-integer (0 dahil) değerlerini alabilen özel değişkenlerdir. Semaforların çalışması sırasında bölünmezlik (atomicity) ön plandadır. Semaforların bir sayacı bulunur. Bu sayaç başlangıçta semaforu oluşturan tarafından set edilir. Bir kod semafora girdiğinde sayaç azaltılır, çıktığında artırılır. Bir kod semafora girerken işletim sistemi semafor sayacına bakar. Sayaç 0’dan büyükse girme hakkını elde eder ve sayaç bir eksiltilir. Sayaç 0 ise semafora girmek isteyen kod semafor içerisinde bloke edilir. Başka bir kod semafordan çıktığında sayaç artırılır. Bekleyen kodlardan en yüksek öncelikli olan kod semafora giriş sağlar.

Semaforlar (Semaphore) Bir process kritik bölgeye girmek istediğinde P(s) işlecini çağırır ve işlemi bitince de V(s) işleciyle kritik bölgeden çıkar. : P(s); (Kritik bölge) V(s); Bu süre içinde gelen process P(s) işlecini çağırdığında kritik bölge kullanıldığından istek yapan process bekleme kuyruğuna alınır. Kritik bölgeyi kullanan process V(s) işlecini çağırmasıyla boşa çıkan kritik bölgeye bu bekleme kuyruğundaki process atanır ve kritik bölge tekrar kullanım durumuna alınır. Kritik bölgeyi kullanan process’in V(s) işlecini çağırmasıyla boşa çıkan kritik bölgeye varsa bekleme kuyruğundan yeni process atanır. Yoksa yeni bir process’in gelmesi beklenir.

Semaforlar (Semaphore) wait(sem) : if sem > 0 then sem ←sem-1 else /* sem 0 ise */ sem semaforu üzerinde bekle wait kendisine parametre olarak geçirilen semafor değişken değerini kontrol eder. Eğer sem 0’dan büyükse sem bir azaltılır ve process wait fonksiyonundan başarılı olarak geri döner ve işine devam eder. Eğer 0 ise process çalışma durumundan blok durumuna geçer ve sem değişkeni üzerinde bekler. signal(sem) : if sem değişkeni üzerinde bekleyen bir process varsa (blok durumunda olup sem değişkeni üzerinde bekleyen) then bu process uyandırılır else sem ←sem+1 signal kendisine parametre olarak geçirilen semafor değişkeni üzerinde bekleyen process varsa bu process’i uyandırır. Bir başka deyimle bu process’in blok durumdan hazır duruma geçmesini sağlar ve o process’e CPU verildiğinde kaldığı yerden devamı sağlanır. wait ve signal bölünemez (atomik) olarak gerçekleştirilirler. Bu sebeple wait ve signal içinde process’lere müdahele edilmesi ve CPU’nun bir başka process’e verilmesi söz konusu değildir. Process’ler kritik kısımlarına girmeden wait, kritik kısımdan da çıkarken signal işlemlerini yaparak karşılıklı dışlamayı garanti ederler.

Semaforlar (Semaphore)

İkili (binary) semaforlar Semaforların sadece 0 ve 1 değerleri alabildiği özel durumdur. Semaphore mutex=1; Process 1 . . . P(mutex); //kritik kesime giriş toplam=toplam + degisim; V(mutex); //kritik kesimden çıkış Process 2 . . . P(mutex); //kritik kesime giriş toplam=toplam -degisim; V(mutex); //kritik kesimden çıkış

Üretici/Tüketici (Producer/Consumer ya da Bounded Buffer) Problemi Üretici-Tüketici probleminde, üreticinin görevi yeni bir ürün ürettiğinde ortaklaşa kullanılan bir alana bırakmaktır, tüketicinin görevi ise bu alandan alarak bu ürünü kullanmaktır. Bu ortak alanın belli bir büyüklük sınırı vardır. Değişik sayıda üretici ve tüketici olabilir, problemin daha kolaylaşması için bir üretici ve bir tüketici olduğu kabul edilecektir.

Üretici/Tüketici (Producer/Consumer ya da Bounded Buffer) Problemi Ortak kullanılan alana aynı anda sadece bir erişim hakkı (üretici yada tüketici) verilir. Bunu sağlamak için mutex (mutual exclusion) isimli semafor kullanılır. Mutex sadece iki değer alır; 1 ise kritik kesime giriş yapılabilir, 0 ise beklenir. İkinci koşul, ortak alan boş ise tüketicinin bekletilmesidir, bu amaç için full semaforu kullanılır. Üçüncü koşul ise, ortak alanın dolması durumunda üreticinin bekletilmesidir, empty semaforu kullanılır. Proseslerin N boyutlu bir bellek alanını ortaklaşa kullandığı varsayılırsa, full ve empty semaforları 0 ile N arasındaki tamsayı değerlerini alabilen sayan (counting) semaforlardır.

Üretici/Tüketici (Producer/Consumer ya da Bounded Buffer) Problemi İnt N=100; Semaphore mutex=1; Semaphore full=0; Semaphore empty=N; Producer: Consumer: int item; . . . produce_item(item); //üretim işlemi P(empty); //bellek bölgesi doluysa proses bloklanır P(mutex); //kritik kesime giriş enter_item(item); //ürünü bellek bölgesine koy V(mutex); //kritik kesimden çıkış V(full); //1 bellek bölgesinin daha kullanıldığını //ifade eder int item; . . . P(full); //bellek bölgesi boşsa prosesi bloklar P(mutex); //krtik kesime giriş remove_item(item); //ürünü tampondan al V(mutex); //kritik kesimden çıkış V(empty); //1 bellek bölgesinin tekrar //kullanılabileceğini ifade eder. consume_item(item); //tüketim işlemi