Bu yazının amacı, eş zamanlı işlemlerin (concurrent processes) yönetimini anlatmak için geliştirilmiş bir örnek olan yemek yiyen filozoflar konusunu açıklamaktır. Eş zamanlı işlemler, işletim sistemleri (operating systems), ağ programlama (network programming) gibi pek çok bilgisayar bilimi konusunda geçmektedir.

Yemek yiyen filozoflar örneği, literatüre Dijkstra tarafından kazandırılmıştır ve eş zamanlı işlem yönetimini (concurrent process management) sembolize eder.

Öncelikle örneği anlatarak konuya başlayalım. Örneğe göre, ikiden fazla ( örnek için n kadar kabul edilebilir) filozof, bir yuvarlak masanın etrafına dizilerek yemek yerler. Literatürde örnek iki şekilde anlatılmaktadır ve orijinalinde filozoflar pirinç pilavı yemektedir. Buna göre pirinç yemek için iki adet yemek sopası (chopstick) gerekmektedir. Çinlilerin yemek yerken kullandıkları sopaları düşünebilirsiniz. Tek sopa ile yemek yenmesi imkansızdır ve her filozofun en az iki sopaya ihtiyacı vardır. Olayın daha iyi anlaşılması için aşağıdaki şekilde bu durum tasvir edilmiştir:

Şekilde de görüldüğü üzere, başlangıç durumunda, her filozofun iki yanında birer sopa durmaktadır.

Örneğin biraz daha batı dünyasına uyarlanmış halinde ( buna göre batıda çatal kullanılmaktadır), her filozof makarna yemek ister ancak makarna yemek için en az iki çatala ihtiyaç vardır. Filozofların iki yanında birer çatal olduğuna göre problem bir önceki pirinç ve Çinlilerin yemek sopası probleminden bir farkı kalmaz.

Problemde, yukarıda anlatılanlara ilave olarak, filozofların belirli bir süre düşünme süreci bulunur.

Problemin buna göre filozofların hepsi örneğin sağındaki sopayı alırsa, hepsinde birer sopa olacak ve yemek yiyemeyeceklerdir. Şayet hepsi iki yanındakini birden almaya kalkarsa, bu durumda, eş zamanlı işlemlerde karşılaşılan yarış durumu (racing condition) ortaya çıkacaktır ve hangisi önce davranırsa (ki bu konuda bir garantimiz bulunmamaktadır) o yemeğini yiyebilecektir. Ve belki de hepsi birer sopa alacağı için yine hiçbirisi yemek yiyemeyecektir. Şayet hepsi birden sopalarını bir diğeri yesin diye bırakırsa, bu durumda yine hiçbirisi yiyemeyecektir. Bu tip problemler, genelde kıtlık problemi (starvation) olarak düşünülebilir. Buna göre her filozofun yemek yeme ihtimali bulunmaktadır ancak hiçbir şekilde yiyeceği garanti edilmemektedir. Örneğin filozoflardan birisi her durumda aç kalabilir ve asla sıra kendisine gelmeyebilir.

Problemde karşılaşılan diğer bir sorun ise ölümcül kilitlenmedir (deadlock). Yanlış bir tasarım sonucunda, tek çatal alan ve çatalı bırakmak için diğer filozofun bırakmasını bekleyen bir filozof sistemi kilitleyebilir. Bu da problemde bulunan ikinci risktir.

Son olarak problemin tanımında, filozoflar birbiri ile konuşamaz kuralı getirilmiştir. Bu kural önemli bir kural olmakla birlikte, aşağıdaki çözümlerin çoğunda bu kuralın ihlal edildiği görülebilir. Aslında filozoflar birbiriyle çatallar üzerinden iletişim kurmaktadır. Örneğin sağındaki veya solundaki filozofun o anda çatalı alıp almaması, yanındaki filozoflar hakkında bilgi vermekte ve bu da üstü kapalı bir iletişim olarak kabul edilmektedir. Aşağıdaki çözümlerin tamamında iletişim sadece çatalların durumuna göre sağlanmaktayken, sadece son çözüm olan chandy misra çözümünde, filozoflar doğrudan birbiri ile iletişime geçebilmektedir.

Problemin çözümü için farklı algoritmalar geliştirilmiştir. Bu algoritmalar aşağıda başlıklar altında anlatılacaktır.

1. Rastgele süre çözümü (Random Solution)

Bu çözümde, filozofların problemi çözmek için tamamen rastgele davranması öngörülür. Filozoflar, bir çatal aldıktan sonra ikincisini alabilirse yemeğini yer. Şayet ikinci çatalı alamazsa rastgele bir süre bekler ve bu süre içinde ikinci çatalın boşalmasını bekler. Şayet bu süre içerisinde diğer çatal, yanındaki filozof tarafından bırakılırsa, çatalı alır ve yemeğini yer. Şayet beklediği bu rastgele süre boyunca ikinci çatal bırakılmazsa bu durumda yemeğini yiyemeden elinde tuttuğu çatalı diğer filozofun yemesi için masaya geri bırakır.

