1. Otomatik Form Oluşturmayın: Normalde, projeye eklediğiniz her bir form uygulama tarafından otomatik olarak oluşturulmak üzere ayarlıdır. Bunu dpr dosyasının kaynak kodunda bulunan Application.CreateForm ile görebilrisiniz. Her ne kadar bu size formlara erişirken büyük kolaylık sağlasa da uygulamanın ilk çalışma zamanını önemli derece de yavaşlatmaktadır. Bu yüzden formları otomatik olarak oluşturmayın. Sadece ihtiyacınız olduğunda dinamik olarak oluşturun. Çoğu zaman sadece ana formu otomatik olarak oluşturmanız kafi glecektir.
2. Mümkün Olduğunca Windows API’lerini Tercih Edin: Yapacağınız bir işlem için eğer Windows API’lerinde bu işi göre bir fonksiyon var ise, sakın ayrı bir fonksiyon yazmaya kalkmayın. Windows fonksiyonlarını kullanmak bizim için en hızlı yöntem olacaktır. Bu yüzden bir fonksiyon yazmadan önce Windows API’si içinde bu işi yapan başka bir fonksiyonun olup olmadığından emin olun.
3. Küçük Fonskiyonlar İçin “inline” Direktifini Kullanın: Yeni Delphi sürümleri “inline” direktifini desteklemektedir. “inline” kullanmak exe boyutunu artıracaktır. Fakat hız da artacaktır. Eğer küçük fonskiyonlarınız varsa veya büyük olsa da çok fazla yerde kullanılmayan fonksiyonlarınız varsa, fonksiyon veya prosedür tanımlamasından sonra “inline” direktifini kullanın.
4. Table yerine Query Tarzı Bileşenler Kullanın: TTable gibi bileşenleri mümkün olduğunca kullanmaktan çekinin. Bunun yerine TQuery veya TSqlQuery tarzı bileşenleri tercih edin.
5. FastMM Kullanın: FastMM projesi, normalde Delphi 2005 ile Delphi’ye dahil oldu. Eğer daha düşük versiyon kullanıyorsanız kesinlikle FastMM kullanın. D2005 ve yukarısı için de yeni güncellemeler oldukça faydası olacaktır. Daha fazla bilgi için FastMM’i google’da arattırın.
6. Kodlarınızı Yazarken Disiplinli Olun: Kodlarınızı yazarken değişken, sınıf, fonksiyon isimlendirmelerinde belli bir standarta uyun. Bıraktığınız kod yorumlarını daha sonradan bakacak mışsınız veya başka birisi projeyi devam ettirecekmişcesine yazın. Bu ve bunun gibi kendinize kurallar belirleyerek disiplinli bir şekilde kodlarınızı yazın. Bu size, daha sonradan programınızı bitirdikten sonra kolay bir optimizasyon imkanı sağlayacak. Tekrar kodlara dönüp baktığınızda disiplinli ve düzenli yazılmış bir kod göreceksiniz ve yavaş çalışan veya hatalı çalışan kısımları daha çabuk farkedip, kodunuzu optimize edebileceksiniz.
7. Basm İle Optimizasyona Gidin: Basm yani Delphi içinde assembler kullanarak bazı önemli yerleri optimize edebilirsiniz. Özellikle hızın çok önemli olduğu yerleri bu şekilde optimize edebilirsiniz. Bununla ilgili olarak  daha önceden burada bir şeyler karalamıştık.

Tabi bunlar dışında hızı etkileyen başka faktörlerin de olduğunu unutmayın. Fakat ilk etapta bu adımlara dikkat etmeniz, programlarınızdaki çalışma hızını önemli derece artıracaktır. Buradaki adımların çoğunun tek dez avantajı, exe boyutunun biraz artabilmesi. Fakat bu devirde kimse exe boyutunu çok önemsemiyor.

Benim aklıma 7 adım geldi fakat sizlerin de önerileri olursa lütfen yorum yazarak katkıda bulununuz.

Güncelleme: 07.03.2009: Bu maddelere ek olarak buradaki yorumda bulunan 3 maddeye daha göz atmanızı tavsiye ediyorum. Saadettin beye teşekkürler.

Fatih Tolga Ata © 2009

Aslında bu bölüm gerçekten uzun oldu. Normalde VCL kullanımını üçüncü bir bölüme taşımayı düşünüyordum. Ama bu konuda istekler olunca birleştrip yayınlamayı düşüdüm. İçeride sizi iki sayfalık bir makale bekliyor. Bu yüzden sayfa sonunda bitti zannedip kapatmayın!

Hazırsanız başlayalım.

Kanallar’ı Eş Zamanlı Olarak Çalıştırmak

Kanallar ile uğraşırken karşılaşılan en büyük sorunlardan bir tanesi de şüphesiz kanalları ortak bir şekilde sorunsuz olarak çalıştırmaktır. Eminim kanallar ile uğraşan birisi bütün kanallar tarafından ortak olarak kullanılan bir kaynağa erişmede problemlerle karşı karşıya gelmiştir ve kanalları bir köşeye itmesine sebep olmuştur.

Mesela şu veritabanı problemi size tanıdık gelecektir. Diyelim ki, iki adet kanalımız var ve bunlardan birincisi veritabanındaki bir kaydı açıp değişiklik yapmaya başladı. Sonra ikinci kanal aynı kaydın belli bölümlerinde düzenlemeler yaptıktan sonra veriyi kaydetti. Ardından birinci kanal, aynı verilerdeki değişikliğini bitirdi ve kaydetti. Birinci kanal, ikinci kanal’ın değişikliklerinden habersiz olduğundan ikinci kanalın yaptığı düzenlemeler de uçtu gitti.

Burada okuduğunuz problem, normalde kanallar ve veritabanı ile uğraşan bir çok programcının başına gelmiş bir problemdir. Bununla birlikte sadece veritabanında değil bir çok noktada özellikle bir dosyayı, bir portu, bir DLL’i veya başka bir şeyi, kanalların ortak kullanmasında hep benzer sıkıntılarla karşılaşılmıştır. Bu gibi sıkıntıların ve problemlerin çözümü kanalları eş zamanlı kullanım için kritik bölgeler tanımlamak ya da muteksleri kullanmaktır. Bu iki yöntem de makalemizin konuları arasındadır.

Kritik Bölgeler(Critical Sections)

Kritik Bölgeler -ya da başka yerlerde görebileceğiniz gibi kritik kesimler, bölümler, vs..- yukarıda anlatığımız problemdeki, birinci kanalın kaynağı kullanması esnasında ikinci kanalın bu kaynağa erişmesini englelemek için kullanılır. Birinci kanal işini yapıyorken, ikinci kanal’a çalışması için bir zaman dili ayrılmaz. Böylece birinci kanal işini bitirene kadar ikinci kanal çalıştırılmaz.

Bunun için örnek bir uygulamada yukarıdaki anlattığımız senaryolara benzer bir problem oluşturalım ve çözümünü aramaya çalışalım.

Diyelim ki, iki adet kanalımız var ve bu kanallar bir döngünün her adımında bir dizi işlem gerçekleştiriyor. Ve bu gerçekleştirdikleri işlemler için ortak kullandıkları global olarak tanımlanmış bir değişken olsun. Meseleyi anlatabilmek için iki kanalında yaptığı işlemlerin sonucunun aynı olmasını sağlamak istiyorum. Böylece problem daha iyi anlaşılabilecek.

Birinci kanal bir döngünün her adımında global değişkenimize teker teker harfler ekliyor ve sonuçta değişkenimizde bir yazı oluşuyor. Aynı işlemi ikinci kanalımız da yapıyor ve sonuç olarak birinci kanal ile aynı yazıyı üretiyorlar. Yanlız ikinci kanal harfleri teker teker eklemek yerine ikişer ikişer ekliyor. Ekleme işlemi çok hızlı olduğundan problemin oluşması için aralara Sleep rutinini ekleyerek işlemi birazcık yavaşlatıyoruz. Şimdi bu mantığımızı koda dökmeye başlayalım.

Yeni bir VCL uygulaması açalım ve bir adet button ekleyelim. Aşağıdaki gibi unitin var bloğunda global bir değişken tanımlayalım:

var
  Form1: TForm1;
  SonucYazi: string; //Global değişkenimiz

Ardından buttonun OnClick olayını aşağıdaki gibi değiştirelim.

procedure TForm1.Button1Click(Sender: TObject);
var
  Kanal1ID, Kanal2ID: DWORD;
begin
  CreateThread(nil, 0, @Kanal1, nil, 0, Kanal1ID);
  CreateThread(nil, 0, @Kanal2, nil, 0, Kanal2ID);
end;

Bu iki adet kanalımıza ait kanal fonksiyonlarını da aşağıdaki gibi oluşturalım:

procedure Kanal1;
procedure Kanal2;

...

implementation

...

procedure Kanal1;
var
  i: Integer;
begin
  for i := 0 to 10 do
  begin
    SonucYazi := SonucYazi + 'd';
    Sleep(10);
    SonucYazi := SonucYazi + 'i';
    SonucYazi := SonucYazi + 'y';
    SonucYazi := SonucYazi + 'e';
    Sleep(10);
    SonucYazi := SonucYazi + 'z';
    SonucYazi := SonucYazi + 'o';
    SonucYazi := SonucYazi + 'n ';
    Sleep(10);
  end;
end;

procedure Kanal2;
var
  i: Integer;
begin
  for i := 0 to 10 do
  begin
    SonucYazi := SonucYazi + 'di';
    Sleep(10);
    SonucYazi := SonucYazi + 'ye';
    SonucYazi := SonucYazi + 'zo';
    Sleep(10);
    SonucYazi := SonucYazi + 'n ';
  end;
end;

Gördüğünüz gibi iki kanal fonksiyonu da aynı sonucu üretiyor. Ama sonucu üretme yolları farklı. Ayrıca iki kanal da peş peşe oluşturulup çalıştırılıyor. Forma bir adet daha button ekleyelim ve bize sonucu göstersin. Bunun için ikinci butonumuzun OnClick olayını aşağıdaki gibi düzenleyelim:

procedure TForm1.Button2Click(Sender: TObject);
begin
  ShowMessage(SonucYazi);
end;

Bu programı çalıştırdıktan sonra ve kanalları birinci düğme ile çalıştırdıktan sonra sonuç yazının "diyezon diyezon diyezon …" gibi bir şey olmasını isteriz. Yani bir for döngüsünün bir adımı tamamlanmadan SonucYazi isimli global değişkene müdahale olmasını istemeyiz. Halbuki programı çalıştırdığınızda sonucun hiç de böyle olmadığını göreceğiz. Kanal1 işini bitirip "diyezon " yazmadan Kanal2 işe karışmış ve aralarda kendi harflerini eklemiştir. Hakeza bu, Kanal2 için de geçerlidir. Yani Kanal2, döngünün bir adımını bitirip istenilen sonucu veremeden Kanal1 global değişkenimize müdahale etmiştir.

Burada verdiğimiz örnek biraz soyut kaçabilir. Çünkü yaptığımız işlemden sonuç olarak elimize bir şey geçmiyor. Ama karşılaşacağınız sorunlar hep bu tarzda sorunlardır. Karşılaştığınız sorunları verdiğimiz bu örnek ile kıyaslama yapabilirsiniz. Mesela biz bu örneğimizde işlem adımlarını yavaşlatmak için Sleep rutinini kullandık. Normal hayatta kanallar ile uğraşırken zaten yaptığımız işlemlerin adımları Sleep rutinini aratmamaktadır. Mesela bir veritabanı tablosunda Edit ve Post gibi metodları kullandığımızda belli bir miktar işlemin tamamlanmasını bekleriz. Bir de eğer sizde sonuç düzgün çıkıyorsa yine söylüyorum işlemciniz, bu makaleyi yazdığım sıralardaki işlemcimden hızlı demektir. Bu durumda Sleep rutinine verdiğimiz değerleri çok az miktarlarda artırmayı deneyin.

Sadede gelelim ve problemi anladı isek şöyle bir soruyu kafamıza getirelim: Bir kanal belli bir işini bitirmeden önce diğer kanalların müdahalesini nasıl engelleyebiliriz?

Cevabı zaten bu bölümün başında verdik. Bunun için belli yerleri kritik bölge ilan edeceğiz. Bir kanalda kritik bölge ilan ettiğimiz yerdeki kodlar çalışmaya başladığı sırada, diğer kanallardaki aynı kritik bölgedeki kodlar işletilmez ve bekler. Yani aynı kritik bölgeye sahip kanallardan aynı anda sadece bir bölgedeki kodlar çalıştırılabilir. Böylece diğer kanalların istenilmeyen müdahalesi engellenmiş olur.

Bir Kritik bölge tanımlamak için bilmemiz gereken üç dört adet Windows apisi vardır.

InitializeCriticalSection: Bu fonksiyon kritik bölge’yi temsil eden recordun ilk değerlerini atamakla sorumludur. Yani kritik bölgeyi kullanıma hazırlamaktadır. Genelde formun OnCreate olayında kullanılır.

DeleteCriticalSection: Yukarıdaki fonksiyonun tam tersi olarak, bu fonksiyon da kritik bölgeyi ortadan kaldırır. Genelde formun OnDestroy olayına yerleştirilir.

EnterCriticalSection: Bu fonksiyonu çalıştırdığınız satırdan itibaren kritik bölgenin başlangıcını belirtirsiniz. Yani Delphi’deki "begin" kelimesi gibi düşünebilirsiniz.

LeaveCriticalSection: Bu fonksiyon ise, çalıştırıldığı satırla kritik bölgeyi sınırlandırır. Yine Delphi’deki "end" ifadesine benzetebiliriz.

Kritik bölgeyi temsil eden record ise TRTLCriticalSection tipindedir. Normalde Windows SDK yardım dosyalarında LPCRITICAL_SECTION şeklinde tanımlanmıştır. Ama Delphi ekibi bir çok windows yapısını tanımlarken bunlara "T" ile başlayan daha iyi okunur alias isimler vermişler. Her neyse…

Kritik bölgenin tanımlanması gayet basittir. Bir kritik bölgeyi işletim sistemine tanıtmak için InitializeCriticalSection fonksiyonunu kullanıyoruz. Kritik bölge ile işimiz bittiğinde de DeleteCriticalSection fonksiyonunu çağırmayı unutmuyoruz. Ardından kanal fonksiyonlarımızda kritik bölgeleri belirleyip başına EnterCriticalSection ve sonuna LeaveCriticalSection sonksiyonlarını koyuyoruz.

Örneğimize dönelim ve kritik bölgeleri eklemeye başlayalım. Bizim müdahale istemediğimiz bölge, kanal fonksiyonlarındaki döngülerin her bir adımıdır. Yani teker teker veya ikişer ikişer ekleme yapılan kısımlarda bir adım işini bitirmeden başka bir kanalın global değişkenimize müdahalesini engellemek istiyoruz. Kısacası kritik bölgemiz bu örnekte, döngünün her bir adımı olmalıdır.

İlk başta global olarak bir değişken daha tanımlayalım. Bu değişken bizim kritik bölgemizi temsil eden record olsun.

var
  Form1: TForm1;
  SonucYazi: string;
  BirinciKritikBolge: TRTLCriticalSection; //kritik bölgemizi temsil ediyor.

Ardından formun OnCreate ve OnDestroy olaylarını aşağıdaki gibi değiştirelim.

procedure TForm1.FormCreate(Sender: TObject);
begin
  InitializeCriticalSection(BirinciKritikBolge);
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  DeleteCriticalSection(BirinciKritikBolge);
end;

Eğer başka kritik bölgeler de tanımlamış iseniz bunları da InitializeCriticalSection ve DeleteCriticalSection fonksiyonlarını kullanarak oluşturmalı ve silme işlemlerini gerçekleştirmelisiniz. Bizim örneğimizde bir adet kritik bölge yeterlidir.

Şimidi kanal fonksiyonlarında bahsettiğimiz yerleri kritik bölge olarak ilan edelim.

procedure Kanal1;
var
  i: Integer;
begin
  for i := 0 to 10 do
  begin
    EnterCriticalSection(BirinciKritikBolge); //BirinciKritikBolge başlangıcı
    SonucYazi := SonucYazi + 'd';
    Sleep(10);
    SonucYazi := SonucYazi + 'i';
    SonucYazi := SonucYazi + 'y';
    SonucYazi := SonucYazi + 'e';
    Sleep(10);
    SonucYazi := SonucYazi + 'z';
    SonucYazi := SonucYazi + 'o';
    SonucYazi := SonucYazi + 'n ';
    Sleep(10);
    LeaveCriticalSection(BirinciKritikBolge); //BirinciKritikBolge bitişi
  end;
end;

procedure Kanal2;
var
  i: Integer;
begin
  for i := 0 to 10 do
  begin
    EnterCriticalSection(BirinciKritikBolge); //BirinciKritikBolge başlangıcı
    SonucYazi := SonucYazi + 'di';
    Sleep(10);
    SonucYazi := SonucYazi + 'ye';
    SonucYazi := SonucYazi + 'zo';
    Sleep(10);
    SonucYazi := SonucYazi + 'n ';
    LeaveCriticalSection(BirinciKritikBolge); //BirinciKritikBolge bitişi
  end;
