Ev  |  Erişimdüzeni  |  İçindekiler  |  Arama

Convert to GutenPalm or to PalmDoc tarafından Leonardo Giordani <leo.giordani(at)libero.it> Yazar hakkında: Yazar, Milan Politecnico Üniversitesinin Telekomunikasyon Mühendisliğinde okumakta ve bilgisayar ağları yöneticisi olarak çalışmaktadır. Daha çok Assemble ve C/C++ olmak üzere, programlamaya ilgi duymaktadır. 1999 yılından beri neredeyse tamamen Linux/Unix ile çalışmaktadır. Türkçe'ye çeviri: Erdal Mutlu <erdal(at)linuxfocus.org> İçerik: Giriş İşlem kavramı Linux ve Unix'teki işlemler libc'de çokluişlem Önerilen kaynaklar Bu yazı için görüş bildiriminde bulunabilirsiniz

Eşzamanlı programlama - Kavramlar ve işlemlere giriş

Özet:

Bu yazı dizisinin amacı, okuyculara Linux işletim sistemindeki çokluişlem (multitasking) ve uygulamasına giriş oluşturmaktadır. Çokluişlem teorisinin temellerinden başlayarak, işlemler veya süreçler (processes) arasındaki haberleşmeyi, basit ve bir o kadar da etkili bir protokol kullanarak gösteren, bir program yazarak konuyu tamamlayacağız. Yazıyı anlayabilmek için gerekli önbilgiler şunlardır:

• Kabuk ortamı hakkında temel bilgi.
• C programlama dili hakkında temel bilgi (Yazım kulları, döngüler, kütüphaneler vs.).

Giriş

İşlem kavramı

Birden fazla programı aynı anda çalıştırabilmek için işletim sisteminin yapması gereken karmaşık işlemlere gereksinimi vardır. Çalışan programlar arasında oluşabilecek karışıklığı önlemek için, programların çalıştırılmaları ile ilgili gerekli tüm bilginin bir yerde saklanması kaçınılmazdır.

Linux bilgisayarımızda ne olup bittiğine geçmeden önce biraz genel kültür bilgisi verelim: çalışan bir PROGRAM verildiğinde, programı oluşturan komutlar kümesine CODE(Program kodu), program verilerin bilgisayar belleğinde kapladığı alana MEMORY SPACE(Bellek alanı) ve mikroişlemcinin parametre değerleri, çeşitli bayrak değerleri veya program sayacına (Bir sonra çalıştırılacak olan komutun adres değeri.), PROCESSOR STATUS (İlemci durumu) denilmektedir.

RUNNING PROGRAM (Çalışan program) kavramını, Program kodu, Bellek alanı ve İşlemci durumu nesnelerinden oluşan bir bütün olarak tanımlıyoruz. Eğer, herhangi bir zaman diliminde, bu bilgiyi kaydedip, başka programın bilgileri ile değiştirdiğimizde, kaydettiğimiz programa tekrar dönüldüğünde, program kaldığı yerden çalışmasına devam edebilmedir: Bu çalışma yöntemi birden fazla programın aynı anda ve birbirleri ile çakışmadan çalışıyor gibi görünmesini sağlamaktadır. PROCESS veya TASK (Süreç veya işlem) kelimesi böyle çalışan bir programı tanımlamak için kullanılmaktadır.

Şimdi, yazının başında sözünü ettiğimiz Linux bilgisayarında neler olduğuna bir göz atalım. Herhangi bir anda, bilgisayarda sadece bir adet işlem çalıştırılabilmektedir (Sistemde sadece bir mikroişlemci vardır ve bu işlemci aynı anda iki işlemi yerine getirememektedir.). Çalışan programın da saedece belli bir kısmı işlem görmektedir. Belli bir süre sonra, buna QUANTUM denmektedir, çalışan işlem durdurulmakta, daha sonra kaldığı yerden devam etmek üzere işlem ile ilgili bilgiler bir yerde ve beklemekte olan başka bir işlemin bilgileri ile değiştirilerek, bir quantum süresi boyunca çalıştırılmaktadır. Aynı anda çalışıyor gibi izlenim veren işlemler böylece çalıştırılmaktadır. Buna biz multitasking (çokluişlem) diyoruz.

Daha önce de söylediğim gibi, çokluişlem kullanılıyor olması bazı sorunları da beraberinde getirmektedir. Sözgelimi, kuyrukta bekleyen işlemlerim yönetimi (SCHEDULING). Herneyse, bunlar işletim sisteminin yapısı ile ilgili konular. Bu belkide başka bir yazı yazımı için uygun bir konu olabilir. Linux çekirdeğini tanıtıcı bir yazı yazılabilir.  