Bu çözümde dikkat edileceği üzere, işlem tamamen rastgelelik üzerine kuruludur. Buna göre sistem tam başarı ile çalışmayabilir. Hatta sistemin çalışacağının hiçbir şekilde garantisi yoktur.

Çözüm yönteminin en önemli özelliği, çözümün gerçeklemesinin (kodlamasının) diğer bütün sistemlere göre çok daha kolay olmasıdır.

2. Garson çözümü (Conductor Solution)

Problemin bir seviye daha karmaşık ancak yine de basit bir çözümü, masanın etrafında bir garsonun (literatürde conductor ismi verilmiştir ve bu yüzden conductor solution olarak geçer) dolaşmasıdır.

Garson, sürekli olarak masada boş duran ve filozoflar tarafından yemek için kullanılan çatalların sayılarını takip etmektedir. Bir şekilde her filozof, masadan çatal alabilmek için garsonun iznini istemek zorundadır. Şayet garson izin vermezse filozof masadan çatal alamaz. Bu çözümde filozofların kıtlık problemi (starvation) ile karşılaşmaları engellenir çünkü mantıklı bir garson tasarımı, bütün filozoflara yemek imkanı tanır. Aynı zamanda ölümcül kilitlenme (deadlock) ihtimali de çözülmüştür çünkü garson hiçbir filozofu sonsuza kadar bekletmez. Yani filozofların birbirini bekleyerek sonsuza kadar yaşlanması sorunu çözülmüştür.

Çözümün daha iyi anlaşılabilmesi için, garsonun, saat yönünde masada döndüğünü, düşünelim. O anda işaretlediği filozof yemek yiyor, sonraki yemiyor sonraki yiyor ve böylece kaç filozof farsa, sırayla bir yiyor bir yemiyor şeklinde düşünülebilir. Bu durumda her filozofun yemek yemek için yeterli çatalı (veya sopası) bulunuyor demektir. Sonra garson, sırasıyla bir yönde (örneğin saat yönünde) dönerek masayı dolaşmakta ve sıradaki filozofa yemek yedirmekte (ve dolayısıyla sıradaki filozoftan sonraki yememekte ve sonraki yemekte ve böylece bütün masadakiler bir yer bir yemez şeklinde işaretlenmektedir).

3. Monitör Çözümü (Monitor Solution)

Bu çözüm, bir önceki garson çözümüne çok benzemektedir. Amaç sırasıyla her filozofun bir yiyen bir de yemeyen şeklinde sıralanmasıdır. Burada her filozof belirli bir sırayla sıralanmaktadır (örneğin saat yönünde veya saat yönünün tersi istikamette) ardından kendinden önceki filozofun durumunu kontrol ederek yemek yiyorsa yemez, kendinden önceki filozof yemek yemiyorsa bu durumda kendisi yemek yer.

Tek sayıda filozof olması durumunda yemek yeme eyleminin masada bir dalga şeklinde bir noktadan başlayarak sürekli döndüğü görülebilir. Şayet filozof sayısı çift ise bu durumda sürekli aynı filozoflar yemek yerken diğer filozoflar ölecektir. Bir çözüm olarak, şayet toplam filozof sayısı çift ise, sırasıyla tek ve çift filozoflara yemek yedirmek bir çözüm olabilir. Örneğin önce 1,3,5 numaralı filozoflar yemek yerken, sonra 2,4,6 numaralı filozoflar yemek yiyebilir.

4. Chandy Misra Çözümü (Chandy Misra Solution)

Bu çözüm, geliştiren iki kişinin ismi ile anılmaktadır (K. Mani Chandy ve J. Misra). Çözümün en önemli özelliği, merkezi bir karar mekanizmasını ortadan kaldırması ancak buna karşılık, filozoflar birbiri ile konuşamaz kuralını çiğnemesidir.

Çözüm aşağıdaki 4 adımdan oluşmaktadır denilebilir:

1. Her filozof ikilisi için bir çatal üretilir ve bu çatal en düşük sayı sahibi olan filozofa verilir. Her çatal kirli veya temiz olarak işaretlenebilir ve başlangıç durumunda bütün çatallar kirlidir.
2. Bir filozof, bir kaynak kümesini kullanmak istediğinde (yani yemek yemek istediğinde), komşusu olan çatalları kullanmak zorundadır. Elinde olmayan (ihtiyacı olan) bütün çatallara bir talep yollar.
3. Bir filozof, elindeki bir çatal için talep aldığında, şayet elindeki çatal temizse kullanmaya devam eder, şayet çatal kirli ise, çatalı masaya koyar. Ayrıca masaya konan çatal temiz olarak işaretlenerek konulur.
4. Bir filozof yemek yedikten sonra çatalı kirli olarak işaretler. Şayet bir filozof, daha önce bir çatalı talep ettiyse, çatalı temzileyerek masaya koyar.