end;

Yapacağımız başka bir işlem kalmadı. Programı çalıştırıp deneybiliriz. Sonucun "diyezon diyezon diyezon …" gibi düzgün olduğunu göreceğiz. Çünkü Kritik bölge tanımlayarak sadece bir kanalın kritik bölgesini çalıştırmış olduk. Böylece bir kanal global SonucYazi değişkeni ile uğraşırken diğer kanal buna müdahale edemeyecektir.

Burada bir adet kritik bölge tanımladık. Sizler ihtiyaca göre projelerinizde bir çok kritik bölge tanımlayabilirsiniz. Ayrıca kritik bölgelerin birbirinden bağımsız hareket ettiğini de aklınızdan çıkarmayın. Bazen karıştırılan nokta bu kısım olabiliyor. Mesela bu örneğimizde bir adet kritik bölge mevcut ama iki farklı yapılan iş var.

Gördüğünüz gibi kanalları eş zamanlı olarak çalıştırmak o kadar da zor değilmiş. Tek yaptığımız bell bölgeleri kritik bölge olarak ilan etmek. Şimdi yeni bir kavramla daha tanışalım.

Muteksler(Mutex)

İngilizce’ de, mutual ve exclusive kelimelerinin birleşiminden meydana gelmiştir. Dilimizde ise müşterek ve seçkin kelimeleri bu kelimeleri karşılamaktadır. Programlama terminolojisinde ise, sadece tek işlemdeki değil birden fazla işlemdeki kanalları eş zamanlı olarak kullanılmasını sağlayan bir tekniktir.

Bir mutekse aynı anda sadece bir tek kanal sahip olabilir. Literatürde, bu mutekse, bir kanal sahip olduğunda, muteksin kanal tarafından "tetiklendiği" ya da "tutulduğu" söylenir. Aynı şekilde eğer kanal bu mutekse sahip deiğilse muteks "serbestir" ya da "tetiklenmemiştir" tabirleri kullanılır.

Şu an kafanızda mutekslerin ne olduğuna dair somut bir düşünce oluşmamış olabilir. Ama bölümün sonuna kadar okuduğunuzda neyin ne olduğuna dair bir fikir oluşacağına eminim.

Bir muteks, CreateMutex fonksiyonu ile oluşturulur. Bu fonksiyonun tanımlanması ve açıklaması aşağıdadır.

function CreateMutex(lpMutexAttributes: PSecurityAttributes;
  bInitialOwner: BOOL;
  lpName: PChar): THandle;

lpMutexAttributes: Muteksin güvenliği ile ilgli parametredir. Bu parametreye nil girerek varsayılan güvenlik özelliklerini ayarlamış oluyoruz.

bInitialOwner: Kanalın bu mutekse sahip olup olmadığını ya da yukarıda bahsettiğimiz gibi muteksin tetiklenip tetiklenmeyeceğini belirler. True ya da False giriyoruz. Genelde muteksi programın ana kanalında oluşturduğumuzdan, ana kanalın mutekse sahip olmasını istemeyiz. Bu yüzden genelde bu parametreye False gireriz.

lpName: Eğer farklı işlemler bu mutekse erişecekse bu muteksimize bir isim vermemiz gerekmektedir. Buraya nil de girebilirisiniz. Bu durumda isimsiz bir muteksimiz olur.

Bu fonksiyon eğer muteksi oluşturabilirse çıktı olarak muteksin handle numarasını dönderir. Eğer muteks oluşmamış ise 0 değerini çıktı olarak verir.

Muteksleri, kritik bölgeler gibi düşünebilirsiniz. Kritik bölge oluşturmak için kullandığımız InitializeCriticalSection fonksiyonu yerine CreateMutex fonksiyonunu, kritik bölgenin başlangıcını belirten EnterCriticalSection yerine WaitForSingleObject fonksiyonunu, kritik bölgenin bitişini bildiren LeaveCriticalSection fonksiyonu yerine de ReleaseMutex fonksiyonunu kullanıyoruz. CloseHandle ile de CreateMutex ile oluşan muteksin handle’ını kapatmayı da unutmuyoruz.

İlk önce bir muteks oluşturalım.

birmuteks := CreateMutex(nil, False, 'ornekmuteks');

Ardından kritik bölgeyi oluşturduğumuz yerlerdeki fonksiyonları muteksin fonksiyonları ile yer değiştiriyoruz. Şimdilik sadece Kanal1 için örnek verelim.

procedure Kanal1;
var
  i: Integer;
begin
  for i := 0 to 10 do
  begin
    WaitForSingleObject(birmuteks, INFINITE); //Muteksin tetiklenmesini bekle
    SonucYazi := SonucYazi + 'd';
    Sleep(10);
    SonucYazi := SonucYazi + 'i';
    SonucYazi := SonucYazi + 'y';
    SonucYazi := SonucYazi + 'e';
    Sleep(10);
    SonucYazi := SonucYazi + 'z';
    SonucYazi := SonucYazi + 'o';
    SonucYazi := SonucYazi + 'n ';
    Sleep(10);
    ReleaseMutex(birmuteks); //Muteksi serbest bırak.
  end;
end;

Şimdi muteksin ne olduğuna dair kafanızda bir şeyler şekillenmeye başlmamıştır. Çünkü kodlara baktığımızda WaitForSingleObject fonksiyonu bir şeyleri bekliyor ve ReleaseMutex ise bir şeyi serbest bırakıyor. WaitForSingleObject, "tek bir nesne için bekle" gibi bir manası var. Esas yaptığı görev, birinci parametresinde verilen handle numarasına göre bir muteksi beklemektir. İkinci parametresinde ise ne kadar bekleyeceğini belirliyoruz. Bu örneğimizde INFINITE (sonsuz) girmekle, bir muteks tetiklenene kadar bekleyeceğini belirttik. Bu parametreye, en fazla ne kadar bekleneceğini milisaniye şeklinde girebilirsiniz.

Muteksi anlamada genelde verilen örnek ve bence en iyi örnek bayrak yarışıdır. Bayrak yarışlarında bir şeritte ancak bir koşucu koşabilir. Bayrağı alan koşmaya başlar. Bir şeritte, bayrağa sahip olmayan, koşabilmek için bayrağı beklemesi gerekmektedir. Böyelece her bir şeritte sadece bir yarışçı koşabilir.

Aynen bunun gibi, kanallar çalışabilmek için mutekse sahip olmaları gerekmektedir. Mutekse sahip olan koşmaya yani çalışmaya başlar. Mutekse sahip olmayan, muteksin kendisine gelmesini bekler. Bir hatırlatma olarak, önceki paragraflarda sahip olmanın tetiklemek olduğundan bahsetmiştik.

İşte WaitForSingleObject ile muteksin bu kanalımıza gelmesini beklemiş oluyoruz. Ve bunu örneğimizde, INFINTE yani sonsuz süre kadar bekliyoruz. Ve muteksle işimiz bittiğinde diğer kanalların kullanabilmesi için muteksi ReleaseMutex ile serbest bırakıyoruz. Ve yine tekrar ediyorum "Bir mutekse aynı anda sadece bir tek kanal sahip olabilir."

CreateMutex ile oluşturduğumuz muteksin handle’nı formun OnDestroy olayında CloseHandle ile kapatmayı da unutmuyoruz. Yani kritik bölgelerde yaptığımız DeleteCriticalSection yerine

CloseHandle(birmuteks);

gibi bir şey yazmalıyız.

Bu örneği, makaleyi fazla uzatmasın diye, burada tüm kodlarını yazmayacağım. Muteks örnek projesini buradan indirebilirsiniz.

Eğer tek bir muteks değil de bir den fazla muteksi tetiklemesini bekelemek istersek ne olacak? Bu durumda WaiıtForMultipleObjects fonksiyonunu kullanacağız. WaitForSingleObject tek bir muteksi beklerken WaitForMultipleObject fonksiyonu birden fazla muteksi beklemektedir. Kullanım aynı olduğu için bununla ilgili bir örnek yapmayacağım. Bu fonksiyon ile iligli tek söyleyebileceğim şey ikinci parametrede beklediğiniz mutekslerin handle’larını dizi şeklinde girmeniz olacaktır.

Başka İşlemlerden Mutekslere Sahip Olma

Dediğimiz gibi, mantık olarak mutekslerin kritik bölgelerden tek farkı, başka program ve işlemlerdeki kanallar ile ortak ve eş zamanlı çalışmaya izin vermesidir. Bunun için muteksimize bir isim vermemiz gerektiğini söylemiştik. İşte bu ismi kullanarak başka bir işlem muteksin handle numarasını alabilir. Gerisinde de WaitForSingleObject ve ReleaseMutex fonksiyonlarında bu handle numarasını kullanabiliriz. Yani mevcut bir muteksin handle numarasını alabilmek için:

birmuteks := OpenMutex(0, False, 'ornekmuteks');

dememiz yeterli. Bunu yukarıdaki örneğimizde CreateMutex yerine kullanabilirsiniz. Ama unutmamanınız gereken nokta bunun ile mevcut bir muteksin handle numarasını alırız. Eğer muteks CreateMutex ile hiç oluşturulmamış ise bu fonksiyon 0 değerini dönderir.

OpenMutex fonksiyonunun parametreleri CreateMutex ile aynı olduğundan burada fazladan bir açıklama yapmayacağım.

Bu konuda bir örnek yapmak isterseniz yukarıda verdiğimiz örneği iki uygulamaya bölebilirsiniz. Kanal1‘i birinci uygulamada, Kanal2‘yi de ikinci uygulamada oluşturursunuz. Ve ikisinde de OnCreate olayında şöyle bir şey girersiniz:

var
  BirMuteks: THandle;
.....
procedure TForm1.OnCreate(....);
begin
  BirMuteks := OpenMutex(0, False, 'ornekmuteks');
  if BirMuteks = 0 then
    BirMuteks := CreateMutex(nil, False, 'ornekmuteks');

Kısaca burada yaptığımız işlem eğer "ornekmuteks" isminde bir mutex henüz oluşturulmamış ise oluşturuyoruz.

Bu şekilde iki veya daha fazla sayıda işlem tek bir muteks üzerinde kanallarını eş zamanlı olarak çalıştırabilirler. Bu örneği kendiniz yapmaya çalışın. Gerçi burada yapılmışı var . Ama lütfen indirip incelemeden önce kendiniz yapmayı deneyin.

—

İşte size iki adet yöntem. Ve ikisi de windows programlamada çok sık kullanılmaktadır. Kanalları beraber çalıştırmak istediğinizde, istrer muteks kullanın isterseniz kritik bölge tanımlayın. Her ikisinin de tanımlanması ve kullanılması çok kolay. Kafanızdaki "kanal kullanmak çok zordur" düşüncesini birinci bölümde aştığınızı düşünüyorum. Buraya kadar olan kısım ile de "kanalları eş zamanlı çalıştırmak zordur" düşüncesini yendiğinizi zannediyorum.

Peki muteks ve kritik bölge arasında tercih yapmak gerekirse hangisini tercih etmeliyiz. Bence performans açısından pek fark olmaz. Seçim noktanız şu olmalı. Eğer, tek bir işlemden değil de bir çok işlemden yani bir çok programdan oluşan bir gurubun kanalları ortak ve eş zamanlı kullanmasını düşünüyorsak kesinlikle muteks kullanmalıyız. Aksi durumda yani eş zamanlı çalışacak olan kanallar sadece tek bir işlemde bulunuyorlarsa o zaman seçim size kalmış. Hangisi rahatınıza gidiyorsa onu kullanabilirsiniz.

Şimdi farklı bir konuya geçiş yapalım. Hazırsanız ikinci sayfadan devem edelim.

Bu makale, ileri seviye Windows programcılığına geçiş kapısıdır. Bu makeledeki konuları öğrendikten sonra Win32 programcılığının en güçlü özelliklerini öğrenmiş olacaksınız.

Yanlız "ileri seviye" tabiri gözünüzü korkutmasın. Çünkü makeleyi bitirdiğinizde thread kullanımının aslında ne kadar kolay olduğunu göreceksiniz. Bununla birlikte bu makalede bu konu ile ilgili her ayrıntıyı anlatabilmemiz için yüzlerce sayfalık kitap yazmamız gereklidir. Bu yüzden burada işin mantığını kapıp, ihtiyacınız oldukça yardım dosyalarına müracaat etmeniz gerekebilir.

Kanallar hakkında hiç bir bilginiz olmayabilir. Bu makalede işin temelinden alacağız ve makaleyi bitirdiğinizde kendi programlarınıza kanal ekleyebilecek duruma geleceğinize inanıyorum.

Bu makale serisinde kanallar temelden anlatılmakla beraber, ileri seviye kanal kullanımı, VCL bileşenlerinde kanal kullanımı ve Muteksler de ana konularımız arasına girecektir.

Giriş

İlk başta bir kaç teorik bilgi ile başlamak istiyorum. Bu bilgilieri olabildiğince sıkmadan, kısa tutmaya çalışacağım.

Disk üzerindeki her bir dosya çalıştırıldığında artık windows için birer işlem(process) olurlar. Bir işlem Windows için fazla bir şey ifade etmez. Çünkü işlemler sadece hafızada belli bir bölgede var olmaktan sorumludur. Esas işlemi yapan kısım kanallardır(thread). Bir işlem en az bir adet kanala sahiptir. Win 3.1 gibi işletim sistemleri sadece bir adet kanala sahiptir. Ama Windows 95 ve üstü, Unix, OSX gibi işletim sistemleri birden fazla kanala sahip olabilirler.

İşletim sistemi bir programı ya da bir DLL’i ilk başta işlem olarak hafızaya taşır. Bu esnada işlem eylemsiz olarak durur. Bu işleme ait kanallar ise bizim belirlediğimiz ölçüde programın kodlarını çalıştırmaya başlar.

Her kanal, çalışma esnasında kendi eax, ebx, edx gibi register verilerini tutan bir yapıya sahiptir. Bu yapıya context(içerik) adı verilmektedir. Bu yapının Delphi’deki karşılığı TContext olup, Windows unitindedir. Bu record tipini incelediğinizde bir çok register’ı barındırdığını göreceksiniz. Eğer buradaki Delphi ve Assembler ile ilgili makaleyi ve buradaki fonksiyon çağırım makenizmalarını okudu iseniz şimdi anlatacaklarımız size tanıdık gelecektir. Çünkü kanalların işleyiş mantığı fonksiyon çağırımlarına benzemektedir. Ama devam edebilmek için bunları okumak zorunda değilsiniz.

Her bir kanal sahip olduğu önceliğe göre işletim sistemi tarafından işleme alınacaktır. Bu işleme alış esnasında sahip olduğu context‘deki register değerleri yüklenir. Esp, Ebp, Eip gibi registerlar da yüklendiğinden, kanal önceden kaldığı yerden önceki stack değerlerine göre işlemine devam edecektir. Ve yine önceliğine göre belli bir süre sonunda işletim sistemi bu kanalı durdurup register değerlerini context yapısında saklar. Daha sonra diğer bir kanalın context verisini yükleyerek başka bir kanalı işlemeye geçer. Ve hakeza bu işlem tüm kanallar için devam edip gider. İşletilme ve geçiş süreleri çok kısa olduğundan, biz sanki aynı anda tüm kanallar işletiliyormuş gibi zannederiz. Halbuki bütün kanallar belli bir sıra ile çok kısa sürelerde işletilip diğer bir kanala geçilmektedir. Yani her kanal aynı anda çalışmaz, biz öyle zannederiz. Tabi bu anlattıklarımız tek işlemci ve tek çekirdek için geçerlidir. Kanalların işletilme sürelerini ise kanalların önceliği belirlemektedir. Hangi kanal daha yüksek öncelikli ise o kanal daha fazla işletilme süresine sahip olur. Eğer kanal arkaplanda çalışma üzere ayarlanmış ise, diğer kanallar işlemlerini tamamladıktan sonra ancak bu kanala sıra gelecektir. Eğer kanal çok yüksek önceliğe sahip ise uzun bir süre bu kanal işleme devam edecek ve diğer kanallara sıra gelmeyecektir.

Demek ki, aynı anda bir kaç işlem yapmak istiyorsak kafa patlatıp, parmak yormamıza gerek yokmuş. Çünkü işletim sistemi zaten sizin için bu sistemi kurmuştur. Sadece biraz vaktiniz ayırmanız ve kanallar nasıl oluşturuluyor öğrenmeniz yeterlidir.

Kanal Oluşturma Yöntemleri

Aslında böyle bir başlıkla konuya giriş yapmak istemezdim. Ama kanal oluşturmayı öğrenmeden önce bir kaç şeyi açığa kavuşturmak istiyorum. Gerek forumlardan gerekse haber guruplarından kanallarla ilgili gelen sorulardan bir çoğu kanalların yanlış oluşturulması üzerine kaynaklanan yanlışlıklardan gelmektedir.

