Bölüm 5: Süreç Senkronizasyonu

Transkript

1 Bölüm 5: Süreç Senkronizasyonu Mehmet Demirci tarafından çevrilmiştir. Silberschatz, Galvin and Gagne 2013

2 Bölüm 5: Süreç Senkronizasyonu Giriş Kritik bölüm problemi Peterson ın Çözümü Senkronizasyon Donanımı Mutex Kilitleri Semaforlar Klasik Senkronizasyon Problemleri İzleyiciler Senkronizasyon Örnekleri Alternatif Yaklaşımlar 5.2 Silberschatz, Galvin and Gagne 2013

3 Hedefler Süreç senkronizasyonu kavramına giriş Paylaşılan verinin tutarlılığına ilişkin kritik bölüm problemine giriş Kritik bölüm problemine yazılım ve donanım çözümleri sunmak Klasik süreç senkronizasyonu problemlerini incelemek Süreç senkronizasyonu problemlerini çözmekte kullanılan araçları incelemek 5.3 Silberschatz, Galvin and Gagne 2013

4 Giriş Süreçler eşzamanlı olarak yürütülebilir. Herhangi bir anda kesilebilirler, yürütülme yarım kalabilir. Paylaşılan veriye eşzamanlı erişim veri tutarsızlığına yol açabilir. Veri tutarlılığını ve işbirliği yapan süreçlerin sıralı yürütülmesini sağlamak için mekanizmalar gereklidir. 5.4 Silberschatz, Galvin and Gagne 2013

5 Giriş Üretici-tüketici problemi için bütün buffer ları dolduran bir çözüm istiyoruz. Bunu yapmak için bir sayaçla dolu buffer sayısını takip edebiliriz. Sayaç 0 dan başlar ve üretici tarafından arttırılır, tüketici tarafından azaltılır. 5.5 Silberschatz, Galvin and Gagne 2013

6 Üretici while (true) { /* produce an item in next produced */ } while (counter == BUFFER_SIZE) ; /* do nothing */ buffer[in] = next_produced; in = (in + 1) % BUFFER_SIZE; counter++; 5.6 Silberschatz, Galvin and Gagne 2013

7 Tüketici while (true) { while (counter == 0) ; /* do nothing */ next_consumed = buffer[out]; out = (out + 1) % BUFFER_SIZE; counter--; /* consume the item in next consumed */ } 5.7 Silberschatz, Galvin and Gagne 2013

8 Yarış Durumu counter++ farklı şekillerde gerçekleştirilebilir: register1 = counter register1 = register1 + 1 counter = register1 counter-- farklı şekillerde gerçekleştirilebilir: register2 = counter register2 = register2-1 counter = register2 count = 5 durumundan başlayan örnek yürütme: S0: producer execute register1 = counter {register1 = 5} S1: producer execute register1 = register1 + 1 {register1 = 6} S2: consumer execute register2 = counter {register2 = 5} S3: consumer execute register2 = register2 1 {register2 = 4} S4: producer execute counter = register1 {counter = 6 } S5: consumer execute counter = register2 {counter = 4} 5.8 Silberschatz, Galvin and Gagne 2013

9 Kritik Bölüm Problemi n süreçli {p 0, p 1, p n-1 } bir sistem düşünün. Her sürecin kritik bölüm denen bir kod parçası var Süreç ortak değişkenleri değiştiriyor, tablo güncelliyor, dosyaya yazıyor vs. olabilir. Bir süreç kendi kritik bölümündeyken başka hiçbir süreç kritik bölümde olamaz. Kritik bölüm problemi bu durumu çözmek için protokol geliştirmeyi hedefler. Her süreç kritik bölüme girmek için izin istemeli (entry section giriş bölümü), daha sonra çıkış bölümü - exit section bulunabilir, daha sonra kalan bölüm - remainder section 5.9 Silberschatz, Galvin and Gagne 2013