Yukarıdaki algoritma adımlarını şu şekilde anlamak mümkündür. Öncelikle bütün çatallara bir işaret getiriliyor. Buna göre bir çatal, kirli veya temiz olabiliyor. Çatalın talep edilmesi ve edilmemesi arasındaki fark, bu işaret ile belirleniyor. Üzerinde talep olmayan çatallar temiz olarak tutulurken, üzerinde bir filozofun talebi bulunması halinde kirli oluyor. Bu durumda ikinci bir filozofun talepte bulunması engelleniyor. Her çatal sadece talep eden filozof tarafından kullanılacağı için de kullanma işlemi öncesinde tek bir filozofa atama yapılmış oluyor. Ayrıca filozofların talep işleminin gerçekleşebilmesi için çatal kümesinin (iki çatalın birden) atamasının yapılması gerekmektedir. Şayet tek bir çatal ataması yapılırsa bu durumda çatal filozofa ayrılmadan diğer filozofun kullanımı için serbest olmuş oluyor.

Burada akla, acaba bu çatal ayırımı sırasında, problemin orjinalinde bulunan kilitlenme ihtimali bulunmaz mı? Şeklinde bir soru gelebilir. Bu soru aslında mantıklı bir soru olmakla birlikte, kilitlenme probleminin önüne geçmek için, algoritma tasarımında bulunan en küçük numaraya sahip filozof koşulu getirilmiştir. Yani filozofların hepsi aynı önceliğe sahip olduğu durumlarda bir kilitlenme ihtimali bulunmakla birlikte, bu ihtimali bertaraf etmek için her filozofa bir numara verilmiş ve bu numaraya göre en düşük değere sahip filozof öncelikli olmuştur. Peki sürekli bu filozof yemek yiyerek diğerlerini bir kıtlığa sokabilir mi? Bu durumda kirli ve temiz çatal ataması ile engellenmiştir.

108 views

Yazan : Şadi Evren ŞEKER

Bilgisayar bilimlerinde işletim sistemi tasarımı konusunda geçen ve kaynaklar üzerindeki kilitlenmeyi (deadlock)engelleme amaçlı algoritmadır. Algoritma Dijkstra tarafından geliştirilmiştir.

Algoritmanın temel 3 durumu ve 2 şartı bulunur:

Bilmesi gerekenler:

1. Her işlem (process) ne kadar kaynağa ihtiyaç duyar?

2. Her işlem (process) şu anda ne kadar kaynağı elinde tutmaktadır?

3. Şu anda ne kadar kaynak ulaşılabilir durumdadır?

Yukarıdaki bu bilgileri bildikten sonra kaynak ayrılması sırasında aşağıdaki şartları uygular:

1. Şayet talep edilen kaynak, azami kaynaktan (maximum) fazla ise izin verme

2. Şayet talep edilen kaynak eldeki kaynaktan fazla ise, kaynak boşalana kadar işlemi (process) beklet.

Yukarıdaki algoritma detayında, kaynak olarak geçen değer, işletim sistemi için herhangi bir şey olabilir (hafıza (RAM), giriş çıkış işlemleri (I/O), gerçek sistemler için çalışma zamanı gibi)

Banker algoritması ayrıca çalışması sırasında yukarıdaki takipleri yapabilmek için bazı veri yapılarına ihtiyaç duyar. Aşağıdaki veri yapıları için n, sistemdeki işlem (process) sayısı ve m birbirinden farklı kaynak sayısı (resource) olmak üzere:

Müsait : m adet elemanı olan bir dizidir. Dizinin her elemanı o kaynak tipinden ne kadar müsait olduğunu tutar. Örneğin M[i] = 5 değerinin anlamı, i kaynak tipinden beşinin müsait olduğudur.

Azami : iki boyutlu dizi ile tutulur ve n x m boyutlarındadır. Her işlem için ilgili kaynaktan ne kadar ayrım yapıldığı dizide işaretlenir. Örneğin Az[2][3]=5 gösteriminin anlamı, 2. işlemin 3. kaynak üzerinde 5 birimlik ayrım hakkı olduğudur. Diğer bir deyişle 2. işlem, 3. kaynaktan 5 birimden fazla kullanmaz, kullanmak istemez, kullanamaz.

Ayrım : yine iki boyutlu bir dizidir ve yine boyutu n x m olarak tutulur. Her işlemin her kaynağın ne kadarını kullandığını gösterir. Örneğin Ay[2][3] = 4 gösteriminin anlamı, o anda, 2. işlemin 3. kaynaktan 4 birim kullanıyor olduğudur (ayırmış olduğudur).

İhtiyaç: Benzer şekilde nxm boyutlarında bir dizi olarak tutulur ve her işlemin her kaynaktan ne kadar ihtiyaç duyduğunu tutar. Örneğin İ[2][3] = 1 gösteriminin anlamı, 2. işlemin, 3. kaynaktan 1 birim ihtiyacı olduğudur.

Algoritmanın çıktısı güvenli veya değildir (safe state, unsafe state). Buna göre algoritma, işlemlerin çalışıp bitme ihtimali varsa güvenli sonucunu döndürürken, işlemler, birbirini kilitliyorsa bu durumda güvensiz sonucunu döndürür.

Hesaplama:

Algoritma, güveni veya güvensiz sonucuna ulaşmak için adıma bağlı olarak, aşağıdaki hesaplamaları yapar:

Müsait = Müsait – İhtiyaç

Ayrım = Ayrım + İhtiyaç

İhtiyaç = Azami – Ayrım

Bu durumu bir örnek üzerinden açıklayalım. Örneğin A,B,C isimli üç kaynağımız olsun ve bu kaynakların müsaitlik durumları aşağıdaki şekilde olsun:

Kaynaklar
 A B C
10 5 7

Ayrıca 5 adet işlemimiz olsun ve bu işlemlerin anlık olarak azami ihtiyaçları, ayrılmış olan kaynaklar ve ihtiyaçları aşağıda verildiği gibi olsun:

     Azami       Ayrım
     A B C       A B C
P0   7 5 3       0 1 0
P1   3 2 2       2 0 0
P2   9 0 2       3 0 2
P3   2 2 2       2 1 1
P4   4 3 3       0 0 2

Soru bu durumun güvenli bir durum olup olmadığıdır. Diğer bir deyişle acaba bir kilitlenme riski bulunur mu? Yukarıda verilen değerlerin üzerinden ihtiyaç tablomuzu hesaplayalım:

     Azami   -   Ayrım    =  İhtiyaç
     A B C       A B C       A B C
P0   7 5 3       0 1 0       7 4 3
P1   3 2 2       2 0 0       1 2 2
P2   9 0 2       3 0 2       6 0 0
P3   2 2 2       2 1 1       0 1 1
P4   4 3 3       0 0 2       4 3 1

Yukarıdaki işlemden anlaşılacağı üzere Azami tablosundan, Ayrım tablosu çıkarılmış ve ihtiyaçlar bulunmuştur.

Bu durumda, sistem güvenli denilebilir çünkü ihtiyaç tablosundaki hiçbir değer, müsait dizimizdeki değeri geçmemektedir. Demek ki sistem bütün ihtiyaçlara cevap verebilecek kapasitededir.

Bu durumun daha iyi anlaşılması için P1, P2, P3, P4, P0 sırası ile çalışmayı görelim:

     Azami   -   Ayrım  =    İhtiyaç Müsait
     A B C       A B C       A B C            A B C
P1   3 2 2       2 0 0       1 2 2    3 3 2   3 3 2
P3   2 2 2       2 1 1       0 1 1    5 3 2
P4   4 3 3       0 0 2       4 3 1    7 4 3
P2   9 0 2       3 0 2       6 0 0    7 4 5
P0   7 5 3       0 1 0       7 4 3   10 4 7
                                     10 5 7<<< Kaynaklar

Görüldüğü üzere işlemlerin sonucunda ilk kaynak değerlerine geri dönülmüştür (aslında bütün işlemler bitince müsait olan kaynak değeri, başlangıçtaki değerdir).
Yukarıdaki çalışma sırası (yani P1, P2, P3, P4, P0 sırası) güvenli çalışma olarak kabul edilir. Örneğimizi biraz daha ilerletelim :
Acaba P1 işlemi (1,0,2) ihtiyacında olsaydı yine de güvenli durumda olur muyduk?
İhtiyaç kontrolümüz (1,0,2)<= (1,2,2) olacaktı
ve müsait durumumuz : (1,0,2)<= (3 3 2) olacaktı
Bu durumda tablomuz aşağıdaki şekilde olabilirdi:

      Azami      Ayrım      İhtiyaç  Müsait
      A B C       A B C     A B C    A B C
P0   7 5 3       0 1 0       7 4 3     2 3 0<<<
P1   3 2 2       3 0 2<<<    0 2 0<<<
P2   9 0 2       3 0 2       6 0 0
P3   2 2 2       2 1 1       0 1 1
P4   4 3 3       0 0 2       4 3 1

Bu durum güvenli midir?
Evet !
Çalışma sırası olarak P1, P3, P4, P0 ve P2 sırasında olması durumunda işlemler kilitlenme olmaksızın başarı ile çalışacaktır. Örneğin P4 için ihtiyacı (3,3,0) olarak yeniden ayarlasaydık güvenli bir durum elde edemeyecektik çünkü bu adımdaki (3,3,0) değeri o anda müsait olan (2,3,0) değerinden büyük olacaktı ve işlem (process) çalışamayacaktı.

658 views

Bilgisayar mühendisliğinde, birbirinde ayrı işlerin kontrolü için kullanılır. Aynı anda çalışan işlerin birbirinden tamamen ayrı olması için (mutually exclusive), bazı kontrollerin yapılması gerekmektedir. Algoritma bu problemi aşağıdaki şekilde çözer.

Yukarıdaki kodda, iki adet paylaşılmış değişken (shared variable) kullanılmış ve bu değişkenlere hem P0 hem de P1′in erişebileceği kabul edilmiştir. İki işlem (process) arasında senkronizasyonu sağlamak için kullanılan bu flag ve turn değişkenleri, P1 için aşağıdaki şekilde kontrol edilir.