Linux ve Unix'teki işlemler

Bilgisayarımızda çalışan işlemler ile ilgili biraz bilgi edinelim. Bu bilgiyi sağlayan komutun adı ps(1) dir ve "process status" (işlem durumu) sözcüklerin kısaltmasıdır. Bir terminal açıp, ps komutunu çalıştrırsanız, aşağıdakine benzer bir çıktı elde edersiniz.

  PID TTY          TIME CMD
 2241 ttyp4    00:00:00 bash
 2346 ttyp4    00:00:00 ps

Daha önce de belirtiğim gibi bu çıktı tam değil, ancak şimdilik buna odaklanalım: ps komutu bize terminalde çalışan işlemlerin listesini vermektedir. Çıktının son sütünunda, işlemin çalıştırıldığı komutun adını görmekteyiz. Sözgelimi, Mozilla sanaldoku gezgini için mozilla, GNU derleyicisi için gcc vs. Çalışmakta olan işlemlerin listesi ekranda gösterilirken ps işlemi de çalıştığından, kendisin de bu listede görünmesi çok doğal. Listede görünen diğer işlemler şunlardır: Benim terminalde çalışan Bourne Again Shell (kabuk ortamı) dir.

Bir an için TIME ve TTY bilgilerini gözardı edelim ve PID (işlem numarası) bilgisine bakalım. Pid, her işleme tekil olarak verilen, sıfırdan farklı pozitif bir sayıdır. İşlem sona erdiğinde, işlem numarası tekrar kullanılabilir. Ancak, işlem çalıştığı sürece, bu numaranın deyişmeyeceği garantilenmektedir. Sizin ps komutundan elde edeceğiniz çıktı, yukarıdakinden farklı olacaktır. Söylediklerimin doğruluğunu sınamak için, başka bir terminal açıp orada ps komutunu çalıştırdığınızda aynı listeyi elde edeceksiniz, ancak bu sefer işlem numaraları farklı olacaktır. Bu da, çalışan işlemlerin birbirlerinden farklı olduklarını göstermektedir.

Linux makinamızda çalışan tüm işlemlerin listesini elde etmek de mümkündür. ps komutunun man sayfasına göre, -e parametresi, tüm işlemleri seçmek için kullanılmaktadır. Şimdi bir terminalde "ps -e" komutunu çalıştıralım. Elde edeceğimiz liste, yukarıdaki biçimde, ancak çok daha uzun olacaktır. Listeyi daha rahat bir şekilde incelebilmek için ps komutunun çıktısını ps.log dosyasına yönlendirelim:

ps -e > ps.log

Oluşan dosyayı, tercih ettiğiniz herhangi bir kelime işlemci veya en basitinden less komutu yardımıyla inceleyebilirsiniz. Yazının başında da sözünü ettiğim gibi, çalışan işlem sayısı, tahmin ettiğmizden daha fazladır. Ayrıca, listede komut satırından veya grafik ortamdan çalıştırdığımız programların dışında da işlemler çalştığını fark ediyoruz. Bu işlemlerden bazılarının isimleri de biraz garip. Sistemizde çalışan işlemler ve sayıları, sisteminizin yapılandırılmasına bağlıdır. Ancak, bazı ortak işlemler de vardır. Sistemde yaptığınız ayarlar ne olursa olsun, işlem numarası 1 ve tüm işlemlerin babası olan işlemin adı hep "init" tir. İşlem numarasının 1 olması, bu programın işletim sistemi tarafından hep ilk sırada çalıştırılmasındandır. Fark edeceğimiz başka bir konu da, bazı isimlerin sonlarının hep "d" karakteri olmasıdır. Bunlara verilen genel isim "daemons" dur ve sistemin en önemli işlemlerindendirler. init ve daemon ları daha sonraki bir yazıda ayrıntılı olarak ele alacağız.  

libc'de çokluişlem

İşlem kavramını ve onun işletim sistemimiz için olan önemini kavradığımıza göre, daha ileriye giderek çokluişlem yapan programlar yazmaya başlayacağız. Aşıkar olan aynı anda birden fazla işlemin birden çalıştırılmasından, daha yeni bir problem olan, işlemler arası haberleşme ve zamanlamasına (senkronizasyon) geçeceğiz. Bu problemi iki güzel yöntem olan mesajlar (messages) ve sayaçlar (semaphors) ile çözeceğiz. Bunlar süreçler (threads) konusunu işleyeceğimiz sonraki bir yazıda ayrıntılı olarak anlatılacaktır. Daha sonra da, tüm anlatılan yöntemleri kullanarak, kendi uygulamalarımızı yazma zamanı gelecektir.

