Bilgisayar bilimlerinin önemli bir kısmını oluşturan otomatlar (Automata) ve Algoritma Analizi (Algorithm analysis) çalıştırmalarının altındaki dil bilimin en temel taşlarından birisidir.1936 yılında Alan Turing tarafından ortaya atılan makine tasarımı günümüzde pekçok teori ve standardın belirlenmesinde önemli rol oynar.

Turing Makinesinin Tanımı

Basitçe bir kafadan (head) ve bir de teyp bandından (tape) oluşan bir makinedir.

Makinede yapılabilecek işlemler

• Yazmak
• Okumak
• Bandı ileri sarmak
• Bandı geri sarmak

şeklinde sıralanabilir.

Chomsky hiyerarşisi ve Turing Makinesi

Bütün teori bu basit dört işlem üzerine kurulmuştur ve sadece yukarıdaki bu işlemleri kullanarak bir işin yapılıp yapılamayacağı veya bir dilin bu basit 4 işleme indirgenip indirgenemeyeceğine göre diller ve işlemler tasnif edilmiştir.

Bu sınıflandırma yukarıdaki venn şeması ile gösterilmiştir. Aynı zamanda chomsky hiyerarşisi (chomsky hierarchy) için 1. seviye (type-1) olan ve Turing makinesi ile kabul edilebilen diller bütün tip-2 ve tip-3 dilleri yani içerk bağımsız dilleri ve düzenli dilleri kapsamaktadır. Ayrıca ilave olarak içerik bağımsız dillerin işleyemediği (üretemediği veya parçalayamadığı (parse) ) aⁿbⁿcⁿ şeklindeki kelimeleri de işleyebilmektedir.  Düzenli ifadelerin işleyememesi konusunda bilgi için düzenli ifadelerde pompalama savı (pumping lemma in regular expressions) ve içerik bağımsız dillerin işlemeyemesi için de içerik bağımsız dillerde pompalama savı (pumping lemma for CFG) başlıklı yazıları okuyabilirsiniz.

Turing Makinesinin Akademik Tanımı

Turing makineleri literatürde akademik olarak aşağıdaki şekilde tanımlanır:

Burada M ile gösterilen makinenin parçaları aşağıda listelenmiştir:

Q sembolü sonlu sayıdaki durumların kümesidir. Yani makinenin işleme sırasında aldığı durumardır.

Γ sembolü dilde bulunan bütün harfleri içeren alfabeyi gösterir. Örneğin ikilik tabandaki sayılar ile işlem yapılıyorsa {0,1} şeklinde kabul edilir.

Σ sembolü ile makineye verilecek girdiler (input) kümesi gösterilir. Girdi kümesi dildeki harfler dışında bir sembol taşıyamayacağı için Σ ⊆ Γ demek doğru olur.

δ sembolü dilde bulunan ve makinenin çalışması sırasında kullanacağı geçişleri (transitions) tutmaktadır.

◊ sembolü teyp bandı üzerindeki boşlukları ifade etmektedir. Yani teyp üzerinde hiçbir bilgi yokken bu sembol okunur.

q₀ sembolü makinenin başlangıç durumunu (state) tutmaktadır ve dolayısıyla q₀ ⊆ Q olmak zorundadır.

F sembolü makinenin bitiş durumunu (state) tutmaktadır ve yine F ⊆ Q olmak zorundadır.

Örnek Turing Makinesi

Yukarıdaki sembolleri kullanarak örnek bir Turing makinesini aşağıdaki şekilde inşa edebiliriz.

Örneğin basit bir kelime olan a* düzenli ifadesini (regular expression) Turing makinesi ile gösterelim ve bize verilen aaa şeklindeki 3 a yı makinemizin kabul edip etmediğine bakalım.

Tanım itibariyle makinemizi aşağıdaki şekilde tanımlayalım:

M = { {q₀,q₁} , { a } , { a,x } , { q₀ a→a R q₀ , q₀ x→x L q₁} , q₀ , x , q₁ }

Yukarıdaki bu makineyi yorumlayacak olursak:

Q değeri olarak   {q₀,q₁} verilmiştir. Yani makinemizin ik idurumu olacaktır.

Γ değeri olarak { a,x } verilmiştir. Yani makinemizdeki kullanılan semboller a ve x’ten ibarettir.

Σ değeri olara {a} verilmiştir. Yani makinemize sadece a girdisi kabul edilmektedir.

δ değeri olarak iki geçiş verilmiştir { q₀ a→a R q₀ , q₀ x→x L q₁} buraadki R sağa sarma L ise sola sarmadır ve görüleceği üzere Q değerindeki durumlar arasındaki geçişleri tutmaktadır.

◊ değeri olarak x sembolü verilmiştir. Buradan x sembolünün aslında boş sembolü olduğu ve bantta hiçbir değer yokken okunan değer olduğu anlaşılmaktadır.

q₀ ile makinenin başlangıç durumundaki hali belirtilmiştir.

F değeri olarak q₁ değeri verilmiştir. Demek ki makinemiz q₁ durumuna geldiğinde bitmektedir (halt) ve bu duruma gelmesi halinde bu duruma kadar olan girdileri kabul etmiş olur.

Yukarıdaki bu tanımı görsel olarak göstermek de mümkündür:

Yukarıdaki bu temsili resimde verilen turing makinesi çizilmiştir.

Makinemizin örnek çalışmasını ve bant durumunu adım adım inceleyelim.

Birinci adımda bandımızda aaa (3 adet a) yazılı olduğunu kabul edelim ve makinemizin bu aaa değerini kabul edip etmeyeceğini adım adım görelim. Zaten istediğimiz de aaa değerini kabul eden bir makine yapabilmekti.

Yukarıdaki ilk durumda bant üzerinde beklenen ve kabul edilip edilmeyeceği merak edilen değerimiz bulunuyor. Makinemizin kafasının okuduğu değer a sembolü. Makinemizin geçiş tasarımına göre q₀ halinde başlıyoruz ve a geldiğinde teybi sağa sarıp yine q₀ durumunda kalmamız gerekiyor.

Yeni durumda kafamızın okuduğu değer banttaki 2. a harfi ve bu durumda yine q₀ durumundayken teybi sağa sarıp yine q₀ durumunda kalmamız tasarlanmış

