İnönü Üniversitesi Bilgisayar Mühendisliği Bölümü İplik Yönetimi İnönü Üniversitesi Bilgisayar Mühendisliği Bölümü

İplikler (Threads) Hafif süreçler (lightweight process) diye de isimlendirilir. Verimlilik için aynı süreç içinde paralel biçimde çalışırlar. Aynı sürecin kısımları olarak çok sayıda faaliyet de yürütebilirler. Yazmaçlar, bellek ve diğer kaynakları paylaşırlar. İplikler aynı zamanda CPU zamanlama birimi (unit of CPU scheduling) de olabilir.

İplikler Günümüz uygulamalarının çoğu (çekirdekler de) çoklu iplik yapısındadır. Görüntüyü yenileme, veri çekme, yazım kontrolü, ağ isteğine yanıt verme vb. işler ayrı ipliklerle yapılır. Kodu basitleştirip verimi (hesaplama gücü) arttırır. Farklı iplikler farklı işlemcilerde kullanıcıdan özel bir girdi almadan veya yazılımcıya külfet getirmeden çalışabilir. Tek iplikli bir program işletim sisteminden bir hizmet talep ettiğinde hizmetin tamamlanmasını beklemek durumundadır, CPU bu sırada genelde boştadır. Çoklu ipliklerde diğer iplikler CPU’ yu kullanmaya devam eder. Tek iplikli bir programda uzun süreli bir iş yapılırken “Lütfen Bekleyiniz” anlamında bir göstergeyle program kullanıcı davranışlarına iş bitene kadar yanıt veremez. Çoklu iplik kullanımında ise bu tarz işler ayrı ipliklerde ve arka planda yürütülür, bu sayede uygulama hala aktif kalır ve kullanıcıya karşılık verebilir.

İplikler

Süreçler ve İplikler Süreçler çekirdek seviyesinde varlıklardır, süreç yapısına sadece sistem çağrılarıyla erişilebilir. İplikler kullanıcı seviyesinde varlıklardır, iplik yapısı kullanıcı uzayında yer alır. Kullanıcı seviyesi fonksiyonları olan iplik kütüphanesi çağrılarıyla ipliklere erişilebilir. Her sürecin içinde bir veya daha fazla iplik olabilir. Her ipliğin kendi yığıtı (stack), CPU yazmaçları vardır. İplikler birbirleriyle direkt iletişim kurabilir. Süreçler iplikleri için kap olurlar. İplikler içinde yer aldıkları süreçle sınırlıdır. Thread 0 İplik 2 İplik 0 İplik 1 Adres Uzayı

Süreçler ve İplikler Süreçler pek verimli değildir; her sürecin kendine ait PCB ve kaynakları olması israfa yol açabilir. (task_struct 1.7 KB yer tutmaktadır.) Süreçler belleği doğrudan paylaşmazlar. Bu da büyük bir dizinin paralel işlenmesi gibi aynı bellek alanını doğrudan düzenlemek isteyen paralel ve koşut zamanlı programlar için sorun olabilir. Süreçler arası paylaşımlı bellek de daha fazla programlama gerektirdiğinden verimlilik mevzularına çare olamamaktadır. Süreçler ağaç hiyerarşisi içindedir, iplikler bir havuz yapısında yer alır. Süreçte çalışan ilk ipliğe ana iplik denir. Her iplik diğerini öldürebilir, diğerinin sonlanmasını bekleyebilir.

Tek ve Çok Sayıda Çalıştırma İplikleri Çoklu İplikler Tek İplik Başla Bitir Dosyayı Düzenle Dosyayı Yazdır Bitir Dosyayı Düzenle Başla Dosyayı Yazdır

Tek ve Çok İplikli Süreçler Tek İplikli Süreç Çok İplikli Süreç

Süreç Adres Uzayı 0xFFFFFFFF (İ.S için ayrılan)‏ Stack Stack işaretçisi Adres uzayı Heap İlk değersiz değiş. (BSS parçası)‏ İlk değerli değiş. (veri parçası)‏ Kod (yazı parçası)‏ Program sayacı 0x00000000