Standart C kütüphanesi (Linux,taki libc, glibc tarafından uyarlanmıştır.) Unix System V'in çokluişlem yöntemlerini kullanmaktadır. Unix System V (Bundan sonra SysV diyeceğiz.) ticari bir Unix uyarlaması olup, BSD Unix ailesi gibi SysV Unix ailesinin de yaratıcısıdır.

libc'de işlem numarasının değerini tutmak üzere, tamsayı (integer) şeklinde, pid_t değişken tipi tanımlanmıştır. Bunadan böyle, pid_t değişken tipini işlem numaraları için kullanacağız. Sırf daha basit olması açısından tamsayı değişken tipini kullanmak da mümkündür.

Programımızın işlem numarasını elde etmeye yarayan fonksiyona bir gözatalım.

pid_t getpid (void)

Bu fonksiyon, pid_tile birlikte unistd.h ve sys/types.h başlık dosyalarında tanımlanmıştır. Şimdi, amacı kendi işlem numarasını bildiren bir program yazalım. Tercih ettiğiniz bir kelime işlemcisi yardımı ile aşağıdaki programı yazınız.

#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>

int main()
{
  pid_t pid;

  pid = getpid();
  printf("The pid assigned to the process is %d\n", pid);

  return 0;
}

gcc -Wall -o print_pid print_pid.c

Şimdi bir işlemin nasıl yaratılacağını öğrenme zamanı geldi. Ancak, daha önce, bu işlem sırasında gerçekte neler olduğunu açıklamak gerek. Bir A işlemi içerisinden B işlemi yaratıldığında, iki işlem benzerdir, yani ikisi de aynı koda sahip, bellek alanı aynı veriler ile dolu (Bellek alanı aynı değil.) ve aynı işlemci durumuna sahiptir. Bu aşamadan sonra işlemler iki farklı şekilde devam edebilir: Kullanıcının vereceği giriş bilgisine veya rastgele olan bir veriye göre. A işlemine baba "father", B işlemine de oğul (son) adı verilmektedir. init işleminin tüm işlemlerin babası deyimi şimdi daha iyi anlaşılıyor olması gerekir. Yeni işlem yaratan fonksiyonun adı:

pid_t fork(void)

Herneyse, ancak hangi işlemin hangisi olduğunu bilmek önemlidir, çünkü programın kodu aynıdır. Her iki işlem de hem baba işlemin hem de oğul işlemin kodunu içerecektir. Önemli olan herbirinin kendine düşen payı çalıştırmalarıdır. Konuyu daha anlaşılır yapmak için, programlama ötesi bir dil gibi gözüken aşağıdaki algoritmaya bir gözatalım:

- FORK
- EĞER OĞUL İSEN BUNU ÇALIŞTIR (...)
- EĞER BABA İSEN BUNU ÇALIŞTIR (...)

int main()
{
  pid_t pid;

  pid = fork();
  if (pid == 0)
  {
    OĞUL İŞLEMİN KODU
  }
  BABA İŞLEMİN KODU
}

(01) #include <unistd.h>
(02) #include <sys/types.h>
(03) #include <stdio.h>

(04) int main()
(05) {
(05)   pid_t pid;
(06)   int i;

(07)   pid = fork();

(08)   if (pid == 0){
(09)     for (i = 0; i  < 8; i++){
(10)       printf("-SON-\n");
(11)     }
(12)     return(0);
(13)   }

(14)   for (i = 0; i < 8; i++){
(15)     printf("+FATHER+\n");
(16)   }

(17)   return(0);
(18) }