3. durumda kafamızın okuduğu değer yine a sembolü olmakta ve daha önceki 2 duruma benzer şekilde q₀ durumundayken a sembolü okumanın sonucu olarak teybi sağa sarıp q₀ durumunda sabit kalıyoruz.

4. adımda teypten okuduğumuz değer boşluk sembolü x oluyor. Bu değer makinemizin tasarımında q₁ durumuna gitmemiz olarak tasarlanmış ve teybe sola sarma emri veriyoruz.

Makinenin son durumunda q₁ durumu makinenin kabul ve bitiş durumu olarak tasarlanmıştı ( makinenin tasarımındaki F kümesi) dolayısıyla çalışmamız burada sonlanmış ve giriş olarak aaa girdisini kabul etmiş oluyoruz.

2. Örnek

Hasan Bey’in sorusu üzerine bir örnek makine daha ekleme ihtiyacı zuhur etti. Makinemiz {a,b} sembolleri için çalışsın ve ilk durum olarak bandın en solunda başlayarak bantta bulunan sembolleri silmek için tasarlansın. Bu tasarımı aşağıdaki temsili resimde görülen otomat ile yapabiliriz:

Görüldüğü üzere makinemizde 4 durum bulunuyor, bunlardan en sağda olan h durumu bitişi (halt) temsil ediyor. Şimdi bu makinenin bir misal olarak “aabb” yazılı bir bantta silme işlemini nasıl yaptığını adım adım izah etmeye çalışalım.

Aşağıda, makinenin her adımda nasıl davranacağı bant üzerinde gösterilmiş ve altında açıklanmıştır. Sarı renge boyalı olan kutular, kafanın o anda üzerinde durduğu bant konumunu temsil etmektedir.

Netice olarak Hasan Bey’in sorusuna temel teşkil eden ve örneğin q1 üzerindeki döngülerden birisi olan b/a,R geçişi, banttan b okunduğunda banta a değerini yaz manasındadır.

Yine bu yazıya yapılan yorumlarda sorulan bir sorunun cevabını aşağıdaki bağlantıda çözdüm. Soru, eşit a ve b içeren Turing makinesinin tasarımı idi, bağlantıya tıklayarak okuyabilirsiniz.

http://www.bilgisayarkavramlari.com/2010/11/19/esit-a-ve-b-bulunduran-turing-makinesi-ornegi/

1,677 views

Bilgisayar bilimlerinde, paralel programlama amacıyla kullanılan bir platformun ismidir. Çok çeşitli işletim sistemlerinde ve çok çeşitli dillerde paralel uygulama geliştirmeye olanak sağlar. Ancak temel çıkış sistemi Linux ve temel programlama dili olarak C dili kabul edilebilir.

İçerik
1. Paralel Programlamaya Giriş
2 MPI Kurulumu
3. MPI ile paralel program geliştirilmesi
4. MPI kodunun çalıştırılması

Buna karşılık windows, Unix gibi işletim sistemleri ve JAVA, C++, C# gibi programlama dillerinde de oldukça yoğun kullanıcıları bulunmaktadır. Ayrıca nadirde olsa bu sayılanlar dışındaki işletim sistemi ve programlama dillerinde geliştirme yapanlar bulunur.

Bu yazının amacı okuyucuya basit paralel programlama yaklaşımını kazandırmak, basit bir MPI kurulumu gerçekleştirme ve üzerinde basit bir uygulama çalıştıracak seviyeye getirmektir.

Paralel Programlamaya Giriş

MPI temel olarak birden fazla bilgisayarın üzerinde aynı programın çalıştırılması ve bu çalıştırma sırasında programların birbiri ile iletişime geçerek birbirinden veri transfer etmesine dayanır.

Temel olarak paralel programlamanın amacı bir bilgisayarda çok uzun sürede işlenen bir işi birden fazla bilgisayara bölerek aynı anda işletmek ve sonucu geri birleştirmektir (Bir anlamda algoritma analizindeki parçala fethet (divide and conquere) yaklaşımı olarak görülebilir)

Örneğin paralel programlama dünyasının en temel problemi olan matrix çarpımını ele alalım. Matrix çarpımı paralel programlamanın Merhaba Dünya (Hello World) uygulaması olarak düşünülebilir ve bu ortamda yazılan en basit program olarak görülebilir.

Matris boyutu büyüdükçe bir bilgisayardaki işlem süresi de uzar. Matrix parçalara bölünerek farklı bilgisayarlarda çarpılırsa bu durumda işlem süresi bölünerek büyür. Yani örneğin bir matrisin bir bilgisayarda çarpılması 1 saat alıyorsa 10 bilgisayarda 6 dakikaya yakın bir süre alır.

Paralel programlama ve paralal işleme (prallel processing) konusunda unutulmaması gereken bir nokta verinin ağ üzerinde bilgisayarlara dağıtılma zamanıdır. Dolayısıyla bir problemin bilgisayarlara dağıtılması her zaman süreyi bilgisayar sayısına bölmez. Hatta problem çok küçükse ve paralel yapılmaya çalışılıyorsa bu durumda ağ üzerindeki iletim süresi problemin çözüm süresini uzatabilir bile.

Ayrıca paralel programlama sırasında, problemin bilgisayarlara nasıl bölündüğü de oldukça önemlidir. Şayet problem birbirinden bağımsız parçalara bölünebiliyor ve birleştirmek veya bölmek için ayrıca işlem zaman almıyorsa bu durumda işleme süresi, topalam sürenin bilgisayara bölünmüş haline yakındır.

Ancak şayet problem bölündükten sonra diğer parçalardan bilgilere ihtiyaç duyuyorsa veya diğer bilgisayarların işlediği bilgileri bekliyorsa veya problemin bölünmesi veya birleştirilmesi çok fazla zaman alıyorsa bu durumda da zamanın tek bilgisayarla işlenen zamana yaklaştığını hatta ağ üzerine kaybedilen vakitten dolayı geçtiğini bile görebiliriz.