Dikkat edilirse, P0 için yazılan kod, turn değişkeninin değeri 1 iken beklemekte ve P1 için yazılan kod ise turn değişkeni 0 iken beklemektedir. Bekleme işlemleri kodların 5. Satırlarında yapılmaktadır. Bekleme işlemi için kontrol edilen ikinci bir değer ise flag değişkeninin değeridir. Flag değişkeni, çalışmakta olan işlemlerin kritik alana girmek istememeleri durumunda boşuna beklemelerini engeller. Örneğin P0, kritik alana girmek istemiyorsa bu durumda P1′in kritik alana girmek için bir kontrol yapmasına gerek yoktur çünkü zaten kritik alana erişecek başka bir işlem de yoktur.

Sistemde kilitlenme (deadlock) ihtimali bulunmaz. Bunun sebebi turn isimli değişkenin anlık olarak 1 veya 0 değerlerinden birisine sahip olacağıdır. Bu değer, hangi işlemin çalışacağını belirler dolayısıyla aynı anda iki işlemin bekleme veya çalıma ihtimali yoktur.

Buradaki bekleme işlemi meşgul bekleme (busy wait) olarak kodlanmıştır. Yani değişkenlerin değerleri kontrol edilerek döngü sürekli olarak dönmektedir. Değişken değerleri, diğer işlem (process) tarafından değiştirildiğinde döngü kırılır ve kritik alan başlar. Bir işlem (process) değişken değerini değiştirip, beklemede olan diğer işlemin çalışabileceği sinyalini verirken aslında kendisinin çalışamayacağını da kodlamış olur. Dikkat edilirse, koddaki turn==0 kontrolü yapılmadan önce turn = 0 veya benzer şekilde turn==1 kontrolü yapılmadan önce turn=1 ataması yapılmaktadır.

252 views

Bilgisayar mühendisliğinde, birbirinde ayrı işlerin kontrolü için kullanılır. Aynı anda çalışan işlerin birbirinden tamamen ayrı olması için (mutually exclusive), bazı kontrollerin yapılması gerekmektedir. Algoritma bu problemi aşağıdaki şekilde çözer.

Yukarıdaki kodda görüldüğü üzere, kod üç kısımdan oluşmaktadır:

1. Bariyer
2. Kritik alan
3. Bitiş

Bariyer kodunda, işlem (process), diğer çalışmakta olan ve o anda kritik bir koda erişen işlemleri bekler. Kendi önündeki bariyerin kalkmasıyla kritik alana girer. Bu alana o anda giren tek işlemdir çünkü kendi önündeki bariyerin kalkması ancak diğer işlemin bitiş kodunu çalıştırması ile mümkündür. Kritik alandaki görevini yerine getirdikten sonra bitiş kodunu çalıştırır ve beklemeden olan diğer işlemin bariyerlerini kaldırır.

Yukarıdaki kodda kullanılan flag dizisi (array), boolean tipinde olup o anda hangi işlemin çalıştığını tutmaktadır. Örneğin yukarıdaki kodun simetriği olarak diğer işlemin kodu aşağıdaki şekilde verilebilir:

İkinci kod ile ilk kod karşılaştırılırsa, flag[] ve turn değişkenlerine göre kimin çalışacağı belirlenmektedir.

Kodlarda bulunan 7. Satırdaki while döngüsü, aslında bekleme işlemini sağlar. Bu döngü turn değişkenine göre sonsuza kadar beklemektedir. Ancak diğer işlem tarafından değeri değiştirilince işlem çalışmasına devam edebilir.

Burada kullanılan turn değişkeni, iki işlem de aynı anda kritik alana girmek istiyorsa, anlık olarak bir tanesinin girmesini sağlar. Flag değişkeni ise o anda kritik alan girmek isteyen diğer işlem olup olmadığını kontrol eder.

Örneğin P1 işlemi, kritik alana girmek istemiyorsa, P2 işleminin kritik alana girerken turn değişkenine bakmasının bir anlamı yoktur. Benzer şekilde P2 işleminin kritik alan ihtiyacı yoksa, P1 de turn değişkenine bakmaz. Ancak iki işlem (yani P1 ve P2) aynı anda kritik alana girmek istiyorlarsa turn değişkeni anlamlı olur.

Bu tip beklemelere meşgul bekleme (busy wait) ismi verilir. Bu ismin verilme sebebi, işlemin sürekli olarak değişkenin değerine bakarak değeri değişene kadar beklemesidir. Bu bekleme işleminin sürekli bir kontrol yapıyor olması, işlemci üzerinde bir yük getirmektedir.

Algoritmanın diğer bir özelliği ise kilitlenme (deadlock) ve kıtlık (starvation) konularına karşı dayanıklı olmasıdır. Algoritmamızda kilitlenme (deadlock) olmayacağı, turn değişkeninin kullanılmasından anlaşılabilir. Bu değişkenin sistemde anlık olarak tek değeri bulunacak (1 veya 0) ve bu değere göre sistem iki işlemden bir tanesini çalıştıracaktır.