Normalde bir kanal windows ortamında CreateThread Windows API’si ile oluşturulur. Fakat VCL bize TThread isminde bir sınıf da sunmuştur. Kullanım açısından ayırt edebileceğiniz temel nokta şudur. Eğer kanalda yapacağınız işlemler VCL sınıflarını etkilemesi gerekiyorsa TThread sınıfını kanal oluşturmak için kullanıyoruz. Yok eğer VCL sınıflarını ilgilendiren bir işlem söz konusu değilse CreateThread API’sini kullanıyoruz. Bunun neden böyle olduğunu ileride VCL ve Kanal kullanımı ile alakalı başlıkda vereceğim. Muhtemelen Bölüm 2′de göreceksiniz. Bu yüzden biraz sabır.

Başlarken bu şekilde bir giriş yapmamın sebibi buradan kaynaklanıyor. Bir çok kişi belki de Windows API’lerine karşı bir soğukluktan dolayı CreateThread ile uğraşmak istemiyor ve CreateThread ile ilgili kısımları gözü kapalı atlayabiliyor. Bu yüzden eksik kanal bilgisi ile ileride bir çok sorunla karşılaşabiliyor. Ama şimdi göreceğimiz gibi kanal oluşturma işlemi sanıldığı kadar zor ve karmaşık bir işlem değil.

Bir Kanal Oluşturalım

Kanal oluşturma ile sorumlu Windows fonksiyonu CreateThread fonksiyonudur ve aşağıdaki gibi tanımlanmıştır:

function CreateThread(lpThreadAttributes: Pointer;
  dwStackSize: DWORD; lpStartAddress: TFNThreadStartRoutine;
  lpParameter: Pointer; dwCreationFlags: DWORD; var lpThreadId: DWORD): THandle; stdcall;

Bu fonksiyonun parametrelerinin kısaca açıklamasını verelim.

lpThreadAttributes: Kanalımıza atanacak olan bir çok güvenlik özelliğini belirtmemize yarar. Eğer nil girerseniz varsayılan güvenlik özellikleri kullanılacaktır. Win9x ve WinMe için bu değer nil olmalıdır. Bu konu ile alakalı daha fazla bilgi almak için sdk yardım dosyalarından SECURITY_ATTRIBUTES başlığına müracaat edebilirsiniz.

dwStackSize: Eğer kanal için özel bir stack büyüklüğü belirlemeyecekseniz bu değeri 0 olarak girmelisiniz. Böylelikle kanalın stack büyüklüğü program ile aynı olacaktır. Gerektiğinde stack boyutu otomatik olarak genişletilebilir.

lpStartAddress: Bu parametre esas işi gören parametredir. Çünkü kanal çalışmaya bu parametredeki fonksiyon işaretçisi ile beraber başlar. Burada tek yapmamız gereken fonksiyonun isminin önüne @ işareti vererek girmektir.

lpParameter: Bir önceki parametrede girdiğimiz kanal fonksiyonuna parametre yollamak istiyorsanız, bu parametrelerin içinde bulunduğu bir record’un adresini buraya girmelisiniz. Ayrıca record haricinde karakter veya sayı değelerini de parametre olarak yollayabiliriz.

dwCreationFlags: Bu parametre ile kanalın oluşturulur oluşturulmaz çalışıp çalışmayacağını belirliyoruz. Eğer bu parametreye CREATE_SUSPENDED girerseniz, kanal oluşturulur fakat kendisine çalışmaya başlaması için izin verilmez. Bu durumda siz ResumeThread fonksiyonu ile bu kanala çalışma talimatı vermedikçe kanal o şekilde çalışmadan duracaktır. Bir kez ResumeThread ile çalışmaya başladıktan sonra SuspendThread ile tekrar kanalı durdurabilirsiniz. Eğer bu parametreye 0 girerseniz, kanal oluşturulur oluşturulmaz çalışmak için sıraya girecektir.

lpThreadId: Bu parametreye kanal kimlik ID’si atanır. Buraya değeri olmayan bir Dword değişken giriyoruz. Değişken gireceğiz çünkü "var" olarak tanımlanmış. Çünkü kanal oluşturulduktan sonra Windows NT,2000 ve üstü işletim sistemlerinde kanalın ID’si bu değişkene yüklenir. Windows 9x/Me işletim sistemlerinde bu değer daima 0′dır.

Şimdi gelin bu fonksiyonu kullanarak bir kanal oluşturalım.

var
  KanalID: DWORD;
begin
  CreateThread(nil, 0, @KanalFonksiyonu, nil, 0, KanalID);

İşte hepsi bu! Tek yaptığımız sadece gerekli parametreleri kullanmak, gerisini duruma göre nil veya 0 yapmak. Bu fonskiyon çağrıldığında KanalFonksiyonu isimli fonksiyonumuz kanal içinde çalışmaya başlayacaktır.

Dilerseniz KanalFonksiyonu isimli fonksiyonumuzun tanımlamasını şimdi yapacağımız örnek içinde verelim.

Basit Bir Örnek

Şimdi oluşturduğumuz bu kanalın nasıl çalıştığını basit bir örnek ile görmeye çalışalım. Yeni bir uygulama oluşturalım ve Form üzerine bir adet button ve bir adet label koyalım. Button’nun Caption özelliğini "Oluştur ve Çalıştır" olarak değiştirelim. Ve Button’nun OnClick olayına kanalımızı oluşturan şu kodları girelim:

procedure TForm1.Button1Click(Sender: TObject);
var
  KimlikID: DWORD;
begin
  CreateThread(nil, 0, @KanalFonksiyonu, nil, 0, KimlikID);
end;

Şimdi de kanalımızda esas işi yapan KanalFonksiyonu isimli fonksiyonumuzun tanımlamasını girelim:

function KanalFonksiyonu(P: Pointer): Longint; stdcall;

...

implementation

...

function KanalFonksiyonu(P: Pointer): Longint; stdcall;
var
  i: Integer;
  Toplam: Int64;
begin
  Toplam := 0;
  for i := 0 to 1000000000 do
  begin
    Toplam := Toplam + i;
    Toplam := Toplam shl 4;
  end;
  Form1.Label1.Caption := 'Kanal işlemini tamamladı. Sonuç:' + IntToStr(Toplam);
end;

Bu fonksiyonda ekstra bir şey yapmıyoruz. Sadece bir for döngüsü var ve matematiksel bir işlem yapılıyor. For döngüsü bittiğinde ise formdaki label’a bir sonuç yazdırıyoruz.

Bu for döngüsünü, ayrı bir kanalda değil de programın ana kanalında çalıştırmaya kalksaydık muhtemelen Application.ProcessMessages ve TTimer gibi çözümlere gidecektik. Bu durum da çok fazla miktarda performans düşüklüğüne sebep olacaktı. Ayrıca işlemlerimiz genelde buradaki gibi basit matematiksel işlemler olmadığından, programda çökmelere ve donmalara sebep olacaktık.

Bu programı çalıştıralım ama button’a basmayalım. Eğer açık değilse View menüsünden "Thread Status" penceresini ve "Event Log" penceresini açalım ve görebileceğimiz bir köşeye yerleştirelim. Eğer BDS 2005 ve üstü kullanıyorsanız bu pencereler debug esnasında altta görünür biçimde hazır olacaklardır.

Ardından buttona bir kez basalım ve "Thread Status" penceresine yeni bir eleman eklendiğine dikkat edelim. Eğer buradaki eleman çok çabuk bir şekilde görünüp kayboldu ise işlemciniz benimkinden hızlı demektir . Bu yüzden for döngüsündeki limit değeri biraz artırıp tekrar çalıştıralım.

Button’a her tıkladığınızda "Thread Status" pencersinden de takip edebileceğiniz gibi yeni bir kanal eklenecek. Tabi butona basma işini o kadar çok abartmayın. Her kanal oluşturulduğunda kendisine bir ID atanacak. Örneğimizde bu değer KimlikID değişkeninde tutuluyor. "Thread Status" pencersinde ise ThreadID sütununda bu değeri görebiliriz. Her kanal işlemini bitirdiğinde "Thread Status" pencersinden kaybolduğunu göreceksiniz. Aynı şekilde "Event Log" pencersinde de kanal’ın ID’sine göre başlama ve bitişi ile ilgili mesajları görebilirsiniz.

Kanal çalışırken program üzerinde istediğiniz işleme devam edebilirsiniz. Formu taşıyabilir, boyutlandırabilir, başka bileşen ve nesneler var ise onları kullanabilirsiniz. Ve bunu yaparken bir yandan kanal(lar) da çalışmaktadır. Aynı kanal fonksiyonunu doğrudan çağırmaya kalktığımızda formumuza döngü bitene kadar müdahale edemeyecektik.

Gördüğünüz gibi bir kaç satır kod ile kanal oluşturuveriyoruz. Tek bilmemiz gereken kısım CreateThread fonksiyonunun parametreleri. Bunların çoğunu da kullanmadık. Ama makalenin ilerleyen kısımlarında bunları da yavaş yavaş kullanıma dahil edeceğiz. İşte bir tanesi geliyor.

Kanal Fonksiyonlarına Parametre Gönderimi

CreateThread fonksiyonunun parametrelerini açıklarken lpParameter‘den söz etmiştik ve bu parametre ile kanal fonksiyonuna istediğimiz parametreyi gönderebileceğimizi belirtmiştik. Şimdi bunu nasıl yapacağımızı görelim.

Bunun için yukarıda yaptğımız örnekten faydalanacağız. İlk başta type bloğunda aşağıdaki record tanımlamasını yapalım.

  PKanalParametresi = ^TKanalParametresi;
  TKanalParametresi = record
    BirParametre: string;
  end;

Ardından kanal fonksiyonumuzu aşağıdaki gibi değiştirelim.

function KanalFonksiyonu(P: Pointer): Longint; stdcall;
var
  Parametreler: PKanalParametresi;
begin
  Parametreler := PKanalParametresi(P); //Parametremizi alalım.
  while True do
  begin
    Form1.Label1.Caption := Form1.Label1.Caption + Parametreler^.BirParametre;
    Sleep(1000); //İşlemcinin %99 çalışmasını istemiyiz değil mi....
  end;
  Dispose(Parametreler);
end;

En son olarak button’nun OnClick olayını da aşağıdaki gibi olacak şekilde değiştirelim.

procedure TForm1.Button1Click(Sender: TObject);
var
  KimlikID: DWORD;
  Parametreler: PKanalParametresi;
begin
  New(Parametreler);
  Parametreler^.BirParametre := 'a';
  CreateThread(nil, 0, @KanalFonksiyonu, Parametreler, 0, KimlikID);
end;

Aslında çok fazla bir şey yapmadık(en azından siz kopyala yapıştır yaptınız:) ). Burada basit bir işaretçi kullanımını görüyoruz. Ve parametre olarak bir record’u kullandık. Record yerine başka veri tiplerini de kullanabilirdik. Ama genelde karşılaşılan sorunlar recordları parametre olarak yollamaktan gelmektedir.

En başta verdiğimiz record tanımlamasına bakarsanız, PKanalParametresi isminde bu recordumuza işaretçi olan bir tip göreceksiniz. Parametremizi işaretçi olarak kullanacağımızdan bu tipe ihtiyacımız olacak. Ardından Button’nun OnClick olayına bakalım. Burada önceki örneğe göre fazladan 2 satır ekledik. İlk başta var bloğunda Parametreler isminde bir record işaretçisi tanımladık. Ardından işaretçi hiç bir şey ifade etmediğinden, işaretçiye ait bir recordun hafızada oluşturulması için New rutinini kullandık. Devamında bu record’un değişkenlerinden birine bir string değer atadık. CreateThread fonksiyonu parametreyi işaretçi olarak istediğinden buraya direk olarak Parametreler değişkenimizi girebiliriz. Çünkü bu değişken bir record işaretçsidir.

En son olarak yeni kanal fonksiyonumuza baktığımızda, işaretçi olarak gelen parametremizin nasıl kullanıldığını görüyoruz. Burada bizim için önemli olan kısım Dispose kısmıdır. Çünkü burada New ile oluşturduğumuz ve işaretçiye ait olan recordu hafızadan siliyoruz.

Record işaretçisi yerine normal record kullansa idik ve sonra da bunu parametre olarak geçirirken pointer olarak geçirse idik olmazmıydı. Olurdu… Üstelik New ve Dispose rutinlerini de kullanmak zorunda kalmazdık. Ama, bu durumda boş yere hafızda yer işgal edecektik. Çünkü parametre recordu sadece bir kerelik işimize yarayacak. Bu yüzden işimiz bitince Dispose ile hafızdan siliyoruz.

Bu örneğimizi de çalıştırıp deneyebilirsiniz. Ayrıca Görev Yöneticisi ile işlemciyi yüzde kaç kullandığını da görebilirsiniz. Tabi burada Sleep rutinini kullanmak yerine daha başka yapılabilecek şeyler var ama şimdilik kafa karıştırmamak için bunları sonraya bırakıyorum.

Sonuç

Bu bölümü burada noktalayalım. Gelecek bölümde kanalların nasıl birbirleri ile birlikte çalışabileceğini göreceğiz. Ayrıca Mutex’ler ve VCL ile kanal kullanımı da gelecek bölümde göreceğimiz konular arasında olacak. Böylece kanallar konusunda hiç bir şüpheniz, korkunuz kalmayacağı gibi programlarınıza da profesyonellik katacaksınız.

Gelecek bölümde buluşmak ümidi ile… Yorumlarınızı ve eleştirilerinizi bekliyorum. Yine her zaman ki gibi sorularınızı buradan yada Delphi Türkiye forumlarından iletebilirsiniz

Fatih Tolga Ata © 2007

Kaynaklar

• Windows SDK Yardım Dosyası
• Delphi 4 Unleashed, Charlie Calvert, Sams Pub., 1999

Bu bölümde Sınırlandırıcıları(Constraints) göstermeye çalışacağız. Hazırsanız buyrun.

Sınırlandırıcılar(Kısıtlamalar, Constraints)

Öyle olurki bazen, tip argümanlarınızın belli metodları ve özellikleri içermesini isteyebilrsiniz. Mesela çizim yapma özelliği olan sınıfların kolleksiyonunu tutan bir generic sınıf düşünün. İsmi de TCizebilenKolleksiyon gibi bir şey olsun. Bu generic kolleksiyona atayacağınız her elemanın bir çizim gerçekleştiren “Ciz” gibi bir metodunun olmasını isteyebilirsiniz. Bu durumda, tip parametresini belli arayüzler ile sınırlandırmanız gerekmektedir. Bu örneğimizi koda dökecek olursak, arayüzümüz şöyle bir şey olacak:

ICizebilen = interface
public
  procedure Ciz;
end;

Bu arayüz ile sınırlandırılmış olan kolleksiyon sınıfımız da şöyle bir şey olabilir:

TCizebilenKolleksiyon<T: ICizebilen> = class
...
end;

Bu durumda T parametresine atayacağımız her argümanın ICizebilen arayüzünün sahip olduğu özellik ve metodlara sahip olacağını garantilemiş oluyoruz.

.Net ortamında kullanabilceğiniz bir çok arayüz bulunmaktadır. Bu arayüzler genelde “able” son eki ile biterler. “able” ekinin Türkçe karşılığı “-ebilen”, “-abilen” olarak düşünebilirsiniz.. ISerializable, IComparable, ICloneable, vs…

Tip parametreleri birden fazla arayüz sınırlandırıcısı alabilir. Bu durumda tip parametreleri virgül yerine aynen prosedür ve fonksiyonların parametrelerinde olduğu gibi “;” noktalı virgül ile ayrılırlar. Mesela:

TSinif<T: ISerializable; U: IColoneable> = class

gibi… Bu örneğe göre T parametresi ISerializable arayüzünü, U parametresi de IColoneable arayüzünü desteklemesi şarttır.

Ayrıca, birden fazla sınırlandırıcı, tek bir tip parametresine atanabilir. Bu durumda bunlar, “AND” lojik mantığına göre tip parametresini sınırlandırırlar.

TSinif<T: ISerializable, IColoneable> = class

gibi… Bu örnekte T parametresi hem ISerializable, hem de IColoneable arayüzlerini desteklemek zorundadır. Aynı şekilde prosedür ve fonksiyon parametrelerinde olduğu gibi aynı sınırlandırmaya sahip iki tip parametresini virgül ile ayrırak beraber yazabilirsiniz:

TSinif<T, U: ISerializable> = class

gibi… Bu örneğe sınırlandırıcıya sahip olmayan bir parametre daha ekleseydik noktalı virgül ile ayırmamız gerekecekti:

TSinif<T, U: ISerializable; Z> = class

gibi…

Bunlar grammer ile ilgili kısımlardı. Peki derleyicinin davranışı nasıl olacak? Aşağıdaki örneğe bakalım:

TPrintableCollect<T: IPrintable> = class ...
...
TDeneme = class(IPrintable)
  procedure Print;
end;

THata = class
end;
...
var
  Calisan: TPrintableCollect<TDeneme>;
  Hatali: TPrintableCollect<THata>; //Syntax hatası: THata sınıfı IPrintable arayüzünü desteklemiyor.

Gördüğünüzü gibi THata sınıfı IPrintable arayüzüne yabancı olduğu için tip argümanı olarak atadığımızda syntax hatası alıyoruz.

Bununla beraber aynı mantık ile arayüz yerine bir sınıfı sınırlandırıcı olarak kullanabilirsiniz. Bu durumda generic sınıfımız ancak ve ancak sınırlayıcı olarak verdiğimiz sınıf ve alt sınıflarından tipleri alabilir. Mesela:

TBirSinif = class...
TBirAltSinif = class(TBirSinif)...
TBirKolleksiyon<T: TBirSinif> = class...

Bu örneğimizde T tip parametresine ancak ve ancak TBirSinif ve ondan türeyen sınıflar argüman olarak atanabilir.

Sınırlandırıcılarda Belirsizlik

İki adet sınırlandırıcı, bir tip parametresine atandığını düşünelim. Mesela:

TTest<T: ISerializable, ICloneable> = class
  BirNesne: T;
  procedure Klonla;
end;

procedure TTest<T>.Klonla;
begin
  BirNesne.Clone;
end;

Derleyici “BirNesne” değişkeninin ISerializable ve ICloneable arayüzlerini desteklediğini biliyor. Ayrıca IClonable arayüzünde de Clone isminde bir metod olduğunu da biliyor. Bu yüzden Klonla metodunda Clone metodunu çağırırken herhangi bir çevirim işlemi yapmadık. Çünkü derleyici, Clone metodunun hangi arayüze ait olduğunu biliyor.

Farz edelim ki Clone metodu, hem ISerializable hem de ICloneable arayüzlerinde bulunuyor olsun. Bu durumda Clone metodunu yukarıdaki gibi çağırdığımızda ne olacak? Derleyici bu durumda belirsizilik olduğuna dair bir hata mesajı gösterecektir. Bu belirsizliği ortadan kaldırmak için harici çevirim(explicit casting) yapmalıyız. Yani:

procedure TTest<T>.Klonla;
begin
  ISerializable(BirNesne).Clone;
  ICloneable(BirNesne).Clone;
end;

Bu durumda, ilk Clone çağırımı ISerializable arayüzü üzerinden, ikincisi ise ICloneable arayüzü üzerinden gerçekleşecektir.

Sınırlandırıcı Olarak constructor, class ve record Kullanmak

Eğer sınırlandırıcı olarak record gibi referansız tipler kullanacaksak bu durumda “record” ayrılmış kelimesini kullanıyoruz. Ama dikkat etmemiz gereken konu kullanacağımız tip argümanı nullable yani null değer alabilen bir tipten olmamalı. Mesela string nullable’dır ama Integer değildir.

Aynı şekilde eğer sınırlandırıcımız sadece referanslı tipler olacaksa bu sefer de “class” ayrılmış kelimesini kullanmaktayız. Ayrıca kullanacağımız tip nullable olabilmeli. Yani tip argümanı olarak sınıfların yaninda string gibi nullable tipleri de kullanabiliriz. Bunları şu şekilde örneklendirelim:

TReferansiz<T: record> = class...
TReferansli<T: class> = class...
TBirRecord = record
end;

var
  Hatali1: TReferansiz<string>; //Hatalı, çünkü string nullable,
  Hatali2: TReferansli<Integer>; //Hatalı, Integer referanslı bir tip değil
  Uygun1: TReferansiz<TBirRecord>;
  Uygun2: TReferansiz<Integer>;
  Uygun3: TReferansli<string>; //string nullable bu yüzden uygun.

gibi…

Constructor kelimse ise, sınırlandırıcıda kullanılan sınıfın mutlaka parametresiz bir constructor’a sahip olmasını şart koşmaktadır. Mesela:

TBirSinif = class
  constructor Create;
end;

TBirBaskaSinif = class

end;

TBirKolleksiyon<T: constructor> = class...
...

var
  Uygun: TBirKolleksiyon<TBirSinif>;
  Hatali: TBirKolleksiyon<TBirBaskaSinif>;

Bu örnekte Uygun nesnesinde tip argümanı olarak TBirSinif tipini girdik. Ve derleyici bunu kabul etti. Çünkü TBirSinif parametresiz bir constructor’a sahip ve sınırlandırıcımız için uygun. Fakat Hatali nesnesinde tip argümanımıza girilen TBirBaskaSinif tipi parametresiz bir constructor’a sahip değil. Bu yüzden derleyici burada hata gösterecektir.

Sonuç

Normalde Delphi.NET derleyicisi, generics ve .net 2.0′a tam destek vermekle beraber, bir çok bug da içeriyor. Gerçi bu cümleleri yazdığım sıralarda, RAD Studio 2007 daha 1 haftadır piyasada. Şu an bildiğim kadarı ile Rad Studio 2007′in çıkacak olan update’inde büyük çoğunlukla derleyici ve asp.net’deki düzeltmeler bulunacak. Derleyici düzeltmelerinde de pastanın büyük payını generics ile ilgili hatalar alacak. Bu yüzden generics ile uğraşırken “Internal Error XXXX” gibi hatalar ile karşılaşırsanız kafanızı duvarlara vurmayın. Çünkü internal error’lerin hepsi bug olarak kabul edilir. Böyle bir durumla karşılaştığınızda eğer yoksa QC’ye rapor edebilirsiniz.

Fatih Tolga Ata © 2007

Kaynaklar:

• CodeGear’ın Delphi Parametrize Tipler ile İlgili Taslak Metinleri
• .NET 2.0 SDK Yardım Dosyası
• Microsoft Visual C# 2005 Step by Step, John SHARP, 2005 Edition

]]> http://www.diyezon.com/enine-boyuna-generics-bolum-2/feed/ 1 http://www.diyezon.com/enine-boyuna-generics-bolum-1/?utm_source=rss&utm_medium=rss&utm_campaign=enine-boyuna-generics-bolum-1 http://www.diyezon.com/enine-boyuna-generics-bolum-1/#comments Tue, 18 Sep 2007 03:58:02 +0000 Fatih Tolga Ata http://www.diyezon.com/?p=54 Bir iki önceki makalemizde, Delphi gramerine katılan generics ve parametrize tipleri yüzeysel olarak tanıtmıştık. Generics, RAD Studio 2007′ nin çıkması ile artık sadece beta tester’larını değil, tüm Delphi programcılarını ilgilendiren bir konu olmuştur. Gerçi şu an için sadece .NET ortamında kullanabildiğimiz bu özellik bir sonraki sürümde Win32 için de kullanılabilir bir gramer olacaktır. Başlangıç için önceki makalemizi okuyabilir ya da direk buradan başlayabilirsiniz. Zira bu bölümde Generics ile ilgili temel bilgiler vereceğiz.

Giriş

Generics’i doğru bir şekilde anlayabilmek için, hangi problemleri çözmek için dizayn edildiğini anlamakta yarar var. Bunun için ilk başta temel bir konudan ve bununla ilgili bir problemden bahsedelim.

.Net ortamı için object tipini herhangi bir değer ya da değişken için referans olarak kullanabilirsiniz. Çünkü her bir referans tipi otomatik olarak System.Object sınıfından türetiilir. Delphi’nin özel tipleri bile .net ortamına geçtiğinde artık birer object olacaktır. Fakat bazı durumlarda explicit casting yapmadan object sınıfına atama yapmak derleyicinin hata üretmesine neden olabilir (Explicit ve Implicit terimlerine yabancı iseniz buradaki makalede ilgili başlığı bulabilirsiniz.). Bunun için AUTOBOX direktifini kullanmamız gerekebilir. Yani aşağıdaki gibi, Delphi’ye ait özel bir tipi, .NET’in object tipine implicit olarak atama yaptığımızda derleyici hata üretecektir.

var
  i: Integer;
  o: &Object;
begin
  o := i;

Derleyicinin hata üretmemesi için ya AUTOBOX kullanacağız ya da explicit casting uygulayacağız:

var
  i: Integer;
  o: &Object;
begin
  o := &Object(i); //Explicit casting
  {$AUTOBOX ON}
  o := i;

Buradan çıkardığımız sonuç, her halükarda eğer .Net ortamından söz ediyorsak, ister Delphi tipi olsun ister olmasın, herşey &Object (System.Object) sınıfından türemiştir. Ve bir şekilde tüm tipler, object nesnesine atanabiliyor.

Biz bu bilgiliyi kullanarak sınıflarımızı ve metodlarımızı bir çok noktada genelleştirebiliriz. Mesela VCL’den hatırlayacağınız TList sınıfına benzer bir liste sınıfı hazırlayabilir ve object‘in yukarıdaki anlattığımız özelliği sayesinde içinde istediğimiz tipte nesneler barındırabiliriz. System.Collections alanında bulunan Queue(kuyruk) sınıfı da bu tarz bir yapıya sahiptir(Kuyruğa ilk giren ilk çıkar.). Mesela aşağıdaki örnekte iki farklı tipi Queue nesnesinin bir elemanı yapıyoruz.

uses
  System.Collections, System.Xml;
  ...

{$AUTOBOX ON}
var
  b: TButton;
  s: XmlDocument;
  q: Queue;
begin
  q := Queue.Create();
  b := TButton.Create(nil);
  x := XmlDocument;
  q.Enqueue(b);
  q.Enqueue(x);

Queue sınıfının Enqueue metodu, kuyruğa yeni bir object eklemeye yarar. Enqueue metodu object tipinde parametre aldığından her çeşit nesne bu metod ile kuyruğumuza eklenebilir. Bu örneğimizde TButton ve XmlDocument tipinde iki farklı nesneyi kuyruğa ekledik. Kuyruktan bir eleman çıkarmak için ise Dequeue metodunu kullanmamız gerekecektir. Dequeue metodu da aynen Enqueue metodu gibi object nesneleri ile çalışır. Yani Dequeue metodunun çıktısı bir object olacaktır. İşte bu noktada, object sınıfının özelliğinden dolayı Queue sınıfı ve bu iki metodu genel çapta kullanılabilir bir yapıdadır.

Yukarıdaki kodlara şunları ekleyip derlemeye çalışalım:

var
  ...
  ...
  cikanB: TButton;
  cikanX: XmlDocument;
begin
  ....
  ....
  cikanB := q.Dequeue; //ilk button girmişti, ilk de o çıkacak.
  cikanX := q.Dequeue;

Bu kodu derlemeye kalkdığınızda “Incompatible types…” hatasını alacaksınız. Halbuki yukarıda AUTOBOX ile implicit çevirimi aktifleştirmiştik. Peki bu hatayı neden aldık?

Birincisi, AUTOBOX sadece object nesnelerine atama yapılacağında işe yarıyor, object nesneleri başka bir nesneye atama yapılacağında değil. Object sınıfndan türemiş olan bir sınıfın nesnesi object‘e atama yapacağınızda, derleyici bunu otomatik çevirebilir. Ama aksi durumda, object nesnesinin hangi sınıftaki bir nesneye dönüşeceğini kestiremez. Bu durumda explicit çevirim yapmak zorundayız. Bunun için sondaki iki satırı şu şekilde değiştirmeliyiz:

  ...
  cikanB := TButton(q.Dequeue);
  cikanX := XmlDocument(q.Dequeue);
  ShowMessage(cikanX.Name); //"#document"

Peki kuyruktan çıkış sırasını yanlışlıkla değiştirseydik ne olurdu? Biliyoruz ki, kuyruk’ta ilk giren ilk çıkar. Yani örneğimize göre ilk olarak button girmişti ve ilk olarak da o çıkacaktır. Bu durumda sıralarını değiştirelim deneyelim:

  ...
  cikanX := XmlDocument(q.Dequeue);
  cikanB := TButton(q.Dequeue);
  ShowMessage(cikanX.Name);

Bu kod derlenir fakat çalışma anında yanlış yaptığımızı gösteren bir hata alırız. Bu durumda object sınıfının bu genelleştirme özelliğini, bunun gibi yerlerde kullanmak, bir çok yanlışı ve dikkatsizliği de beraberinde getiriyor.

Genelleştirilmiş sınıf ve metodlar oluşturmak için kullanılan bu object yaklaşımının diğer bir dezavantajı ise, object sınıfının diğer bir nesneye çevirim yapılması(unbox işlemi ya da unboxing de denilir) yada başka bir sınıfın object sınıfına çevirim yapılması(box ya da boxing yapılması) esnasında gereken ek hafıza ve işlemci zamanıdır. Yani her defasında Enqueue yapıldığında bir nesne object tipine dönüştürülecek ve her Dequeue yapıldığında ise object nesnesinin tipi başka bir nesneye dönüştürülecektir. Bu da ek işlem gücü ve hafızayı gerektirir.

Sınıfları ve metodları genelleştirmede object yaklaşımının belki başka dezavantajlarda sayılabilir ama, bizim işimiz burada generics ve parametrize tipler. Object yaklaşımı kafamızın bir köşesinde yer etmişken, dilerseniz generics yaklaşımına bir göz atalım.

Generics ve Parametrize Tipler(Parameterized Types)

Aslında Delphi programcıları bunu çok uzun süreden beri bekliyorlardı. Belki de .NET 2.0′a böyle bir özellik gelmeseydi, uzun bir süre daha Delphi böyle bir özellikten yoksun kalacaktı. Borland ya da CodeGear’ın .NET ortamına yaptığı yatırımları eleştirenler olmuştur. Fakat bu yatırımlar sayesinde hem Win32 hem de .NET üzerinde Delphi bir çok yeniliğe gitmiştir. Buradaki makaleden bu yeni özellikleri kısaca tanıyabilirsiniz.

Gramere ve kullanışına geçmeden önce bir kaç terim üzerinde duralım. Terimler ilk başta kafa karıştırıcı gibi gelse de bu terimleri kullandıkça alışacağınıza inanıyorum. Bu terimleri önce veriyorum çünkü makale içerisinde bu terimler kullanılacak.

Terminoloji

Parametrize Tip (Parameterized Type:): Tip Paremetresine ihtiyaç duyan bir çeşit tiptir. Generic tip, parametrize tipin daha çok bilinen ismidir. Ama literatürde ikisi de kullanılmaktadır. Aşağıdaki kodda “Liste<eleman>” sınıfı, bir parametrize tiptir.

type
  Liste<eleman> = class
    ...
  end;

Tip Parametresi (Type Parameter): Bir parametrize tip veya metod başlık tanımlamasında, parametrize tipin veya metodun kodlarında kullanılacak olan bir tipi ifade eden bir parametredir. Daha sonra bu parametreye bir tip argümanı bağlanacaktır. Aşağıdaki kodda “eleman” bir tip parametresidir ve sınıfın kodlarında kullanılacak olan bir tipi ifade eder.

type
  Liste<eleman> = class
    ...
  end;

Oluşturulmuş Tip (Instantiated Type, Constructed type): Parametre kümesi tanımlanmış olan bir parametrize tiptir. Liste<Integer> gibi…

Tip Argümanı (Type Argument): “Oluşturulmuş” bir tip yapmak için gereken bir çeşit tiptir. Mesela Liste<Integer> bir oluşturulmuş parametrize tip ise, Integer bunun tip argümanıdır.

Kapalı Oluşturulmuş Tip (Closed Constructed Type): Bir parametrize tipin tüm parametreleri, gerçek tip olan argümanlar ile çözümlenmiş ise bu tipe, Kapalı Oluşturulmuş Tip denir. Liste<Integer> kapalıdır, çünkü Integer tip argümanı gerçek bir tiptir.

Açık Oluşturulmuş Tip (Open Constructed Type): Eğer bir parametrize tipin en az bir parametresi bir tip parametresi ise, bu tip bir açık oluşturulmuş parametrize tiptir. Ayrıca eğer Liste<T> parametrize tipinde T parametresi bir sınıfı içeren parametre ise Liste<T> açık oluşturulmuş bir tiptir. İleride örnekler yaptığımızda bu daha da pekişecektir.

Oluşturma İşlemi (Instantiation): Derleyici, parametrize tiplerde tanımlı metodlar için gerçek işlem kodunu oluşturur ve kapalı tipler için gerçek virtual metod tablosunu oluşturur. Bu işlem ön derleme esnasında gerçekleşir. Bu işlem Win32′de *.dcu ve *.obj dosyalarını çıkarırken gereklidir. Fakat .Net ortamında gerekli değildir. Çünkü .Net oluşturulmuş tipler için gerekli tanımlamalara sahiptir. Bu yüzdendir ki, C++’da template oluşturduğunuzda, derleyici ilk başta template’li tipleri ayrı ayrı oluşturmak için ön derleme işlemine girişir. Anlaşılan o ki, Delphi’nin bir sonraki versiyonunda da Win32′de generics desteği verebilmek için buna benzer bir yönteme gidilecek. Her neyse…

Bunlar dışında bir kaç terim daha var. Fakat daha fazla kafa karıştırmamak için, o terimleri ayrı başlıklar halinde ileride görelim. Dilerseniz önceden object yaklaşımı ile yaptığımız işlemleri şimdi de generics ile yapmaya çalışalım.

Kullanımı

Kuyruk örneğimizi hatırlayacak olursanız, ekstradan tip çevirim işlemleri yapmıştık. Ayrıca tip güvenliğinin gerekli olduğundan ve bir dikkatsizlikte belli sorunların oluşabileceğinden bahsettik. Ayrıca fazladan gerçekleştirilen object’den bir başka tipe ve daha sonra da o tipden tekrar object’e çevirim yapılmasından dolayı(box / unbox), ekstra hafıza ve işlem gücü gerektiğinden bahsetmiştik.