10 Kritik Bölüm P i sürecinin genel yapısı 5.10 Silberschatz, Galvin and Gagne 2013

11 P i Sürecinin Algoritması do { while (turn == j); critical section turn = j; remainder section } while (true); 5.11 Silberschatz, Galvin and Gagne 2013

12 Kritik Bölüm Problemine Çözüm 1. Karşılıklı Dışlama (Mutual Exclusion) - Eğer P i süreci kritik bölümündeyse, başka bir süreç kritik bölümde olamaz. 2. İlerleme Eğer hiçbir süreç kritik bölümde değilse ve kritik bölüme girmek isteyen süreçler varsa, kritik bölüme girecek sonraki sürecin seçimi süresiz ertelenemez. 3. Sınırlı Bekleme (Bounded Waiting) Bir sürecin kritik bölüme girme isteği yapmasından bu isteğin yerine getirilmesine kadarki sürede diğer süreçlerin kendi kritik bölümlerine kaç kere girebilecekleri sınırlanmış olmalıdır. Her sürecin sıfır olmayan bir hızda yürütüldüğü varsayılır. n sürecin göreceli hızları hakkında varsayım yapılmaz Silberschatz, Galvin and Gagne 2013

13 OS içinde Kritik Bölüm Yönetimi İki yaklaşım Preemptive çekirdek modundaki süreçlerin boşa çıkarılmasına izin verir Non-preemptive çekirdek modundan çıkana kadar çalışır, engeller, veya CPU yu kendisi verir. Çekirdek modunda yarış durumları oluşmaz Silberschatz, Galvin and Gagne 2013

14 Peterson Çözümü İki süreç için çözüm load ve store makine dili komutlarının atomik olduğunu, yani kesilemeyeceklerini varsayalım. Süreçler iki değişken paylaşır: int turn; Boolean flag[2] turn değişkeni kritik bölüme girme sırasının kimde olduğunu gösterir. flag dizisi bir sürecin kritik sürece girmeye hazır olup olmadığını gösterir. flag[i] = true ise P i hazırdır Silberschatz, Galvin and Gagne 2013

15 P i Sürecinin Algoritması do { flag[i] = true; turn = j; while (flag[j] && turn == j); critical section flag[i] = false; remainder section } while (true); 5.15 Silberschatz, Galvin and Gagne 2013

16 Peterson Çözümü Üç kritik bölüm gereksiniminin karşılandığı ispatlanabilir: 1. Karşılıklı dışlama korunur. P i kritik bölüme ancak şu koşulda girer: flag[j] == false veya turn == i 2. Süreç ilerlemesi sağlanır. 3. Sınırlı bekleme gereksinimi karşılanır Silberschatz, Galvin and Gagne 2013

17 Senkronizasyon Donanımı Birçok sistemde kritik bölüm kodunun gerçekleştirimini destekleyen donanım vardır. Bundan sonra açıklanacak bütün çözümler locking (kiliteme) fikrine dayalıdır. Kritik bölümler kilitlerle korunur. Tekli işlemciler kesmeleri devre dışı bırakabilir. Çalışan kod preemption olmadan yürütülür. Çok işlemcili sistemlerde verimsizdir. Modern makineler özel atomik donanım komutları sunar. Atomic = kesilemez Ya bellek kelimesini sına (test) ve değerini değiştir (set). Veya iki bellek kelimesinin değerlerini değiş-tokuş et (swap) Silberschatz, Galvin and Gagne 2013

18 Kritik Bölüm Problemine Kilitlerle Çözüm do { acquire lock critical section release lock remainder section } while (TRUE); 5.18 Silberschatz, Galvin and Gagne 2013

19 test_and_set Komutu Tanım: boolean test_and_set (boolean *target) { boolean rv = *target; *target = TRUE; return rv: } 1. Otomatik olarak yürütülür. 2. Verilen parametrenin orijinal değerini döndürür. 3. Verilen parametrenin yeni değerini TRUE olarak değiştirir Silberschatz, Galvin and Gagne 2013