Kıtlık (starvation) problemini görmek için ise bir ihtimalin daha hesaplanması gerekir. Buna göre örneğin P1 çalışıyor ve P0 bekliyorken, P1 işini bitirip P0′ın kilidini kaldırdığında P0 henüz çalışmaya başlamadan P1 yeniden çalışıyor mu diye algoritmaya bakmalıyız. Diğer bir deyişle, sürekli olarak kritik alana erişmeye çalışan P1 ve P0 işlemlerinden örneğin P1 işini bitirip kritik alandan çıktından sonra henüz P0 kritik alana girmeden yeniden P1 kritik alana giriyorsa kıtlık (starvation) oluşuyor demektir.

Algoritmada böyle bir durum yaşanmaz. Bunun sebebi algoritmanın kullandığı flag değişkenidir. P1 işlemi, kritik alandan çıkarken, beklemede olan P0 işleminin bariyerini kaldırır ve bu kaldırma sonucunda P0 işlemi çalışırken P1′in yeniden çalışmasını engelleyici biçimde, diğer tarafın flag değişkenini atar.

Kısaca algoritma kilitlenme (deadlock) ve kıtlık (starvation) ihtimallerine karşı başarılı bir şekilde çalışır.

249 views

Birbirini dışlama özelliği, birden fazla işin birbiri ile ilişkisizliğini belirtmek için kullanılan bir terimdir. Örneğin iki işlem (process) veya iki lifin (thread) birbirinden bağımsız çalışmasını, aynı anda bir işlemi yapmamasını istediğimiz zaman birbirini dışlama özelliğini kullanabiliriz. Bazı kaynaklarda, kısaca mutex (mutually exclusive kısaltması) olarak da geçer.

İki adet birbirine paralel ilerleyen iş için (concurrent) aynı anda bir kaynağa erişme veya birbirleri için kritik olan işlemler yapma ihtimali her zaman bulunur. Örneğin bilgisayarda çalışan iki ayrı lifin (thread) JAVA dilinde ekrana aynı anda bir şeyler basmaya çalışması veya paylaşılan bir dosyaya aynı anda yazmaya çalışması, eş zamanlı programlamalarda, sıkça karşılaşılan problemlerdendir. Bu problemin çözümü için, işlemlerin senkronize edilmesi gerekir ve temel işletim sistemleri teorisinde 4 yöntem önerilir:

• Koşullu Değişkenler (Conditional Variable)
• Semaforlar (Semaphores)
• Kilitler (Locks)
• Monitörler (Monitors)

Yukarıda sayılan bu 4 yöntem, basitçe iki farklı işi senkronize hale getirmeye yarar. Şayet iki ayrı işin birbirine hiçbir şekilde karışmaması isteniyorsa (mutex) bu durumda çeşitli algoritmaların kullanılmasıyla sistemdeki işlerin ayrılması sağlanabilir. Örneğin aşağıda, iki çok kullanılan algoritmaya bağlantı verilmiştir:

• Dekker Algoritması
• Peterson Algoritması

300 views

Bu yazının amacı, işletim sistemlerinde, özellikle de birden fazla işlemin çalıştığı ve aynı hafızayı paylaştığı çok işlemli (multiprocessed) sistemlerde, hafızadaki güvenlik çözümlerini açıklamaktır.

Birden fazla işlemcinin çalıştığı ortamlarda karşılaşılan en kritik hafıza problemi, bir işlemin diğer işlemlerin hafızada (RAM) tutulan bilgilerini okuması veya değiştirmesidir. Bir işlem (prcocess) tanım itibariyle kendi hafıza alanında çalışır. Dolayısıyla kendisine ayrılan yer dışında bulunan, işletim sisteminin temel bilgilerine (ki işletim sisteminin kendisi de bir işlemdir (process)) veya diğer programlara eriştiği anda bir güvenlik ihlali olur. Bu ihlal veri çalınması, veri değiştirilmesi veya sistemin bozulması olarak karşımıza çıkabilir. (İngilizcedeki security ve reliability kelimelerinin ikisi için de Türkçede kullanılan güvenlik, buradaki iki durumu da karşılıyor, yani hem verinin korunması anlamında security, hem de sistemin sağlıklı çalışması anlamında reliability)

Çit Koruması (Fence)

Hafızayı korumak için kullanılan en basit yöntemdir. İşletim sisteminin kendisini koruması için kullanılır. Bu yöntemde, işletim sistemi ile kullanıcı programları arasında bir çit varmış gibi kabul edilir ve çitin bir tarafındaki kullanıcı programlarının, diğer tarafa geçmesi engellenir.

Yukarıdaki şekilde örneğin 12022 adresinde bir çit bulunmaktadır. Bu durumda kullanıcı programları 12023 numaralı adresten başlamakta ve daha büyük değerlere sahip olmaktadır. İşletim sistemi, herhangi bir işlemin (process) daha düşük değerdeki bir adrese erişmesine izin vermemektedir.

Bu yaklaşımda tek amaç, işletim sisteminin kendisini, kullanıcı programlarından korumasıdır. Kullanıcı programları arasında bir güvenlikten bahsedilemez.