Bütün bunlara gerek duymadan, genelleştirilmiş sınıflar oluşturabilmek için parametrize tipleri ve generic yapısını kullanabiliriz. Generic sınıflar, tip parametresine sahip olduğundan dolayı, sadece object gibi bir tipe bağlı kalmaz. Böylece yukarıda bahsettiğimiz sıkıntıları da bertaraf etmiş oluruz.

.Net 2.0 ile birlikte System.Collections.Generic alan adının altında bir çok yararlı generic sınıf tanımlanmıştır. Aşağıdaki kod parçasında parametrize Queue sınıf ile oluşturulmuş bir Integer kuyruğu ve bir string kuyruğu görmekteyiz.

uses
  System.Collections.Generic;

  ...
  ...

var
  SayiKuyruk: Queue<Integer>;
  YaziKuyruk: Queue<string>;
  Sayi: Integer;
  Yazi: string;
begin
  SayiKuyruk := Queue<Integer>.Create;
  YaziKuyruk := Queue<string>.Create;
  Sayi := 123;
  Yazi := 'Deneme';
  SayiKuyruk.Enqueue(Sayi);
  YaziKuyruk.Enqueue(Yazi);
  ...

Gördüğünüz gibi, ne bir çevirim işlemi var ne de tipler uyuşuyor mu diye bir endişe… “SayiKuyruk” ve “YaziKuyruk” nesnelerinin ikisi de Queue<T> gibi bir parametrize tip’den oluşturulmuş tipten oluşturulmuştur . Terimlerimizde hatırlarsanız “Kapalı oluşturulmuş tip“ten bahsetmiştik. Derleyici bu örneğimizde Queue<T> tipinden iki adet yeni tip oluşturmuştur. Bunlardan birisi Queue<Integer> ve diğeri ise Queue<string> tipidir. Ve ikisi de kapalı oluşturulmuş bir tiptir. Ayrıca iki tip tamamen bir birinden bağımsız iki farklı tiptir!

Bu örnekten ne öğrendik? Özet olarak, bir generic sınıfa atadığımız tip argümanlarına göre(Integer, string, vs..) yeni bağımsız bir tip oluşturuyoruz. Ve bu oluşturulan tip, parametre olarak verdiğimiz argümanlara göre işlem yapıyor.

Önceki Queue sınıfı, sadece object tipinde nesneler ile çalşıyordu. Bu sınıftan sadece bir adet vardı ve oluşturduğumuz nesneler hep aynı sınıftan oluşturuluyordu. Ama generic Queue sınıfında ise iş biraz değişiyor. Artık tanımladığımız farklı tip için ayrı bir sınıf oluşturuluyor. Bu yüzden örneğimizdeki SayiKuyruk ve YaziKuyruk nesnelerinin sınıfları aynı değildir! Derleyici her iki tip argümanı için de ayrı ayrı sınıflar oluşturmuştur. Tip argümanları gerçek tipler olduğu için de oluşturulan bu iki sınıf da kapalı oluşturulmuş tip olmuştur.

Tanımlanması

Generic tiplerin tanımlanması kullanımı kadar kolaydır. Delphi’de sınıflar, interface’ler ve record’lar tip parametreleri ile birlikte tanımlanabilirler. Ayrıca metodlar ve prosedürel tipler de parametrize yapılabilir. Aşağıdaki sınıf tanımlamasına göz önüne alalım:

type
  TBirSinif = class
  public
    procedure BirSeylerYap(Parametre: string); overload;
    procedure BirSeylerYap(Parametre: Integer); overload;
    procedure BirSeylerYap(Parametre: Boolean); overload;
  end;

Sadece bu sınıf ve metodları düşündüğümüzde aynı iş için üç farklı metod tanımlaması yapıyoruz. Ne için? Sadece bir tipin değişmesi yüzünden. Bir de ikinci bir parametre aldığını düşünün. Veya üç, dört… Ne yapacağız? 4′ün 3′lü kombinasyonunu alıp o kadar farklı metod tanımlaması mı yapacağız?

Bunun yerine bu işi derleyiciye bırakıp, biz sadece tipler ile uğraşıyoruz. Yukarıdaki sınıfımızı parametrize olarak yeniden tanımlayalım:

type
  TBirSinif<T, K, L> = class
  private
    FBirOzellik: K;
  protected
    procedure SetBirOzellik(const Value: K);
  public
    procedure BirSeylerYap(Parametre: T);
    property BirOzellik: K read FBirOzellik write SetBirOzellik;
  end;

Gördüğünüz gibi, Integer string gibi değişkenler yerine sınıfa eklediğim tip parametrelerini kullanıyorum. Bu parametrize tipimizde 3 adet tip parametresi mevuct. Gerçi bu örnekte sadece ilk ikisini kullanıyoruz.

Bir genel kültür bilgisi mahiyetinde, ek olarak, bu sınıf derlendikten sonra TBirGenericSinif`3 gibi bir şekle girecektir. Eğer tip parametre sayısı 4 olsaydı, son kısım “`4” olacaktı. Bu yüzden derlenmiş assembly’nizi ya da programınızı reflect ettiğinizde bu tarz şeyler görürseniz şaşırmayın. Her neyse…

Önceden de bahsettiğimiz gibi yukarıdaki TBirSinif sınıfı ile TBirSinif<T, K, L> generic sınıfı birbirinden çok farklı şeylerdir. İsimleri aynı olabilir ama kesinlikle aralarında bir bağlantı yoktur. Aynı şekilde TBirSinif<Integer, string, Boolean> gibi bir kapalı oluşturulmuş sınıf, TBirSinif<string, string, Integer> gibi başka bir kapalı sınıftan çok çok farklıdır ve bağlantıları yoktur. Çünkü derleyici, tip argümanlarına göre tipleri tekrar tekrar tanımlamaktadır.

Generic Metodlar

Sınıflar gibi metodlar ve prosedürel tipler de parametrize olarak tanımlanabilir. Mesela:

type
  TBirProsedur2<T> = procedure(Param1, Param2: T) of object;
  TNormalBirSinif = class
    procedure BirProsedur<X>(Param1, Param2: X);
  end;

procedure TNormalBirSinif.BirProsedur<X>(Param1, Param2: X);
begin

end;

Görüldüğü gibi parametrize olmayan bir tip içinde(TNormalSinif) parametrize bir metod tanımladık. Bunu yaparken aynen sınıflarda olduğu gibi metod isminden sonra tip parametrelerini giriyoruz. Aynı şeyi parametrize olan bir tip içinde de yapabilirdik. Ama burada karar size ait. Eğer generic bir sınıf içinde farklı parametrelerle tanımlamamız gereken metodlar olursa, bu şekilde parametrize edebiliriz. Yani:

type
  TBirSinif<T> = class
    ...
    procedure BirProc<X>(Param1: X; Param2: T);
  end;

Görüldüğü gibi sınıf tanımlamasında X parametresi tanımlı olmadığı halde, metod tanımlamamızda kullanabiliyoruz. Peki bu gibi bir şeyi nasıl kullanacağız?

Farkında iseniz bir kaç paragraf yukarıda verdiğimiz bir örneğin tam bir çözümlemesini yapmadık. Yani:

type
  TBirSinif = class
  public
    procedure BirSeylerYap(Parametre: string); overload;
    procedure BirSeylerYap(Parametre: Integer); overload;
    procedure BirSeylerYap(Parametre: Boolean); overload;
  end;

Bu sınıfta “BirSeylerYap” metodu overload edilmiştir. Bu sınıfı generic yaparken şu şekilde bir tanımlama yapmıştık:

type
  TBirSinif<T> = class
  public
    procedure BirSeylerYap(Parametre: T);
  end;

Burada her bir kapalı tip için sadece bir adet metodumuz olabiliyor. Yani mesela TBirSinif<Integer> gibi kapalı bir sınıf içinde sadece bir adet “BirSeylerYap” metodu vardır ve sadece Integer tipinde bir parametre almaktadır. Halbuki bizim esas yapmak istediğimiz her bir kapalı sınıf içinde overload yaptığımız tiplerin sınırlandırmasını kaldırmak. Sadece bir çeşit metod yerine birden fazla çeşitte parametre alan metodlarımız olması gerekiyor. Bu yüzden metodumuzu genelleştirmek için onu da parametrize ediyoruz:

type
  TBirSinif<T> = class
  public
    procedure BirSeylerYap<X>(Parametre: X);
  end;

gibi… Bu şekilde bir metodun, istediğimiz kadar çeşidini overload yapmadan oluşturabiliriz. Mesela:

var
  BirNesne: TBirSinif<Integer>;
begin
  BirNesne := TBirSinif<Integer>.Create;
  BirNesne.BirSeylerYap<string>('Deneme bir string');
  BirNesne.BirSeylerYap<Integer>(123);
  BirNesne.BirSeylerYap<Boolean>(True);
  BirNesne.BirSeylerYap<TForm>(Form1);
  BirNesne.BirSeylerYap<TButton>(Button1);

gibi…

Gördüğünüz gibi overload ile kısıtlı sayıda yaptığımız metod tanımlamalarını bu şekilde artırabiliriz. Bu da aynen sınıflarda olduğu gibi, metodlarımızı da genelleştirmemize imkan sağlıyor.

Gelecek Bölümde

Gelecek bölümde Sınırlandırıcıları ya da başka yerlede göreceğiniz tabir ile Kısıtlamalar ya da Constraints tabirlerini göreceğiz. Diğer bölüme geçmek için buraya tıklayabilirsiniz.

Her zamanki gibi yorum ve eleştirilerinizi bekliyorum.

Fatih Tolga Ata

Kaynaklar:

• CodeGear’ın Delphi Parametrize Tipler ile İlgili Taslak Metinleri
• .NET 2.0 SDK Yardım Dosyası
• Microsoft Visual C# 2005 Step by Step, John SHARP, 2005 Edition

Bu makalemizde bu yeniliklere değinmeye çalışacağız. Bunlardan bir kısmını önceki makalelerimizde ayrıntılı olarak işlemiştik. Burada sadece bu sitede bahsetmediğimiz kısımlar bahsedilecek ve önceden bahsettiklerimize linkler içerecektir.

Operator Overloading:

Buradaki makalede ayrıntılı olarak işlenmiştir: http://www.diyezon.com/?p=52

Inline Belirleyicisi:

Derleyiciye tavsiye niteliğinde olan bu belirleyici (ya da direktif), fonksiyon ya da prosedürün kod çıktısında, çağrıldığı yere gömülmesini sağlar. Tavsiye niteliğinde diyorum çünkü, eğer prosedür ya da fonksiyon inline yapılmaya müsait değilse derleyici bu direktifi es geçecektir.

Inline yapılmış prosedür ya da fonksiyon, "call", "ret" gibi assembler komutlarına ihtiyacı olmadığı gibi, stack’ın push ve pop ile yedeğinin de alınmasına ihtiyaç yoktur. Çünkü inline yapılan fonksiyon, direk olarak çağrıldığı kısma yerleşecektir. Halbuki normal fonksiyonlarda call komutu ile hafızada başka bir kod kısmına dallanmaktadır. Ve burada stack’ın yedeği alınıp, fonksiyon sonunda yedek tekrar yüklenmektedir. Daha fazla bilgi için (Delphi ve C++ Builder ile Assembler ve Fonksiyon Çağırım Mekanizmaları).

Inline prosedür ve fonksiyonda bu gibi işlemler yapılmadığından kod daha hızlı çalışacaktır. Ama her fonksiyon çağırımında fonksiyon kodları direk olarak çağrıldığı yere yerleşeceğinden, programınızın boyutu biraz büyüyecektir. Tanımlaması normal fonksiyon ve prosedür gibi olup sadece son tarafa inline belirleyicisi eklenir:

procedure MyProc(x:Integer); inline;
begin
    // ...
end;

Strict Private

Sınıf kavramına katılan bu alan tipi, normal private alan gibidir. Tek fark bu alan daha da gizlidir Bu dediğimizin anlaşılabilmesi için private alanın ne olduğu bilinmesi gerek. Tabi ondan önce sınıfların ne olduğunu biliyorsunuzdur umarım(Bileşen Yazım Klavuzunun ilk bölümleri sınıfları anlatmaktadır).

Private sınıflar normalde, aynı unit içindeki başka sınıflar içinden erişilebilir. Strict Private ise gerçekten gizler. Yani aynı unit içinde bile olsa başka bir sınıf strict private alana erişemez.

Strict Protected

Private için geçerli olan durumun aynısı protected için de geçerlidir. Strict Protected ise sadece aynı sınıf ve sınıfın çocukları tarafından görülebilirler. Aynı unit bile olsa başka bir sınıf bu alanı göremez.

Metodlu Record’lar

Artık Recordlar için private, public gibi alanlar tanımlayıp procedure, function, constructor gibi metodlar tanımlayabiliyoruz. Ayrıca property’ler de tanımlanabiliyor. Yani aynı sınıflar gibi…

type
  TMyRecord = record
    type
      TBirTip = Integer; //tip tanımlaması
    var
      BirAlanDegiskeni: TColor;
    class var
      StatikDegisken: Integer;
    procedure BirProsedur();
    constructor Create;
    property Color: TColor read BirAlanDegiskeni write BirAlanDegiskeni;
    class property StatikOzellik: TBirTip read StatikDegisken write StatikDegisken;
  end;

constructor TMyRecord.Create;
begin

end;

procedure TMyRecord.BirProsedur;
begin
  ShowMessage(IntToStr(Color));
end;

Abstract ve Sealed Sınıflar

Önceden abstract sınıf tanımlanamıyordu. Bunun yerine interface’ler kullanılıyordu. Ama bu her zaman işe yaramayabiliyor. Yabancı olanlar için kısaca abstract, kendisinde herhangi bir tanımlama ve kod bulunayan, kod kısmı, sınıflar için çocuk sınıflarda, metodlar için ise mirasçı metodlarda tanımlı olan bir yapıdır.

type
  TAbstractClass = class abstract
    procedure SomeProcedure;
end;

Bu sınıfın kod tanımlaması TAbstractClass sınıfından türeyecek olan sınıflarda yapılacaktır.

Sealed sınıflar ise, kısır sınıflardır. Yani artık sınıf hiyerarşisinde en sonda bulunan ve kendisinden herhangi bir türetme yapılamayacak olan sınıflardır.

type
  TSealedClass = class sealed
    procedure SomeProcedure;
end;

Bu sınıftan başka bir sınıf türetilemez.

Class Helper’lar

Buradaki makalede ayrıntılı olarak işlenmiştir: http://www.diyezon.com/?p=50

Class Statik Tipler, Değişkenler, Özellikler, Sabitler, Metodlar

Bazen olurki nesneyi tanımlamadan, sınıf içinde bulunan bazı değerlere erişilmesini istersiniz. Bu durumda erişilmesini istediğiniz şeyi, statik olarak tanımlamalısınız. Mesela aşağıdaki örneğe bakalım:

type
  TAClass = class
    strict private
      class var
        StatikDegisken: Integer;
    strict protected
      class function GetStatikOzellik: Integer; static;
      class procedure SetStatikOzellik(val: Integer); static;
    public
      class property StatikOzellik: Integer read GetStatikOzellik write SetStatikOzellik;
  end;

TAClass.StatikOzellik := 879;

Burada gördüğünüz gibi TAClass sınıfından bir nesne oluşturmadan içindeki bir özelliğie eriştik. Class Static tekniğini kullanırken dikkat etmeniz gerken bir kaç önemli nokta şudur:

• Statik metod’lar içinde artık Self değişkenini kullanamazsınız. Çünkü sınıfa referans içeren bir nesne yoktur.
• Statik metodlar ve özelliklerde ancak ve ancak statik olan değişken ve metodları kullanabilirsiniz.
• Statik metodları virtual ya da dynamic olarak tanımlayamazsınız.

Bunun dışında bir sınıf içinde statik sabitler ve statik tipler de oluşturulabilir:

type
  TBirClass = class
  private
    type
      TBirStatikRecord = record
        BirAlan: string;
      end;
  public
    class var
      BirStatikRecord: TBirStatikRecord;
    const StatikSabit = 'Burada class kelimesini kullanmanıza gerek yok!!';
  end;

....
ShowMessage(TBirClass.StatikSabit);

gibi…

İç içe Geçmiş Sınıflar – Nested Classes

Artık bir sınıf tanımlamasının içinde başka bir sınıf tanımlanabiliyor:

type
  TDistakiSinif = class
  public
    type
      TIctekiSinif = class
      public
        procedure IctekiMetod;
      end;
      procedure DistakiMetod;
  end;

procedure TDistakiSinif.TIctekiSinif.IctekiMetod;
begin
  ...
end;

Final Metodlar

Sealed sınıflar gibi final metodlar da bir sınıfın çocuk sınıflarında, final olarak tanımlanmış olan virtual metodun miras alınamadığını ifade eder. Mesela:

TSonMetodluSinif = class(TBirAtaSinif)
public
  procedure SonMetod; override; final;
end;

Bu tanımlamadan sonra artık SonMetod isimli metod, "TSonMetodluSinif" isimli sınıfın çocuk sınıfları tarafından override yapılamayacaktır. Final metodların sadece virtual metodlarda işe yaradığına dikkat edin.

For-In Döngüsü

Artık bir dizi veya kolleksiyon içinde for-in döngüsü ile iterasyon yapılabilmekte:

for DiziElemani in BirDizi do
begin
  ....
end;

for BirKarakter in BirString do
begin
  ...
end;

for BirKumeElemani in BirKume do
begin
  ...
end;

for BirKolleksiyonElemani in BirKolleksiyon do
begin
  ...
end;

Sonuç

Yeni gelen özelliklerin unutmamış isem tamamına değinmeye çalıştım. Bunlara ek olarak Highlander çıktığında generic yani parametrize tiplere de ayrı olarak değineceğiz. Generics’in nasıl bir şey olduğunu merak edenler buraya tıklayarak meraklarını giderebilirler.

Bunlarla ilgili uygulama yapıp geliştirmek sizlere kalmış. Buradaki bilgiler önfikir mahiyetindedir. Derleyici bazındaki yenilikler bunlar olmakla birlikte, VCL ve diğer alanlarda da bir çok yeniliğe gidilmiştir. Yeri geldikçe bunlardan da bahsedebiliriz.

Yorumlarınız önemlidir, bekliyorum.

Delphi’ye, belki de çok uzun zaman önce eklenmesi gereken bu özellik ile, herhangi bir sınıf veya record için toplama(+), çıkarma(-), çarpma(*) gibi operatörlere bazı özel anlamlar yükleyebiliyoruz. C++ programcılarının hiç de yabancı olmadıkları bu teknik ile kendimize özel veri tipleri tanımlayıp, bu tiplerin Integer, string gibi başka tipler ile etkileşimlerinin nasıl sonuç vereceğini belirleyebilirsiniz.

Giriş

Delphi programcılarının uzun zamandır en çok yakındıkları ve Delphi derleyicisi tasarımcılarının başını ağrıttıkları belli başlı konular vardır. Birisi şüphesiz parametrize tiplerdir(generics, c++ için STL). Highlander sürümü ile birlikte bu özellik de Delphi’ye kazandırılmış olacak. Diğerleri de nested tipler, class static tipler ve operator overloading olarak sıralanabilir. Parametrize tipler hariç diğerlerini hem Delphi, hem de Delphi.NET için şu anda kullanabiliyoruz.

Bu makalemizde göreceğimiz operator aşırı yükleme veya operator overloading, sınıf ya da record’ların kullanımını büyük bir ölçüde genişletmektedir. Delph.NET için hem record hem de class veri tipleri için operator overloading yapılabilirken, Delphi for Win32 için sadece record veri tiplerinde operator overloading yapılabilir. Ama bu kullanım bakımından o kadar da etki etmemektedir. Hatta çoğu durumda operator overloading için record kullanılmaktadır. Vereceğimiz örnekler sınıflar ile yapılmış olduğundan Delphi.NET ortamında denemelisiniz. Sınıflar ile örnek veriyorum, çünkü recordlar’dan farklı olarak yapılacak fazladan bir kaç işlem var. Mesela record’larda çoğu durumda Result çıkış değeri Record olduğundan, Create ile oluşturmanıza gerek yok.

Ayran’nın Suyu Fazla mı Olmuş, Ne?

Operator overloading’i anlatabilmek için böylesine uçuk sayılabilecek bir örnek seçtim. Belki ayran içtikçe bu konuyu hatırlarsınız

Şimdi 3 adet tipimiz olsun. TAyran, TYogurt ve TSu. TAyran sınıfı içinde hem TYogurt tipinde, hem de TSu tipinde iki adet özelliğimiz olsun. TTuz da olurdu ama şimdilik ayranımız tuzsuz olsun

TYogurt = class
  Miktar: Integer;
end;

TSu = class
  Miktar: Integer;
end;

TAyran = class
  Yogurt: TYogurt;
  Su: TSu;
public
  constructor Create;
end;

constructor TAyran.Create;
begin
  inherited;
  Yogurt := TYogurt.Create;
  Su := TSu.Create;
end;

Şimdi diyelimki TAyran tipimize TYogurt ve TSu tiplerinde ekleme yapılabilsin. Ayrıca TYogurt ve TSu kendi aralarında toplanabilsin. Ayrıca bir de TAyran ile diğer tipler karşılaştırılmaya tabi tutulabilsin. Bu işlemleri siz, ayrı ayrı metodlar tanımlayarak ve bu metodları gerektiği yerde kullanarak gerçekleştirebilirisiniz. Ama operator overloading kullanarak aşağıdaki gibi işlemler yapabileceğiz:

var
  Yogurt: TYogurt;
  Su: TSu;
  Ayran: TAyran;
begin
  Yogurt := 15;
  Su := 5;
  Ayran := Yogurt + Su;
  Yogurt := Yogurt - 5;
  if Ayran > Yogurt then
    ShowMessage('Ayrandaki yogurt miktarı daha fazla');
end;

Nesne oluşturma kısımlarını konumuz dışında olduğu için atladım. Tabi ki bu işlemler, operator overloading olmadan hataya sebep olacaktır. Çünkü bir sınıf tipini kalkıp başka bir sınıf tipi ile topluyorsunuz, sonra bu sınıf tipine Integer ekliyorsunuz ve sonra da başka bir sınıf tipi ile karşılaştırmaya tabi tutuyorsunuz. Dediğim gibi bu işlemleri prosedür ve fonksiyonlarla da halledebilirsiniz. Ama bu işlemleri operator overloding üzerinden yaparsanız, kullanımda yukarıdaki gibi bir kolaylık sağlamış olacaksınız. Şimdi veri tiplerimiz ile yukarıdaki işlemleri gerçekleştirebilmek için gereken operator tanımlamalarını yapalım.

Add ve Subtract

Şimdi TYogurt nesnesi için aşağıdaki tanımlamayı yapalım. Ama ondan önce TYogurt içinde TAyran ve TSu sınıflarına referanslarımız olduğundan ikisi için forward tanımlaması gerekmekte. Çünkü TAyran ve TSu, TYogurt’dan sonra tanımlanmıştır. Her neyse bu zaten nesne programlama konusu. Şu an bizim konumuzla alakası fazla yok.

  TAyran = class; //forward tanımlama
  TSu = class; //forward tanımlama

  TYogurt = class
    Miktar: Integer;
    class operator Add(Yogurt: TYogurt; Su: TSu): TAyran; //Ayran := Yogurt + Su
    class operator Add(Yogurt1: TYogurt; Yogurt2: TYogurt): TYogurt; //Yogurt3 := Yogurt1 + Yogurt2
    class operator Subtract(Yogurt1: TYogurt; Yogurt2: TYogurt): TYogurt; //Yogurt3 := Yogurt1 - Yogurt2
  end;

Gördüğünüz gibi üç adet satır ekledik. Bunlardan ilki "+" yani toplama operatorünün üzerine yazar. Bu class statik metod ile Add metodunun üzerine yazmak ile nesnemiz ile yapılacak olan her "+" toplama işleminde bu metod çağrılacaktır. Ama verdiğimiz kriterlere göre… Örneğimizde gördüğünüz gibi iki adet Add operatoru tanımlandı. Bunlardan ilki TYogurt ile TSu değerlerini topluyor ve sonucu TAyran olarak çıktı veriyor. İkincisi ise iki adet TYogurt nesnesin topluyor ve yine TYogurt cinsinden çıktı veriyor.

Buradaki altın kural, eğer iki parametreli operator metodu var ise, tanımlayacağınız operator metodundaki parametrelerden en az birisi işleme girecek olan sınıftan olmalı. İki parametre alan çoğu operator metodları için bu mantık vardır. Bu yüzden bir operator’e overload yapacaksanız, kara kara hangi sınıfta tanımlıyacağınızı düşünmenize gerek yok. Çünkü işleme girecek olan herhangi bir sınıf bu metodun bir parametresi olacağından, işleme girecek olan herhangi bir sınıf içinde bu overload işlemini yapabilirsiniz. Mesela ilk Add tanımlamasını TSu sınıfında da yapabilirdik. Çünkü TSu da işleme girmektedir. Ama artık gerek kalmadı. Çünkü:

Ayran := Yogurt + Su;

gibi bir ifade için bu Add metodu çağırılacaktır.

Tek parametreli operator metodlarında ise aslında mantık ile parametresinin ne olacağını bilebiliyorsunuz. Zaten yanlış bir tanımlama yaptığınızda derleyici sizi uyaracaktır. Operator metodlarının parametreleri dahil tam listesi için yardım dosyasına müracaat etmelisiniz.

En son satırdaki Subtract operator metodu ise "-" çıkarma işleminin görevini görmektedir. Burada gördüğünüz örnekte iki adet TYogurt nesnesi birbirinden çıkarılıp sonuç olarak TYogurt cinsinden çıktı veriliyor. Yani:

Yogurt3 := Yogurt1 - Yogurt2;

gibi.. Şimdi bu metodların kod kısımlarını da verelim.

class operator TYogurt.Add(Yogurt: TYogurt; Su: TSu): TAyran;
begin
  Result := TAyran.Create;
  Result.Yogurt.Miktar := Yogurt.Miktar;
  Result.Su.Miktar := Su.Miktar;
end;

class operator TYogurt.Add(Yogurt1, Yogurt2: TYogurt): TYogurt;
begin
  Result := TYogurt.Create;
  Result.Miktar := Yogurt1.Miktar + Yogurt2.Miktar;
end;

class operator TYogurt.Subtract(Yogurt1, Yogurt2: TYogurt): TYogurt;
begin
  Result := TYogurt.Create;
  Result.Miktar := Yogurt1.Miktar - Yogurt2.Miktar;
end;

Gördüğünüz gibi Result değerlerini her defasında Create ile oluşturduk. Çünkü Result bir nesnedir. Ve Result ile atanacak olan nesne birbirinden farklıdır. İşte record kullanmanın bir yararı da burada. Create ile ikide bir oluşturmanıza gerek yok. Record kullanmanın tek dez avantajı, forward tanımlama yapamamanız. Ama bu sorun, her bir record’u ayrı dosyalara alınarak üstesinden gelinebilir. Ben bununla kafanızı karıştırmamak için sınıf’ları ve forward tanımlamaları kullandım. Ayrıa record’un bir avantajı da sınıf gibi private, public, protected alanlarda prosedür ve fonksiyon oluşturabilmenizdir. Gerçi bu özellik operator overloading ile aynı zamanda Delphi’ye kazandırılmıştır. Her neyse…

Implicit ve Explicit

Şimdi diyelimki TYogurt tipindeki nesnemizi TAyran nesnesine dönüştüreceğiz. Yani TYogurt nesnesindeki miktarı, TAyran üzerine yazacaz. Bunun için TYogurt nesnesine şunu eklemeliyiz:

class operator Implicit(Yogurt: TYogurt): TAyran; //Ayran := Yogurt;

Implicit operator metodu hangi sınıf veya record içinde tanımlanmış ise o sınıf veya record’u metodun Result kısmında bulunan sınıfa dönüştürür. Örneğimiz için bu Ayran değişkene Yogurt’u atamak ile olur. Bu metodun kodları ise örneğimize göre şöyle olabilir:

class operator TYogurt.Implicit(Yogurt: TYogurt): TAyran;
begin
  Result := TAyran.Create;
  Result.Yogurt.Miktar := Yogurt.Miktar;
end;

Eğer sınıf için operator overloading kullanıyorsanız, burada ve diğer tanımlamalarda dikkat etmeniz gereken nokta parametre ile gelen nesneleri direk olarak Result içine atama yapmamanız. Çünkü bu taktirde sınıfın işaretçisini eşitlemiş olursunuz ve işler istemediğiniz noktalara gelebilir.

Explicit operatorü ise mantık olarak aynıdır. Sadece kullanımda fark vardır. Yani yukarıdaki "Ayran := Yogurt" işleminde, kullanıcının böyle kolay bir şekilde eşitlemesini istemeyebiliriz. Yani direk böyle bir eşitleme yaptığında hata yapmış olabileceğini düşündürtmek için bu kullanıma izin vermeyebiliriz. Ve sadece type casting ile tip dönüşümüne izin verebiliriz. İşte bunu bize sağlayan operator Explicit’dir.

"Ayran := Yogurt" eşitlemesini "Ayran := TAyran(Yogurt)" şeklinde yapabilmek için sadece yukarıda yazdığımız Implicit yazan yeri Explicit olarak değiştirin:

class operator TYogurt.Explicit(Yogurt: TYogurt): TAyran;
begin
  Result := TAyran.Create;
  Result.Yogurt.Miktar := Yogurt.Miktar;
end;

Kod aynı kod, ama sadece Implicit yerine Explicit var. Bunu yapmakla artık "Ayran := Yogurt" çevirimi derleyici tarafından hatalı olarak görülecek ve "Incompatible types" yani uyumsuz tipler gibi bir hata verecektir. Böylece kullanıcıyı "Ayran := TAyran(Yogurt)" işlemini yapmaya zorlamış oluyoruz.

Peki neden Implicit’i kaldırdık? Hem Implicit hem de Explicit operatorunu kullanamazmıydık. Kullanabiliridik. Ama Explicit çalışmazdı. Çünkü Implicit daima Explicit’den önceliklidir.

Karşılaştırma

Karşılaştırma işlemleri için bir çok operator vardır. Burada hepsine değinmemiz biraz zor. Sadece makalemizin başında verdiğimiz kodda kullandığımız ">" büyüktür karşılaştırma operatoru için overload işlemini yapalım. Bu sefer dilerseniz TAyran sınıfımızda böyle bir tanımlama yapalım:

  TAyran = class
    Yogurt: TYogurt;
    Su: TSu;
  public
    constructor Create;
    class operator GreaterThan(Ayran: TAyran; Yogurt: TYogurt): Boolean;
  end;

Karşılaştırma operatorlerini overload yaparken dönüş değerinin Boolean olmasına dikkat edin. Bu operator metodunu aşağıdaki gibi kodlayabiliriz:

class operator TAyran.GreaterThan(Ayran: TAyran; Yogurt: TYogurt): Boolean;
begin
  if Ayran.Yogurt.Miktar > Yogurt.Miktar then
    Result := True
  else
    Result := False;
end;

Yada daha kısa ve şık bir birçimde şöyle de olabilir:

class operator TAyran.GreaterThan(Ayran: TAyran; Yogurt: TYogurt): Boolean;
begin
  Result := Ayran.Yogurt.Miktar > Yogurt.Miktar;
end;

İçini nasıl doldurmanız gerektiği size kalmış. Ama burada Yogurt için de büyüktür operatorünü overload yapabilirdik. Bu durumda

Ayran.Yogurt.Miktar > Yogurt.Miktar

yazmak yerine:

Ayran.Yogurt > Yogurt

yazabilirdik. Gerisi size kalmış.

Sonuç

Burada değinmediğimiz bir çok operatöre aşırı yükleme yapabilirsiniz. Bunların tam listesi için yardım dosyasında "Operator Overloading" ile ilgili kısma bakmanız yeterli.

Tabi burada verdiğimiz sınıflar için tek tek operator tanımlaması yaptığınızda ortalık biraz karışabiliyor. Bunların önüne geçmek için operator tanımlamalarını daha çok ata sınıflarda gerçekleştirmelisiniz. Böylece çocuk sınıflarda bu tanımlamaları bir daha yapmak zorunda kalmazsınız. Mesela örneğimizde TSu ve TYogurt sınıflarının her ikisinin de Miktar isminde bir özelliği mevcut. Bu iki sınıfı TSiviMadde gibi "Miktar" özelliği olan bir ata sınıftan türetebilirdiniz. Ve bu operator tanımlamalarını ata sınıf için yapıp, ayrı ayrı TSu ve TYogurt için yapmanıza gerek kalmazdı.

Yorumlarınız önemlidir, bekliyorum.

Bu senaryo hemen hemen çoğu programıcının başına gelebilecek hadiselerden. Ve çok sinir bozucu bir durum. O an herkesin içinden, son kullanıcının bilgisayarına Delphi, C++ Builder, ya da VS’yi kurup programı orada test etmek geçer. Ama bu her zaman için müsait olmayan bir durum. Üstelik kaybolan zaman da cabası.

Bu gibi sorunların üstesinden gelebilmek için Remote Debugging denen bir sistem geliştirilmiştir. Kullanıcının bilgisayarına Remote Debugger programı kurulur ve siz kendi bilgisayarınızdan uzaktaki bilgisayara bağlanarak debug işleminizi yaparsınız. Ve hatanın ne olduğunu anlamaya çalışırsınız.

Bir çok geliştirme ortamı remote debug işlemine izin vermektedir. Bizim bu yazıda bahsedeceğimiz işlem, Delphi ve C++ Builder için olacak. Bir kaç adımda bu işlemin nasıl yapıldığını öğrenin ve yukarıdaki senaryonun aktörlerinden biri olmayın.

Uzak Bilgisayarda Yapılacak İşlemeler

İlk önce Remote Debugger’ın kurulum programına ihtiyacımız var. Delphi ya da BCB kurulum diskinizde eğer yoksa CodeGear ya da Borland’ın sitesinden bu programı edinelim. Ardından üzerinde debug yapacağımız uzak makinada şu işlemleri gerçekleştirelim:

• Eğer uzak bilgisayar LAN üzerinde değilse, daha rahat çalışabilmek için Hamachi kurabilirsiniz. Ama zorunlu değil.
• Uzak masaüstü bağlantısı, Vnc, DameWare ya da Radmin gibi programlar ile uzaktaki bilgisayara bağlantı kurun. Burada bu programların nasıl kurulup kullanıldığından bahsetmeyeceğim.
• Remote Debugger’ı uzak bilgisayara kurun.
• Ardından C:\Program Files\Remote Debugger altındaki rmtdbtXXX.exe programını çalıştıralım. Buradaki XXX, programın versiyonu olacak. Karşınıza bir dos penceresi çıkacak ve saatin yanında bir tray ikonu göreceksiniz.
• Ardından bu bilgisayarda "DebugKullanicisi" isimli bir kullanıcı oluşturun ve şifre verin. Eğer bu kulanıcının bilgisayarı kullanan kişi tarafından görünmesini istemiyorsanız Users gurubundan kaldırırmanız gerekmekte. Bu kullanıcı sadece klasör paylaşımı için kullanılacak.
• Uzak bilgisayarın C sürücüsünü, sadece "DebugKullanicisi"na izin vermek şartıyla paylaşıma açın. Ayrıca paylaşımı "yazılabilir" de yapın.
• Programınızın hangi klasörde çalışacaksa oraya dosyaları kopyalayın. Mesela "C:\Program Files\ProgramAdi"
• Programın uzak bilgisayarda çalışabilmesi için gereken veritabanı, bde, registry ayarları vs.. gibi işlemleri gerçekleştirin. Eğer programın çalışması için böyle şeylere ihtiyaç yoksa bu maddeyi atlayabilrsiniz.

Kendi Bilgisayarımızda Yapılacak Olanlar

Bu işlemlerden sonra artık uzaktaki bilgisayar debug yapılmak için hazır. Şimdi kendi bilgisayarımızda şu işlemleri gerçekleştirelim:

• Map Netowork Drive(Ağ Sürücüsüne Bağlan) ile uzaktaki bilgisayarda paylaşıma açtığınız C sürücüsünü Z gibi bir sürücü ismine bağlayın. Kullanıcı adı ve şifre olarak uzaktaki bilgisayarda oluşturduğumuz "DebugKullanicisi"nı kullanın. Artık kendi bilgisayarımızdan "Z:\" ile uzaktaki bilgisayarın C sürücüsüne bağlanabiliyoruz.
• Projemizi açalım ve "Project Options" ile proje özelliklerini açalım. Burada Directories kısmından Output Folder olarak Z:\ altından programın çalışacağı klasörü belirleyin. Mesela "Z:\Program Files\ProgramAdi"
• Proje özelliklerinde Linker sekmesinde remote debugger ile ilgili kısmı seçin. RAD Studio 2007 için bu seçenek "Include remote debug symbols" şeklinde geçiyor.
• Programınızı Shift+F9 ile bir kez derleyin böylece "Z:\Program Files\ProgramAdi" altına programın çalıştırılabilir hali oluşacaktır.
• Şimdi remote debug işlemine başlayabiliriz. Bunun için ilk önce Run menüsünden Load Process kısmına gelelim.
• Burada "Remote" sekmesine geçelim.
• "Remote Path" olarak uzak masa üstündeki programın yolunu yazalım. Burada dikkat etmeniz gereken nokta buraya "Z:\" üzerindeki yolu yazmamanız gerekmekte. Uzak bilgisayarda programımıza ulaşmak için hangi yol gerekiyorsa onu yazın. Mesela bizim örneğimiz için "C:\Program Files\ProgramAdi\Program.EXE" gibi bir şey yazmanız gerekmekte.
• "Remote Host" olarak uzak bilgisayarın IP’sini buraya yazın.
• Eğer gerekiyorsa "Parameters" ve "Working Directory" kısımlarını da doldurun.
• Eğer bir adım atlamadı isek "Load" düğmesine basabiliriz.

Eğer her şey yolunda gittiyse artık remote debug işlemine başladık. Uzak masaüstü bağlantısı, Vnc ya da Radmin gibi programlar ile programınızı görebelir, kullanabilir ve kendi bilgisayarınızda da debug işlemini gerçekleştirebilirsiniz. Bu arada bu işlemler, Firewall ayarları göz ardı edilerek anlatılmıştır. Gerekli port izinleri size kalmış.

Karşılaşabileceğiniz Bazı Sorunlar

Bazen remote debugger inatçılık yapabiliyor. Özellikle bazı durumlarda remote debugger kilitlenip çökebiliyor. Ve tekrar remote debugger’ı çalıştırmaya kalktığınızda çalışmadığını göreceksiniz. Çünkü arkaplanda halen çalışmakta olduğundan ikinci bir debugger açılamıyor. Görev yöneticisi ile bu işlemi sonlandırarak tekrar açmayı denemelisiniz.

Diğer sorunlardan biri de, debugger’ın breakpointleri bazen es geçmesi. Bu gibi bir durumda programı tekrar derlemeyi deneyebilir ve debugger’ı tekrar çalıştırmayı deneyebilirsiniz.

Bunun gibi sorunlarınız olduğunda ingilizceniz varsa doğrudan CodeGear ekibine newsgrouplar üzerinden danışabilirsiniz. Ya da http://www.delphiturkiye.com/forum adresinden karşılaştığınız sorunları iletebilirsiniz.

Umarım faydası olmuştur.

Hayırlı çalışmalar.

Bütün bunları geçelim ve generic tiplere yabancı olanlar için bir kaç küçük örnek verelim.

TGenericClass<T> = class
private
  FProperty: T;
public
  property AProperty<T> read FProperty write FProperty;
end;

Basit bir generic sınıf tanımlaması bu şekilde. Bu sınıfı aşağıdaki gibi kullanabiliriz.

var
  AStringClass: TGenericClass<string>;
  AIntegerClass: TGenericClass<Integer>;
begin
  AStringClass := TGenericClass<string>.Create;
  AIntegerClass := TGenericClass<Integer>.Create;

  AStringClass.AProperty := 'Bu bir string';
  AIntegerClass.AProperty := 456;
end;

Burada T parametresi bir tipi ifade etmektedir. İçine koyacağımız tipe göre sınıfımız kendini şekillendirmektedir. İstersek sınıfmızı <T, U> gibi birden fazla tip ile tanımlayabiliriz. Önceden de dediğim gibi eğer fikirlerini değiştirmezlerse highlander sürümünde editör, generic tipleri normal bir tip gibi algılıyor. Yani siz <T, U> gibi tanımladığınız generic sınıfınızı kullanırken iki yerine bir parametre kullanırsanız delphi böyle bir tanımlamanın olmadığından felan bahsedecektir. Ama eksik parametre kullanıldığını söylemesi gerekmektedir. Bu da çok karmaşık uygulamalarda sizi şaşırtabiliyor.

Aslında generic tiplerin en çok kullanıldığı yerler belki de kolleksiyon tiplerindedir. Mesela:

var
  AStringList: List<string>;
  AStreamList: List<TMemoryStream>;
begin
  AStringList := List<string>;
  AStreamList := List<TMemoryStream>;

  AStringList.Add('Birinci sıradaki yazı');
  AStringList.Add('İkinci sıradaki yazı');
end;

Bu List<T> sınıfını kullanabilmek için System.Collections.Generic’i uses kısmına eklemelisiniz. Yukarıda gördüğünüz işlem Delphi’de TList ve pointer’lar ile yaptığımız işlemleri daha basit bir şekilde yapmamıza yarıyor. List dışında, .net kütüphanesi bir çok generic tip barındırmaktadır. Ama şimdilik highlander’da generic’lerin nasıl olacağına dair bu kadar bilgi yeterli. Highlander çıktıktan sonra bununla ilgili bir makale buralarda olabilir.

Yorumlarınızı bekliyorum.

Ayrıca derleyicinin kod üretimi(code generation) safhasının nasıl işlediği hakkında da fikir sahibi olacaksınız.

Örneklerimizi Delphi üzerinde yapacağız. Az da olsa assembler bildiğinizi kabul ediyorum.

Klasik makale ve kitap yapısına aykırı olarak direk örnekler ile başlamak istiyorum. Çünkü bu makale, assembler diline giriş değil, assembler’ın Delphi ve CB’de kullanımı ile ilgilidir.

Şimdi yeni bir uygulama açalım ve şöyle bir fonksiyon yazalım:

function CarpBakalim(Sayi: Integer): Integer;
begin
  Result := Sayi * 2;
end;

Buradan gördüğümüz kadarı ile “Sayi” parametresi, eax register’ı ile geliyor ve tekrar çıktı olarak eax olarak çıkıyor. Bu register çağırımı, Delphi’de default olarak kullanılır. Burada yapılan işlem çok basittir. 2 ile çarpmak için, değişkenin kendisini kendisi ile toplatılıyor. Ret ile de tekrar çalışma satırına dönülüyor. Şimdi buna göre bunu inline assembler ile nasıl yapabileceğimize bakalım:

function CarpBakalimADD(Sayi: Integer): Integer;
asm
  ADD eax,eax//Result := Sayi * 2;
end; //ret

procedure TForm1.Button1Click(Sender: TObject);
var
  Sayi1, Sayi2: Integer;
begin
  Sayi1 := StrToInt(Edit1.Text);
  Sayi2 := CarpBakalimADD(Sayi1);
  Edit1.Text := IntToStr(Sayi2);
end;

call StrToInt
call CarpBakalimADD
mov esi, eax

StrToInt çağırımından sonra sonuç eax içine alınıyor. Bir önceki örnekte CarpBakalimADD fonksiyonumuz da eax’dan parametre alıp, yine eax’a çıktı verdiğini gördük. Böylece ikinci satırdaki fonksiyon çağırımından sonra sonuç, eax içinde olacaktır. En son satırda da eax, esi içine kopyalanıyor.

İki ile çarpma işlemi iki yolla daha yapılabilir. Bir tanesi mul komutunu kullanarak, diğeri shift ile kaydırarak. Mul komutu eax içindeki değeri başka bir register’daki değer ile çarpar ve sonucu edx:eax register çiftinde tutar. Sonuç için iki çift register gereklidir çünkü iki adet 32 bit sayı çarpıldığından maksimum 64 bit olacaktır.

Bir asm bloğu için altın kural, EDI, ESP, ESI, EBX ve EBP registerlarını korumasıdır. Ama EAX, ECX ve EDX registerlarını da özgürce değiştirebilmesidir. Bu açıklamayı Delphi yardım dosyalarından da bulabilirsiniz.

Mul komutunun edx ve eax’ı kullandığından bahsetmiştik. Öyle ise yukarıdaki tanıma göre, fonksiyonumuzu mul ile de yapabiliriz:

function CarpBakalimAsmMUL(Sayi: Integer): Integer;
asm
  MOV ecx,2
  MUL ecx
end;

Ekstradan ecx de kullanıyoruz ama bu sorun değil. Çünkü ecx’i de istediğimiz gibi değiştirebiliriz. Altın kuralı hatırlayın.

Sonucumuz eax’in içine sığabilecek durumda olduğunda, mul komutunun sonucu eax’de olacaktır. Çünkü edx:eax sonuç çiftinde, edx sayının yüksek kısmını, eax ise düşük kısmını tutacaktır. Ama sonuç, eax’e sığamayacak kadar büyükse, yani sonucun yüksek kısmı edx’e aktarıldığında, fonksiyonun çıktısı yanlış olacaktır. Çünkü fonksiyon çıktısı eax’de çıkmaktadır.

function CarpBakalimAsmSHL(Sayi: Integer): Integer;
asm
  SHL eax,1
end;

function BolBakalim(Bolunen, Bolen: Integer): Integer;
begin
  Result := Bolunen div Bolen;
end;

function BolBakalim(Bolunen, Bolen: Integer): Integer;
begin{
push ebx
mov  ebx,edx
mov  ecx,eax }
  Result := Bolunen div Bolen; {
  mov  eax,ecx
  cdq
  idiv ebx}
end;{
pop  ebx
ret}

Eğer sağlam bir optimize işlemi yapmak istiyorsanız, ilk başta optimize yapacağınız kodları güzel bir şekilde analiz yapmalısınız. Şimdiki gelecek bir kaç paragraf kodların nasıl çalıştığını anlatmaktadır.

İlk baştaki begin’den sonra gelen 3 satırlık assembler kodları, bir çeşit hazırlık kodlarıdır. Önceki örnekte altın kuralımızda bahsettiğimiz gibi EBX register’ı serbest bir şekilde değiştirilemez. Serbest bir şekilde sadece EAX, ECX ve EDX register’larını değiştirebildiğimizi hatırlayınız. EBX register’ı ilerleyen satırlarda IDIV tarafında kullanılması gerekecek. Bu yüzden ebx’i stack üzerine almamız gerekecek. Bunu ilk satırdaki "push ebx" talimatı ile yapıyoruz.

Stack’a ebx’i atmak ile, stack işaretçisinin değeri “4” byte düşüyor. Bildiğiniz gibi Intel tabanlı işlemcilerde stack işaretçisi, stack’a bir değer atmakla yükselmez, tam tersine değer düşer. Her register 32 Bit olduğundan, bir register’ı stack’a atmak, işaretçi değerini 32 bit yani 4 byte azaltır.

Fonksiyonun iki parametresi başlangıçta eax ve edx registerlarında saklanırlar. Bolunen parametresi eax içinde, Bolen parametresi de edx içinde olması, Delphi’nin standart register çağrımları tarafından belirlenmiştir. "push ebx" talimatından sonra gelen iki adet mov komutu ile edx ve eax registerları, ebx ve ecx içine kopyalanıyor.

Bu hazırlık aşamasından sonra esas bölme işlemini yapan komutlarımız sonraki gelen 3 satırdır. Bu satırların ilkinde ecx’i tekrar eax üzerine kopyalandığını görüyorsunuz (mov eax, ecx). Bu satır gereksizdir. Çünkü eax değişmemiştir.

Cdq komutuna geçmeden önce idiv’den bahsetmek istiyorum. Idiv komutu, edx:eax değer çiftindeki 64 Bitlik sayıyı, bu örnekteki 32 Bitlik sayı olan ebx’e bölmektedir. Yani Bolen ebx’de ve Bolunen ise edx:eax çiftinde olmalıdır. Idiv komutu edx:eax çiftini, ebx ile böler. İşte cdq burada devreye giriyor. Cdq komutu, eax içinde bulunan sayıyı işareti ile birlikte edx:eax register çiftine taşır. Yani Dword(32Bit) olan bir değeri QWord(64Bit) yapar. Cdq komutu, idiv’den önce gereklidir. Çünkü eax’in 31’inci biti işaret bitidir. Bu yüzden eax’deki değeri edx:eax register çiftine taşıyabilmek için sayının işaretini de göz önünde bulundurmalıyız. Çünkü edx:eax register çifti için, 63’üncü bit yani, edx’in 31’inci biti, sayının işaret biti olmuştur artık. İşareti ile edx:eax’e taşıma işlemini ise cdq yapmaktadır.

Idiv komutunun sonucu yani bölüm değeri, eax içinde bulunur. Bölme işleminin kalan değer ise edx içinde bulununur.

Bizim için önemli olan şey, eax içinde sonuç değerimiz ile fonksiyondan çıkış yapmamızdır. Zaten idiv komutunun sonucu da eax içinde bulunmaktadır. Yani yapacağımız bir işlem kalmadı. Fonksiyonun sonucu eax içinde çıktı vermektedir.

En sonda bulunan iki satırlık kod ise, bitiş kodlarıdır. Hazırlık kodları ile ebx’i stack’a atmıştık, şimdi tekrar ebx’in ilk baştaki değerini stack’dan almalıyız. Bunun için pop komutunu kullanıyoruz ve ret ile de fonskiyondan çıkıyoruz.

Şimdi bu kodlar ile fonksiyonumuzun assembler halini yazalım. Yapacağımız işlem oldukça basit sadece begin yerine asm yazıyoruz ve ret komutu yerine end ile fonksiyonumuzu bitiriyoruz.

function BolBakalimAsm(Bolunen, Bolen: Integer): Integer;
asm
  PUSH ebx
  MOV  ebx,edx //edx: Bolen
  MOV  ecx,eax //eax: Bolunen
  //Result := Bolunen div Bolen;
//  MOV eax,ecx
  CDQ
  IDIV ebx
  POP  ebx
end;

Kodları incelerken bir satırın fazlalık olduğunu görmüştük. Burayı açıklama satırı ile çıkardık.

Ayrıca farkında iseniz ecx hiç kullanılmıyor. Tek yaptığımız edx:eax’i ebx’e bölmek. Bu yüzden eax’deki Bolunen parametresini ecx’de saklamamıza gerek yok:

function BolBakalimAsm(Bolunen, Bolen: Integer): Integer;
asm
  PUSH ebx
  MOV  ebx,edx//edx: Bolen
//  MOV ecx, eax //eax: Bolunen
 //Result := Bolunen div Bolen;
//  MOV eax,ecx
  CDQ
  IDIV ebx
  POP  ebx
end;