Yukarıda açıkladığım bu temel paralel programlama mantığının aslında MPI ile hiç ilgisi yoktur. MPI sadece yukarıda açıkladığım bu yaklaşımın programcı tarafından kodlanmasına yardımcı olur. Ancak yine de MPI kullanımını anlatmadan önce kısaca paralel programlama hakkında bilgi vermek istedim.

Şimdi MPI kurulumuna ve kullanılması konularına bakabiliriz.

MPI kurulumu

Daha önce de bahsedildiği üzere MPI kullanımı için çok farklı dil ve çok farklı ortam seçenekleri bulunmaktadır. Bu yazı kapsamında windows işletim sistemi üzerinde kullanılabilen MPICH2 paketi tanıltılacaktır.

MPICH2 paketi argonna üniversitesinde geliştirilen ve windows üzerine oldukça fazla kullanıcısı bulunan bir pakettir. Hatta bu paket esas alınarak daha kolay kullanım sağlayan farklı paketler de geliştirilmiştir.

MPICH2 paketini http://www.mcs.anl.gov/research/projects/mpich2/ adresinden indirebilirsiniz. Bilgisayar mimarinize uygun paketin indirdikten sonra aşağıdakine benzer bir kurulum ekranı belirir:

Bu ekranda krımızı daire içerisindeki Next düğmesine basılarak bir sonraki adıma geçilir:

Yukarıda MPICH2 kurulumu hakkında genel bilgiler içeren ekrandan Next düğmesi ile devam edilir:

Yukarıdaki bu adımda lisans sözleşmesini kabul edip Next düğmesine basılır:

Yukarıdaki ekranda, ileride kullanacağımız şifreyi giriyoruz. Bu şifre kendiliğinden “behappy” olarak geliyor. İstenirse bu şekilde bırakılabilir ancak bunun bir günvelik açığı olduğu unutulmamalı. Şifremizi girdikten sonra Next düğmesi ile devam ediliyor:

Yukarıdaki kurulum bilgileri ekranında, MPICH2′nin kurulmasını istediğimiz dizini belirtiyoruz. Ayrıca kullanıcı hakkı olarak sadece aktif kullanıcı veya bütün windows kullancıları için kurulumdan birisini seçiyoruz.

Dilenirse bu aşamada “Disk Cost” düğmesi ile de kurulum yapılabilecek diskler ve bu disklerde kurulumun kaplayacağı yer hakkında bilgi alınabilir.

Son olarak aşağıdaki ekrana Next Düğmesi ile geçiyoruz

Yukarıdaki bu son ekran MPICH2′nin kuruluma hazır olduğunu ve Next düğmesi ile kurulumun başlayacağını belirtiyor.

Next düğmesine basıyoruz ve kurulum başlıyor. Kurulum sırasında bir ilerleme çubuğu ile kurulum devam eder. Ayrıca bir iki kere konsolu açıp bazı komutlar çalıştırır. Bu işlemler sırasında en önemli adımlardan birisi de ateş duvarında (firewall) yetki verilmesi aşamasıdır. Şayet bir ateş duvarınız bulunuyorsa, yeni kurduğumuz bu program için yetkilendirme yapmanız gerekir. Örneğin bu ekran Windows Vista için aşağıdaki şekilde görülür ve Engellemeyi Kaldır seçeneği seçilmelidir.

Yukarıdaki ateş duvarı hakkı verildikten sonra MPICH2 kurulumu tamamlanır ve aşağıdaki şekilde kurulumun bittiğini belirten ekran görüntülenir:

Şayet kurulum başarıyla tamamlanırsa Başlat menüsünün altına MPICH2 grubu eklenir.

MPICH2′nin çalıştırılması için kurulum dizini altında bulunan bin isimli dizine girilmesi ve içerisindeki mpiexec komutunun çalıştırılması yeterlidir. Tabi mpiexec ile çalıştırmak için öncelikle bir de MPI ortamına uygun kodun yazılması gerekir.

Yukarıdaki şekilde kurulumu gerçekleştirdikten sonra MPI ile kod yazmaya başlayabiliriz.

MPI ile paralel program geliştirilmesi

Bu bölümde basit bir matrix çarpım programını yazacağız. Amacımız programın paralel olarak çalışmasıdır. Öncelike matris çarpımı yapan bu kod için gerekli kütüphaneleri kodumuzdan çağıralım:

#include <stdio.h>
#include "mpi.h"

Şayet mpi kurulumunuz başarılı olduysa mpi.h dosyasının çağrılmasında bir problem olmamalıdır. Ancak kodumuzu çalıştırırken ilave olarak bağlayıcıya (linker) bu kütüphaneyi tanıtmamız gerektiğini unutmayalım.

#define MASTER 0		/* taskid of first task */
#define FROM_MASTER 1		/* setting a message type */
#define FROM_WORKER 2		/* setting a message type */

Yukarıdai kodumuz kapsamında master (ana bilgisayarımız ve kodumuzu derleyip çalıştırdığımız bilgisayar olarak kabul ediyoruz) ve worker (işçi bilgisayarlar, yani programın üzerine dağıtıldığı ve sadece işlemci gücünden faydalandığımız bilgisayarlar) bilgisayarlar arasındaki mesajlaşma için kullanılan değişkenleri tanımlıyoruz. Bu değişken değerleri mesaj geçirilirken birer sinyal olarak kullanılacak ve mesajın kimden geldiğini belirtecektir.

MPI_Status status;

MPI_Status tipinden tanımlanan yukarıdaki değişken ise mesajlaşma sırasında sistemin durumu hakkındaki bilgileri tutarak gerektiğinde durum tespiti yapmamızı sağlar. Bu değişken de mesaj gönderme ve alma sırasında kullanılacaktır.