İplik İçeren Süreç Adres Uzayı 0xFFFFFFFF (İ.S için ayrılan)‏ İplik 0 için stack İplik 0 için stack işaretçisi İplik 1 için stack İplik 1 için stack işaretçisi İplik 2 için stack İplik 2 için stack işaretçisi Adres uzayı Heap İlk değersiz değiş. (BSS parçası)‏ İlk değerli değiş. (veri parçası) ‏ İplik 1 için PS Kod (yazı parçası) ‏ 0x00000000 İplik 0 için PS İplik 2 için PS

İplik İmplementasyonu PCB iki parçaya bölünür. İşlemci durumu (ipliğe has içerik), adres uzayı ve açık dosyalar vb. İ.S. kaynakları (sürece has içerik) PC Yazmaçlar İplik ID 4 Durum: Hazır Ağ soketleri Kullanıcı ID Grup ID Adres uzayı Açık dosyalar PID 27682 İplik ID 5 TCB PCB

İplik Denetim Bloğu (Thread Control Block) Bir iplik hakkında işlemci durumu ve ilgili PCB’ yi gösteren işaretçi bilgilerini içerir. Adres uzayı ve İ.S. kaynakları PCB içindedir. Süreçlerden daha ufak ve düşük maliyetlidir. Linux TCB (thread_struct) 24 alandan, PCB (task_struct) 106 alandan oluşur.

İplikler için Context Switch Bu durumda TCB geçişler için birim bileşen olur. Hazır, bekleme vb. kuyruklar TCB’ yi gösteren işaretçiler içerir. Geçişlerde CPU durumu TCB’ den kopyalanır, TCB’ ye yazılır. Aynı süreç içindeki iki iplik arası geçişte adres uzayını değiştirmeye gerek yoktur. Farklı süreçler içindeki iki iplik arası geçişte adres uzayını değiştirmek gerekir. Önbelleği bile değiştirmeye neden olabileceğinden sanal bellek konusunda bir daha ele alınacaktır.

Kullanıcı Düzeyi İplikler ve İmplementasyonu Eski işletim sistemi tasarımlarında çekirdek düzeyi iplik desteği yoktu. Ancak kullanıcı düzeyi iplik kütüphaneleri oluşturulabiliyordu. Bir süreçteki çoklu ipliklerin yönetmek için sadece CPU durumunu değiştirmek (PC, yazmaçlar vs.) yeterlidir. Bunun için sistem çağrısı yapmak gerekmez. Bütün iplik fonksiyonları kullanıcı düzeyi bir kütüphanede tanımlanır. (libpthread.a gibi) İ.S. sürecin bir ipliği olduğunu varsayar. İplik kütüphanesi bağlı liste veya başka bir veri yapısı kullanarak uygulamadaki her bir iplik için bir TCB oluşturur. malloc/new ile her iplik için ayrı bir yığın (stack) tahsis edilir.

İplik Kütüphaneleri Yazılımcıya iplik oluşturma ve yönetme için API sağlar. Kütüphane tamamen kullanıcı uzayında olabileceği gibi işletim sistemince desteklenen çekirdek düzeyinde de olabilir.

Kullanıcı Düzeyi İplik Adres Uzayı İplik kütüphanesi, yığınlar için belleği dikkatlice tahsis etmeli ve yönetmelidir. İplik 1 için stack‏ Heap İlk değerli değiş. (veri parçası) Kod (yazı parçası) İplik 1 için stack işaretçisi İplik 1 için PS İlk değersiz değiş. (BSS parçası)‏ (İ.S için ayrılan)‏‏ İplik 2 için PS İplik 2 için stack İplik 2 için stack işaretçisi Orijinal stack (İ.S.’nin verdiği)‏ Süreç tarafından tahsis edilen ek iplik yığınları

Kullanıcı Düzeyi Context Switch CPU durumu değişikliği (swap) için imtiyazlı talimatlara ihtiyaç yoktur. İplik kütüphanesi CPU durumunu TCB’ ye yüklemek veya kaydetmek için işletim sistemi ile aynı talimatları kullanabilir. setjmp() ve longjmp() ile işlemci durumu kaydedilir/yüklenir. int setjmp(jmp_buf env); «jmp_buf» yapısına mevcut CPU durumunu kaydeder. Eğer dönüş doğrudan başlatmadan yapılırsa setjmp 0 döner. longjmp çağrısından yapılırsa sıfırdan farklı değer döner. void longjmp(jmp_buf env, int returnval); CPU durumunu «jmp_buf» yapısından geri yükler, buna karşılık gelen setjmp() çağrısının «returnval» değeriyle dönmesini sağlar. Değer tarafından belirlenen değer longjmp’ dan setjmp’ a geçer. longjmp tamamlandıktan sonra program yürütmesi, karşılık gelen setjmp başlatması dönmüş gibi devam eder. Eğer longjmp’ a 0 değeri geçilirse, setjmp 1 dönülmüş gibi davranır. Aksi halde dönülmüş değere göre davranır. struct jmp_buf {…} Yazmaç, program sayacı vb. kaydı için CPU’ya has alanlar içerir.