Farkında iseniz, ecx register’ı boşa çıktı. Altın kurala göre ecx’i serbestçe kullanabildiğimizi biliyoruz. Ama ebx öyle değildi. Bu yüzden ebx’i kullanabilmek için stack’da değerini saklayıp ardından tekrar stack’dan değerini okutmalıydık. Ama ecx boşa çıktığına göre artık ebx kullanmamıza gerek kalmadı. Haliyle ebx yerine ecx kullanacağımızdan, ebx’i stack’de saklamak için pop ve push komutlarına da ihtiyacımız yok artık:

function BolBakalimAsm(Bolunen, Bolen: Integer): Integer;
asm
//  PUSH ebx
  MOV ecx,edx//edx: Bolen
//  MOV ecx, eax //eax: Bolunen
 //Result := Bolunen div Bolen;
//  MOV eax,ecx
  CDQ
//  IDIV ebx
  IDIV ecx
//  POP ebx
end;

Yeni kodlarımıza göre artık edx:eax çiftini ecx register’ına bölüyoruz. Kodları temizlediğimizde, optimize edilmiş son kodumuz şu şekilde olacaktır:

function BolBakalimAsm(Bolunen, Bolen: Integer): Integer;
asm
  MOV  ecx,edx //edx: Bolen
  CDQ  //eax => edx:eax
  IDIV ecx //Result(eax) := Bolunen(edx:eax) div Bolen(ecx);
end;

Gördüğünüz gibi fonksiyonumuz daha hızlı ve daha az yer kaplayarak optimize edilmiş duruma geldi.

function BirFonksiyon(Param: Double): Double;
const
  LocalConst1: Double = 1;
  LocalConst2: Double = 2;
  LocalConst3: Double = 3;
begin
  Result := LocalConst1*Param*Param + LocalConst2*Param + LocalConst3;
end;

function BirFonksiyonAsm(Param: Double): Double;
const
  LocalConst1: Double = 1;
  LocalConst2: Double = 2;
  LocalConst3: Double = 3;
begin{
  push  ebp
  mov   ebp,esp
  add   esp,-$08}
  Result := LocalConst1*Param*Param + LocalConst2*Param + LocalConst3;
  {
  fld   qword ptr [LocalConst1]
  fmul  qword ptr [ebp+$08]
  fmul  qword ptr [ebp+$08]
  fld   qword ptr [LocalConst2]
  fmul  qword ptr [ebp+$08]
  faddp st(1)
  fadd  qword ptr [LocalConst3]
  fstp  qword ptr [ebp-$08]
  wait
  fld   qword ptr [ebp-$08]
  }
end;{
  pop   ecx
  pop   ecx
  pop   ebp}

push ebp
mov  ebp, esp
add  esp, -$08

İlk satırdaki kod ile ebp stack üzerine saklanıyor. Çünkü bu değer fonksiyondan çıkıldığında eski değerine tekrar kavuşmalıdır. Taban işaretçisinin yeni değeri ikinci satırdaki mov komutu ile esp’deki değer olarak belirleniyor. Yani stack işaretçisinin değeri, taban işaretçisine kopyalanıyor. Böylelikle, taban işaretçisi olan ebp, stack’ın tepe noktasına işaret ediyor. Tabi hatırlarsanız stack, Intel işlemcilerde geriye doğru işlemektedir. Yani stack’ın tepe noktası, sayı değeri olarak en düşük noktadır. Son satırdaki komut ile, stackpointer 8 byte kadar ilerletiliyor.

Bu üç satırlık kod ile fonksiyonumuz için bir stackframe oluşturulmuş oluyor. Şimdi esas işlemi yapan kodlara bakalım:

fld   qword ptr [LocalConst1]
fmul  qword ptr [ebp+$08]
fmul  qword ptr [ebp+$08]
fld   qword ptr [LocalConst2]
fmul  qword ptr [ebp+$08]
faddp st(1)
fadd  qword ptr [LocalConst3]
fstp  qword ptr [ebp-$08]
wait
fld   qword ptr [ebp-$08]

Burada görülenler basit bir virgüllü sayı hesabıdır. İlk satırdaki fld komutu, LocalConst1 isimli sabiti, virgüllü sayı stack’ının tepesine taşır. Buradadaki komutlar, bildiğimiz mul, add gibi komutların virgüllü sayı (floating point) için olan versiyonlarıdır. Başlarına “f” harfi getirilmesi ile bu fonksiyonların floating point yani virgüllü sayı işlemi yapan komutlar olduğunu anlıyoruz.

Bizim için en mühim nokta “qword ptr [ebp+$08]” gibi ifadelerdir. “Qword ptr”, sonrasında gelecek olan değerin tipini belirtmektedir. Qword ile değerin 64 bit yani 8 byte’lık bir değer olduğunu, ptr ile de, değerin aslında başka bir değere işaret eden bir adres olduğunu gösterir. Sonrasında gelen [ ] köşeli parantezleri içine yazılan değer, işaret edilen adrestir. Yani [ebp+$08] ile ifade edilen, ebp’den 8 byte yani 64bit önceki değerdir. Bildiğiniz gibi ebp, bu fonksiyon için oluşturulan stackframe’in başlangıç adresini tutmaktadır. Öyle ise ebp’den 8 byte önceki değer, önceki stackframe’e işaret etmektedir. Fonksiyonumuzun Double tipinde bir parametre aldığını biliyoruz. Önceki örneklerimizde, fonksiyon parametreleri eax, ecx gibi registerlarda saklanıyordu. Ama Double tipi 64bit uzunluğundadır. Ve eax gibi registerlar ise 32bit uzunluğundadır. Double tipi bu registerlara sığmayacağından, Delphi burada bir seçim yapmıştır ve, parametreleri stack üzerine taşımıştır. Tabi burada double tipindeki bir değer için stack yerine, virgüllü sayı registerları kullanılsa idi daha verimli ve hızlı olacaktı. Borland’ın seçimi stack çözümü üzerine olmuştur. Kısacası, [ebp+$08] ile ifade edilen, fonksiyonumuzun ilk ve tek parametresi olan "Param"dır. “qword ptr” ise bu parametrenin 64bit uzunluğunda olduğunu ifade ediyor.

“faddp st(1)” satırına bakalım. “st(1)”, ikinci sıradaki virgüllü sayı registerıdır. İkinici sıradakidir, çünkü birincisi st(0) register’ıdır. Virgüllü sayı registerları bir stack üzerinde birleşik halde bulunurlar. Ve virgüllü sayı komutları, dolaylı olarak bu stack’ın tepesinde bulunan st(0) ile işlem yaparlar. Fld komutu, değeri virgüllü sayı stack’inin tepesine yani st(0)’a yerleştiriyor. Bunu ilk satırdaki fld komutu ile gördük. Fmul işlemleri yapıldığında sonuç yine st(0) üzerinde duracaktır. Çünkü virgüllü sayı komutları st(0) ile işlem yapıyorlardı. İki fmul komutundan sonra gelen fld komutu LocalConst2 değerini st(0)’a yerleştirir. Haliyle st(0)’da bulununan önceki değer st(1)’e kayar. Ardından gelen fmul ile işleminin sonucu st(0)’da depolanır. Devamında gelen “faddp st(1)” ile st(0)’da bulunan değer ile st(1) toplanır ve toplam sonucu st(0) üzerine kaydedilir. st(1) içinde “LocalConst1*Param*Param” sonucu olduğunu biliyoruz. Çünkü birinci sıraya “LocalConst2” fld ile yerleştirilmiş, “LocalConst1*Param*Param” sonucu st(0)’dan st(1)’e kaymıştır.

“faddp” komutundaki “p” harfi, st(1)’ın stack’dan çıkarılması yani “pop” yapılmasını sağlar. Böylece sonuç st(0) üzerinde durmakla birlikte, st(1)’de stack’dan silinecektir.

Buraya kadar olan komutlar “LocalConst1*Param*Param + LocalConst2*Param” işlemi gerçekleştirdi ve sonucu st(0) üzerine kaydetti. Sonrasında gelen fadd ile LocalConst3 değeri st(0) üzerine eklenmiştir. Fonksiyonun çıktısı st(0) üzerinden verilmektedir.

Bu işlemleri FPU ve CPU pencerelerinden debug yaparak takip edebilirsiniz.

Sonrasında gelen 3 satırlık kod gereksiz parçalar taşımaktadır. “fstp” kısmına bakalım. “fstp” ile sonuç, fonksiyonun stackframe’i üzerine taşınırken, fld ile tekrar stacktan yükleniyor. Bu işlem gereksizdir. Arada bulunan wait komutu gereklidir. Çünkü floating point komutları sırasında herhangi bir hata olup olmadığının kontrolü gerekmektedir. Wait komutu için ayrıntılı bilgi Intel’in yardım dosyalarında bulunmaktadır.

pop  ecx
pop  ecx
pop  ebp

bu komutlar, stackframe’i ortadan kaldırıyor. Ard arda iki adet pop çağrılmak ile esp’ye başta eklenen 8 byte geriye çekiliyor, yani eski pozisyonuna geliyor. Sonrasında ise ilk başta stack üzerine kaydettiğimiz ebp’nin eski değeri tekrar yükleniyor.

Şimdi bu fonksiyonu assembler versiyonunu yazalım ve optimize edelim:

function BirFonksiyonAsm(Param: Double): Double;
const
  LocalConst1: Double = 1;
  LocalConst2: Double = 2;
  LocalConst3: Double = 3;
asm
  //begin
  push  ebp
  mov   ebp,esp
  add   esp,-$08

  //Result := LocalConst1*Param*Param + LocalConst2*Param + LocalConst3;
  fld   qword ptr [LocalConst1]
  fmul  qword ptr [ebp+$08]
  fmul  qword ptr [ebp+$08]
  fld   qword ptr [LocalConst2]
  fmul  qword ptr [ebp+$08]
  faddp st(1)
  fadd  qword ptr [LocalConst3]
  fstp  qword ptr [ebp-$08]
  wait

  //end
  fld   qword ptr [ebp-$08]
  pop   ecx
  pop   ecx
  pop   ebp
end;

Bunu derlemeye kalktığınızda “faddp st(1)”in tanınamadığına dair bir hata mesajı alacaksınız ve bu kodları derleyemeyeceksiniz. Intel dökümanlarına baktığınızda, faddp komutunun sadece bir çeşitinin olduğunu göreceksiniz. Yani başka kullanımı yoktur. Yani her zaman st(1) ile st(0)’ı toplar ve sonucu st(0)’a yazar. Bu yüzden st(1)’i yazmaya gerek yoktur. st(1) yazan kısmı açıklama satırı yapıyoruz. Bundan sonra program derlenecektir.

Bu fonksiyonu 2 değerini verek çağırdığımızda sonucun “1*2*2 + 2*2 + 3 = 11“ olması gerekirken 3 sonucunu verdiğini göreceğiz. Peki nerede yanlış yaptık?

FPU ve CPU pencereleri ile adım adım debug yaptığımızda bu sorunu çözebileceğiz. CPU View’e bakarsanız baş tarafa eklediğimiz “push ebp” ve “mov ebp, esp” talimatları iki defa tekrar etmiş. Biz kodları direk kopyala yapıştır ile aldığımızdan, derleyicinin otomatik olarak eklediği bu kodlarını da almış olduk. Bu yüzden bu ilk iki satırı açıklama satırı ile kadırmalıyız. Çünkü zaten derleyici bu satırları ekliyor. Fonksiyonun girişinde ebp’nin otomatik olarak stack’a alınması ile haliyle bizim tekrar ebp’yi en son satırda pop yapmamız da gereksizdir.

Bu sorunu hallettikten sonra pascal versiyonu ile aynı sonuca ulaşıyoruz. Artık optimize işlemine geçebiliriz.

İlk başta en son satırlarda bulunan gereksiz fstp ve fld komutlarını çıkaralım. Bunların neden gereksiz olduğunu yukarıda bahsettik.

function BirFonksiyonAsm(Param: Double): Double;
const
  LocalConst1: Double = 1;
  LocalConst2: Double = 2;
  LocalConst3: Double = 3;
asm
  //begin
//  push  ebp
//  mov   ebp,esp
  add   esp,-$08

 //Result := LocalConst1*Param*Param + LocalConst2*Param + LocalConst3;
  fld   qword ptr [LocalConst1]
  fmul  qword ptr [ebp+$08]
  fmul  qword ptr [ebp+$08]
  fld   qword ptr [LocalConst2]
  fmul  qword ptr [ebp+$08]
  faddp //st(1)
  fadd  qword ptr [LocalConst3]
  //  fstp qword ptr [ebp-$08]
  wait

//end
//  fld   qword ptr [ebp-$08]
  pop   ecx
  pop   ecx
//  pop   ebp
end;

Bu işlemden sonra kodlara baktığımızda tüm işlemlerin virgüllü sayı registerları ile yapıldığını görüyoruz. Yani ek bir stackframe’e ihtiyaç yok. Bu yüzden stack frame ekleyen “add esp, -$08” satırını da kaldırmalıyız. Haliyle esp değişmediğinden en sonda bulunan iki adet pop komutu ile esp’nin eski değerini tekrar yüklememize de gerek yok.

function BirFonksiyonAsm(Param: Double): Double;
const
  LocalConst1: Double = 1;
  LocalConst2: Double = 2;
  LocalConst3: Double = 3;
asm
  //begin
//  push  ebp
//  mov   ebp,esp
//  add   esp,-$08

 //Result := LocalConst1*Param*Param + LocalConst2*Param + LocalConst3;
  fld   qword ptr [LocalConst1]
  fmul  qword ptr [ebp+$08]
  fmul  qword ptr [ebp+$08]
  fld   qword ptr [LocalConst2]
  fmul  qword ptr [ebp+$08]
  faddp //st(1)
  fadd  qword ptr [LocalConst3]
//  fstp qword ptr [ebp-$08]
 wait
 //end
//  fld   qword ptr [ebp-$08]
//  pop   ecx
//  pop   ecx
//  pop   ebp
end;

function BirFonksiyonAsm(Param: Double): Double;
const
  LocalConst1: Double = 1;
  LocalConst2: Double = 2;
  LocalConst3: Double = 3;
asm
  fld   qword ptr [LocalConst1]
  fmul  qword ptr [ebp+$08]
  fmul  qword ptr [ebp+$08]
  fld   qword ptr [LocalConst2]
  fmul  qword ptr [ebp+$08]
  faddp
  fadd  qword ptr [LocalConst3]
  wait
end;

function BirFonksiyonAsm(Param: Double): Double;
const
  LocalConst1: Double = 1;
  LocalConst2: Double = 2;
  LocalConst3: Double = 3;
asm
  fld   qword ptr [ebp+$08] //Param'ı st(0)'a at
  fld   qword ptr [LocalConst1] //st(0)'a LocalConst1 atıldı, Param şimdi st(1)'e kaydı
  fmul  st(0), st(1) //LocalConst ile Param'ı çarp sonucu st(0)'a at
  fmul  st(0), st(1) //st(0) ile Param'ı çarp sonucu st(0)'a at
  fld   qword ptr [LocalConst2] //LocalConst2 st(0)'da, sonuç st(1)'de ve Param st(2)'de
  fmul  st(0), st(2) //LocalConst2 ile Param yani st(2)'yi çarp ve sonucu st(0)'a at.
  ffree st(2) //Param'ı boşalt.
  faddp //st(0) ile st(1)'i topla ve sonucu st(0)'e at ve st(1)’i boşalt.
  fadd  qword ptr [LocalConst3] //st(0) ile LocalConst3'ü topla ve sonucu st(0)'a at.
  wait
end;

Kodların açıklamaları yanlarında mevcut. Burada ekstradan ffree adlı komutu gördük. Kodlar bu haliyle optimize edilmiş gibi.

Son olarak bir optimizasyon daha yapalım. LocalConst1 sabitimizin değeri 1’dir. Bu değeri fld ile hafızadan yüklemek yerine, st(0)’ı bir yapan fld1 komutu kullanılabilir. Böylelikle hem hafıza kullanımını hem de saykıl gecikmesini azaltmış olacağız. Kodlarımızın son hali şu şekilde olacaktır:

function BirFonksiyonAsm(Param: Double): Double;
const
//  LocalConst1: Double = 1;
  LocalConst2: Double = 2;
  LocalConst3: Double = 3;
asm
  fld   qword ptr [ebp+$08] //Param'ı st(0)'a at
//  fld   qword ptr [LocalConst1] //Param şimdi st(1)'de
  fld1
  fmul  st(0), st(1) //LocalConst ile Param'ı çarp sonucu st(0)'a at
  fmul  st(0), st(1) //st(0) ile Param'ı çarp sonucu st(0)'a at
  fld   qword ptr [LocalConst2] //LocalConst2 st(0)'da, sonuç st(1)'de ve Param st(2)'de
  fmul  st(0), st(2) //LocalConst2 ile Param yani st(2)'yi çarp ve sonucu st(0)'a at.
  ffree st(2) //Param'ı boşalt.
  faddp //st(0) ile st(1)'i topla ve sonucu st(0)'e at.
  fadd  qword ptr [LocalConst3] //st(0) ile LocalConst3'ü topla ve sonucu st(0)'a at.
  wait
end;

Bu bölümde bu kadar yeterli. Gelecek bölümlerde if-else, while-do, for döngüsü gibi yapılara ve sse, sse2 ve mmx gibi teknolojilere de göz atmaya çalışacağız.