main(int argc, char **argv)
{
int numtasks,			/* number of tasks in partition */
    taskid,			/* a task identifier */
    numworkers,			/* number of worker tasks */

C dilinde geliştirdiğimiz programımızda main fonksiyonu ile koda başlıyoruz. tanımlanan numtasks değişkeni kaç işlem (process) çalıştığını tutacak.

MPI ile işimizi bilgisayarlara dağıtabildiğimiz gibi bir bilgisayar üzerinde de birden fazla iş (process) çalıştırmamız mümkündür. Dolayısyla örneğin 10 bilgisayarın bulunduğu bir ortamda her bilgisayarda 3′er iş çalıştırılırsa bu durumda toplam 30 iş çalışmış olur. Yani programımız sanki 30 farklı bilgisayarda çalışıyormuş gibi davranmak zorundadır.

Yukarıdaki taskid değişkenini hangi iş (process) olduğumuzu tutmak için kullanacağız. Daha önce de belirttiğimiz üzere birden fazla bilgisayar (yada işlemde) programımız kopyalanır. Yani aslında bütün bilgisayarlarda aynı kod çalışır. Çalışan kodun farkı veya yapılan işin farkını belirtebilmek için öncelikle kim olduğumuzu (hangi process olduğumuzu) bilmeliyiz. İşte bu taskid değişkenindeki bilgiyi yine MPI fonksiyonlarından alacağız ve programımız hangi işlem olduğuna göre farklı davranacak (matrisin hangi bölümünü çarptığımızı buradan öğrenceğiz.

numworkers değişkeni ise mevcut sistemde toplam kaç iş (process) olduğunu tutacak. Bu bilgi de MPI fonksiyonları ile elde edilen bir bilgi olacak.

MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &taskid);
MPI_Comm_size(MPI_COMM_WORLD, &numtasks);
numworkers = numtasks-1;

Yukarıda ilk defa MPI fonksiyonlarını kullandık. MPI_Init fonksiyonu sistemi ilklendirir (initialize). Burada dikkat edilirse main fonksiyonunun parametreleri aynen geçirilmiştir. Bu parametreler konsoldan okunan program parametreleridir (console parameters).

Yukarıdaki ikinci fonksiyonda (MPI_Comm_rank) oluşturulan paralel dünyamızdan (ki bu dünya MPI kurulumu ile oluşturulmaktadır) taskid değişkenine rank (seviye) bilgisi okunmaktadır. Yani kısacası kaç numaralı iş (process) olduğumuz bu fonksiyondan atıf  ile çağırılarak (call by reference) öğrenilmiştir.

Benzer şekilde sistemdeki iş (process) sayısı da MPI_Comm_size fonksiyonu ile öğrenilmiştir. Bu sayı kurulumumuzdaki toplam işin miktarını vermektedir.

Hemen altında numworkers değişkeni numtasks değişkeninden 1 eksik olarak ayarlanmıştır. Bunun sebebi ana işin (process) toplam çalışan sayısından çıkarılmasıdır. Yani bütün işleri dağıtan ve sistemden bilgileri toplayan, bizim kullanıcı olarak doğrudan iletişimde olduğumuz ve hesaplama işini yapmayacak olan ana iş (master process) toplam işçi sayısıyndan çıkarılmıştır. Çünkü birazdan matrisi parçalara ayırıp işçilere (slaves) yollarken ve matrisin kaç parçaya bölüneceğine karar verirken bu sayının içerisinde ana işin bulunmaması gerekmektedir.

if (taskid == MASTER) {

Yukarıdaki if ile mevcut işin (process) ana iş olup olmadığını kontrol ediyoruz. Benzer şekilde

if (taskid > MASTER) {

Yukarıdaki satır ile de diğer işlerin (process) durumu belirtilir. Burada ilk değişken tanımlarımızı hatırlayacak olursak MASTER değişkeninin değeri 1 olarak tanımlanmıştı. Yani şayet bizim taskid değerimiz 1 ‘ise ana işlem (master process) diğer bütün durumlarda da çalışan (slave) olmuş oluyoruz.

Kodun tamamı aşağıda verilmiştir:

#include <stdio.h>
#include "mpi.h"
#define NRA 62 			/* number of rows in matrix A */
#define NCA 15			/* number of columns in matrix A */
#define NCB 7   		/* number of columns in matrix B */
#define MASTER 0		/* taskid of first task */
#define FROM_MASTER 1		/* setting a message type */
#define FROM_WORKER 2		/* setting a message type */

MPI_Status status;
main(int argc, char **argv)
{
int numtasks,			/* number of tasks in partition */
    taskid,			/* a task identifier */
    numworkers,			/* number of worker tasks */
    source,			/* task id of message source */
    dest,			/* task id of message destination */
    nbytes,			/* number of bytes in message */
    mtype,			/* message type */
    intsize,			/* size of an integer in bytes */
    dbsize,			/* size of a double float in bytes */
    rows,                      	/* rows of matrix A sent to each worker */
    averow, extra, offset,      /* used to determine rows sent to each worker */
    i, j, k,			/* misc */
    count;
double a[NRA][NCA], 		/* matrix A to be multiplied */
       b[NCA][NCB],      	/* matrix B to be multiplied */
       c[NRA][NCB];		/* result matrix C */

intsize = sizeof(int);
dbsize = sizeof(double);

MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &taskid);
MPI_Comm_size(MPI_COMM_WORLD, &numtasks);
numworkers = numtasks-1;

/**************************** master task ************************************/
if (taskid == MASTER) {
  printf("Number of worker tasks = %d\n",numworkers);
  for (i=0; i<NRA; i++)
    for (j=0; j<NCA; j++)
      a[i][j]= i+j;
  for (i=0; i<NCA; i++)
    for (j=0; j<NCB; j++)
      b[i][j]= i*j;

  /* send matrix data to the worker tasks */
  averow = NRA/numworkers;
  extra = NRA%numworkers;
  offset = 0;
  mtype = FROM_MASTER;
  for (dest=1; dest<=numworkers; dest++) {
    rows = (dest <= extra) ? averow+1 : averow;
    printf("   sending %d rows to task %d\n",rows,dest);
    MPI_Send(&offset, 1, MPI_INT, dest, mtype, MPI_COMM_WORLD);
    MPI_Send(&rows, 1, MPI_INT, dest, mtype, MPI_COMM_WORLD);
    count = rows*NCA;
    MPI_Send(&a[offset][0], count, MPI_DOUBLE, dest, mtype, MPI_COMM_WORLD);
    count = NCA*NCB;
    MPI_Send(&b, count, MPI_DOUBLE, dest, mtype, MPI_COMM_WORLD);

    offset = offset + rows;
    }

  /* wait for results from all worker tasks */
  mtype = FROM_WORKER;
  for (i=1; i<=numworkers; i++)	{
    source = i;
    MPI_Recv(&offset, 1, MPI_INT, source, mtype, MPI_COMM_WORLD, &status);
    MPI_Recv(&rows, 1, MPI_INT, source, mtype, MPI_COMM_WORLD, &status);
    count = rows*NCB;
    MPI_Recv(&c[offset][0], count, MPI_DOUBLE, source, mtype, MPI_COMM_WORLD,
               &status);

    }

  /* print results */
  printf("Here is the result matrix\n");
  for (i=0; i<NRA; i++) {
    printf("\n");
    for (j=0; j<NCB; j++)
      printf("%6.2f   ", c[i][j]);
    }
  printf ("\n");

  }  /* end of master section */

/**************************** worker task ************************************/
if (taskid > MASTER) {
  mtype = FROM_MASTER;
  source = MASTER;
  printf ("Master =%d, mtype=%d\n", source, mtype);
  MPI_Recv(&offset, 1, MPI_INT, source, mtype, MPI_COMM_WORLD, &status);
  printf ("offset =%d\n", offset);
  MPI_Recv(&rows, 1, MPI_INT, source, mtype, MPI_COMM_WORLD, &status);
  printf ("row =%d\n", rows);
  count = rows*NCA;
  MPI_Recv(&a, count, MPI_DOUBLE, source, mtype, MPI_COMM_WORLD, &status);
  printf ("a[0][0] =%e\n", a[0][0]);
  count = NCA*NCB;
  MPI_Recv(&b, count, MPI_DOUBLE, source, mtype, MPI_COMM_WORLD, &status);
  printf ("b=\n");
  for (k=0; k<NCB; k++)
    for (i=0; i<rows; i++) {
      c[i][k] = 0.0;
      for (j=0; j<NCA; j++)
        c[i][k] = c[i][k] + a[i][j] * b[j][k];
      }

  mtype = FROM_WORKER;
  printf ("after computer\n");
  MPI_Send(&offset, 1, MPI_INT, MASTER, mtype, MPI_COMM_WORLD);
  MPI_Send(&rows, 1, MPI_INT, MASTER, mtype, MPI_COMM_WORLD);
  MPI_Send(&c, rows*NCB, MPI_DOUBLE, MASTER, mtype, MPI_COMM_WORLD);
  printf ("after send\n");

  }  /* end of worker */
  MPI_Finalize();
} /* of main */

Yukarıdaki kod Dev-CPP ortamında mingw derleyicisi (compiler) ile test edilmiştir. Ayrıca kodun çalışması için aşağıdaki bölümü okuyabilirsiniz.

MPI kodunun çalıştırılması

Kodun çalıştırılması için yukarıda anlatıldığı gibi bir MPICH2 kurulumunun yapıldığını kabul ediyoruz. Ayrıca kodumuzu derlemek için Dev-CPP kullanacağız. Ancak kodlama hakkında tecrübesi olan bir okuyucu dilediği başka bir derleyici (compiler) kullanarak devam edebilir.

314 views

Bilgisayar bilimlerinde sıra (queue) teorisinde, sıradaki bir varlığın ne kadar meşgul edildiğini ölçmeye ve bu ölçüme göre kararlar vermeye verilen isimdir.

İstatistiksel olarak ρ sembolü ile gösterilir ve şayet ρ değeri 1′den büyükse sıranın uzadığı, 1′e eşitse sıranın ne kısalıp ne de uzadığı ve şayet 1′den küçükse sıranın kısaldığı veya sırada kimse kalmadığı sonucu çıkarılır.

Burada ρ değerinin hesaplanması için aşağıdaki formül kullanılabilir:

ρ = λ / μ

Yukarıdaki formülde λ değeri sıraya gelen varlıkların oranını, μ değeri ise sistemin bu sıradaki varlıklara hizmet verme oranını göstermektedir. Yani basitçe sıraya girenler ve sıradan çıkanların oranı olarak düşünülebilir. Daha basit bir ifadeyle talep/arz oranı olarak düşünülebilir.

Basit bir örnek üzerinden anlatmak gerekirse örneğin bir bankada bulunan banka görevlileri ortalama olarak bir müşteriye 1 dakikada hizmet veriyor olsun. Saatte 50 müşterinin geldiği bir bankada meşguliyet aşağıdaki şekilde hesaplanabilir:

Öncelikle arz ve talebi aynı birimlere getirmek gerekir. Yani bankanın arz ettiği hizmet değeri müşteri/saat şeklindeyken, bankanın talep değeri müşteri/saat cinsinden. Bu durumda bankanın arz değerini de müşteri/saat cinsine çevirelim.

Basit bir hesapla 1 dakikada bir müşteriye hizmet verilen bir bankada saatte 60 müşteriye hizmet verilir. Öyleyse bu bankanın meşguliyet oranı (utilization):

ρ = λ / μ

λ = 50

μ = 60

için ρ = 50 / 60

= 0.83

olarak bulunur. Bu durumda bankanın müşterilerine zamanında hizmet verebileceğini ve müşterilerin sıra beklemeyeceğini veya bir sıra varsa zamanla azalacağını yorumlayabiliriz.

68 views

Latince bölünemez anlamına gelen atom kökünden üretilen bu kelime, bilgisayar bilimlerinde çeşitli alanlarda bir bilginin veya bir varlığın bölünemediğini ifade eder.

Örneğin programlama dillerinde bir dilin atomic (bölünemez) en küçük üyesi bu anlama gelmektedir. Mesela C dilinde her satır (statement) atomic (bölünemez) bir varlıktır.

Benzer şekilde bir verinin bölünemezliğini ifade etmek için de veri tabanı, veri güvenliği veya veri iletimi konularında kullanılabilir.

Örneğin veri tabanında bir işlemin (transaction) tamamlanmasının bölünemez olması gerekir. Yani basit bir örnekle bir para transferi bir hesabın değerinin artması ve diğer hesabın değerinin azalmasıdır (havale yapılan kaynak hesaptan havale yapılan hedef hesaba doğru paranın yer değiştirmesi) bu sıradaki işlemlerin bölünmeden tamamlanması (atomic olması) gerekir ve bir hesaptan para eksildikten sonra, diğer hesapa para eklenmeden araya başka işlem giremez.

Benzer şekilde işletim sistemi tasarımı, paralel programlama gibi konularda da bir işlemin atomic olması araya başka işlemlerin girmemesi anlamına gelir.

Örneğin sistem tasarımında kullanılan check and set fonksiyonu önce bir değişkeni kontrol edip sonra değerini değiştirmektedir. Bir değişkenin değeri kontrol edildikten sonra içerisine değer atanmadan farklı işlemler araya girerse bu sırada problem yaşanması mümkündür. Pekçok işlemci tasarımında buna benzer fonksiyonlar sunulmaktadır.

Genel olarak bölünemezlik (atomicity) geliştirilen ortamda daha düşük seviyeli kontroller ile sağlanır. Örneğin işletim sistemlerinde kullanılan semafor’lar (semaphores), kilitler (locks), koşullu değişkenler (conditional variables) ve monitörler (monitors) bunlar örnektir ve işletim sisteminde bir işlemin yapılması öncesinde bölünmezlik sağlayabilirler.

Kullanılan ortama göre farklı yöntemlerle benzer bölünmezlikler geliştirilebilir. Örneğin veritabanı programlama sırasında koşul (condition) veya kilit (lock) kullanımı bölünmezliği sağlayabilir.

174 views

C dilinde mevcut zamanı almak ve işlemek mümkündür. Bunun için time.h dosyasının içerisinde bulunan fonksiyonlar kullanılabilir. Ayrıca time.h dosyasında bulunan time_t oluşumu (struct) zaman tutmak için geliştirilmiştir ve zamanı oluşturan alt unsurları da içerir.

Örneğin şu andaki zamanı ekrana basmak için aşağıdaki kod kullanılabilir:

  struct timeval tv;
  time_t curtime;
  gettimeofday(&tv, NULL);
  curtime=tv.tv_sec;
  printf("%m-%d-%Y  %T.",localtime(&curtime));

Örneğin bir kullanıcıdan yazı okuyan ve ne kadar zamanda okuduğunu ekrana basan kod aşağıdaki şekilde yazılabilir:

#include <stdio.h>
#include <time.h>
#include <conio.h>
int main ()
{
  time_t start,end;
  time (&start);
  printf ("Bir tuşa basınız");
  getch();
  time (&end);
  printf ("Tuşa basmanız %.2lfsaniye sürdü.\n", difftime (end,start));
  return 0;
}

Yukarıdaki time_t yapısı oldukça kullanışlı olmasına karşılık mikro saniye gibi düşük zamanları algılamakta yetersizdir. Bunun için biraz daha detaylı çalışan timeeval yapısından ve gettimeofday fonksiyonundan faydalanılabilir:

struct timeval starttv, endtv;

struct timezone starttz, endtz;gettimeofday(&starttv, &starttz);

for (i=0;i<100;i++)

   for(j=0;j<256;j++)

      for(k=0;k<10;k++)

         printf("deneme") ;

gettimeofday(&endtv, &endtz);

float fark1=getdiff(endtv, starttv);

Örneğin yukarıdaki kodda iç içe 3 döngü içerisinde ekrana deneme yazdırılıyor (toplam 100x256x10 tane) bu işlemin aldığı vakti ölçmek için gettimeofday fonksiyonundan faydalanılmış ve en sonunda da fark hesaplanmış. Burada eksik olan getdiff fonksiyonu aşağıdaki şekilde yazılabilir:

float getdiff(struct timeval endtv, struct timeval starttv)
{
   float diff=0;
   diff=(endtv.tv_sec-starttv.tv_sec)*1000000+
   (endtv.tv_usec-starttv.tv_usec);
   return diff;
}

Serper Bey’in sorusu üzerine ekliyorum, büyültmek için resme tıklayabilirsiniz:

Dev-CPP üzerinde zaman işlemleri

Yukarıdaki, linux kodlarından farklı olarak Dev-CPP kullanmak isteyenler clock sınıfından yararlanabilir.

Kod basitçe zamanı clock() fonksiyonu ile okur ve dört işleme tabi tutar. Buradaki değişken tipi ise clock_t cinsindendir.

clock_t start, end;

start=clock();

…. işlemler ……

end = clock();

printf(“fark: %f”,end-start);

şeklinde yazılan kod başarılı bir şekilde çalışma süresini ölçer. Elbette bu işlemler sırasında sys/time.h kütüphanesi include edilmelidir.

805 views

YACC, bilgisayara bilimlerinin önemli dallarından birisi olan dil tasarımı ve dil geliştirilmesi sırasında (compiler teory) sıkça kullanılan bir kod üretici programdır. YACC basitçe dildeki sözdizim (syntax) tasarımı için kullanılır ve tasarladığımız dildeki kelimelerin sıralamasının istediğimiz şekilde girilip girilmediğini kontrol eder. Aynı zamanda sıralamadaki her kelimenin anlamını da yacc marifetiyle belirleyebiliriz.

YACC temel olarak BNF (Backus Normal Form) kullanarak cümle dizimini belirtmektedir.

LEX ile birlikte kullanıldığıdan bir dil tasarımının neredeyse yarısı olan lexical (kelime) ve syntax (cümle) analizi tamamlanmış olur. Bundan sonra dildeki her kelime ve cümle diziliminin anlamını (semantic) kodlamak kalır.

YACC neredeyse tamamen aynı olan açık kaynak kodlu bison isimli paket ile de kurulabilir.

Aşağıda örnek bir yacc dosyası verilmiştir. Bu dosyayı inceleyerek yacc’ın kullanımını anlamaya çalışalım:

%{ // tanımlamam yapılan ilk bölüm
    #include <stdio.h>
    int yylex(void);
    void yyerror(char *);
%}

%token INTEGER

%% // BNF yapısındaki ikinci bölüm

program:
        program expr '\n'         { printf("%d\n", $2); }
        |
        ;

expr:
        INTEGER
        | expr '+' expr           { $$ = $1 + $3; }
        | expr '-' expr           { $$ = $1 - $3; }
        ;

%%
// fonksiyon içeriklerinin bulunduğu son bölüm
void yyerror(char *s) {
    fprintf(stderr, "%s\n", s);
}

int main(void) {
    yyparse();
    return 0;
}

Dosyamız LEX’e benzer şekilde 3 bölümden oluşmaktadır. İlk bölümde kodumuza dahil edilecek kütüphaneleri ve fonksiyon prototiplerini tanımlıyoruz.

ikinci bölümde BNF yapısı benzeri bir şekilde dilimizdeki sözdizim tanımlanıyor.

üçüncü ve son bölümde fonksiyon tanımları ve main fonksiyonu bulunmaktadır.

Yukarıdaki dosyada yapılan işlemleri aşağıda anlatalım:

YACC dosyasında %token ve %type olarak iki farklı tanım yapılabilmektedir. %token tanımı lex’den gelen bir sabit bilgiyi taşımak için kullanılır. %type ise yacc içerisinde tanımlanan devamlıları (nonterminal) ifade etmek için kullanılır.

Genelde bir kural olmamasına karşılık BNF yapısındaki sonlular (terminal) büyük harfle ve devamlılar (nonterminal) küçük harf ile yazılırlar. (dosyamızın C kodu üreteceğini ve gerek yacc gerek lex gerek se C dilinin büyükküçük harfe duyarlı (case sensitive) olduğunu unutmayınız)

yyerror fonksiyonu yacc tarafından girilen değeri kontrol ederken bir dizilim hatası bulunması (syntax error) çağrılan fonksiyondur.

main fonksiyonu aynen üretilen koda kopyalanmakta ve ilk çalışan C fonksiyonumuzdur.

BNF yapısının yanında bulunan ve küme parantezleri arasında (curved brackets) bulunan kodda ise aşağıdaki terimler kullanılabilir:

$$ -> bu devamlıdan (nonterminal) dönecek olan değerdir.

$1 -> BNF yapımızdaki ilk parametredir. Örneğin aşağıdaki satırı ele alalım:

 | expr '+' expr           { $$ = $1 + $3; }

Bu satırda ilk sembol veya anlamında | sembolüdür. Bu sembolün amacı bir expr tanımlanırken ihtimallerden birisi olmasıdır. Ardından expr sembolü ilk sembol ‘+’ ikinci sembol ve ikinci expr sembolü ise 3. semboldür. Dolayısıyla sırasıyla :

$1= expr

$2= ‘+’

$3 = expr

anlamına gelmektedir.

Bu satırın bulunması durumunda yapılacak işlem ilk expr karşılık gelen değer ile ikinci expr karşılık gelen değerin sayısal olarak toplanması ve sonuç olarak $$ marifeti ile döndürülmesidir.

283 views

Bilgisayar bilimlerinde programlama dillerinin tasarımı ve geliştirilmesi sırasında kullanılan ve dildeki kelimelerin analizine (lexical analysis) yarayan kod üretme programıdır. Yani lex için hazırlanmış bir dosyayı lex programından geçirdikten sonra size C dilinde bir kod çıkar. Bu kodu C dilinde derledikten (compile) sonra çalışan bir programınız olur. Veya tercihen bu çıktıyı yacc programına alt yapı oluşturmak için de kullanabilirsiniz.

LEX programının ismi inigilizcedeki lexical analyzer kelimesinden gelir. Kelime bilimi anlamına gelen Lexical kelimesinin ilk 3 harfinden kısaltılmıştır. LEX programının linux üzerinde çalışan ve yaygın bir sürümü flex ismindedir. flex programı da lex gibi çalışmaktadır ve hemen hemen aynı parametre ve özelliklerle kullanılabilir.

LEX dosyalarının 3 ana bölümü bulunur. İlk bölümde fonksiyon ve değişke tanımlamaları ve projeye dahil edilecek (include) kütüphaneler tanımlanır.

ikinci bölümde LEX dosyamızın omurgasını oluşturan düzenli deyimler ( regular expression ) kısmı yer alır. Burada her ihtimal için ayrı bir regular expression tanımlanarak ilgili regular expression’a girilmesi durumunda ne yapılacağı kodlanır.

Son bölümde ise fonksiyon içerikleri yer alır.

Aşağıda basit bir lex dosyasının içeriği verilmiştir:

%{ // yukarıda anlatılan ilk bölüm tanımlamalar yapılıyor
    #include "y.tab.h"
    #include <stdlib.h>
    void yyerror(char *);
%}

// ikinci bölüm regular expressionlar
%%

[0-9]+      {
                yylval = atoi(yytext);
                return INTEGER;
            }

[-+\n]      { return *yytext; }

[ \t]       ;       /* skip whitespace */

.           yyerror("Unknown character");

%%
// son bölüm fonksiyon içerikleri
int yywrap(void) {
    return 1;
}

Yukarıdaki bu dosya daha önce de anlatıldığı üzere 3 parçadan oluşmaktadır. Koddaki düzenli deyimler( regular expression) kısaca aşağıda açıklanmıştır:

• [0-9]+ 0 ile 9 arasındaki sayılar (yani 0 1 2 3 4 5 6 7 8 9 sayılarından en az bir yada istenildiği kadar çok
• [-+\n] sembol olarak “+”, “-” veya “\n” sembolleri (yani artı eksi veya satır sonu (enter tuşu))
• [ \t] sembol olara ” ” veya “\t” yani boşluk karakteri (space) veya tab karakteri
• . geri kalan bütün karakterler. LEX dosyasında üstte yazılı olan düzenli deyimlerin önceliği var ve . sembolü herşeyi kapsar dolayısıyla yukarıdakilerden birisine girmezse buraya girer.

Yukarıdaki düzenli deyimler için yapılan işlemler küme parantezleri arasında (curved brackets) yazılmaktadır. Bu alanlarda yazılanları da tanıyalım:

yylval değişkeni lex tarafından döndürülen değerdir. Bu değer dahil edilen y.tab.h dosyasında tanımlanır ve bu değişkene değer atanarak lex’den örneğin yacc’a veri geçişi sağlanır.

yytext değişkeni ilgili düzenli deyime (Regular expression) giren terimleri alır. Örneğin lex çalışırken 123 gibi bir girdi aldı diyelim. Bu girdi ilk düzenli deyime girecek (çünkü 123 sayısal değerleri [0-9] aralığına uyan 3 sembolden oluşuyor ve bu sembollerin 3 kere tekrarlanması bu düzenli deyim tarafından algılanır). Bu deyim girdikten sonra yapılan iş gelen metin değerini (yytext ki burada “123″ dizgisi (String) oluyor) atoi fonksiyonu ile integer tipine çevirir. Bu çevrilen değer yylval değişkenine atanarak yacc’a geçirilmektedir.

207 views

Parçalam işlemi  (parsing) bilgisayar bilimlerinde çeşitli amaçlar için kullanılmaktadır. Özellikle de dil ile ilgili işlemlerin hemen hepsinde ihtiyaç duyulan bir işlemdir. Örneğin bir programlama dilinde yazılan komutların algılanması için öncelikle kelimeleirn parçalanması (parse) gerekir. Benzer şekilde dopal dil işleme (natural language processing) işlemlerinde de doğal dilde bulunan kelimelerin algılanması bir parçalamadan (ek ve köklerin ayrılmasından) sonra gerçekleşmektedir.

Çeşitli sebeplerle kullanılan parçalama ağaçları basitçe verilen bir dilbilgisine (grammer) göre verilen cümlenin (veya kelimenin) nasıl parçalandığını şekilsel olarak gösteren ağaçlardır:

Örneğin aşağıda BNF yapısında verilmiş dili ele alalım:

<dil>::=<işlem>

<işlem> ::= <işlem> + <terim> | <işlem> – <terim> | <terim>

<terim> ::= <terim> * <unsur> | <terim> / <unsur> | <unsur>

<unsur> ::= sayı | ( <işlem> )

<sayı> ::= 1|2|3…|9|0

Bu dilde aşağıdaki örneğin nasıl parçalandığını inceleyelim:

4+8*(2-3)

Bu dilde tanımlı olan yukarıdaki işlemin parçalama ağacı aşağıdaki şekildedir:

yukarıdaki şekilde devamlı (nonterminal) terimlerden sonuncu (terminal) terimlere kadar bir BNF dilinin nasıl açıldığı gösterilmiştir.

284 views

Bilgisayar bilimlerilnde genellikle bir dil tanımlamada ve bu dilin gramerini (Dil bilgisini) belirlemekte kullanılan gösterim biçimidir.

Basitçe dil bir dil tanımında başlayarak Terminal (sonuncu) ve Non-Terminal (Devamlı) terimler kullanarak tanılmanmaktadır.

Örneğin aşağıda basit bir örneği verilmiştir:

<dil> ::= <harf>|<imla>

<harf> ::= a|b|…|z

<imla> ::= .| |,|?

Yukarıda bir dil tanımı yapılmış ve bu dilde harf veya imlalar bulunduğu söylenmiştir. Buna göre dilimizdeki harfler a’dan z’ye kadar olup imla işaretleri de “. ,?” işaretleridir.  Bir ifadenin (nonterminal veya terminal) alabileceği alternatifler | işareti ile ayrılır. Yani harf ya “a”, ya “b” ya… şeklinde sayılan alternatiflerden birisi olabilir demektir. (aralarında veya (or) bağlantısı varmış gibi düşünülebilir)

Yukarıda da görüldüğü üzere BNF gösteriminde nonterminal’ler (devamlılar) <> işaretleri arasında belirtilmektedir.

Yukarıdaki dilimize aşağıdakine benzer bir ek yapılırsa:

<dil> ::= <harf><dil> |<harf>|<imla>

<harf> ::= a|b|…|z

<imla> ::= .| |,|?

Yukarıda fark edilsin diye koyu gösterilen ek marifetiyle dilimizde bir dögü elde edilmiş ve bu sayede dilimizdeki harfler istenildiği kadar tekrar edilmiştir. Yani ilk örnekte dilimizde sadece tek bir harf veya tek bir imla işareti bulunabilirken yeni eklentimiz ile dilimizde istediğimiz kadar harf bulunudurabiliriz. Elbette bu durumun bir harf veya imla ile bitmesi gerekmektedir.

BNF ayrıca döngü miktarını belirlemek için de {}_i^j sembollerini kullanır. Bu gösterim i’den j’ye kadar tekralanacağı anlamındadır:

192 views

Hafıza yönetimi sırasında kullanılan kıtalama (bölütleme, segmentation) hafızadaki her işleme tam olarak istediği kadar yer ayırmaya çalışır. Bu yaklaşımda, işlemler arasında oluşabilecek boşluklara verilen isim harici parçalar (dış parçalar, external fragments)’dir.

Her işleme ihtiyaç duyduğu kadar yer ayırmak ilk başta daha verimli gibi görülse de bu çözümde de boşluklar ve hafıza israfı söz konusudur. Sayflama (Paging) yaklaşımında slotların içine olan boşluklara iç parça (internal fragment) ismi verilirken kıtalama (segmentation) sırasında oluşan boşluklara dış parça (external fragment) ismi verilir. Bu boşluklar aşağıdaki şekilde oluşur.

Yukarıdaki şekilde görüldüğü üzere sırasıyla 1, 2 ve 3. işlemler gelmiş hafızada gösterilen alanlar bu işlemlere ayrılmıştır. Şimdi bu işlemlerden örneğin 2. işlemin çalışıp bittiğini düşünelim. Bunun anlamı 2. işlem hafızadan kaldırılacak demektir.

2. işlem hafızadan kaldırıldıktan sonra oluşan tablo aşağıdaki şekildedir:

Yukarıda da görüldüğü üzere 400 ile 500 arasındaki hafıza alanı boşalmıştır. Buradaki boşluk verimsiz bir boşluktur bunun sebebi 100 boyutunda başka bir işlem gelmediği sürece bu alan kullanılamaz. Hele bir de aşağıdaki gibi örneğin 75 boyutunda bir işlem gelirse arada kalan 25 birimlik boşluğun kullanılabilirliği oldukça azalır.

işte bu alanlara bilgisayar bilimlerinde verilen isim harici parça (external fragment)’dir.

142 views