20 test_and_set() Kullanan Çözüm Paylaşılan boolean değişken - lock, ilk değeri FALSE Çözüm: do { while (test_and_set(&lock)) ; /* do nothing */ lock = false; } while (true); /* critical section */ /* remainder section */ 5.20 Silberschatz, Galvin and Gagne 2013

21 compare_and_swap Komutu Tanım: int compare _and_swap(int *value, int expected, int new_value) { int temp = *value; if (*value == expected) *value = new_value; return temp; } 1. Otomatik olarak yürütülür. 2. Verilen value parametresinin orijinal değerini döndürür. 3. Ancak value == expected ise, value parametresine verilen new_value parametresinin değerini yaz. Değiş-tokuş için yukarıdaki eşitlik şarttır Silberschatz, Galvin and Gagne 2013

22 compare_and_swap Kullanan Çözüm Paylaşılan tamsayı lock ilk değeri 0 Çözüm: do { while (compare_and_swap(&lock, 0, 1)!= 0) ; /* do nothing */ /* critical section */ lock = 0; /* remainder section */ } while (true); 5.22 Silberschatz, Galvin and Gagne 2013

23 test_and_set ile Sınırlı Beklemeli Karşılıklı Dışlama do { waiting[i] = true; key = true; while (waiting[i] && key) key = test_and_set(&lock); waiting[i] = false; /* critical section */ j = (i + 1) % n; while ((j!= i) &&!waiting[j]) j = (j + 1) % n; if (j == i) else lock = false; waiting[j] = false; /* remainder section */ } while (true); 5.23 Silberschatz, Galvin and Gagne 2013

24 Mutex Kilitleri Bundan önce sunulan donanım çözümleri karmaşıktır ve genelde uygulama programcılarının kullanımına açık değildir. OS tasarımcıları kritik bölüm problemini çözmek için yazılım araçları geliştirirler. En basiti mutex kilididir. Kritik bölümü korumak için önce kilit acquire() ile alınır, sonra release() ile bırakılır. Kilidin alınabilir olup olmadığını bir boolean değişken belirler. acquire() ve release() çağrıları atomik olmalıdır. Çoğunlukla donanımdaki atomik komutlarla gerçekleştirilirler. Fakat bu çözüm busy waiting (meşgul bekleme) gerektirir Silberschatz, Galvin and Gagne 2013

25 acquire() ve release() acquire() { while (!available) } ; /* busy wait */ available = false;; release() { } do { available = true; acquire lock critical section release lock remainder section } while (true); 5.25 Silberschatz, Galvin and Gagne 2013

26 Semafor Süreçlerin senkronize olması için mutex kilitlerinden daha ileri yöntemler sunan senkronizasyon aracı Semafor S tamsayı değişken Sadece iki bölünemez (atomik) işlem ile erişilebilir. wait() ve signal() Eski isimleri P() ve V() wait() işlemi wait(s) { } while (S <= 0) S--; ; // busy wait signal() işlemi signal(s) { } S++; 5.26 Silberschatz, Galvin and Gagne 2013

27 Semafor Kullanımı Sayan semafor sınırsız tamsayı değer İkili semafor sadece 0 veya 1 olabilen tamsayı değer mutex kilidi ile aynı Çeşitli senkronizasyon problemlerini çözebilir. P 1 ve P 2 süreçlerinde S 1 olayı S 2 den önce gerçekleşmek zorunda olsun. synch semaforu oluştur ve 0 yap. P1: S 1 ; signal(synch); P2: wait(synch); S 2 ; Sayan semafor S ikili semafor olarak gerçekleştirilebilir Silberschatz, Galvin and Gagne 2013