Taban Sınır Yazmaçları (Base Bound Registers)

Bu yaklaşımda, sistemde çalışan işlemler arasında güvenlik sağlanması amaçlanır. Buna göre sistemde bulunan bütün işlemlerin bir başlangıç (base) bir de sınır (bounds) değeri bulunur. Bu değerlerin dışına erişimleri yasaktır ve erişim talepleri, işletim sistemi tarafından engellenir.

Örneğin, yukarıdaki şekilde iki programın sistemde çalışıyor olduğunu kabul edelim. Program A’nın başlangıç değeri 16384 ve Program B’nin başlangıç değeri 24576 olarak verilmiş.

Programların her birisi için ayrı ayrı olmak üzere taban ve sınır değerleri belirlenmiştir. Örneğin yukarıdaki şekilde, Program A’nın taban ve sınır değerleri görülmektedir. Bu durumda Program A’nın belirtilen taban değerinden düşük ve belirtilen sınır değerinden yüksek adreslere erişimi engellenmiştir.

Ayrıca işletim sisteminde, kıtalama (segmentation) veya sayfalama (paging) kullanılması durumlarında, kullanılan yöntem, hafızadaki programın başlangıç ve bitiş değerlerini de tutmaktadır. Bu yönteme göre sistemde hafıza erişim politikası kullanılabilir.

Ayrıca hafıza üzerinde yapılan bazı işlemler için de güvenlikten bahsedilebilir.

İşlem Taşıma (Relocation)

Bir işlemin, hafızadaki bir konumdan farklı bir konuma taşınması işlemidir.

Yukarıdaki şekilde görüldüğü üzere, Program A, eski konumundan yeni konumuna taşınır. Taşıma işleminden sonra tasarıma bağlı olarak, programın adres erişimleri güncellenebilir veya yeni adrese göre kaydırma değeri eklenebilir.

Etiketleme (Tagging)

Hafızaya yüklü bir programın, kendisine tanınan alanların dışında bir yere erişip erişmediğini kontrol etmeye yarayan bir yöntemdir. Öncelikle programda bulunan komutlar aşağıdaki üç değerden birisine göre etiketlenir.

• Veri (Data)
• Gösterici (Pointer)
• Kontrol (Control)

Bu değerlere göre işaretlemenin ardından, ilgili adres değerleri kontrol edilir ve erişim haklarının olup olmadığı sınanır.

Yukarıdaki şekilde, programın her satırında ilgili işaretleme işlemleri yapılmıştır. Bu işaretleme işlemlerine göre erişilmek istenen hafıza alanı kontrol edilebilir.

166 views

Linux 2.6.23 sürümünden sonra çekirdekte (kenel) kullanılan zamanlama algoritmasıdır (CPU Scheduling). Algoritmanın özelliği, CPU meşguliyetini (CPU Utilisation) azami seviyeye getirmek ve işlemciden azami derecede istifade etmektir.

2.6.23 sürümünden önce Linux çekirdeğinde kullanılan O(1) zamanlama (O(1) scheduling) algoritması, performans kriterini sistemdeki bekleme sırası (ready queue) üzerine kurmaktaydı. CFS algoritması ise işlemlerin bekletildiği veri yapısını, kırmızı-siyah ağacına (red black tree) çevirmiştir.

Ayrıca CFS algoritmasında, zaman aralıkları nano saniyeler cinsinden hesaplanmakta ve dolayısıyla çok küçük zaman aralıklarında yapılan işlemler, sezgisel algoritmaların (heuristic algorithm) kullanılması gereğini ortadan kaldırmaktadır.

Zamanlama yaklaşımında, ayrıca işlem grupları oluşturulmakta ve gruplar arasında adalet sağlanması hedeflenmektedir. Bu sayede kullanıcı ile iletişimde olan masa üstü uygulamaları gibi uygulamalara daha fazla öncelik verilerek, arka planda çalışan daha düşük öncelikli sunucu görevlerinin, işlemci üzerindeki yükü azaltılmaktadır.

185 views

İşlemci zamanlama (CPU Scheduling) yaklaşımlarından birisidir. Bu yaklaşımda, işlem (process) sayısına bakılmaksızın bütün işlemlere eşit miktarda zaman ayrılır. Genel olarak bir işletim sistemi zamanlama algoritmasının öncelikli amacı, sistemin verimli olarak kullanılması ve sistemdeki ek yükleri (overhead) azaltarak sistemde kıtlık (starvation) ve kilitlenmeleri (deadlock) önlemektir.

Ayrıca özel bir işletim sistemi grubu olan gerçek zamanlı işletim sistemleri (RTOS, real time operating systems) için zamanlama işlemlerinin belirgin olması gerekir. Yani bir işlemin çalışacağı ve biteceği zamanlar tam olarak bilinmelidir. O(1) zamanlama algoritmasında, bir işlemin sistemde çalışacağı süre kesin olarak belirlenmiştir. Linux 2.6.23 sürümü öncesinde kullanılan bu O(1) zamanlama sisteminde, işlemler kesin bir süre çalışıp ardından bitmemeleri halinde bekleme sırasına (ready queue) taşınmakta ve tekrar çalıştırılmak için beklemektedir. Linux zamanlaması 2.6.23 sonrasında CFS (completely fair schedular, Tam Adil Zamanlama) ile değiştirilmiştir.