(01)-(03) satırları gerekli başlık kütüphaneleri (standart Giriş/Çıkıs I/O, çokluişlem) programa dahil etmektedir.
GNU ortamlarında olduğu gibi, main programı bir tamsayıyı, program hatasız bir şekilde sona erdiğinde sıfır, hatalı olarak sona erirse hata numarasını, dönüş değeri olarak üretmektedir. Şu an için herşeyin hatasız sonuçlanacağını varsayalım. Temel kavramlar anlaşıldıkça programa, hata denetimleri de ekleyeceğiz. (05) satırında, işlem numarasını tutacak değişkeni tanımlıyoruz. (06) satırda, döngülerde kullanacağımız bir tamsayı değişkeni tanımlıyoruz. Daha öncede açıklandığı gibi tamsayı ve pid_t tipleri eşdeğerdir. Biz burada sırf daha anlaşılır olsun diye böyle kullanıyoruz.
(07) satırında, oğul işlemine sıfır ve baba işlemine oğul işlemin işlem numarasını geri gönderecek olan fork fonksiyonunu çağırıyoruz. Hangisinin hangisi olduğu denetim satırı (08) dir. (09)-(13) satırları oğul, geriye kalan (14)-(16) satırları da baba işleminde çalıştırılacaktır.
Hangi işlemin çalıştığına bağlı olarak, kısımların yaptığı tek şey 8'er defa ekrana "-SON-" veya "+FATHER+" yazıp 0 değeri ile programı bitirmektedir. Bu çok önemlidir, çünkü "return" olmadan, oğul işleminin komutlarını yerine getrdikten sonra programın akışı gereği baba işlemlerine geçerek devam edebilir. İsterseniz bir deneyin. Bilgisayarınıza zarar vermeyecektir, ancak istediğimizi de tama olarak yerine getirmemiş olacaktır. Bu şekildeki hataların ayıklanması zor olmaktadır, çünkü özellikle karmaşık çokluişlem programların çalıştırılması sonucunda farklı sonuçlar elde edilecek ve böylece hata ayıklanması imkansızlaşacaktır.

Programı çalıştırdığınızda belkide sonuçtan memnun kalmayacaksınız. Nedenine gelince, elde edilen sonuçların "+FATHER+" ve "-SON-" bir karışımından ziyade, önce "+FATHER+" satırlarının ardından "-SON-" gelecek veya tam tersi de olabilir. Ancak, programı birden fazla defa çalıştırın, belki o zaman sonuç değişebilir.

Herbir printf'ten önce rastgele bekleme süresi eklersek, daha fazla çokluişlem hissi elde etmiş oluruz. Bunu yapabilmek için sleep ve rand fonksiyonlarını kullanıyoruz.

sleep(rand()%4)

(09)  for (i = 0; i < 8; i++){
(->)    sleep (rand()%4);
(10)    printf("-FIGLIO-\n");
(11)  }

[leo@mobile ipc2]$ ./fork_demo2
-SON-
+FATHER+
+FATHER+
-SON-
-SON-
+FATHER+
+FATHER+
-SON-
-FIGLIO-
+FATHER+
+FATHER+
-SON-
-SON-
-SON-
+FATHER+
+FATHER+
[leo@mobile ipc2]$

Şimdi karşımıza çıkacak problemlere bir göz gezdirelim: Çokluişlem ortamında baba işleminden farklı işler yapabilecek birden fazla oğul işlemi yaratmamız olasıdır. Doğru zamanda doğru işi yapabilmek için, baba ilşlem, oğul işlemler ile haberleşmek zorundadır. En azından bir zaman ayarlanması (synchronize) yapılması gerekmektedir. Böyle bir zaman ayarlanmasını olası kılan ilk yöntem wait fonksiyonunu kullanmaktır.

pid_t waitpid (pid_t PID, int *STATUS_PTR, int OPTIONS)

#include <unistd.h>
#include <sys/types.h>
#include <stdio.h>

int main()
{
  pid_t pid;
  int i;

  pid = fork();

  if (pid == 0){
    for (i = 0; i < 14; i++){
      sleep (rand()%4);
      printf("-SON-\n");
    }
    return 0;
  }

  sleep (rand()%4);
  printf("+FATHER+ Waiting for son's termination...\n");
  waitpid (pid, NULL, 0);
  printf("+FATHER+ ...ended\n");

  return 0;
}

Bir sonraki yazıda zamanlama ayarlaması ve işlemler arası iletişim konusu hakkında daha fazla bilgi edineceğiz. Şu ana kadar anlatılan fonksiyonları kullanarak kendi programlarınızı yazın ve açıklamaları ile birlikte .c dosyası halinde bana gönderin. Böylece ben aralarından iyi olan çözümler ile kötüleri gösterme şansı elde etmiş olurum. Adınızı ve e-posta adresinizi yazmayı unutmaın. İyi çalışmalar!  

Önerilen kaynaklar

• Silberschatz, Galvin, Gagne, Operating System Concepts - Sixth Edition, Wiley&Sons, 2001
• Tanenbaum, WoodHull, Operating Systems: Design and Implementation - Second Edition, Prentice Hall, 2000
• Stallings, Operating Systems - Fourth Edition, Prentice Hall, 2002
• Bovet, Cesati, Understanding the Linux Kernel, O'Reilly, 2000

Bu yazı için görüş bildiriminde bulunabilirsiniz

2002-11-28, generated by lfparser version 2.31