28 Semafor Gerçekleştirimi Aynı semafor üzerinde aynı anda iki sürecin wait() ve signal() yürütememesi garantilenmelidir. wait ve signal kodunun kritik bölüme koyulduğu bir kritik bölüm problemine dönüştü. Şimdi kritik bölüm gerçekleştiriminde meşgul bekleme bulunabilir. Ama kod kısa Kritik bölüm nadiren doluysa meşgul bekleme azdır. Uygulamalar kritik bölümlerde uzun zaman harcayabilir, dolayısıyla bu iyi bir çözüm değildir Silberschatz, Galvin and Gagne 2013

29 Meşgul Beklemesiz Semafor Gerçekleştirimi Her semafor için bir bekleme kuyruğu bulunur. Kuyruktaki her girdi iki tür veri tutar: değer (tamsayı) bir sonraki kayda pointer İki işlem: block (engelle) işlemi çağıran süreci uygun bekleme kuyruğuna yerleştir. wakeup (uyan) bekleme kuyruğundaki süreçlerden birini oradan çıkarıp hazır kuyruğuna yerleştir. typedef struct{ int value; struct process *list; } semaphore; 5.29 Silberschatz, Galvin and Gagne 2013

30 Meşgul Beklemesiz Semafor Gerçekleştirimi wait(semaphore *S) { } S->value--; if (S->value < 0) { add this process to S->list; } block(); signal(semaphore *S) { } S->value++; if (S->value <= 0) { remove a process P from S->list; } wakeup(p); 5.30 Silberschatz, Galvin and Gagne 2013

31 Deadlock and Starvation Deadlock (kilitlenme) iki veya daha fazla sürecin yalnızca içlerinden birinin sebep olabileceği bir olayı süresiz beklemesi S ve Q semafor, ilk değerleri 1 P 0 P 1 wait(s); wait(q); wait(q); wait(s); signal(s); signal(q); signal(q); signal(s); Starvation (açlık) süresiz engelleme Sürecin askıda beklediği semafor kuyruğundan hiç çıkamaması Priority Inversion (önceliğin ters dönmesi) düşük öncelikli sürecin elindeki bir kilide yüksek öncelikli sürecin ihtiyaç duyması Çözüm için priority-inheritance (öncelik kalıtım) protocol 5.31 Silberschatz, Galvin and Gagne 2013

32 Klasik Senkronizasyon Problemleri Önerilen yeni senkronizasyon yöntemlerini sınamak için kullanılan klasik problemler: Bounded-Buffer (Sınırlı Arabellek) Problemi Readers and Writers (Okurlar ve Yazarlar) Problemi Dining-Philosophers (Yemek Yiyen Felsefeciler) Problemi 5.32 Silberschatz, Galvin and Gagne 2013

33 Sınırlı Arabellek Problemi n arabellek, her biri bir item tutabilir. mutex semaforunun ilk değeri 1 full semaforunun ilk değeri 0 empty semaforunun ilk değeri n 5.33 Silberschatz, Galvin and Gagne 2013

34 Sınırlı Arabellek Problemi Üretici sürecin yapısı do {... /* produce an item in next_produced */... wait(empty); wait(mutex);... /* add next produced to the buffer */... signal(mutex); signal(full); } while (true); 5.34 Silberschatz, Galvin and Gagne 2013

35 Sınırlı Arabellek Problemi Tüketici sürecin yapısı Do { wait(full); wait(mutex);... /* remove an item from buffer to next_consumed */... signal(mutex); signal(empty);... /* consume the item in next consumed */... } while (true); 5.35 Silberschatz, Galvin and Gagne 2013

36 Okurlar Yazarlar Problemi Eşzamanlı süreçler arasında paylaşılan veri kümesi Okurlar yalnızca okuyabilir; güncelleme yapamazlar Yazarlar hem okuyup hem yazabilir Problem birden fazla okurun aynı anda okumasına izin verme Bir anda sadece bir yazar veriye erişebilir Paylaşılan veri Veri kümesi rw_mutex semaforunun ilk değeri 1 mutex semaforunun ilk değeri 1 read_count semaforunun ilk değeri Silberschatz, Galvin and Gagne 2013