setjmp()/longjmp() Örneği int main(int argc, void *argv) { int i, restored = 0; jmp_buf saved; for (i = 0; i < 10; i++) { printf("i’ nin değeri şimdi %d oldu\n", i); if (i == 5) { printf("Tamam, durumu kaydediyor...\n"); if (setjmp(saved) == 0) { printf("CPU durumunu kaydetti ve döngüden çıkıyor.\n"); break; } else { printf("CPU durumunu geri yükledi, kaydettiğimiz yerden devam ediyor\n”); restored = 1; } if (!restored) longjmp(saved, 1);

setjmp()/longjmp() Örneği i’ nin değeri şimdi 0 oldu i’ nin değeri şimdi 1 oldu i’ nin değeri şimdi 2 oldu i’ nin değeri şimdi 3 oldu i’ nin değeri şimdi 4 oldu i’ nin değeri şimdi 5 oldu Tamam, durumu kaydediyor... CPU durumunu kaydetti ve döngüden çıkıyor. CPU durumunu geri yükledi, kaydettiğimiz yerden devam ediyor i’ nin değeri şimdi 6 oldu i’ nin değeri şimdi 7 oldu i’ nin değeri şimdi 8 oldu i’ nin değeri şimdi 9 oldu

Ctrl+C ile Yeniden Başlayan Bir Program #include <stdio.h> #include <signal.h> #include <setjmp.h> sigjmp_buf buf; void handler(int sig) { siglongjmp(buf, 1); } main() { signal(SIGINT, handler); if (!sigsetjmp(buf, 1)) printf("başlıyor\n"); else printf("yeniden başlıyor\n"); while(1) { sleep(1); printf("çalışıyor...\n"); bass> a.out başlıyor çalışıyor... çalışıyor... Ctrl-c yeniden başlıyor çalışıyor... çalışıyor... Ctrl-c yeniden başlıyor çalışıyor...

Kullanıcı Düzeyi İplikler İplik işlemleri çekirdeğe gitmekten 10-100 kat daha hızlıdır. İplik durumu sadece CPU durumu ve yığın içerir, ek yük getirmez. Bir iplik bloklarsa bütün süreci durdurabilir, G/Ç bekleyen bir iplik diğer iplikleri beklemek zorunda bırakır. Çoklu CPU yapısını kullanamaz. Çekirdek sadece bir CPU içeriğini bilir. İşletim sistemi iyi kararlar veremeyebilir, bir süreci boşta duran ipliklerle zamanlayabilir veya kilit koyan bir ipliği zamanlamadan çıkarabilir. POSIX, Windows, Java iplikleri kullanıcı düzeyinde tanımlanabilir.

Çekirdek Düzeyi İplikler İşletim sistemi bir süreçteki bütün iplikleri bilir. Her birine farklı zamanlama (scheduling) önceliği atayabilir. Bir süreçteki iplikler arası geçişi çekirdek yapabilir. Bu düzeydeki iplik işlemleri çekirdek çağrısına (sistem çağrısı) ihtiyaç duyar. Windows, Solaris, Linux, Tru64 UNIX, Mac OS X, iOS ve Android çekirdek düzeyi iplikleri destekler.

Çoklu İplik Modelleri – Çoktan Bire Çok sayıda kullanıcı düzeyi iplik bir çekirdek ipliğine eşlenir. Bir ipliğin bloklaması tümünü etkiler. Çekirdekte (kernel) bir anda bir iplik olabileceğinden, çoklu iplikler çok çekirdekli (core) sistemlerde paralel çalışmayabilir. Az sayıda sistem bu modeli kullanmaktadır. Solaris Green Threads, GNU Portable Threads

Çoklu İplik Modelleri – Bire Bir Her kullanıcı düzeyi ipliği, çekirdekte bir ipliğe eşlenir. Kullanıcı düzeyi bir iplik oluşturmak, çekirdekte de bir iplik oluşturur. Çoktan bireden daha koşut zamanlıdır. Ek iş yükü nedeniyle süreç başına düşen iplik sayısı sınırlandırılabilir. Windows, Linux, Solaris 9 ve sonrası

Çoklu İplik Modelleri – Çoktan Çoğa Çok sayıda kullanıcı düzeyi ipliğin çok sayıda çekirdek ipliğine eşlenmesini sağlar. İşletim sisteminin yeter sayıda çekirdek ipliği oluşturmasına izin verir. Sürüm 9 öncesi Solaris ThreadFiber paketi ile Windows

Çoklu İplik Modelleri – İki Seviye Bir öncekine benzer, istisna olarak kullanıcı ipliğinin çekirdek ipliği tarafından sınırlanmasına izin verir. IRIX, HP-UX, Tru64 UNIX, Solaris 8 ve öncesi

POSIX İplikleri – Pthreads İplik oluşturma ve senkronizasyonu için tanımlanan bir POSIX API standartıdır. (IEEE 1003.1c) Kullanıcı veya çekirdek düzeyinde olabilir. 60’ dan fazla fonksiyon için tanımlanan bir arayüz içerir. Belirtim biçimidir (specification), kodlamanın kendisi değildir. API iplik kütüphanesinin davranışını belirtir, kodlama detayları kütüphane geliştiricisine bırakılır. UNIX tabanlı işletim sistemlerinde kullanılır. (Solaris, Linux, Mac OS X, Android vd.)

POSIX İplikleri – Pthreads void *threadroutine(void *vargp): İplik rutinlerini çalıştırır. İplik oluşturmak için int pthread_create(pthread_t *thread, pthread_attr_t *attr, void *(*threadroutine)(void *), void * vargp); thread: Yeni TCB’ yi gösteren bir işaretçi döner. attr: Yeni iplik için (zamanlama politikası vb.) özellikleri belirler. threadroutine: Yeni ipliğin çalıştıracağı fonksiyonu gösteren fonksiyon işaretçisi vargp: threadroutine() fonksiyonunun parametresi

POSIX İplikleri – Pthreads İplikleri kaldırmak (reap) için pthread_join(pthread_t tid, void **thread_return) tid ile belirtilen ipliğin çıkmasını bekler, ipliğin thread_return dönüşünü döner. pthread_self(): İpliğin kimliğini belirler. İplikleri sonlandırmak için pthread_cancel(pthread_t tid) pthread_exit(void *thread_return): Verilen dönüş değeriyle çıkar. return: Ana iplik rutini, ipliği sonlandırır. exit(): Bütün iplikleri sonlandırır. Ortak değişkenlere erişimin senkronizasyonu

Pthreads Örneği İplik özellikleri (genelde NULL) İplik argümanları /* * hello.c - Pthreads "hello, world" programı */ #include "csapp.h" void *thread(void *vargp); int main() { pthread_t tid; Pthread_create(&tid, NULL, thread, NULL); Pthread_join(tid, NULL); exit(0); } /* iplik rutini */ void *thread(void *vargp) { printf("Hello, world!\n"); return NULL; İplik özellikleri (genelde NULL) İplik argümanları (void *p) Dönüş değerini atar (void **p)

İplikleri ”Ayırmak” İplik tabanlı sunucularda bellek sızıntısının önüne geçmek için “ayrılmış” iplikler kullanılır. Herhangi bir anda bir iplik bağlanabilir (joinable) veya ayrılmış (detached) durumdadır. Bağlanabilir iplik, diğer ipliklerce kaldırılabilir (belleği boşaltır), öldürülebilir. Ayrılmış ipliklere diğer iplikler dokunamaz, sonlandıklarında otomatik olarak kaldırılır. Normal durum ”bağlanabilir”dir, “ayrılmış” hale gelmesi için: pthread_detach(pthread_self())

Pthreads Örneği

Bağlanabilir 10 İplik için Pthreads Kodu

POSIX İplikleri Detayları İçin https://computing.llnl.gov/tutorials/pthreads/ http://www.yolinux.com/TUTORIALS/LinuxTutorialPosixThreads.html

Windows İplikleri Windows API, Windows işletim sistemi için iplik programlama arayüzü de sağlar. Çekirdek düzeyinde birebir eşlemeyi gerçekleştirir. Her iplik; bir iplik no, işlemci durumunu gösteren yazmaç kümesi, iplik çekirdek veya kullanıcı modunda çalıştığında ayrı kullanıcı ve çekirdek yığınları (stack), çalışma zamanı kütüphaneleri ve dinamik bağlama kütüphaneleri (DLL) tarafından kullanılan özel veri kayıt alanını içerir. Yazmaç kümesi yığınlar ve özel kayıt alanı ipliğin içeriği olarak geçer. Bir ipliğin ana veri yapıları: ETHREAD (executive thread block) – Çekirdek uzayında ipliğin ait olduğu süreci ve KTHREAD’i gösteren işaretçiler KTHREAD (kernel thread block) – Zamanlama ve senkronizasyon bilgisi, çekirdek modu yığıtı, TEB’ i gösteren işaretçi TEB (thread environment block) – İplik kimliği, kullanıcı modu yığını, iplik yerel kayıt alanı

Windows İplikleri Veri Yapıları

Windows İplikleri Örneği

Java İplikleri JVM tarafından yönetilir. Genelde üzerinde çalışan işletim sistemi tarafından sağlanan iplik modeli kullanılarak oluşturulurlar. Java iplikleri Thread sınıfından kalıtım yapılarak (…extends Thread) veya Runnable arayüzünün tanımlanmasıyla (…implements Runnable) oluşturulur.

Java İplikleri Örneği

Java İplikleri Örneği (Devam)

Örtülü İplik Programlama (Implicit Threading) İplik sayısı arttıkça açık (explicit) iplik programlama ile doğru çalışan program geliştirmek zorlaştığından, daha tercih edilen yöntemdir. İplik oluşturma ve yönetimi yazılımcı yerine derleyici ve çalışma zamanı kütüphaneler tarafından yapılır. Bu kapsamda iplik havuzları, OpenMP ve Grand Central Dispatch ele alınacaktır. Ayrıca Microsoft Threading Building Blocks (TBB) ve java.util.concurrent paketi de örtülü iplik programlar.

İplik Havuzları Bir havuzda iş bekleyen iplikler oluşturmaktır. Bir isteğe yeni bir iplik oluşturmaktansa var olan bir iplik ile hizmet etmek genelde biraz daha hızlıdır. Uygulamaların iplik sayılarını havuz boyutuyla sınırlamaya izin verir. Yapılacak görevleri görev oluşturma mekaniğinden ayırmak çalışan görev için farklı stratejilere imkan tanır. (görevler periyodik olarak zamanlanabilir.) Windows API iplik havuzlarını destekler.

OpenMP C, C++ ve FORTRAN için derleyici yönergeleri ve bir API içerir. Paylaşımlı bellek ortamlarında paralel programlama için destek sağlar. Paralelde çalışabilen kod blokları olan paralel bölgeler tanımlar. #pragma omp parallel Çekirdek (core) sayısı kadar iplik oluşturmak için #pragma omp parallel for for(i=0;i<N;i++) { c[i] = a[i] + b[i]; } for döngüsü paralel olarak çalışır.

Grand Central Dispatch Apple tarafından Mac OS X ve iOS için geliştirilen bir teknolojidir. C ve C++ dillerine, API ve çalışma zamanı kütüphanesine eklentiler içerir. Paralel bölümlerin tanımlanmasını sağlar. İpliklerin pek çok detayını yönetir. Bloklar “^{ }” içindedir. - ˆ{ printf("I am a block"); } Bloklar sevketme kuyruğuna yerleştirilir. Kuyruktan çıkarıldığında iplik havuzundaki uygun ipliğe atanır.

Grand Central Dispatch İki tür sevk etme kuyruğu vardır: Seri: Bloklar FIFO usulüyle çıkarılır, her süreç için ana kuyruk oluşturulur. Program içinde ilave seri kuyruklar oluşturulabilir. Koşut Zamanlı: Yine FIFO usulüyle çıkarılır fakat bir anda çok sayıda blok çıkarılabilir. Sistem boyunca düşük, varsayılan ve yüksek öncelikli üç kuyruk

Google Chrome Çizgi Romanı Süreç ve iplik kullanımında sık karşılaşılan bir örnek olarak: https://www.google.com/googlebooks/chrome/