O(1) ismi, karmaşıklık teorisindeki big-oh gösteriminden gelmektedir ve sistemin en kötü durum analizinin 1 olduğunu belirtir. Bu değer karmaşıklık analizi (complexity class) için elde edilebilcedek en iyi değerdir.

292 views

Genel olarak bir işin yapılması için, gereken ek maliyetlere verilen isimdir. Örneğin bir kamyonun, bir yükü taşıması için, kendisini de taşıması gerekir. Kendisini taşımasının maliyeti, bu işlemdeki ek yüktür (overhead).

Bilgisayar bilimlerinde, çeşitli alanlarda farklı anlamlarla kullanılmaktadır.

Örneğin veri iletişimi (network) konusunda ek yük (overhead) denildiğinde genelde bir veriyi iletmek için kullanılan teşrifatın (protokol) kendi içindeki ilave haberleşmeleri kast edilir. Örneğin TCP/IP protokolünü ele alalım. Veriyi doğrudan iletmek yerine öncelikle 3 yönlü el sıkışma (three way hand shaking) işlemi ile taraflar arasında iletişim kurulur. Ardından her taşınan veri için TCP/IP paketinin başlık ve sonluk bilgileri de taşınır (ki bu bilgilerin içerisinde örneğin paketin nereden gelip nereye gittiği bilgisi bulunur). İşte veri iletmek için ayrılan kanal veya kaynakların bir kısmının, veriyi taşımak yerine protokole özgü ilave bilgileri taşıması genelde veri iletişimi (network) açısından ek yük (overhead) olarak isimlendirilir.

Programlama dilleri açısından çağırma ek yükü (call overhead) ismi verilen kavram, bir fonksiyonun çağrılması sırasında yaşanan ek yüktür. Bir programlama dilinde, herhangi bir fonksiyon çağrıldığında, bu fonksiyonun çalışması sonucunda döneceği yer bir yığında (stack) tutulur. Fonksiyon çalışıp işi bittikten sonra program akışına bu noktadan devam edilir. Bu şekilde fonksiyonlar birbirini çağırarak devam edebilir. Örneğin A fonksiyonu B’yi, B fonksiyonu C’yi … şeklinde birbirilerini çağırdıklarında fonksiyonun çalışması için gereken yere ilave olarak fonksiyon bilgisi için ilave bir yer tutulması gerekir. Bu yere ve bu yer üzerine yapılan işlemlere çağırma ek yükü (call overhead) ismi verilir.

İşletim sistemleri açısından zamanlama ek yükü (scheduling overhead) ismi verilen kavram, bir zamanlama algoritmasının, işlemler arasında geçiş yaparken kaybettiği kaynaklardır. Örneğin kesintili zamanlama (preemptive scheduling) kullanılan algoritmalarda bu ek yük miktarı (overhead) artacaktır.

161 views

İşlemci zamanlama (CPU Scheduling) konusunda kullanılan kavramsal bir yaklaşımdır. Bu zamanlama algoritmasının amacı, en kıymetli sistem kaynaklarından birisi olan işlemcinin (CPU), adil bir şekilde dağıtılmasıdır. Örneğin 10 kullanıcılı bir sistemde, kaynaklar bütün kullanıcılara %10 oranında dağıtılacak ve sonuçta adalet sağlanacaktır.

Şayet kullanıcılardan birsinin iki farklı işlemi bulunursa, bu durumda kaynakları %5 oranında paylaşılacaktır çünkü kullanıcının toplam CPU hakkı %10′dur.

FSS yaklaşımında ayrıca grup kullanımı da mümkündür. Kullanıcı gruplarına ve bu gruptaki kullanıcılar arasında işlemcinin paylaştırılması mümkündür. Örneğin 4 gruplu bir sistemde, her gruba işlemci zamanının %25′i ayrılacaktır. Örneğin 5 kullanıcılı bir grupta, kullanıcı başına %5 kaynak ayrılırken, 10 kullanıcılı ikinci bir grupta, kullanıcı başına %2,5 kaynak ayrılacaktır. Bu yaklaşımda grup kullanıcıları arasında da adalet sağlandığı var sayılmıştır. Gruplar arası adalet sağlayıp (fairness) grup içerisinde farklı algoritmalar da kullanılabilir.

Benzer bir adalet sağlama yaklaşımı da round robin algoritmasının kullanılmasıdır. Adalet sağlanmak istenen varlıklar arasında (örneğin gruplar, kullanıcılar, işlemler (process)) belirli bir zaman aralığında dönme sağlanarak adalet hedeflenebilir.

Burada anlatılan adaletli dağıtım yaklaşımı sadece kavramsal bir yaklaşımdır, bu yaklaşımın gerçek uygulamaları da bulunmaktadır. (örneğin CFS, completely fair scheduling, tam adil zamanlama gibi)

175 views