37 Okurlar Yazarlar Problemi Yazar sürecin yapısı do { wait(rw_mutex);... /* writing is performed */... signal(rw_mutex); } while (true); 5.37 Silberschatz, Galvin and Gagne 2013

38 Okurlar Yazarlar Problemi Okur sürecin yapısı do { wait(mutex); read_count++; if (read_count == 1) wait(rw_mutex); signal(mutex);... /* reading is performed */... wait(mutex); read count--; if (read_count == 0) signal(rw_mutex); signal(mutex); } while (true); 5.38 Silberschatz, Galvin and Gagne 2013

39 Okurlar ve Yazarlar Probleminin Çeşitleri İlk farklı çeşit yazarın paylaşılan nesneye erişim izni olmadığı sürece okurlar bekletilmez. İkinci farklı çeşit yazar hazır olur olmaz yazma işlerimi yapar. İki durumda da açlık olabilir. Çözüm bazı sistemlerde çekirdekteki okur-yazar kilitleri ile sağlanır Silberschatz, Galvin and Gagne 2013

40 Yemek Yiyen Filozoflar Problemi Çinli filozoflar düşünerek ve yiyerek hayatlarını sürdürürler. Tabaktaki pilavı yemek için iki çubuk almaları gerekir. Yedikten sonra ikisini de bırakırlar. 5 filozoflu durum Paylaşılan veri Pilav tabağı (veri kümesi) chopstick [5] semaforunun ilk değeri Silberschatz, Galvin and Gagne 2013

41 Yemek Yiyen Filozoflar Problemi Algoritması Filozof i: do { wait (chopstick[i] ); wait (chopstick[ (i + 1) % 5] ); // eat signal (chopstick[i] ); signal (chopstick[ (i + 1) % 5] ); // think } while (TRUE); Bu algoritmadaki sorun nedir? 5.41 Silberschatz, Galvin and Gagne 2013

42 Yemek Yiyen Filozoflar Problemi Algoritması Deadlock yönetimi En fazla 4 filozofun masada oturmasına izin ver. Filozofun çubukları almasına ancak iki çubuk da boştaysa izin ver. (alma kritik bölümde olmalı) Asimetrik çözüm kullan tek numaralı filozof önce sol sonra sap çubuğu, çift numaralı filozof önce sağ sonra sol çubuğu alsın Silberschatz, Galvin and Gagne 2013

43 Semafor Sorunları Semafor işlemlerinin yanlış kullanımı: signal (mutex). wait (mutex) wait (mutex) wait (mutex) wait (mutex) veya signal (mutex) ten birini (veya ikisini) yazmamak Kilitlenme ve açlık mümkün Silberschatz, Galvin and Gagne 2013

44 İzleyiciler Süreç senkronizasyonu için kolay ve etkin bir mekanizma sunan bir soyutlama Abstract data type (soyut veri tipi), iç değişkenlere ancak yordam içindeki kodla erişilebilir. İzleyici içinde bir anda sadece bir süreç aktif olabilir. Bazı senkronizasyon yöntemlerini modellemek için yeterince güçlü değildir. monitor monitor-name { // shared variable declarations procedure P1 ( ) {. } procedure Pn ( ) { } } } Initialization code ( ) { } 5.44 Silberschatz, Galvin and Gagne 2013

45 İzleyicinin Şematik Görüntüsü 5.45 Silberschatz, Galvin and Gagne 2013

46 Koşul Değişkenleri condition x, y; Koşul değişkeni ile iki işlem yapılabilir: x.wait() çağıran süreç x.signal() işlemine kadar askıya alınır x.signal() x.wait() i çağırmış olan süreçlerden birini devam ettir x.wait() çağıran yoksa değişkene etkisi olmaz Silberschatz, Galvin and Gagne 2013

47 Koşul Değişkenleri ve İzleyici 5.47 Silberschatz, Galvin and Gagne 2013

48 Koşul Değişkeni Seçenekleri Eğer süreç P x.signal() çağırırsa, ve süreç Q x.wait() içinde askıdaysa, ardından ne olmalı? Q ve P paralel olarak çalışamaz. Eğer Q devam ederse, P bekler. Seçenekler Signal and wait P, Q izleyiciden ayrılana kadar veya başka bir koşul gerçekleşene kadar bekler. Signal and continue Q, P izleyiciden ayrılana kadar veya başka bir koşul gerçekleşene kadar bekler. İkisinin de iyi ve kötü yanları vardır. Concurrent Pascal içindeki izleyiciler P signal yürütünce anında izleyiciden ayrılır, Q devam eder. Mesa, C#, Java gibi başka dillerde gerçekleştirilmiştir Silberschatz, Galvin and Gagne 2013

49 Yemek Yiyen Filozoflara İzleyici Çözümü monitor DiningPhilosophers { enum { THINKING; HUNGRY, EATING) state [5] ; condition self [5]; } } void pickup (int i) { state[i] = HUNGRY; test(i); if (state[i]!= EATING) self[i].wait; void putdown (int i) { state[i] = THINKING; // test left and right neighbors test((i + 4) % 5); test((i + 1) % 5); 5.49 Silberschatz, Galvin and Gagne 2013

50 Yemek Yiyen Filozoflara İzleyici Çözümü void test (int i) { if ((state[(i + 4) % 5]!= EATING) && (state[i] == HUNGRY) && (state[(i + 1) % 5]!= EATING) ) { state[i] = EATING ; self[i].signal () ; } } } initialization_code() { for (int i = 0; i < 5; i++) state[i] = THINKING; } 5.50 Silberschatz, Galvin and Gagne 2013

51 Yemek Yiyen Filozoflara İzleyici Çözümü Her filozof i, pickup() ve putdown() işlemlerini aşağıdaki sırada çağırır: DiningPhilosophers.pickup(i); EAT DiningPhilosophers.putdown(i); Deadlock yok, ama açlık mümkün 5.51 Silberschatz, Galvin and Gagne 2013

52 Semaforlarla İzleyici Gerçekleştirimi Değişkenler semaphore mutex; // (başta = 1) semaphore next; // (başta = 0) int next_count = 0; Her yordam F yerine şu koyulur: wait(mutex); body of F; if (next_count > 0) signal(next) else signal(mutex); İzleyici içinde karşılıklı dışlama garanti edilir Silberschatz, Galvin and Gagne 2013

53 Koşul Değişkenleriyle İzleyici Gerçekleştirimi Her koşul değişkeni x için: semaphore x_sem; // (başta = 0) int x_count = 0; x.wait işlemi şöyle gerçekleştirilebilir: x_count++; if (next_count > 0) signal(next); else signal(mutex); wait(x_sem); x_count--; 5.53 Silberschatz, Galvin and Gagne 2013

54 Koşul Değişkenleriyle İzleyici Gerçekleştirimi x.signal işlemi şöyle gerçekleştirilebilir: if (x_count > 0) { next_count++; signal(x_sem); wait(next); next_count--; } 5.54 Silberschatz, Galvin and Gagne 2013

55 İzleyici İçindeki Süreçlerin Sürdürülmesi Birkaç süreç x koşulunun kuyruğundaysa, x.signal() yürütülünce hangisi devam etmelidir? FCFS (ilk gelene ilk hizmet) yetersiz olabilir. conditional-wait (koşullu bekleme) - x.wait(c) c - priority number (öncelik sayısı) En küçük sayı (yani en yüksek öncelik) sahibi süreç ilk sıraya koyulur Silberschatz, Galvin and Gagne 2013

56 Tek Kaynak Ayırma Her sürecin kaynağı en çok ne kadar süreyle kullanacağını belirten öncelik sayıları var. Bunlar kullanılarak tek bir kaynak rakip süreçler arasında paylaştırılır. R.acquire(t);... kaynağa eriş;... R.release; R, ResourceAllocator tipinin bir örneği 5.56 Silberschatz, Galvin and Gagne 2013

57 Tek Kaynak Ayırma için İzleyici monitor ResourceAllocator { boolean busy; condition x; void acquire(int time) { if (busy) x.wait(time); busy = TRUE; } void release() { busy = FALSE; x.signal(); } initialization code() { busy = FALSE; } } 5.57 Silberschatz, Galvin and Gagne 2013

58 Senkronizasyon Örnekleri Solaris Windows Linux Pthreads 5.58 Silberschatz, Galvin and Gagne 2013

59 Solaris te Senkronizasyon Çok görevli, çok iş parçalı ve çok süreçli yapı için çeşitli kilitler vardır. Adaptive mutexes kısa kod bölümlerinden veriyi korumada verimlilik için Standard semafor gibi başlar Kilidi başka CPU üzerinde çalışan bir thread tutuyorsa, thread bekler Kilidi tutan thread çalışır durumda değilse, thread engellenir ve kilit bırakılana kadar uyur Koşul değişkenleri kullanılır. Uzun kod bölümlerinin veriye erişmesi gerektiğinde okur-yazar kilitleri kullanılır. Adaptive mutex veya okur-yazar kilidi bekleyen threadleri sıralamak için turnike kullanılır Silberschatz, Galvin and Gagne 2013

60 Windows ta Senkronizasyon Tek işlemcili sistemlerde global kaynaklara erişimi kontrol etmek için kesme maskeleri kullanılır. spinlocks - çok işlemcili sistemlerde Kilitleyen thread boşa çıkartılmaz. dispatcher objects - mutexler, semaforlar, olaylar, süreölçerler Events (olaylar) Koşul değişkeni gibi davranır. Süreölçerler süre dolunca bir veya daha fazla thread e haber verir Dispatcher objects signaled-state (nesne boşta) veya non-signaled state (thread engellenir) içinde bulunabilir Silberschatz, Galvin and Gagne 2013

61 Linux ta Senkronizasyonu Linux: Çekirdek Versiyon 2.6 öncesinde, kesmeleri devre dışı bırakarak kısa kritik bölümleri gerçekleştirirdi. Versiyon 2.6 ve sonrasında, tamamen preemptive Linux şunları sağlar: Semaforlar atomik tamsayılar spinlocks Okur-yazar kilitleri Tek cpu lu sistemde, spinlock yerine çekirdek preemption açılır ve kapanır Silberschatz, Galvin and Gagne 2013

62 Pthreads ile Senkronizasyon Pthreads API OS-bağımsızdır. Şunları sunar: mutex kilitleri Koşul değişkeni Taşıabilir olmayan eklentiler: Okur-yazar kilitleri spinlocks 5.62 Silberschatz, Galvin and Gagne 2013

63 Diğer Yaklaşımlar Transactional Memory OpenMP İşlevsel Programlama Dilleri 5.63 Silberschatz, Galvin and Gagne 2013

64 Transactional Memory Memory transaction atomik olarak yapılan okuma-yazma işlemleri dizisi void update() { /* read/write memory */ } 5.64 Silberschatz, Galvin and Gagne 2013

65 OpenMP OpenMP paralel programlamayı destekler. void update(int value) { #pragma omp critical { count += value } } #pragma omp critical altındaki kod kritik bölgedir ve atomik olarak çalışır Silberschatz, Galvin and Gagne 2013

66 İşlevsel Programlama Dilleri İşlevsel programlama dilleri farklı bir paradigma sunar, durum bilgisi tutmazlar. Değişkenler değer atamasından sonra değiştirilemez. Erlang, Scala gibi işlevsel dillere ilgi giderek artmaktadır Silberschatz, Galvin and Gagne 2013

67 Bölüm 5 Sonu Silberschatz, Galvin and Gagne 2013