OpenGL TABANLI ANİMASYONLARDA GÖRÜNTÜ KALİTESİNİN CUDA MİMARİSİ İLE ARTIRILMASI Taner UÇKAN Yüksek Lisans Tezi Bilgisayar Mühendisliği Anabilim Dalı

Transkript

1 OpenGL TABANLI ANİMASYONLARDA GÖRÜNTÜ KALİTESİNİN CUDA MİMARİSİ İLE ARTIRILMASI Taner UÇKAN Yüksek Lisans Tezi Bilgisayar Mühendisliği Anabilim Dalı Yrd. Doç. Dr. Deniz DAL 2015 Her hakkı saklıdır

2 ATATÜRK ÜNİVERSİTESİ FEN BİLİMLERİ ENSTİTÜSÜ YÜKSEK LİSANS TEZİ OpenGL TABANLI ANİMASYONLARDA GÖRÜNTÜ KALİTESİNİN CUDA MİMARİSİ İLE ARTIRILMASI Taner UÇKAN BİLGİSAYAR MÜHENDİSLİĞİ ANABİLİM DALI ERZURUM 2015 Her Hakkı Saklıdır

3 T.C. ATATÜRK ÜNİVERSİTESİ FEN BİLİMLERİ ENSTİTÜSÜ TEZ ONAY FORMU OpenGL TABANLI ANİMASYONLARDA GÖRÜNTÜ KALİTESİNİN CUDA MİMARİSİ İLE ARTIRILMASI Yrd. Doç. Dr. Deniz DAL danışmanlığında, Taner UÇKAN tarafından hazırlanan bu çalışma.../.../... tarihinde aşağıdaki jüri tarafından Bilgisayar Mühendisliği Anabilim Dalı nda Yüksek Lisans tezi olarak oybirliği/oy çokluğu ( / ) ile kabul edilmiştir. Başkan :... İmza : Üye :... İmza : Üye :... İmza : Yukarıdaki sonuç; Enstitü Yönetim Kurulu.../.../.. tarih ve....../ nolu kararı ile onaylanmıştır. Prof. Dr. Ertan YILDIRIM Enstitü Müdürü Not: Bu tezde kullanılan özgün ve başka kaynaklardan yapılan bildirişlerin, çizelge, şekil ve fotoğrafların kaynak olarak kullanımı, 5846 sayılı Fikir ve Sanat Eserleri Kanunundaki hükümlere tabidir.

4 ÖZET YÜKSEK LİSANS TEZİ OpenGL TABANLI ANİMASYONLARDA GÖRÜNTÜ KALİTESİNİN CUDA MİMARİSİ İLE ARTIRILMASI Taner UÇKAN Atatürk Üniversitesi Fen Bilimleri Enstitüsü Bilgisayar Mühendisliği Anabilim Dalı Danışman: Yrd. Doç. Dr. Deniz DAL Gerçek hayatta meydana gelen birçok fiziksel olayın bilgisayarlar yardımıyla grafiksel olarak modellenebilmesi amacıyla 2 veya 3 boyutlu görüntü oluşturma teknolojilerinden faydalanılmaktadır. Öte yandan grafik uygulamalarının yoğunluğu artıkça söz konusu bu modellemelerin hem daha hızlı yapılabilmesi ve hem de görüntü kalitelerinin artırılması gereksinimleri ortaya çıkmaktadır. Bu doğrultuda 2006 yılının sonlarında Nvidia firması tarafından CUDA isimli bir yazılım ve donanım mimarisi piyasaya sürülmüştür. Bu mimari sayesinde ekran kartları üzerinde bulunan çok sayıdaki grafik işlemcisi genel amaçlı problemlerin paralel olarak çözülebilmesine katkı sağlar hale gelmiştir. Bu tez kapsamında bu yeni paralel hesaplama mimarisi dikkate alınmış, C++ ve OpenGL kütüphanesi kullanılarak farklı davranış özelliklerine sahip insansı robotlardan oluşan bir animasyon uygulaması geliştirilmiştir. Bu animasyon öncelikle merkezi işlemci üzerinde seri olarak çalıştırılmış ve sonrasında CUDA mimarisi kullanılarak paralelleştirilmiştir. En sonunda aynı animasyonun seri ve paralel versiyonları saniyede oluşturulan görüntü karesi sayıları temel alınarak karşılaştırılmıştır ve paralel uygulamanın açık ara yüksek kaliteli görüntü ürettiği gözlemlenmiştir. 2015, 103 Sayfa Anahtar Kelimeler: 3D Modelleme, OpenGL, C++, Nvidia, CUDA, GPGPU, Animasyon, İnsansı Robot i

5 ABSTRACT MASTER THESIS IMAGE QUALITY IMPROVEMENT ON OpenGL-BASED ANIMATIONS BY USING CUDA ARCHITECTURE Taner UÇKAN Ataturk University Graduate School of Natural and Applied Sciences Department of Computer Engineering Supervisor: Asst. Prof. Dr. Deniz DAL 2D or 3D rendering technology is used for graphically modelling many physical phenomena occurring in real life by means of the computers. On the other hand, the ever-increasing intensity of the graphics applications require that the image quality of the so-called modellings is enhanced and they are performed more quickly. In this direction, a new software and hardware-based architecture called CUDA has been introduced by Nvidia at the end of Thanks to this architecture, larger number of graphics processors have started contributing towards the parallel solutions of the general-purpose problems. In this thesis, this new parallel computing architecture is taken into consideration and an animation application consisting of humanoid robots with different behavioral characteristics is developed using the OpenGL library in C++. This animation is initially implemented on a single serial CPU and then parallelized using the CUDA architecture. Eventually, the serial and the parallel versions of the same animation are compared against each other on the basis of the number of image frames per second. The results reveal that the parallel application is by far the best yielding high quality images. 2015, 103 Pages Keywords: 3D Modelling, OpenGL, C++, Nvidia, CUDA, GPGPU, Animation, Humanoid Robot ii

6 TEŞEKKÜR Bu tez çalışmasının planlanmasında, araştırılmasında, yürütülmesinde ve oluşumunda ilgi ve desteğini esirgemeyen, engin bilgi ve tecrübelerinden yararlandığım, yönlendirme ve bilgilendirmeleriyle çalışmamı bilimsel temeller ışığında şekillendiren hocam Sayın Yrd. Doç. Dr. Deniz DAL a sonsuz teşekkürlerimi sunarım. Atatürk Üniversitesi Mühendislik Fakültesi Bilgisayar Mühendisliği öğretim üyelerinden Sayın Yrd. Doç. Dr. Tolga AYDIN a ve Endüstri Mühendisliği öğretim üyelerinden Sayın Yrd. Doç. Dr. Burak ERKAYMAN a teşekkürlerimi sunarım. Ayrıca sevgili aileme manevi desteklerini esirgemeden yanımda oldukları için tüm kalbimle teşekkür ederim. Taner UÇKAN Ocak, 2015 iii

7 İÇİNDEKİLER ÖZET... i ABSTRACT... ii TEŞEKKÜR... iii SİMGELER ve KISALTMALAR DİZİNİ... vi ŞEKİLLER DİZİNİ... viii ÇİZELGELER DİZİNİ... x 1. GİRİŞ Tezin Amacı Tezin Yapısı Problemin Tanımı KAYNAK ÖZETLERİ MATERYAL ve YÖNTEM OpenGL Visual studio 2010 kurulumu ve OpenGL adaptasyonu OpenGL komut prototipi OpenGL hizmet aracı (OpenGL Utility ToolKit) Pencere yönetimi Görüntüyü geri çağırma (The Display Callback) Dışarıdan veri girişini tutmak OpenGL ilkel geometrik nesneleri (OpenGL Primitives) Köşegenleri belirleme Renklendirme Koordinat çevrimleri Görüntü dönüşümleri (Viewing Transformation) Model dönüşümleri Matris yığınları Doku haritalama İki boyutlu doku haritalama Doku haritalama nesneleri iv

8 3.2. CUDA Cuda sistem modeli Cuda programlama modeli Heterojen programlama Çekirdek fonksiyonlar Kanal hiyerarşisi Hafıza hiyerarşisi CUDA hesaplama yeteneği CUDA ile paralel programlama CUDA kurulumu ve visual studio platformunda kullanımı CUDA nın grafik uygulamalarında kullanımı CUDA ve OpenGL birlikteliği NVIDIA GeForce 9500 GT ekran kartı özellikleri Yöntem ARAŞTIRMA YÖNTEMLERİ Problemin Seri ve Paralel Çözümü Problemin seri çözümü OpenGL ile grafik ortamı hazırlanması OpenGL ile robot oluşturulması Robot animasyon işlemleri Doku haritalama işlemleri Merkezi işlem birimi (CPU) üzerinde fps ölçümü Problemin CUDA ile Paralel Çözümü TARTIŞMA ve SONUÇ Test Ortamı Analiz Sonuçları KAYNAKLAR ÖZGEÇMİŞ v

9 SİMGELER ve KISALTMALAR DİZİNİ 3D AES ANSI API ASCII CASH CPU CT CUDA DLL GCA GİB GLU GLUT GPGPU GPU ID KERNEL MRI MRT NVCC OpenCL OpenGL RAM 3 Boyutlu (3 Dimension) Gelişmiş Şifreleme Standartı (Advanced Encryption Standard) Amerikan Ulusal Standartlar Enstitüsü (American National Standards Institute) Uygulama Geliştirme Arayüzü (Application Programming Interface) Amerikan Standart Kodlama Sistemi (American Standard Code for Information Interchange) Nakit Merkezi İşlem Birimi (Central Processing Unit) Bilgisayarlı Tomografi (Computed Tomography) Birleştirilmiş Hesaplama Mimarisi (Compute Unified Device Architecture) Dinamik Bağlantı Kütüphanesi (Dynamic Link Library) Grafik Cihaz Arayüzü Grafik Işlem Birimi OpenGL Yardımcı Kütüphanesi (OpenGL Utility Library) OpenGL Araç Seti (OpenGL Utility Toolkit) Genel Amaçlı Grafik İşlem Birimi (General Purpose Computing on Graphical Processing Unit) Grafik İşlem Birimi (Graphical Processing Unit) Benzersiz Değer (Identity) Çekirdek Manyetik Rezonans Görüntüleme (Magnetic Resonance Imaging) Manyetik Rezonans Tomografisi (Magnetic Resonance Tomography) Nvidia Cuda Derleyicisi (Nvidia CUDA Compiler) Açık Hesaplama Dili (Open Computing Language) Açık Grafik Kütüphanesi (Open Graphics Library) Rastgele Erişim Hafızası (Random Access Memory) vi

10 RGBA RPM THREAD VERTEX Renk Kodları Kırmızı, Yeşil, Mavi, Bölünme Değeri (Red-Green-Blue- Alpha) Dakikadaki Devir Sayısı (Revolutions Per Minute) İşlem Kanalı Köşe vii

11 ŞEKİLLER DİZİNİ Şekil 3.1. OpenGL çalışma mimarisi Şekil 3.2. OpenGL boru hattı Şekil 3.3. İlkel nesneler Şekil 3.4. Console uygulaması oluşturma Şekil 3.5. OpenGL.dll dosyalarının uygulamaya eklenmesi Şekil 3.6. OpenGL komut prototipi Şekil 3.7. Örnek 2 nin ekran çıktısı Şekil 3.8. Örnek 3 ün ekran görüntüsü Şekil 3.9. OpenGL koordinat dönüşüm sırası Şekil Görüntü dönüşümü Şekil Görüntü taşıma işlemi Şekil Görüntü döndürme Şekil Görüntünün ölçeklendirilmesi Şekil Matris yığın yapısı Şekil Matris yığınına ekleme ve çıkarma işlemi Şekil GeForce GT 9500 ekran kartı Şekil CUDA mimarisi Şekil CUDA destekli yazılım platformları Şekil Heterojen programlama yapısı Şekil Çekirdek fonksiyon yapısı Şekil CUDA kanal mimarisi Şekil CUDA işlem kanalı modeli Şekil CUDA blok modeli Şekil CUDA grid modeli Şekil CUDA hafıza hiyerarşisi Şekil CUDA genel bellek modeli Şekil CUDA paylaşımlı bellek modeli Şekil CUDA yerel bellek modeli Şekil GeForce 9500 GT ekran kartı hesaplama kapasitesi viii

12 Şekil NVCC ile program derleme Şekil CUDA bellek bölgelerine erişim Şekil Visual Studio platformunda CUDA programı oluşturma Şekil CUDA derleyicisinin seçilmesi Şekil Program dosyasında CUDA C ayarlaması Şekil Gerekli CUDA kütüphanelerinin uygulamaya eklenmesi Şekil CUDA ve OpenGL işbirliği Şekil CUDA ve OpenGL programlama algoritması Şekil OpenGL veri havuzu yapısı Şekil PBO kullanmadan veri aktarım işlemi Şekil PBO kullanarak veri aktarim işlemi Şekil 4.1. Grafik uygulama ortamının hazırlanması Şekil 4.2. Işıklandırma ve doku haritalama ayarlamaları Şekil 4.3. OpenGL ile zemin oluşturma Şekil 4.4. Ekran çıktısı görüntüsü Şekil 4.5. OpenGL ile robot eklemi oluşturma komutları Şekil 4.6. OpenGL ile robot tasarımı Şekil 4.7. Klavye ve fare araçlarından bilgi girişi kontrolü Şekil 4.8. Robot hareketleri Şekil 4.9. Doku bilgisi oluşturma Şekil Doku haritalama işlemi Şekil FPS hesaplama kod bloğu Şekil PBO oluşturma ve CUDA ya tanıtılma kodları Şekil PBO bilgisinin CUDA üzerinde haritalanması Şekil Blok ve thread belirleme Şekil 5.1. Grafik ortamı oluşturulma analizi Şekil 5.2. Grafik ortamın görüntü kesiti Şekil adet robot için performans analizi Şekil adet robot için karşılaştırmalı performans analizi Şekil adet robot için karşılaştırmalı performans analizi Şekil 5.6. CPU üzerinde çalışan 140 robotlu ekran görüntüsü Şekil 5.7. CPU ve GPU üzerinde çalışan 140 robotlu ekran görüntüsü ix

13 ÇİZELGELER DİZİNİ Çizelge 3.1. OpenGL veri tipleri Çizelge 3.2. Ekran kartı üzerinde bulunan bellek özellikleri Çizelge 3.3. GeFrorce 9500 GT Ekran kartı özellikleri Çizelge 5.1. Grafik ortamı hazırlanması aşamasında oluşan frame sayıları Çizelge adet robot hazırlanması aşamasında oluşan frame sayıları Çizelge adet robot hazırlanması aşamasında oluşan frame sayıları Çizelge adet robot hazırlanması aşamasında oluşan frame sayıları x

14 1 1. GİRİŞ Günlük yaşantımızın birçok alanında karşılaştığımız fiziksel olayların sonuçlarının değerlendirilmesi ve/veya bu olayların modellenebilmesi/benzetimlerinin yapılabilmesi amacıyla bilgisayarlardan sıklıkla faydalanılmaktadır. Söz konusu bu alanların en başta gelenlerinden biri bilgisayar grafiği ve görüntü işleme temeline dayanan uygulamaları içermektedir. Bu türden uygulamalara örnek olarak x-ray ve ultrason gibi medikal görüntüler üzerinden tanı koyabilmeye imkan sağlayan tıbbi görüntü işleme, jeolojide kullanılan zemin modelleme, otomotiv sektöründe kullanılan parça modelleme, inşaat sektöründe kullanılan yapı modelleme ve oyun programlama verilebilir. Yukarıda listelenen uygulamaların çoğunda modelleme amacıyla genellikle OpenGL (Open Graphics Library) benzeri bir grafik ara yüzü oluşturma kütüphanesi bir programlama dili ile birleştirilerek kullanılır. OpenGL, grafiksel donanıma ara yüz olan bir yazılımdır. Bu ara yüz, bu tezin yazımının gerçekleştirildiği tarih itibariyle, yaklaşık olarak 700 adet komut içermektedir. Bu komutlar kullanılarak objeler oluşturabilir ve interaktif bir şekilde üç boyutlu uygulamalar gerçekleştirilebilir. İnsanın doğasında mevcut bir işi daha hızlı ve daha kaliteli yapma isteği hep var olmuştur ve bu istek bilgisayar dünyasında en hızlı işlem yapabilen bilgisayarı üretebilmek şeklinde bir rekabete bile dönüşmüştür. Bu tür bilgisayarların paralel hesaplama adı verilen, birden fazla hesaplama ünitesinin birbirinden bağımsız olarak çalıştığı ve gerektiğinde birbiri ile haberleştiği bir model sayesinde hızı artırılabilmektedir. Paralel hesaplama, uzun yıllar sadece süper bilgisayarlar ve bilgisayar kümeleri kullanılarak gerçekleştirilebiliyorken, 2007 yılının sonunda grafik kartı üreticisi NVIDIA firmasının yayınladığı CUDA (Compute Unified Device Architecture) mimarisi sayesinde kişisel bilgisayarlarla da yürütülebilir bir hale gelmiştir. CUDA, oldukça fazla sayıda ancak basit yapıda işlemciden oluşan NVIDIA üretimi grafik kartlarının genel maksatlı hesaplama amaçlı kullanılmasını sağlayan bir uygulama ara yüzüdür (Çolak 2010).

15 Tezin Amacı Bu tezin amacı, OpenGL grafik oluşturma kütüphanesi kullanılarak oluşturulan animasyon uygulamalarında görüntü kalitesinde meydana gelen netlik problemlerinin GPU üzerinde CUDA C dili ile CPU üzerinde yapılan örneklerine göre daha kaliteli görüntü elde edildiğini göstermektir. Bunlara ek olarak diğer amaçları ise; Microsoft Visual Studio.Net Platformu üzerinde C++ programlama dili kullanarak OpenGL tabanlı grafik uygulamalarının geliştirilmesi ve grafik kartı üreticisi NVIDIA firmasının yayınladığı CUDA mimarisi ile entegre edilerek paralelleştirilmesidir. OpenGL, C++ ve CUDA teknolojilerinin birlikteliğini kullanarak yüksek görüntü kalitesine sahip bir animasyon programının geliştirilmesidir Tezin Yapısı Bu tez çalışmasında Nvidia CUDA C ve C++ dilleri kullanılarak, OpenGL tabanlı bir robot animasyon uygulaması ve bu uygulamanın dinamik doku haritalama (Dynamic Texture Mapping) işlemi gerçekleştirilmiştir. Uygulama Visual Studio 2010 ortamında geliştirilmiştir. Bu tez beş bölümden oluşmaktadır. Tezin birinci bölümü giriş bölümüdür. İkinci bölümde tez konusu ile ilgili daha önce yapılan çalışmaların kısa bir özeti sunulmuştur. Üçüncü bölümde OpenGL kütüphanesi ve CUDA teknolojisi hakkında genel bilgiler verilmiştir. Bu bölümde ayrıca Visual Studio ortamında OpenGL ve CUDA kütüphanesini içeren bir C++ projesinin nasıl oluşturulduğu adım adım anlatılmış ve NVIDIA firması tarafından üretilen GeForce 9500 GT ekran kartı tanıtılmıştır. Ayrıca bu bölümde problemin çözüm yöntemine kısaca değinilmiştir. Dördüncü bölümde ise çözüm getirilmesi düşünülen problemin tanıtılması ve Visual Studio ortamında C++ ile hazırlanan seri OpenGL grafik animasyon uygulaması anlatılarak tek bir işlemci (CPU) ile saniyede oluşturulan görüntü karesi (FPS- Frame Per Second) sayısının bulunması ve bu uygulamanın GPU üzerinde yer alan işlemciler ile CUDA teknolojisi sayesinde

16 3 paralelleştirilmesinden elde edilen yeni FPS değerlerinin bulunması anlatılmıştır. Tezin beşinci ve son bölümü ise paralel uygulama ile seri uygulama arasındaki farklılıkların görüntü kalitesi açısından analizlerini ve grafiksel sonuçlarını içermektedir Problemin Tanımı Günümüzde teknolojinin gelişmesi ile karşılaşılan problemlerin programlanabilme kapasitesi de işlenecek veri miktarı da bu gelişmelere paralel olarak artmaktadır. Artan bu veri miktarlarının tek bir işlemci (CPU) kullanılarak işlenme süresi düşük veri miktarına göre daha çok zaman almakta ve verimlilik oranı da beraberinde düşmektedir. Bu problemler, grafik tabanlı uygulamalarda görüntüdeki netlik oranının düşmesi ve animasyonlarda bulunan hareket ettirme işlemlerindeki yavaşlama olarak karşımıza çıkmaktadır. Grafik yoğunluklu işlemlerde karşılaşılan görüntü problemlerinin çözülmesinde paralel programlama yapısından faydalanılmaktadır. Paralel programlama mantığının gelişiminin başlarında birden fazla bilgisayarın bir araya getirilerek çalıştırılması amaçlanmıştır. Bu çalışma mantığının performans ve maliyet açısından yetersiz görülmesinin ardından 2007 yılının başlarında bir ekran kartı üreticisi olan Nvidia firması tarafından genel amaçlı uygulamalarda kullanılabilen ve yüzlerce küçük işlem biriminden aynı anda faydalanılabilecek CUDA paralel hesaplama mimarisi piyasaya sürülmüştür. Bu tezde, OpenGL grafik ara yüz oluşturma kütüphanesi kullanılarak geliştirilen animasyon uygulamalarında artan grafik verilerinin işlenmesi sırasında görüntülerin netliğinde meydana gelen bozukluların giderilmesi için Nvidia CUDA teknolojisi kullanılarak paralel programlama mantığı ile bir çözüm geliştirilmiştir.

17 4 2. KAYNAK ÖZETLERİ Teknolojinin gelişimi ile birlikte grafik uygulamaları insan hayatının vazgeçilmez bir parçası olmuştur. İhtiyaç duyulan grafik uygulamalarının geliştirilebilmesi için DirectX ve OpenGL gibi grafik ara yüzü oluşturma kütüphaneleri geliştirilmiştir. Günümüzde OpenGL, diğer grafik arayüzü oluşturma kütüphanelerine göre daha esnek ve taşınabilirlik özelliğine sahip olduğundan bilimsel çalışmalarda yoğun bir şekilde kullanılmıştır. Literatürde OpenGL kütüphanesini kullanan birçok çalışma bulunmaktadır. Li et al. (1997) düşük maliyetli seri bilgisayarların düşük hızlı networklerini temel alarak OpenGL özelliklerine uygun 3 boyutlu bir poligon modelleme sistemini PVM (Parallel Virtual Machine) üzerine uygulamışlardır. Benzer şekilde OpenGL grafik arayüzü ile ilgili literatürde bulunan bazı çalışmalar şöyledir: Kılıç (2001), An Open Graphics Library (OpenGL) based Toolbox for Biomedical Image Display and Processing başlıklı yüksek lisans tezinde insan dokularının 3 boyutlu gösterimi için MRI ve CT verilerini kullanarak OpenGL tabanlı 3DVIEW isimli işleme ve görüntüleme araç kutusunu geliştirmiştir. Şaşoğlu (2010) tarafından hazırlanan OpenGL ile 3 Boyutlu Arazi Modellerinin Üretimi ve Çoklu Çözünürlükte Sadeleştirilmesi adlı yüksek lisans tezinde bir poligon sadeleştirme yönteminin 3 boyutlu arazi üretimi algoritması ile birleştirilmesi ve sadeleştirme performansı incelenmiştir. Tokatlı (2010), Modeling of Geological Measurements with OpenGL adlı yüksek lisans tezinde çeşitli istasyonlardan aldığı mağara fotoğraflarının verilerini çeşitli işlemlerden geçirdikten sonra OpenGL grafik kütüphanesini ve C Sharp programlama dilini kullanarak oluşturduğu programa aktarmakta ve sonuç olarak mağaranın katı modelini oluşturmaktadır.

18 5 Wang and Lei (2011) çalışmaları sonucunda jeolojik nesneler arasındaki geçici, mekânsal ilişkileri tanımlamada ve mineral kaynaklarının sayısal hesaplanmasında jeologlara yardımcı olacak 3 boyutlu bir jeolojik modelleme (3DGM) programını literatüre kazandırmışlardır. Daha önce belirtildiği gibi OpenGL taşınabilirlik açısından diğer grafik arayüzlerinden farklılık göstermekte ve çeşitli yazılım platformaları ile birlikte sorunsuz bir şekilde çalışabilmektedir. Ma et al. (2013) Linux platformu üzerinde C programlama dili ve OpenGL grafik kütüphanesi kullanarak Yürüyen Küpler (Marching Cubes) algoritmasını geliştirerek moleküler yüzeylerin gösteriminde daha kaliteli görüntülerin oluşturulmasını sağlamışlardır yılının şubat ayında Nvidia nın CUDA paralel hesaplama mimarisi ortaya çıkmıştır. Araştırmacılar, GPU kullanılarak mevcut grafik API leri ile gerçekleştirilen uygulamalarda karşılaşılan problemleri çözüme ulaştırmak için C programlama diline benzer özelikler gösteren ve yüzlerce çekirdekli yüksek derecede paralel bir mimariden ve çok yüksek bellek bant genişliğinden faydalanmak istemişlerdir. CUDA mimarisinin yayınlanması ile birlikte geleneksel birçok problem bu mimari üzerinde uygulanmış ve yüksek performanslar elde edilmiştir. Genel amaçlı GPU lar üzerinde CUDA mimarisi öncelikli olarak yüksek matematiksel işlemler içeren uygulamalarda kullanılmıştır. Manavski (2007) simetrik anahtar şifreleme uygulamalarının modern GPU ların kullanımında oluşacak etkilerini Cuda Compatible Gpu as an Efficient Hardware Accelerator For AES Cryptography adlı makalesinde anlatmıştır. Bu çalışma kapsamında gelişmiş şifreleme standartları (AES) algoritmasının, Nvidia tarafından üretilmiş CUDA teknolojisi üzerine uygulanması amaçlanmıştır. Çalışma sonucunda kullanılan yeni GPU teknolojileri ile Pentium IV 3.0 işlemcili sistemin kullanımı durumunda oluşan performans farkları karşılaştırılmış ve Nvidia CUDA teknolojisi ile yapılan uygulamaların 20 kat daha hızlı oldukları belirlenmiştir. Okitsu et al. (2010) CUDA destekli GPU larda koni ışınlarının yeniden oluşumunu hızlandırmak için Feldkamp, Davis, and Kress (FDK) algoritmasını hızlandıran bir metot sunmuşlardır. Yapılan çalışmalar sonucunda, daha önce yapılan CUDA tabanlı uygulamalara göre

19 6 %41 ve geleneksel CPU tabanlı metotlardan 24 kat daha iyi performans elde edildiği gösterilmiştir. Benzer şekilde yüksek hesaplama kapasitesi gerektiren sıralama algoritmalarına Lin et al. (2012) çok çekirdekli GPU larda CUDA teknolojisini kullanarak etkili bir sıralama uygulaması olan CUDA Shellsort u önermiştir. Yapılan çalışmalar sonucunda tekdüze dağılım altında CUDA shellsort algoritmasının performansının GPU Quicksort algoritmasından ortalama iki kat daha hızlı ve Thrust Mergesort algoritmasından ise %37 daha hızlı olduğu görülmüştür. CUDA ile birlikte gelen yüksek hesaplama kapasitesine ve programlamadaki kolaylıklara grafik programcıları tarafından kayıtsız kalınmamıştır. Özellikle grafik uygulamalarında karşılaşılan hız ve netlik problemlerinin çözümünde CUDA mimarisi kullanılarak yoğun çalışmalar yapılmıştır. OpenGL ve CUDA mimarisinin birlikteliğinin kullanıldığı bazı çalışmalar şöyledir: Çolak (2010) tarafından Grafik kartı üzerinde paralel hızlandırılmış ışın izleme adlı yüksek lisans tezinde ışın izleme işlemi, ışık benzetimi için kullanılmış ve 2 boyutlu fotogerçekçi görüntüler elde edilmesi amaçlanmıştır. Bu çalışma kapsamında hesaplamayı kolaylaştırdığı, hızlandırdığı ve karmaşık ya da basit tüm cisimler için uygulanabilir hale getirdiğinden dolayı cisimlerin 3 boyutlu modellerinin bilgisayar ortamına aktarılmasında üçgen modellemesi kullanılmıştır. Cismin üçgen modelinin bilgisayara aktarılmasının ardından, ışınlar oluşturulmuş ve bu ışınların cismi oluşturan üçgenlerin hangilerine hangi noktalarda çarptığı ışın-üçgen kesişim algoritmalarıyla tespit edilmiştir. Işın izleme işlemini daha verimli hale getirerek hızlandırmak için uzay bölmeleme algoritmaları geliştirilmiştir. Bu çalışmada uzay bölmeleme algoritması kullanılarak verimli hale getirilen ışın izleme işleminin, CUDA kullanılarak grafik kartları üzerinde yürütülebilmesi anlatılmıştır. Tıbbi görüntüleme cihazlarında elde edilen 2 boyutlu görüntülerden 3 boyutlu görüntüler elde edilmesi amacı ile Archirapatka et al. (2011) GPU lar üzerinde genel amaçlı hesaplama performansından faydalanarak 3 boyutlu görüntü oluşturmayı hedeflemiştir. GPGPU lar yüksek hesaplama performansına sahip oldukları için gerçek zamanlı görüntü üretimi için yeni modeller üretmede bunlardan faydalanılabileceği düşünülmüştür. Bu çalışma

20 7 kapsamında 2 boyutlu enine kesitli resimler ve veri yığınlarını GPGPU lar üzerinde işleyerek 3 boyutlu görüntülerin oluşturulması ve oluşturulan 3 boyutlu görüntülerin OpenGL kütüphaneleri kullanılarak oluşturulan bir kullanıcı ara yüzü programı ile sunulması amaçlanmıştır. CUDA mimarisi OpenGL kullanılarak oluşturulan dinamik görüntülerde kullanıldığı gibi var olan sabit resimler üzerinde de yüksek performans göstermektedir. Yıldız (2011) tarafından hazırlanan Nvidia CUDA ile yüksek performanslı görüntü işleme adlı yüksek lisans tezinde resim işlemedeki bazı konvolüsyon ve filtreleme örneklerinin GPU üzerinde CUDA C dili ile CPU üzerindeki örneklerine göre daha yüksek performans gösteren türevleri oluşturulmuştur. Centelles et al. (2011) tarafından hazırlanan Rain Simulation in Dynamic Scenes adlı makalede parçacık sistemine dayalı tamamen GPU üzerinde yapılacak bir sistem sunulmaktadır. Bu çalışma kapsamında yağmur yağışı esnasında oluşabilecek çarpışmaları yakalamak ve tespit etmek için Nvidia CUDA teknolojisinin esnekliğinden faydalanılmıştır. Ayrıca, yağmur tanelerinin aynı zamanda sıçramalarının tespitinde de bu teknoloji kullanılmıştır. Yapılan çalışmalar sonucunda CUDA nın donanım programlama kapasitesinden dolayı çok yüksek performanslar elde edildiği görülmüştür. Yan et al. (2012) tarafından hazırlanan GPU Accelerated High Accuracy Surface Modelling adlı makalede büyük ölçekli verilerde yüksek doğrulukta yüzey modelleme (HASM) yapılırken karşılaşılan en büyük problemin hız olduğu ve bu problemin GPU kullanılarak hızlandırılabileceği düşünülmüştür. Nvidia CUDA teknolojisi ve Nvidia Quadro 2000 ekran kartı ile HASM nin hesaplama işlemlerinin en yoğun olduğu yerde ekran kartı üzerinde bulunan genel amaçlı işlemcileri kullanarak paralel hesaplama yapılmıştır. Sonuçlar geleneksel CPU metotları ile karşılaştırıldığında, GPU da yapılan paralel işlemler ile önemli ölçüde hız kazancı olduğu görülmüştür.

21 8 Chickerur et al. (2013), Parallel Rendering Mechanism for Graphics Programming on Multicore Processors isimli çalışmasında çok çekirdekli işlemcileri destekleyen bir platforma OpenGL kütüphanesinin entegre edilmesine yer vermiştir. Yukarıda kısa özetleri verilen literatür çalışmaları incelendiğinde CUDA mimarisinin sağladığı yüksek hesaplama kapasitesi ve çoklu işlemci mimarisi çoğunlukla yoğun matematiksel hesaplama işlemlerinde kullanılmakta ve temel amacın işlem süresini kısaltmak olduğu anlaşılmaktadır. Bu tezi diğer çalışmalardan ayıran en önemli özellik görüntünün oluşturulma süresini düşürmekten ziyade elde edilen yoğun grafiksel bilgilerin görüntü kalitesini artırmaktır. Tez kapsamında yapılan çalışmalar sonucunda yüksek görüntü kalitesine sahip grafiksel görüntüler elde edildiği sayısal ve grafiksel analizler yapılarak sunulmuştur.

22 9 3. MATERYAL ve YÖNTEM Bu bölümde tezde kullanılacak materyaller, yani OpenGL kütüphanesi, CUDA mimarisi ve NVIDIA GeForce 9500 GT ekran kartı hakkında genel bilgiler verilmiştir. Ayrıca Visual Studio ortamında C++ dili ile OpenGL ve CUDA komutlarını içeren bir C++ projesinin adım adım nasıl oluşturulduğu anlatılmıştır OpenGL OpenGL (Open Graphics Library), iki ve üç boyutlu grafikleri ekrana çizdirmek amacıyla donanım özelliklerini kullanan ücretsiz bir grafik ara yüz oluşturma kütüphanesidir. İlk olarak 1992 yılında SGI firması tarafından etkili grafik görüntüleri elde etmek için oluşturulan OpenGL in gelişimi 2006 yılından sonra Khronos Group tarafından devam ettirilmektedir. Bu grafik ara yüzü, bu tezin yazıldığı tarih itibari 700 ün üzerinde fonksiyona sahip olan OpenGL 4.5 versiyonu ile kullanımdadır. Çoklu platform desteğinden dolayı Windows, Linux, MacOS gibi farklı platformlar üzerinde sorunsuz bir şekilde çalışmaktadır. OpenGL i diğer grafik ara yüz oluşturma kütüphanelerinden ayıran ve çoğunlukla tercih edilmesini sağlayan en önemli özeliği taşınabilir olmasıdır. Fakat her platformun kendine özgü pencere yönetimi ve dış birimlerden veri alma fonksiyonlarının farklı olması OpenGL in taşınabilirlik özelliğini kısıtlamaktadır. Ayrıca OpenGL ile karmaşık grafik nesneleri oluşturmak için gereken fonksiyonlar bulunmaması da programcılar tarafından hızlı program geliştirmeye engel oluşturmaktadır. Bu kısıtlamaları ortadan kaldırmak için OpenGL de bulunan fonksiyonlara ek olarak GLU ve GLUT adında kütüphaneler geliştirilerek kısıtlamalar ortadan kaldırılmıştır. Böylelikle OpenGL grafik ara yüzünün platform bağımlılığı tamamen giderilmiştir. OpenGL, üzerinde çok özellikli işlemlerin geliştirilebileceği gelişmiş bir kütüphanedir. GLU ise quadric yüzeyleri, NURBS (Non Uniform Rational B-Spline) eğrileri ve yüzeyleri gibi birçok ek özelliği sağlamaktadır. GLU, her OpenGL uygulamasının bir

23 10 gerçekleştirim standardıdır. Ayrıca OpenGL, üzerinde yüksek seviyeli ve nesne tabanlı çoğu uygulamayı destekleyebilecek araçları içermektedir (Neider et al. 1997). Şekil 3.1. OpenGL çalışma mimarisi Yazılım bazındaki OpenGL işlem mimarisi Şekil 3.1 deki yapıya sahiptir. Tipik bir program birçok çağrıda bulunur. Bunlardan bir kısmı programcı, bir kısmı işletim sistemi ve bir kısmı da programlama dilinin kendi kütüphaneleri tarafından sağlanır. Windows uygulamaları, çıktıları ekranda göstermek için Grafik Cihaz Ara Yüzü (GCA- İngilizce GDI) denilen bir Windows API kullanırlar. Bu GCA pencereye yazılar yazmak, çizgiler çizmek için kullanılır. Grafik kart üreticileri genellikle GCA nın çıktı üretmek için etkileştikleri bir grafik sürücüsünü de kart ile birlikte vermektedirler. Grafik tabanlı oyunlar oynanırken grafik kartlarında problem çıkmasının sebeplerinden birisi de GCA ile kullanılan sürücünün uyuşmamasıdır. OpenGL in yazılım tanımlaması grafik isteklerini bir uygulamadan alarak, 3 boyutlu grafiklerin renkli bir görüntüsünü oluşturur. Bu görüntünün oluşturulmasından sonra onu GCA ya geri vererek monitöre yansıtılmasını sağlar. Windows dışındaki işletim sistemlerinde de benzer durumlar söz konusudur ancak onlarda GCA nın yerini o işletim sistemine özgü grafik servisi almaktadır.

24 11 Şekil 3.2. OpenGL boru hattı (Chuan 2012) Bilgisayar terminolojisinde bir boru hattı, bir adımın diğer bir adımdan beslendiği bir dizi sıralı işlem anlamına gelmektedir. Boru hattı yüksek paralellik içeren sistemlerde kullanıldığı zaman önemli ölçüde performans artışı sağlamaktadır. Boru hatlı sistemlerde bir durumun çıkışı, sonrasında bulunan durum için bir giriş niteliğindedir. Şekil 3.2 de gösterilen OpenGL boru hattı veri olarak ilk etapta pozisyon değerlerini (x, y, z), renk değerlerini (red, green, blue), pozisyon öteleme değerlerini (n x, n y,n z ) ve doku değerlerini almaktadır. Bir ilkel nesne, bir veya birden fazla köşegen değerinden oluşmaktadır. Gelen değerler bir tarayıcı ile orta değer hesaplama yöntemi kullanılarak bir nokta kümesine dönüştürülmektedir. Bir 3 boyutlu boru hattı işlemi şu dört adımı içermektedir: 1-Vertex Processing: Her köşenin ayrı ayrı dönüşümü ve işlenmesidir. 2-Rasterization: Bütün ilkel nesnelerin bir görüntü dizisinin içine dönüştürülmesi işlemidir. (Görüntü dizisinde bulunan elemanlar 3 boyutlu alanda işlenebilmelidir.) 3-Fragment Processing: Her bir görüntü parçacığının bireysel olarak işlenmesidir. 4- Output Merging: Bütün ilkel nesnelerin görüntülenmesi için görüntü dizininde bulunan bütün elemanların birleştirilmesi işlemidir (Chuan 2012).

25 12 Şekil 3.3. İlkel nesneler (Chuan 2012) OpenGL grafik işleme boru hattının giriş değerleri üçgen, nokta ve dörtgen gibi bir veya birden fazla köşe değerinden oluşan ilkel geometrik şekillerdir. OpenGL; nokta, çizgi bölümleri ve kapalı çokgenlerden oluşan 3 çeşit geometrik nesneyi desteklemektedir. Her köşe değeri kendisinde bulunan pozisyon, renk ve doku değerleri ile ilişkilendirilir. Şekil 3.3 te gösterildiği gibi OpenGL 10 adet ilkel nesneyi desteklemekte ve bu şekillerin dışında kalan 3 boyutlu kutu, küre ve piramit benzeri şekiller OpenGL de tanımlı olan dörtgen ve üçgen gibi ilkel nesneler kullanılarak oluşturulmaktadır (Chuan 2012).

26 Visual studio 2010 kurulumu ve OpenGL adaptasyonu OpenGL bir programlama kütüphanesidir, bir programlama dili değildir. Bu yüzden OpenGL kullanılarak bir grafik programı geliştirilmek istenildiğinde bu kütüphanelerin çalıştırılacağı bir yazılım platformuna ihtiyaç duyulmaktadır. OpenGL platform bağımsızlığı özelliğinden dolayı Linux, Unix, Mac OS, OS/2, Windows, OPENStep ve BeOS işletim sistemlerinde çalışabilmektedir. Buna benzer olarak OpenGL in herhangi bir programlama dili bağlılığı yoktur ve C, C++, Ada, C# (SharpGL), Perl, Java, Fortran gibi birçok yazılım platformu üzerinde kullanılabilme özelliğine sahiptir. Bu tez kapsamında OpenGL in Microsoft Visual Studio 2010 platformu üzerinde C++ programlama dili ile birlikte kullanımı anlatılmaktadır. Yazılım geliştiriciler tarafından kullanılan Microsoft Visual Studio yazılım platformu ile Grafik, Web, Windows, Bulut ve SharePoint dâhil birçok platformda yüksek seviyeli uygulamalar geliştirilmekte ve Microsoft Visual Studio hata ayıklama sistemi sayesinde uygulamalar çalıştırılıp test edilebilmektedir. Visual Studio 2010 aşağıdaki işletim sistemleri üzerine kurulabilir; Windows 8 (x86 ve x64) Windows 7 (x86 ve x64) Service Pack 1 e sahip Windows Vista (x86 ve x64) Service Pack 3 e sahip Windows XP (x86) Service Pack 2 ye sahip Windows XP (x64) Service Pack 2 içeren Windows Server 2003 (x86 ve x64) Windows Server 2008 R2 (x64) Windows Server 2003 R2 (x86 ve x64) Service Pack 2 içeren Windows Server 2008 (x86 ve x64) Visual Studio 2010 tarafından desteklenen mimariler;

27 14 32-Bit (x86) mimarisi 64-Bit (x64) mimarisi Minimum donanım gereksinimleri: 1.6 GHz veya üstü hıza sahip işlemci barındıran bir bilgisayar 1024 MB RAM 3 GB sabit disk sürücü alanı 5400 RPM sabit disk sürücü 1280x1024 veya üzeri ekran çözünürlüğünde çalışan DirectX 9 özellikli video kartı Windows işletim sistemlerinde OpenGL standart kütüphaneleri bulunmamaktadır. OpenGL ile Visual Studio platformu üzerinde grafik programlarının hazırlanabilmesi için öncelikle işletim sistemi için gerekli olan dosyaların, ardından Visual Studio C++ derleyicisi ile ilişkili dll (Dinamik Bağlantı Kütüphanesi) ve kütüphane dosyalarının ilgili klasörlere kopyalanması gerekmektedir. Bu amaçla ilk olarak internet üzerinden bir çok sunucu üzerinde bulunabilecek glut bin.zip ve FreeGlut zip dosyalarının sıkıştırılmış halleri indirilmelidir. Gerekli dosyalar elde edildikten sonra sıkıştırılmış halden çıkarılmalıdırlar. Oluşan glut bin klasörünün içerinde bulunan glut32.dll dosyası ve FreeGlut klasörü içerisinde bulunan freeglut.dll dosyası, sistem dosyalarının da bulunduğu C:\WINDOWS\system32 klasörünün içine kopyalanmalıdır. İşletim sistemi için gereken dosya ayarlarından sonra kullanılan derleyici platformu tarafından OpenGL dosyalarının kullanılmasını sağlayacak ayarların yapılması gerekmektedir. Tez kapsamında Visual Studio 2010 platformu kullanılacağı için bu platforma yönelik ayarlamalar anlatılmaktadır. Visual Studio için yapılan ayarlamalar Java, Fortran gibi programlama dilleri için geçerli değildir.

28 15 Visual Studio 2010 tarafından OpenGL dosyalarının tanınabilmesi için glut.h ve freeglut.h dosyalarının da C:\ProgramFiles\Microsoft SDKs\Windows\v7.0A\include\gl klasörü altına kopyalanması gerekmektedir. OpenGL adaptasyonu için kullanılan glut.h ve freeglut.h dosyalarının Visual Studio nun başlık dosyalarının bulunduğu klasöre kopyalanmasının ardından.lib uzantılı freeglut.lib ve glut32.lib kütüphane dosyalarının C:\Program Files\Microsoft SDKs\Windows\v7.0A\Lib klasörü altına kopyalanması gerekmektedir. Dosya taşıma ve kopyalama işlemlerinin ardından derleyici üzerinde bazı ayarlamalar yapılmalıdır. Öncelikle Visual Studio platformu kullanılarak New Project Visual C++ Win32 Console Application adımları takip edilerek ve Şekil 3.4 te görülen ekrandan uygun seçenekler seçilerek Yeni_Proje adında bir C++ uygulaması oluşturulur. Şekil 3.4. Konsol uygulaması oluşturma Visual Studio platformu üzerinde bir konsol uygulaması geliştirildikten sonra Solution Explorer penceresinin altında bulunan Source Files klasörü fare ile sağ tıklanıp gelen menüden Add New Item yolu izlenerek.cpp uzantılı kod sayfası projeye eklenmelidir.

29 16 Ekleme işlemi tamamlandıktan sonra programda kullanılacak.dll uzantılı dosyalara bağlantı sağlanmalıdır. Bunun için Solution Explorer penceresinin altında bulunan projeye (Yeni_Proje) fare ile sağ tıklanarak açılan pencereden Properties (Özellikler) sekmesi seçilmelidir. Properties menüsü seçildikten sonra karşılaşılan ekrandan Configuration Properties Linker Input yolu takip edilerek Additional Dependencies sekmesi seçilmelidir. Seçilen ekrandan Şekil 3.5 te bulunan Edit menüsüne tıklanarak opengl32.lib, glu32.lib dosyaları eklenmelidir. Şekil 3.5. OpenGL.dll dosyalarının uygulamaya eklenmesi Kurulum için gereken adımlar doğru sırada yapıldıktan sonra proje kodlarının bulunduğu sayfaya #include <GL\gl.h> ve #include <GL\glut.h> başlık dosyaları eklenerek kodlamaya başlanılabilir. Oluşturulan projede OpenGL başlık dosyaları dışında başlık dosyaları kullanılacaksa sıralamaya dikkat edilmelidir. Projede #include<stdio.h> ve <stdlib.h> gibi kütüphane dosyalarının kullanılması durumunda #include <GL/glut.h> kütüphane dosyası bu iki dosyanın sonrasına eklenmelidir.

30 OpenGL komut prototipi OpenGL komut prototipinde bütün komutlar gl ön eki ile başlamaktadır. OpenGL de tanımlı olan sabit değişkenler GL ön eki ile başlar ve tamamıyla büyük harflerden oluşurlar (örneğin; GL_COLOR_BUFFER_BIT). OpenGL komutlarında gl ekinden sonra gelen ekler komutun yapacağı iş, alacağı parametre sayısı ve alacağı parametre tipi hakkında bilgi vermektedir. OpenGL de komutlar alacakları parametre sayısına ve parametre türüne göre farklılıklar göstermektedir. Şekil 3.6. OpenGL komut prototipi Şekil 3.6 da görüldüğü üzere glcolor3f() komutu Color kelimesinden de anlaşılacağı gibi o an oluşturulan şeklin rengini belirlemek için kullanılmakta ve büyük harfle başlamaktadır. OpenGL de bazı komutlar Çizelge 3.1 de belirtildiği gibi 8 farklı tipte parametre alabilmekte ve bu parametrelere göre de farklı komutlar oluşturulmaktadır.

31 18 Çizelge 3.1. OpenGL veri tipleri (Neider et al. 1997) Önek Veri Tipi C programlama dilinde OpenGL Tip Tanımı Kullanılan Tipler B 8-bit integer signed char GLbyte S 16-bit integer short GLshort İ 32-bit integer int veya long GLint, GLsizei F 32-bit floating-point float GLfloat, GLclampf D 64-bit floating point double GLdouble, GLclampf Ub 8-bit unsigned integer unsigned char GLubyte, GLboolean Us 16-bit unsigned integer unsigned short GLushort Ui 32-bit unsigned integer unsigned int veya unsigned long GLuint, GLenum, GLbitfield OpenGL hizmet aracı (OpenGL Utility ToolKit) OpenGL de yapılan grafik tabanlı programların sonucunda oluşturulan görüntüleri işleme görevini yine OpenGL in kendi içindeki fonksiyonlar yapmaktadır. Ayrıca bu işlemler, üzerinde çalışılan platformdan bağımsız olarak yapılmaktadır. (Her ne kadar OpenGL taşınabilir yani platformdan tam bağımsız olsa da her platformun kendine ait pencere oluşturma, fare kontrolü, klavye kontrolü ve kullanıcıdan değer alma kontrolleri farklıdır.) Farklı platformların kullanıcı etkileşimi için farklı komutları bulunduğundan dolayı OpenGL in taşınabilirlik özelliği bu noktada kısıtlanmıştır. Linux platformu üzerinde herhangi bir ek kütüphane kullanılmadan X-Window pencere sistemi kullanılarak OpenGL programlama yapılabilmektedir. Fakat yapılan program sadece X-Window üzerinde çalışabilir. X-Window kullanılarak oluşturulan program Windows işletim sistemi üzerinde çalışmamaktadır. Çünkü X-Window pencere oluşturma özelliği sadece Linux ta bulunmakta Windows işletim sistemi üzerinde bulunmamaktadır.

32 19 Bu kısıtlamalardan dolayı bütün platformlara uyumlu olarak oluşturulmuş olan Glut (OpenGL Araç Seti) kütüphanesi geliştirilmiştir. Glut kütüphanesi kullanılarak işletim sisteminden bağımsız kullanıcıdan giriş değerleri alınabilmekte, fare ve klavye kontrolleri yapılabilmektedir Pencere yönetimi Daha önceki aşamalarda da bahsedildiği gibi taşınabilirliği sağlamak için pencere işlemleri GLUT kütüphanesi tarafından yapılmaktadır. Yazılan bir programda pencere oluşturma, pozisyon belirleme ve görüntüleme modu gibi ayarlamalar yapmak için aşağıda belirtilen beş adet komutun gereken parametrelerle kullanılması gerekmektedir. glutinit(int *argc, char** argv) fonksiyonu GLUT ı ilklemekte ve komut satırı argümanlarını işlemektedir. GLUT kütüphanesi hazırlama işlemini yaptığından dolayı bu komut kullanılmadan diğer GLUT komutları çağırılmamalı ve diğer GLUT çağrılarından önce bu komut yazılmalıdır. glutinitdisplaymode(unsigned int mode) renk modunu belirlemektedir. Bu renk modu, RGBA veya color-index mod olabilir, ayrıca oluşturulan görüntü penceresinin tek veya çift buffer lı olacağını belirler. Eğer bir pencerenin RGBA(Renk Kodları Kırmızı, Yeşil, Mavi, Bölünme Değeri) ve double buffered modda olması istenirse, bu fonksiyon glutinitdisplaymode (GLUT_RGB GLUT_DOUBLE) şeklinde çağrılmalıdır. glutinitwindowposition(int x, int y) fonksiyonu grafik penceresinin sol-üst köşesini temel alarak, pencerenin ekrandaki yerini belirlemek için kullanılır. glutinitwindowsize(int width, int height) piksel değerlerini parametre alarak oluşturulacak grafik penceresinin büyüklüğünü belirlemek için kullanılmaktadır. int glutcreatewindow(char* string), OpenGL içeriğine sahip bir pencere oluşturma işlemini yapmaktadır. Yeni pencereye ait tek yani eşsiz bir değer döndürür. Ayrıca işlem

33 20 döngüsünü başlatmak için kullanılan glutmainloop() komutu çağrılmadan pencere oluşturma işlemi yapılmamaktadır. Pencere işlemlerinin oluşturulması ile ilgili örnek bir kod parçacığı Örnek 1 de gösterilmiştir. Örnek 1; int main(int argc, char **argv) { glutinit(&argc, argv); //Glut hazırlanmaktadır glutinitdisplaymode(glut_double GLUT_RGB GLUT_DEPTH); //Görüntü renk modu ayarlanır glutinitwindowsize(1400,800); //Oluşturulacak pencere boyutu pixel olarak verilir glutinitwindowposition(0,0); //Sol üst köşeden başlanarak pencere pozisyonu belirlenir glutcreatewindow("robot Uygulaması"); //Pencere isim verilerek oluşturulur } Görüntüyü geri çağırma (The Display Callback) OpenGL tabanlı programlarda hazırlanan görüntülerin sürekli yenilenmesi gerekmekte ve en son aşamada oluşan görüntünün pencereye yansıtılması gerekmektedir. OpenGL de görüntülerin tekrardan işlenip ekrana getirilmesini sağlayan çağırma işlemi glutdisplayfunc() komutu sayesinde yapılmaktadır. glutdisplayfunc(void (*func)(void)), OpenGL içinde bulunan en önemli geri çağırma fonksiyonudur. GLUT kütüphanesinin oluşturulan görüntü içeriğinin değiştirilmesine ihtiyaç duyduğu zamanlarda glutdisplayfunc(void (*func)(void)) komutu çağrılmalı ve çalıştırılmalıdır. Bu amaçla ekrandaki görüntü parçalarının hangilerinin yeniden

34 21 oluşturulup pencereye aktarılması isteniyorsa glutdisplayfunc tarafından çağrılan fonksiyon içerisinde bu tanım yapılmalıdır. Bazı durumlarda pencere içeriği değişebilmektedir. Oluşan bu değişikliklerin ekrana yansıtılabilmesi için glutmainloop() komutunun glutdisplayfunc fonksiyonunu tetiklemesi beklenmelidir (Shreiner et al. 2013). OpenGL kullanılarak temel ilkel nesnelerden biri olan üçgen çizimini ve glutdisplayfunc() kullanımını örneklendirmek için hazırlanmış olan bir uygulama kodu Örnek 2 de ve program çıktısı Şekil 3.7 de verilmiştir. Örnek 2; #include <GL\glut.h> void Goruntu_olustur() { glclear(gl_color_buffer_bit); glbegin(gl_polygon); glcolor3f(1.0,0.0,0.0); glvertex3f(-1,0,0); glcolor3f(0.0,1.0,0.0); glvertex3f(0,1,0); glcolor3f(0.0,0.0,1.0); glvertex3f(1,0,0); glend(); glflush(); } int main(int argc,char** argv) { glutinit(&argc,argv); glutinitdisplaymode(glut_single GLUT_RGB); glutinitwindowposition(80,80); glutinitwindowsize(400,400); glutcreatewindow("renkli Üçgen uygulamsı");

35 22 } glutdisplayfunc(goruntu_olustur);//tekrar oluşturulması istenilen fonksiyon çağırılması glutmainloop(); Şekil 3.7. Örnek 2 nin ekran çıktısı Dışarıdan veri girişini tutmak GLUT kütüphanesi, kullanıcı tarafından gerçekleştirilen olaylara bir dizi geri çağırma fonksiyonu aracılığı ile destek vermektedir. GLUT içerisinde window, menü ve global olmak üzere üç çeşit geri çağırma fonksiyonu bulunmaktadır. Geri çağırma fonksiyonları görüntünün tekrar oluşturulması, pencere boyutunun değiştirilmesi, pencerenin görünürlük oranının değiştirilmesi ve pencere yolu ile dışardan herhangi bir giriş talebi bulunduğu zaman tetiklenmektedir. Menü çağırma işlemi GLUT içinde tanımlı glutcreatemenu isimli çağırma fonksiyonu tarafından yapılmaktadır ve son olarak GLUT içinde bulunan global geri çağırma fonksiyonları ise oluşturulan menülerin ve işlem yaparken geçen zamanın yönetimini gerektiren durumlarda kullanılmaktadır. Bu üç tür geri çağırma fonksiyonu arasında herhangi bir öncelik tanımlı olmadığı için kullanım sıraları arasında bir fark bulunmamaktadır (Kilgard 1996).

36 23 Öte yandan herhangi bir olay meydana geldiği zaman bu olayların tanımlanması ve işlenmesi için gereken temel geri çağırma fonksiyonları bulunmaktadır. Bu geri çağırma fonksiyonları aşağıdaki gibidir. glutreshapefunc(void (*func)(int w, int h)) geri çağırma fonksiyonu aktif olan pencerede yeniden boyutlandırma işlemi olması durumunda tetiklenir ve çalıştıracağı fonksiyona pencerenin son boyutunun genişlik ve yükseklik değerleri gönderilerek ekran boyutunun tekrardan ayarlanması sağlanır. Program yazılırken glutreshapefunc() geri çağırma fonksiyonunun kullanılmaması veya NULL (Boş Değer) değer gönderilmesi durumda OpenGL de tanımlı bulunan işlemler uygulanır. glutkeyboardfunc(void (*func)(unsigned char key, int x, int y)) geri çağırma fonksiyonu aktif olan pencereden yapılan klavye girişleri sırasında çalıştırılacak fonksiyonları tetikleme görevini yapmaktadır. Program çalıştığı esnada klavyeden yapılan veri girişleri glutkeyboardfunc() fonksiyonu tarafından ASCII (Amerikan Standart Kodlama Sistemi) koda çevrilerek çalıştırılacak fonksiyona gönderilmektedir, aksi takdirde klavyeden hangi tuşa basıldığının anlaşılması mümkün olmamaktadır. Ayrıca glutkeyboardfunc fonksiyonuna çalıştırılacak metot ismi yanında gönderilen int x, int y değerleri fare imlecinin o anki pozisyon bilgilerini içermektedir. glutmousefunc(void (*func)(int button, int state, int x, int y)) geri çağırma fonksiyonu aktif olan pencere üzerinden fare tuşlarına basılması ve basılıp kaldırılması sırasında tetiklenmektedir. Bu fonksiyon, button parametresine atanan glut_left_button, glut_middle_button veya glut_right_button değerlerinden biri sayesinde farenin hangi tuşuna tıklandığını belirlemektedir. Çalıştırılacak fonksiyona gönderilecek değerlerden olan state Parametresi ile GLUT_UP veya GLUT_DOWN değerleri sayesinde fare tuşuna tıklandığı veya fare tuşundan tıklamanın kaldırıldığı anlaşılabilmektedir. Gönderilen parametrelerden olan x, y değeri ise aktif olan pencerede fare imlecinin o an bulunduğu pozisyon değerlerini belirtmektedir.

37 24 glutmotionfunc(void (*func)(int x, int y)) geri çağırma fonksiyonu, aktif olan pencerede fare butonlarına bir veya birden fazla sayıda basıldığı durumlarda farenin koordinatlarının yeniden hesaplanması için kullanılmaktadır. glutidlefunc(void (*func)(void)) geri çağırma fonksiyonu, aktif olan programda arka planda bir işlemin yapılmaması, dışardan bir değer alınmaması durumunda kendisine parametre olarak aktarılan fonksiyonu çalıştırmaktadır OpenGL ilkel geometrik nesneleri (OpenGL Primitives) OpenGL kullanılarak 2 ve 3 boyutlu karmaşık nesneler oluşturmak mümkündür. Oluşturulan 2 ve 3 boyutlu nesneler tek bir komut ile oluşturulamazlar, aksine bir ve birden fazla ilkel nesnein birleşiminden yeni şekiller oluşturulmaktadır. OpenGL temelde on adet ilkel nesneyi destekler ve diğer bütün nesneler on ilkel nesnenin bir arada kullanılmasıyla oluşturulur. OpenGL ile yüzlerce veya binlerce ilkel nesne kullanılarak oyun programları yazılabilmektedir. Önemli olan bu ilkel nesnelerin nasıl çalıştığını bilmektir. İlkel nesneler oluşturulurken kullanılan iki temel kod bloğu bulunmaktadır. Bunlardan birincisi void glbegin(glenum mode) fonksiyonudur. Bu fonksiyon ile OpenGL çizimi yapmak için hazır olunduğu söylenmekte ve GLenum Mode özelliği ile çizilmek istenilen şekil bildirilmektedir. OpenGL in çizmesi için talep edilecek temel ilkel nesneler şekil 3.3 te gösterilmiştir. İkinci kod bloğu ise void glend() prototipine sahip olan fonksiyondur. Bu fonksiyon OpenGL glbegin() bloğu tarafından talep edilen çizimin ve istenilen ilkel nesneye ait çizme işleminin bittiğini bildirir. Bu iki blok daima beraber kullanılmalıdır (Benstead et al. 2009). Ayrıca glbegin()/glend() bloğu içerisinde, başka bir glbegin()/glend() bloğu kulllanılamamaktadır. Tüm OpenGL fonksiyonları, bu bloğun içerisinde kullanılamayabilirler. Gerçekte, sadece glvertex(), glcolor(), glindex(), glnormal(),

38 25 gltextcoord(), glevalcoord(), glevalpoint(), glmaterial(), gledgeflag(), glcalllist() ve glcalllists() fonksiyonlarının çeşitli varyasyonları glbegin()/glend() bloğu içerisinde kullanılabilirler (Anonim 2014). OpenGL kullanılarak Örnek bir ilkel nesne çizimi aşağıdaki gibi yapılmaktadır. Örnek 3; #include <GL\glut.h> void Kare_olustur() { glclear(gl_color_buffer_bit); glbegin(gl_quads); glcolor3f(1.0,0.0,0.0); glvertex3f(-0.5,0.5,0); glcolor3f(1.0,0.0,0.0); glvertex3f(0.5,0.5,0); glcolor3f(0.0,0.0,1.0); glvertex3f(0.5,-0.5,0); glcolor3f(0.0,0.0,1.0); glvertex3f(-0.5,-0.5,0); glend(); glflush(); } int main(int argc,char** argv) { glutinit(&argc,argv); glutinitdisplaymode(glut_single GLUT_RGB); glutinitwindowposition(80,80); glutinitwindowsize(400,400); glutcreatewindow("örnek Kare oluşumu"); glutdisplayfunc(kare_olustur); glutmainloop(); } Yukarıdaki kod bloğunun ekran görüntüsü Şekil 3.8 de gösterilmiştir.

39 26 Şekil 3.8. Örnek 3 ün ekran görüntüsü Köşegenleri belirleme OpenGL ile çizilecek bütün geometrik ilkel nesneler belli bir sıraya sahip koordinat bilgilerini içeren vertex (Köşe) değerleri ile ifade edilmektedirler. Aktif olan pencerenin istenilen bölgesinde çizilecek bütün nesnelerin koordinat değerleri glvertex*() komutu ile verilmelidir. void glvertex[2, 3, 4][s, i, f, d][v](type coords); OpenGL de glvertex fonksiyonu kullanılacak koordinat sistemine ve program yapısına göre farklı sayıda parametre alabilmektedir. Bu fonksiyon, en fazla dört, en az iki parametre alabilir. Bilindiği gibi 3 boyutlu koordinat sistemleri sırasıyla x, y, z değerlerinden oluşmaktadır. Çizilecek nesnenin iki boyutlu olması isteniliyor ise x, y parametreleri yeterli olacaktır. OpenGL de koordinat noktalarına ek olarak dördüncü bir değer olan w parametresi vardır. Bu parametre x, y, z değerlerini istenilen değere bölme işleminden sorumludur. Anlaşılacağı gibi eğer bir koordinat sisteminde x, y, z ve w değerleri girilmiş ise OpenGL bu koordinat değerlerini x, y, z olarak değil de x/w, y/w, z/w olarak yorumlamaktadır. Bazı durumlarda iki boyutlu nesneler oluşturulmak

40 27 istendiğinde z değeri girilmemekte ve OpenGL bu değeri sıfır olarak kabul etmektedir. Benzer şekilde w değerinin girilmemesi durumda OpenGL bu değeri 1 olarak kabul etmektedir. glvertex2f(5.0, 2.5); glvertex3i (2, 4, 5); glvertex4d(6.2, 3.5, 2.7, 2.0); Yukarıda görüldüğü gibi ilk örnekte sadece iki parametreli float değerleri alabilen koordinat bilgileri, ikinci örnekte ise integer değerler alabilen koordinat sistemi kullanılmaktadır. İlk örnekte z değeri 0 ve w değeri ise 1 olarak kabul edilmektedir. İkinci örnekte x, y, z değerleri girilmekte w değeri 1 olarak kabul edilmektedir. Son olarak verilen örnekte x, y ve z değerlerine ek olarak w değeri de 2 olarak verilmiştir. Bu sebeple OpenGL verilen koordinat değerlerinin 2 ye bölünmüş halini kabul etmektedir. Sonuç olarak x değeri 3.1, y değeri 1.75 ve z değeri 1.35 şeklinde kabul edilip çizilmektedir. Bazı durumlarda çok sayıda koordinat değeri vermek gerekebilmekte, bu da hem zaman hem de performans açısından sıkıntılar doğurabilmektedir. GLfloat Kordinatlar[] = {6.2, 3.5, 2.7, 2.0}; glvertex3fv(kordinatlar); Bu durumda yukarıda gösterildiği gibi koordinat değerleri toplu bir şekilde bir dizi içine kaydedilmekte ve bu dizi ile işlemler daha efektif bir şekilde yapılabilmektedir Renklendirme OpenGL ile çizilen bir nesnenin şekli ve koordinatları nesnenin renginden tamamen bağımsızdır. OpenGL de çizilen nesneler o an hafızada aktif olan rengi almaktadırlar.

41 28 Bu nedenle OpenGL ile nesneler çizildiğinde öncelikle nesneye uygulanacak renk veya renk şeması belirlenmeli ardından nesne çizimi ve koordinat ayarlamaları yapılmalıdır. O anki renk şeması değiştirilinceye kadar çizilecek bütün nesnelerin aynı renk koduna tabi tutulacağı unutulmamalıdır. Bir nesneye renk kodu verilmek istenildiğinde 0 ile 1 arasında değerler alan glcolor3f() komutunun kullanılması esneklik sağlamaktadır. Bu komut sırasıyla red, green, blue olmak üzere üç parametre almaktadır. Bu parametrelerin alacağı değerler kullanılarak farklı renkler elde edilmektedir. Kullanılan üç parametreden herhangi birinin 0 olarak girilmesi o renkten hiç kullanılmayacağı, 1 girilmesi ise en yoğun şekilde kullanılacağı anlamına gelmektedir. Örneğin; glcolor3f(1.0,0.0,0.0); fonksiyonu sadece kırmızı rengin en yoğun halinin kullanılacağı yeşil ve mavi renklerin hiç kullanılmayacağı anlamına gelmektedir. Renk parametrelerinin üçünün birden 0 değerini alması ekranda siyah rengin oluşacağı, 1 değerini alması ise ekranda beyaz rengin oluşacağı anlamına gelir. Temel bazı renklerin kullanımı aşağıda gösterilmiştir (Neider et al. 1997). glcolor3f(0.0, 0.0, 0.0); glcolor3f(1.0, 0.0, 0.0); glcolor3f(0.0, 1.0, 0.0); glcolor3f(1.0, 1.0, 0.0); glcolor3f(0.0, 0.0, 1.0); glcolor3f(1.0, 0.0, 1.0); glcolor3f(0.0, 1.0, 1.0); glcolor3f(1.0, 1.0, 1.0); siyah kırmızı yeşil sarı mavi magenta çiyan beyaz

42 Koordinat çevrimleri Koordinat çevrimleri üç boyutlu bir ortamda varlıkları gerçekleştirme, döndürme ve hareket ettirme gibi olanaklar sağlar. Bu çevrimler, nesneleri ve nesnelerin koordinat sitemlerini doğrudan değiştirir. Nesneler çizilmeden önce üç tip dönüşümden geçmektedir. Bunlar; Viewing transformation: Kameranın yerinin belirlendiği dönüşüm türüdür. Modeling transformation: Nesnenin ekranda hareketini sağlayan dönüşüm işlemidir. Projection transformation: Kameranın bakış hacmini belirleyen dönüşüm işlemidir. Viewing transformation, yazılan kod içerisinde modeling transformation dan önce gelmelidir fakat çizim yapmadan önce projection ve viewport transformationları yani dönüşümleri belirlenebilir. Şekil 3.9 da dönüşüm işlemleri sıralı halde gösterilmektedir.

43 30 Nesne Koordinatları (x, y, z, w) Vertex Modelview Matrisi Göz Koordinatları Projeksiyon Matrisi Kesme Koordinatları Perspektif Bölümü Normalleştirilmiş Araç Koordinatları Perspektif Bölümü Pencere Koordinatları Viewport Dönüşümü Şekil 3.9. OpenGL koordinat dönüşüm sırası (Anonim 2014) Viewing, modeling ve projection dönüşümlerini belirlemek için, 4X4 lük bir M matris tanımlaması yapılmakta ve tanımlanan matris değerleri istenilen dönüşümleri gerçekleştirebilmek için ekrandaki her bir v köşe koordinatlarıyla çarpılmaktadır. Viewing ve modeling dönüşümleri otomatik olarak yüzey normal vektörlerine ve ek olarak vertex lere uygulanmaktadır. Normal vektörler ise sadece göz koordinatlarında kullanılmaktadır. Bu, normal vektörün vertex verisi ile olan ilişkisini uygun bir şekilde sağladığını temin etmektedir. Belirtilen viewing ve modelling dönüşümleri, modelview matrisini oluşturmak için bir araya getirilirler. Göz koordinatlarını vermek için, gelen nesnenin koordinat bilgilerine, bu matris uygulanmaktadır. Eğer nesnenin ekranda gözükmeyen kısımlarını silmek gerekiyorsa, kesme yüzeyleri uygulanır. Bundan sonra OpenGL, projection matrisini kesme koordinatlarını verebilmek için uygulayacaktır. Bu

44 31 sayede kameranın nesneyi gösteremediği kısımlar kesilecektir, yani gözükmeyecektir. Bu noktadan sonra perspektif bölümü, normalleşmiş araç koordinatlarını üretebilmek için koordinat değerlerini w ile böler. Son olarak ise, viewport dönüşümü uygulanarak, dönüştürülmüş koordinatlar pencere koordinatlarına çevrilir. Böylece viewport boyutları üzerinde resim ile oynamak için çeşitli işlemler uygulamak mümkün olur (Anonim 2014) Görüntü dönüşümleri (Viewing Transformation) Viewing Transformation görüntünün pozisyonunu ve yönünü değiştirmektedir. Bu dönüştürme işleminde kamera ayakları gösterilecek noktaya odaklanır. Bu durum kameranın istenilen noktaya gelene kadar ötelenmesi ve döndürülmesi işlemi ile aynıdır. Viewing Transformation temel olarak öteleme ve döndürme işlemlerinden oluşmaktadır. Son aşamada istenilen fotoğraf veya görüntünün elde edinilmesi isteniyorsa ya kameranın ya da sahnede bulunan bütün nesnelerin tersi istikamette hareket ettirilmesi gerekmektedir. Modelling Transformasyonlarının aksine bu dönüştürme yönteminde saat yönünde bir yönlendirme olmaktadır. Bu yüzden Modelling Transformasyon işlemlerinin nesne üzerinde daha etkili olabilmesi için Viewing Transformation komutları, Modeling Transformation komutlarından önce gelmek zorundadır. OpenGL ile programlama yapılırken birkaç yöntem kullanılarak dönüştürme işlemi yapılabilir. Dönüştürme işlemi yapılmak istenmediği taktirde OpenGL tarafından tanımlı olan merkez noktasını baz alan dönüştürme işlemleri kullanılmaktadır. OpenGL ile programlamada gltranslate*() ve glrotate*() gibi bir veya birden fazla dönüştürme komutu kullanılarak gerek kameranın pozisyonunu gerekse gerçek dünyadaki nesnelerin konumunun değişimi sonucunda oluşacak etkiler görülebilmektedir. GLU kütüphanesi altında tanımlı olan glulookat() komutu kullanılarak gözün bakış açısı belirlenebilmektedir. Bu komut gözün görüş ayarlarını yapabilmek için kendi içinde dönüşüm ve öteleme fonksiyonları barındırmaktadır (Neider et al. 1997).

45 32 Modeling transformation komutları kullanılarak görüntü dönüşümleri yapılmaya çalışıldığında, gerçek dünyada olduğu gibi eğer nesnenin konumu değişmeyecekse sabit duran nesnelere karşı bakış açısının değiştirilmesi gerekmektedir. Çünkü bakılmakta olan nesne, hali hazırda zaten kolaylıkla oluşturulmuş ve görüntü alanının tam merkezinde yerleştirilmiştir. Bu durumda nesnenin istenildiği gibi görünebilmesi için birkaç dönüşüm işleminden geçirilmesi gerekmektedir. Şekil 3.10 da görüldüğü gibi nesne ve bakış açısı merkez olarak tanımlanmıştır. En basit haliyle, bakış açısını nesneden uzaklaştırmak için geri yönde taşıma yapmak mümkündür. Bu olay nesneyi ileriye doğru taşımakla aynı etkiyi göstermektedir. Unutulmaması gereken bir detay da OpenGL tarafından başlangıç olarak tanımlı olan ilerletme yönünün z yönü olduğudur. Fakat görüş açısını döndürmek ile ilerletmek yani ileriye taşımak ayrı anlamlar taşımaktadır. gltranslatef(0.0, 0.0, -5.0); Yukarıda verilen komut ile nesne Şekil 3.10 da görüldüğü gibi z yönünde 5 birim taşınacaktır. Bu işlem kameranın z yönünde 5 birim taşınması ile aynı anlama gelmektedir. Şekil Görüntü dönüşümü (Neider et al. 1997)

46 33 OpenGL kullanılarak oluşturulan nesnelerin x, y, z yönlerine doğru taşıma işlemleri yapıldıktan sonra bu nesnelerin farklı yüzeylerinin de gösterilmesi gerekmektedir. Normal şartlar altında öncelikle nesnenin döndürme işlemine tabi tutulması ve ardından arzu edilen bölgeye taşınması gerekmektedir. Fakat bilindiği gibi sabit koordinatlı sistem yaklaşımlarında, görüntüden istenilen etkinin alınabilmesi için komutların tersi sırada yazılması gerekmektedir. Yani taşıma ve döndürme işlemleri bir arada kullanılacaksa öncellikle taşıma kodunun ardından döndürme kodunun yazılması gerekmektedir. gltranslatef(0.0, 0.0, -5.0); glrotatef(90.0, 0.0, 1.0, 0.0); Yukarıdaki kod bloğunda görüldüğü gibi, oluşturulan nesne öncelikle z yönünde 5 birim taşınmakta ve ardından z yönünde 90 derecelik açı ile döndürülmektedir (Neider et al. 1997) Model dönüşümleri Model transformasyon işlemi gltranslate*(), glrotate*() ve glscale*() komutlarını kullanarak dönüştürme işlemlerini yapmaktadır. Bu komutlar sayesinde nesne üzerinde taşıma, germe, çekme, hareket ve yansıtma işlemleri gerçekleştirilmektedir. Bu komutların hepsi döndürme, germe, matris ölçeklendirme ve sahip oldukları parametreleri kullanarak glmultmatrix*() fonksiyonu çağırma işlemlerinde birbirlerine benzerdirler. Fakat OpenGL, programcılar için matris çarpım işlemini kendisi otomatik olarak yaptığı için gltranslate*(), glrotate*() ve glscale*() fonksiyonları daha hızlı işlem yapabilmektedir. Yapılacak herhangi bir dönüşüm işlemini başlatmadan önce hangi matris modu üzerinde değişiklikler yapılacağı önceden belirtilmelidir. Yapılacak işlemler modelview modu üzerinde ise parametre olarak GL_MODELVIEW parametresi aktarılmalıdır.

47 34 glmatrixmode() fonksiyonunun desteklemiş olduğu diğer dönüşüm modları için GL_PROJECTION veya GL_TEXTURE parametreleri kullanılmaktadır. Üç boyutlu pencere nesnelerinin bir noktadan başka bir noktaya taşınabilmesi için gltranslate*() komutu x, y, z eksenlerinden oluşan parametrelerini kullanarak taşıma işlemini gerçekleştirmektedir. void gltranslate{fd}(typex, TYPE y, TYPEz); Float veya double olarak alınan eksen değerleri var olan koordinat matris değerleri ile çarpılarak nesnenin yeni konumu Şekil 3.11 de gösterilmektedir. Şekil Görüntü taşıma işlemi (Neider et al. 1997) OpenGL de döndürme işlemleri glrotate() fonksiyonu kullanılarak yapılmaktadır. Bu fonksiyon kullanılarak yapılan döndürme işlemi sonucunda nesnenin saatin tersi yönünde dönüş yapması sağlanmaktadır. void glrotate{fd}(type angle, TYPE x, TYPE y, TYPE z);

48 35 float ve double değerler alabilen bu fonksiyonun TYPE parametresi sayesinde nesnenin kaç derece döndürüleceği belirlenmektedir. Ayrıca x, y, z eksen parametreleri ile nesnenin hangi eksen etrafında döndürüleceğine karar verilmektedir. Şekil 3.12 de görüldüğü gibi glrotatef(45.0, 0.0, 0.0, 1.0) komutunun almış olduğu parametreler doğrultusunda var olan nesnenin z ekseni yönünde 45 derecelik bir açı ile döndürülmesi sağlanmıştır (Neider et al. 1997). Şekil Görüntü döndürme (Neider et al. 1997) Üç boyutlu modellemelerde bazı durumlarda oluşturulan nesnenin büyütülmesi, küçültülmesi ve gerginleştirilmesi gibi işlemlerin yapılması gerekmektedir. İşte bu durumlarda oluşturulan modele, bahsedilen işlemlerin yapılabilmesi için OpenGL de bulunan glscale*() komutu kullanılmaktadır. void glscale{fd}(typex, TYPE y, TYPEz); Komutun almış olduğu x, y ve z parametrelerine aktarılan değerler var olan görüntü matrisi ile çarpılmakta ve nesnenin son boyut değerleri hesaplanarak ekranda gösterilmektedir.

49 36 Şekil Görüntünün ölçeklendirilmesi (Neider et al. 1997) Şekil 3.13 te glscalef(2.0, -0.5, 1.0) değerlerinin nesneye uygulanması sonucu nesne 2 birim x yönünde genişletilmekte, nesnenin y ekseni tersine çevrilerek yarı boyutunda daraltılmakta ve z eksenindeki boyutu 1 ile çarpılarak bir değişiklik yapılmamaktadır (Neider et al. 1997) Matris yığınları OpenGL programlama yapılırken oluşturulan modelview ve projection matrisleri buzdağının sadece görünen tarafıdır. İşlem yapılan bu matrisler Şekil 3.14 te görüldüğü gibi gerçekte var olan matris yığınının en üstünde bulunan matrislerdir. Şekil Matris yığın yapısı (Shreiner 2010)

50 37 Hiyerarşik bir model oluşturmak için matris yığınları çok kullanışlıdırlar. Bu matris yığınları içerisinde karmaşık nesneler basit nesneler yardımıyla oluşturulmaktadırlar. OpenGL programlama teknikleri kullanılarak Örnek 4 te programlandığı gibi 3 boyutlu bir araba tasarımı yapılmak istenildiğinde model arabanın parçalarının oluşturulması ve sonrasında birleştirilmesi gerekmektedir. Bu durumda arabanın temel olarak gövdesinin ve 4 tekerlekten her birinin vidalama işleminin yapılması gerekmektedir. Daha önce de söylendiği gibi yığın mantığı kullanılmadan yapılan projeler sadece matris yığınının en üstündeki matris üzerinden işlemler yapmaktadır. Araba modelinde matris yığınının kullanılması durumunda her tekerlek ve her vidalama işlemi için ayrı öteleme ve döndürme kodlarının yazılması gerekmektedir. Bu tür işlemlerde OpenGL tarafından matris yığını işlemleri yapan glpushmatrix() ve glpopmatrix() komutları geliştirilmiştir. Burada tekerlekleri takma ve vidaları monte etme işlemleri için sadece birer fonksiyon oluşturulması gerekmektedir. Her bölgenin tekerleği takılmadan önce o anki matris değeri glpushmatrix() komutu ile matris yığınına atılmakta ve işlemler bittikten sonra glpopmatrix() kodu ile başlangıç durumuna gelmektedir. Böylelikle sadece 2 adet fonksiyon hazırlanarak sadece taşıma ve döndürme işlemleri kullanılarak araba modelleme işlemi gerçekleştirilmektedir. Şekil Matris yığınına ekleme ve çıkarma işlemi (Shreiner 2010) Matris yığınında bulunan bütün bilgilerin bir seviye aşağı itilmesi işlemini ve gönderilen matris değerlerini yığının en üst kısmına koyma işlemini Şekil 3.15 te gösterildiği gibi glpushmatrix() komutu yapmaktadır. O an matris yığınına atılacak değerler glmatrixmode() fonksiyonu tarafından belirlenmektedir. Program içerisinde matris

51 38 yığınının kullanımına dikkat edilmelidir, aksi takdirde çok fazla matris değerinin yığına yüklenmesi durumunda hatalar ortaya çıkmaktadır. void glpushmatrix(void); fonksiyonu matris yığınının en üst seviyesinde bulunan matris değerlerini yığından çıkartma işlemini yapmakta ve yığına ikinci sırada bulunan matris değerlerini aktif matris değerleri olarak ayarlamaktadır. Matris yığınında sadece bir adet matris değerinin bulunması durumunda, glpopmatrix() komutunun kullanılmasıyla bütün matris değerlerinin silinmesi söz konusu olacağı için hata ile karşılaşılması mümkündür. Yığına matris değerlerinin yüklenmesi ve çıkarılması için yazılmış örnek bir kod parçacığı aşağıdaki gibidir (Anonim 2014). Örnek 4; tekerlek_vida_ciz() { int i; tekerlek_ciz(); for(i=0;i<5;i++) { glpushmatrix(); glrotatef(72*i,0.0,0.0,1.0); gltranslatef(3.0,0.0,0.0); vida_ciz(); } } govde_tekerlek_vida_ciz() { govde_ciz(); glpushmatrix() gltranslatef(40,0,30);

52 39 tekerlek_vida_ciz(); glpopmatrix(); glpushmatrix(); gltranslatef(40,0,30); tekerlek_vida_ciz(); glpopmatrix(); } Doku haritalama Tek boyutlu veya çok boyutlu uygulamalarda doku haritalama işlemi, oluşturulan nesnelerin daha gerçekçi görünebilmesi için çok önemlidir. Günümüzde geliştirilen oyun uygulamaları incelendiğinde doku haritalama özelliğinden yoğun bir şekilde faydalanıldığı görülmektedir. OpenGL programlama kütüphaneleri tek boyutlu, iki boyutlu ve üç boyutlu doku haritalamaya destek vermektedir. Doku haritalamayı en temel ifade ile var olan nesnelerin istenilen resimler ile kaplanması olarak tanımlamak mümkündür. Doku haritalamada işlemler kare dizilerinden oluşmakta ve bu dizilerde bulunan her bir veriye texel denilmektedir. Her ne kadar kare bazlı işlemler yapılsa da, doku haritalama işlemi oval nesneler üzerinde de uygulanmaktadır İki boyutlu doku haritalama İki boyutlu bir resmin bir nesne üzerinde haritalanması istenildiğinde öncelikle bu resmin hafızaya yüklenmesi gerekmekte ardından bu resmin bir doku haritalama işlemi için kullanılacağı belirtilmelidir. OpenGL deki diğer komutlarda olduğu gibi doku haritalama işleminde de komutlar yapacağı işlemlere göre biçimlendirilmektedir. İki boyutlu bir doku haritalama işlemi yapılacaksa glteximage2d() fonksiyonu kullanılmakta, tek boyutlu bir doku haritalama işlemi yapılacaksa glteximage1d() komutu kullanılmakta ve 3 boyutlu bir doku haritalama işlemi yapılacaksa glteximage3d() haritalama komutunun kullanılması gerekmektedir.

53 40 void glteximage2d(glenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid * data); Yukarıda formatı verilen iki boyutlu doku haritalama fonksiyonuna aktarılan parametrelerin kullanım amacı şöyledir; Target: Aktif doku ünitesindeki hedef dokuyu belirtir. Bu parametre GL_TEXTURE_2D,GL_TEXTURE_CUBE_MAP_POSITIVE_X,GL_TEXTURE_CU BE_MAP_NEGATIVE_X,GL_TEXTURE_CUBE_MAP_POSITIVE_Y,GL_TEXTUR E_CUBE_MAP_NEGATIVE_Y,GL_TEXTURE_CUBE_MAP_POSITIVE_Z veya GL_TEXTURE_CUBE_MAP_NEGATIVE_Z değerlerinden birini almak zorundadır. Level: Yapılacak doku haritalamasının çözünürlüğünü belirlemek için kullanılır. Level değişkeninin 0 değerini alması temel çözünürlük işleminin uygulanacağı anlamına gelir. Internal format: Oluşturulan dokunun iç formatını belirlemek için kullanılmaktadır. Bu Parametrenin değeri olarak GL_ALPHA, GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB, GL_RGBA sabitlerinden biri kullanılmaktadır. Width: Oluşturulan dokunun genişliğini belirtmek için kullanılmaktadır. Bu değerler 2 nin üstleri şeklinde olmalıdır. Height: Oluşturulan dokunun yüksekliğini belirtmek için kullanılmaktadır. Border: Oluşturulan doku çerçevesinin bir sınırının olup olmadığını belirler. Bu parametrenin 0 değerini alması bir sınır olmadığını, 1 değerini alması ise bir sınırın olduğunu göstermektedir. Format: Oluşturulan texel verilerinin formatını belirtmektedir. Bu format internal format parametresine uygun olmak zorundadır. OpenGL tarafından GL_ALPHA, GL_RGB,

54 41 GL_RGBA, GL_LUMINANCE ve GL_LUMINANCE_ALPHA değerleri kabul edilmektedir. Type: Oluşturulan dokuda verinin tipini belirlemek için kullanılmaktadır. OpenGL tarafından GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_4_4 _4_4 ve GL_UNSIGNED_SHORT_5_5_5_1 değerleri kabul edilmektedir. Data: Kullanılmak için hafızaya yüklenen resmin hafızadaki adresini tutan bir işaretçidir. glteximage2d(gl_texture_2d, 0, GL_RGBA, DokuGenişliği, DokuYüksekliği, 0, GL_RGBA, GL_UNSIGNED_BYTE, DokuResmi); Doku haritalama nesneleri Grafik tabanlı programlarda doku haritalama işlemleri yapılırken birden fazla doku kullanılması gerekebilir. Örneğin bir oyun programı yapılırken farklı nesnelerin farklı karakterleri yansıtabilmeleri için değişik resimler kullanılarak doku haritalama işleminden geçirilmektedir. OpenGL de birden fazla dokuyu hafızaya kaydetmek ve istenildiği zaman bu doku nesnelerine referans vererek kullanabilmek mümkündür. Birden fazla resmi hafızada tutup sırası geldiğinde kullanıma sunmak için OpenGL de glgentextures() komutu kullanılmaktadır. Bu komut sıfırdan ve birbirinden farklı işaretsiz rakamlar kullanarak doku nesneleri oluşturmaktadır. void glgentextures(glsize n, GLuint *texturenames); Yukarıdaki kullanım şekline sahip glgentextures() komutuna parametre olarak aktarılan n değeri kaç tane doku nesnesinin oluşturulacağını göstermektedir. Ayrıca

55 42 oluşturulan doku nesnelerinin bir dizi içerisinde tutulması ve bu dizinin index değerleri kullanılarak çağrılması amacıyla *texturenames parametresi kullanılmaktadır. unsigned int DokuAdi[3]; glgentextures(3, DokuAdi); Doku isimlerinin oluşturulması yukarıda gösterildiği gibi yapıldıktan sonra bu isimlerin doku verilerine uygulanması gerekmektedir. Doku verilerinin bağlanması veya uygulanması işlemini yapabilmek için glbindtexture() komutu kullanılmaktadır. void glbindtexture(glenum target, GLuint texturename); Bu fonksiyon tanımlandıktan sonra yeni bir doku nesnesi varsayılan değerlere sahip olacak şekilde OpenGL tarafından oluşturulmaktadır. Burada kullanılan target nesnesi ile doku haritalama işleminin kaç boyutta yapılacağına karar verilmektedir. Bu parametreye GL_TEXTURE_1D, GL_TEXTURE_2D veya GL_TEXTURE_3D değerleri verilebilmektedir. Bu komut sayesinde daha önceden oluşturulan doku nesnelerinin belirli isimlere bağlanması sağlanmaktadır. Ayrıca glbindtexture() komutu kullanılarak o an aktif olan doku nesnesinin belirleme işlemi yapılmaktadır. unsigned int DokuAdi [3]; glgentextures(3, DokuAdi); glbindtexture(gl_texture_2d, DokuAdi [1]); 3.2. CUDA Yüksek performanslı sistemler doğalarında paralellik barındırır. Tek işlemcili bir sistemden yüksek performans elde etmek hem fiziksel ve hem de ekonomik nedenlerden dolayı zordur. Bunun yerine ortak bellekli veya dağıtık bellekli sistemler olarak ifade edilen paralel sistemlerin kullanılması çözüm olabilir. Ortak bellekli paralel sistemlerin

56 43 programlanması kolay, ancak üretilmesi zor ve bu nedenle pahalıdır. Dağıtık bellekli sistemlerin ise programlanması zor, piyasadan kolaylıkla temin edilebilen bilgisayarların hızlı bir ağ ile haberleştirilmesi sonucu elde edildikleri için kurulumları kolaydır. Dağıtık sistemlerde mevcut sistem kaynakları kullanılabildiğinden maliyeti de azdır. Amaç yüksek performans elde etmek olduğundan, pahalı kaynakların en verimli şekilde kullanılmasına dikkat edilmelidir (Akçay vd 2011). Yüksek performanslı sistemlerin ihtiyaç duyulduğu birçok alan vardır. Bunlar; karmaşık ve büyük zaman alan sayısal hesaplamalar, farklı uygulamalar için simülasyonlar, deney sonuçlarının görüntülenmesi, hesaplamaların hata oranlarının tespitidir. Özellikle mühendislik uygulamalarında, tasarım sürecindeki prototip gerçekleme ve test evresi ortadan kaldırılarak simülasyon yoluyla üretilen ürünler test edilmektedir. Bu da zaman ve maliyet açısından önemli katkı sağlamaktadır. Örneğin artık araba firmaları üreteceği arabaların modellerini bilgisayar ortamında simule etmekte ve sonuçlarını (örneğin çarpışma hasar deneyleri) değerlendirip, üreteceği modelin kısa zamanda revizyonlarını yaparak, üretim sürecine geçmektedir (Akçay vd 2011). Özellikle son yıllarda, bilgisayar oyunlarının ve grafik tasarım programlarının gelişmesi, Grafik İşlem Birimi (GİB) adı verilen ve grafik kartlarının yerel merkezi işlem birimleri olarak nitelendirebileceğimiz bileşenlerin oldukça yüksek bir ivmeyle evrimleşmesine neden olmuştur. Zaman içerisinde GİB ler, yüksek işlem kapasitesine sahip, muazzam derecede paralel, aynı anda birden fazla iplik işleyebilen, çok çekirdekli bir işlemciye dönüşmüştür (Çolak 2010). CUDA (Compute Unified Device Architecture), yoğun grafik işlemlerinde ve büyük çaplı matematiksel işlemler barındıran uygulamalarda genel amaçlı paralel işlemler yapmaya uygun olarak Nvidia firması tarafından sunulmuş bir paralel hesaplama mimarisidir. NVIDIA firması tarafından 2006 yılının son dönemlerinde geliştirilen CUDA mimarisi sayesinde ekran kartlarının donanım yapısının ayrıntılı bilinmesine gerek kalmadan paralel programlama imkânı sağlanmıştır. Genel amaçlı ekran kartları üzerindeki basit işlemcileri kontrol edebilmek amacıyla CUDA kütüphaneleri

57 44 geliştirilmiş ve bu kütüphanelerin C, Fortran ve OpenCL (Açık Hesaplama Dili) gibi programlama dillerini desteklemesi sağlanmıştır. CUDA, temel olarak grafik kartlarının merkezi işlemciye ek olarak hesaplama işlemlerinin büyük bir kısmını yüklenmesi için geliştirilmiştir. CUDA teknolojisi ilk olarak GeForce 8 serisi üzerinde kullanılmış olup devamında Quadro ve Tesla ekran kartı serilerinde geliştirilerek piyasaya sunulmuştur. Tez kapsamında kullanılan ekran kartı Şekil 3.16 da gösterilmiştir. Şekil GeForce GT 9500 ekran kartı Cuda sistem modeli CUDA mimarisinden önce üretilen ekran kartları genellikle grafik uygulamalarını çalıştırmak amacıyla geliştirilmekteydi. Fakat 2006 yılının son dönemlerinde NVIDIA firması tarafından sunulan mimariden başlamak üzere sonrasında üretilen ekran kartları

58 45 büyük çapta programlanabilmekte ve genel amaçlı birçok problemin çözümünde etkili bir şekilde kullanılmaktadır. Şekil CUDA mimarisi (Inam 2009) NVIDIA ekran kartları Şekil 3.17 de gösterildiği gibi aynı anda bir komut çekirdeğini çok sayıda küçük işlemcilerde çalıştırabilecek çoklu işlemcilerin bulunduğu bir mimari yapıya sahip olacak şekilde tasarlanmışlardır Cuda programlama modeli CUDA mimarisi, yazılımcıların basit bir şekilde programlama yapabilmelerini sağlamak için C programlama dilinin ek fonksiyonlarla genişletilmiş şekli olan CUDA C dilini

59 46 kullanmaktadır. Ayrıca CUDA tarafından desteklen diğer yazılım platformları Şekil 3.18 te gösterilmiştir. Şekil CUDA destekli yazılım platformları (Nvidia 2007) CUDA öncesinde, programcıların ekran kartları üzerinde bulunan küçük işlemcileri genel amaçlı işlemlerde kullanabilmeleri için ekran kartının donanım yapısına hâkim olmaları gerekmekteydi. CUDA tasarım yapısında programcıların ayrıntılı donanım yapısını bilmeleri gerekmemektedir. CUDA C ile birlikte sunulan bazı fonksiyon ve kısıtlamaların bilinmesi ile bir iş birimini binlerce işlem kanalı üzerinde çalıştırma imkânı sunulmuştur Heterojen programlama CUDA programlama modeli, GPU üzerindeki işlem birimlerini merkezi işlem birimine yardımcı bir işlemci olarak tanımlamaktadır. Merkezi işlem birimleri genel olarak bir veya iki tane işlemi ardı ardına işleme ile görevlendirilmiş ve hafıza alanlarına ulaşımda oluşabilecek gecikmeleri önlemek için optimize edilmiştir. GPU lar ise çoklu işlemleri ardı ardına yapmak ve yüksek çalışma performansları elde etmek amacıyla tasarlanmış

60 47 olup hafızaya ulaşım sırasında oluşabilecek gecikmeleri engelleyen çok kanallı çalışma yapısına sahiptirler. Bir yazılım uygulaması çalıştırılırken sadece belli bir kısmı paralel çalıştırmaya uygun olmaktadır. Bu durumda Şekil 3.19 da görüldüğü gibi programın seri kısımları merkezi işlem birimi (Host) üzerinde, paralel kısımları ise GPU (Device) üzerinde çalıştırılır (Balfour 2011). Şekil Heterojen programlama yapısı (Balfour 2011) Çekirdek fonksiyonlar CUDA C yapısı standart C programlama dilini genişleterek programcılara kernel denilen C fonksiyonlarını tanımlama imkânı sağlamaktadır. Yazılan kernel fonksiyonları standart C fonksiyonlarından farklı olarak N defa çalıştırıldıklarında N farklı kanalda paralel olarak koşturulmaktadırlar. CUDA C ile kernel fonksiyonları global ifadesi ile tanımlanmaktadırlar. Tanımlanan kernel fonksiyonunun çalışacağı kanal sayısı <<< >>> ifadesi kullanılarak belirtilmektedir. Her kanal kendisine verilen threadidx diye isimlendirilen benzersiz bir numara kullanılarak çağrılır ve çalıştırılacak görevler atanır.

61 48 Şekil Çekirdek fonksiyon yapısı (Nvidia 2007) Şekil 3.20 de gösterildiği gibi N kanal boyunca iki sayının toplanıp bir sayıya atanma işlemi VecAdd() kernel fonksiyonu tarafından yapılmaktadır (Nvidia 2014) Kanal hiyerarşisi Kanalların ID (Benzersiz Değer) değerlerine ulaşmasını sağlayan threadidx değişkeni 3 bileşenli bir elemandır. Bu yapısı ile vektör, matris veya 3D data kümeleri üzerinde işlemlerin kolayca yapılmasını sağlar. Kanal indeks değeri ve kanal ID değerleri arasındaki ilişki, veri bloğunun boyutlarına göre değişir. Tek boyutlu bir veri bloğu için kanal index ve ID değerleri birbirine eşittir. İki boyutlu ve boyutları Dx ve Dy olan bir veri bloğu için x ve y koordinatlarında bulunan bir thread in kanal içi indeks (Kin) değeri aşağıdaki formül kullanılarak hesaplanmaktadır. Kin=x+y *Dy x: Kanalın, kanallardan oluşan matris içerisindeki sütun numarası y: Kanalın, kanallardan oluşan matris içerisindeki satır numarası Dx: Kanal matrisinin sütun sayısı Dy: Kanal matrisinin satır sayısı

62 49 Yukarıda bir GPU üzerinde bulunan küçük işlem birimlerinin indeks değerlerini hesaplama formülü verilmiştir. Bu formülün tek boyutlu bir blokta kullanım şekli aşağıdaki gibidir. GPU üzerinde bloklara ayrılmamış tek boyutlu thread dizisi Her biri 8 thread içeren tek boyutlu blok dizisi. Dy=8 threadidx.x (x) = blockidx.x (y) =0 blockidx.x (y) =1 blockidx.x (y) =2 Kin=x+y*Dy Kin=5 +2*8 Kin=21

63 50 Şekil CUDA kanal mimarisi (Nvidia 2007) Bir blokta açılabilecek kanal sayısı donanıma göre değişiklik göstermektedir. Mevcut ürünlerde bu sayı 1024 e kadar çıkabilir. İşlenecek verinin tam kapsanması için eşit şekillendirilmiş bloklardan yararlanılabilir. Böylece toplam kanal sayısı, bir bloktaki kanal sayısının toplam blok sayısı ile çarpılmasıyla elde edilir. Şekil 3.21 de gösterildiği gibi bloklar bir boyutlu veya iki boyutlu kümeler halinde olabilir. Bu yapılara grid denir. Grid içerisindeki herhangi bir blok, bir boyutlu veya iki boyutlu bir indeks ile ifade edilebilir. Bu indeks değeri blockidx olarak adlandırılır. blockdim elemanı üzerinden söz konusu bloğun boyutları elde edilebilir. Blok içerisindeki kanallar etkileşimli olarak çalışabilirler. Ayrıca erişim hızının çok yüksek olduğu ortak paylaşımlı bellek yapısı mevcuttur. Bu yapıya erişimleri düzenleyen ve blok içerisindeki kanalların senkronizasyonunu sağlayan mekanizmalar da mevcuttur (Yıldız 2011).

64 51 CUDA mimarisi thread (kanal) adı verilen küçük işlem birimlerinden oluşmaktadır. GPU lar üzerinde bulunan binlerce işlem kanalı Şekil 3.22 de görüldüğü gibi ardışık olarak yerleştirilmekte ve çalıştırılmaktadır. Şekil CUDA işlem kanalı modeli (Balfour 2011) GPU lar üzerinde bulunan kanallar programcılar tarafından istenilen sayıda bir araya getirilerek Şekil 3.23 te görüldüğü gibi gruplar halinde çalışmaları sağlanmaktadır. Şekil CUDA blok modeli (Balfour 2011) Şekil 3.24 te belirtildiği gibi kanal işlem birimlerinden oluşan bloklar GPU işlem biriminin tamamını temsil eden Grid i oluşturmaktadırlar. Temel olarak işlem kanalları bir araya gelerek grupları, gruplar bir araya gelerek Grid i meydana getirmektedir.

65 52 Şekil CUDA grid modeli (Balfour 2011) Hafıza hiyerarşisi CUDA mimarisinde Şekil 3.25 te belirtildiği gibi birden fazla farklı özelliklere sahip hafıza tipleri bulunmaktadır. Bu hafızaların kullanımında programcı açısından avantajlı ve dezavantajlı olan durumlarla karşılaşmak mümkündür.

66 53 Şekil CUDA hafıza hiyerarşisi (Nvidia 2007) Genel Bellek (Global Memory) Aygıt belleği olarak bilinen genel bellek Şekil 3.26 da görüldüğü gibi bütün kanallar ve merkezi işlem birimi tarafından ulaşılabilen bir hafıza türüdür. Okunabilme ve yazılabilme özelliğine sahip olan bu hafıza türünün en büyük dezavantajı ulaşım sırasında oluşan gecikmelerdir. Özellikle aynı anda birden fazla kanalın hafızaya ulaşması durumda ulaşım zamanında ciddi sıkıntılar oluşabilmektedir. Genel bellekteki verilerin yaşam süresi verinin hafızadan silinmesine kadardır. İlk üretilen CUDA mimarisine sahip ekran kartlarında bulunan genel belleklerde cash (ön) bellek

67 54 bulunmamakla birlikte hesaplama kapasitesi 2.x ten sonra cash bellek (Ön Bellek) özelliği eklenmiştir. Şekil CUDA genel bellek modeli (Woolley 2014) Paylaşımlı Bellek (Shared Memory) Genel belleğe benzer yapıya sahip olmakla birlikte bazı farklılıklara sahiptir. Şekil 3.26 da görüldüğü gibi CUDA mimarisinde belli sayıda kanal işlemcileri gruplar halinde çalışmakta ve bu gruplara blok adı verilmektedir. Şekil 3.27 de görüldüğü gibi her bloğun kendine ait bir paylaşımlı belleği bulunmakta ve sadece bu bloktaki kanallar tarafından ulaşılabilmektedir. Bundan dolayı farklı bloklarda bulunan iplikler tarafından paylaşımlı belleğe aynı anda ulaşma isteği olmamaktadır. Aynı bellek bölgesine birden fazla isteğin olmaması paylaşımlı belleği global belleğe göre çok daha hızlı kılmaktadır. Ayrıca paylaşımlı bellek global bellekten boyut olarak çok küçüktür. Bu nedenle CUDA

68 55 mimarisinde veriler çoğunlukla genel bellekte depolanarak sonrasında kısımlar halinde paylaşımlı belleğe aktarılarak işlenmektedirler. Şekil CUDA paylaşımlı bellek modeli Yerel Bellek (Local Memory) Aygıt belleği içinde her kanal için ayrılmış bir bellek alanıdır. Şekil 3.28 de görüldüğü gibi aygıt üzerinde bulunan her kanalın kendine ait bir yerel bellek alanı bulunmakta ve buraya sadece sorumlu kanal ulaşabilmektedir. Aygıt belleği üzerinde bulunduğundan dolayı yerel belleğe ulaşımda yüksek gecikmeler olmaktadır. CUDA nın 1.x hesaplama kapasitesine ait mimarisinde cash bellek yok iken 2.x ve üzeri hesaplama mimarilerinde cash bellekte bulunmaktadır. Şekil CUDA yerel bellek modeli

69 56 Kayıtçı Bellek (Registers) Her kanal için ayrı bulunan bir bellek tipidir. Sadece bir kanal tarafından ulaşılabildiğinden dolayı hızlıdır. Kayıtçı belleklerin boyutlarının küçük olması işlem kapasitesi açısından bir dezavantaj oluşturmaktadır. Değişmez Bellek (Constant Memory) Aygıt belleği üzerinde bulunan değişmez bellekte sabit fonksiyonlar ve bu fonksiyonların parametreleri tutulmaktadır. Değişmez bellek 8 kb (KiloByte) lık bir cash belleğe sahip olduğundan dolayı genel belleğe göre daha hızlıdır. Değişmez bellek üzerinde bulunan veriler çalışma esnasında değiştirilemezler. Ayrıca bu bellek üzerinde dinamik olarak yer ayırılmasına izin verilmemektedir. Doku Belleği (Texture Memory) Aygıt belleğinde bulanan doku belleği, doku verilerinin tutulması için geliştirilmiştir. Kendisine ait cash belleği bulunduğundan dolayı genel belleğe oranla daha hızlıdır. Farklı boyutlarda doku adresleme türlerine sahiptir.

70 57 Çizelge 3.2. Ekran kartı üzerinde bulunan bellek özellikleri Bellek Tipi Kayıtçı Bellek (Register) Yerel Bellek (Local) Paylaşımlı Bellek (Shared) Genel Bellek (Global) Değişmez Bellek (Constant) Doku Belleği (Texture) Bulunduğu Yer Cash (Nakit) Bellek Erişim Türü Erişim Alanı On-chip Yok Okuma / Yazma Bütün kanallar Off-chip Yok Okuma / Yazma Bütün kanallar On-chip Yok Okuma / Yazma Bir blok içerisindeki bütün kanallar Off-chip Yok Okuma / Yazma CPU ve bütün kanallar Off-chip Var Okuma CPU ve bütün kanallar Off-chip Var Okuma CPU ve bütün kanallar CUDA hesaplama yeteneği Hesaplama kapasitesi büyük versiyon ve küçük versiyon numaralarıyla ifade edilir. Büyük versiyon numaraları aynı olan ürünler aynı çekirdek mimarisine sahiptirler. Küçük versiyon numarası ise mimari üzerinde yapılan güncellemelere göre değişir. Örneğin Fermi mimarisine sahip ürünlerin hesaplama kapasitesi 2.x ile ifade edilir. Fermi mimarisinden önceki CUDA mimarili ürünlerin hesaplama kapasiteleri ise 1.x ile ifade edilir. Hesaplama kapasitesine göre çoklu işlemcilerin yetenek ve özellikleri farklıdır (Yıldız 2011). Bu tez kapsamında kullanılan GeForce GT 9500 ekran kartı 1.x hesaplama yeteneği ile üretilmiş mimariye sahiptir. GeForce 9500 GT nin sahip olduğu mimari özellikler Şekil 3.29 da gösterilmektedir.

71 58 Şekil GeForce 9500 GT ekran kartı hesaplama kapasitesi CUDA ile paralel programlama CUDA C standart C programlama diline çok az eklentiler ve kısıtlamalar yapılarak sunulmuş bir programlama dilidir. Bu dil ile programcılar kolaylıkla GPU üzerinde paralel programlama yapabilmektedirler. Yapılan yeni eklentiler sayesinde programcılar ekran kartlarına etki edebilmekte, ayrıca eklenen komutları kullanarak çalıştırılacak blok ve kanal boyutlarını tanımlayabilmektedirler. CUDA C ile getirilen bazı kısıtlamalar sadece CUDA 1.x hesaplama mimarisi için geçerlidir; 2.x ve üstü sürümler için kısıtlamalar kaldırılmıştır. Yazılan programların içinde CUDA C ye ait herhangi bir komut bulunması durumunda bu komutların NVCC derleyicisi ile derlenmesi gerekmektedir. CUDA C programlarının çalıştırılıp derlenebilmesi için CUDA sürücüsünün sistemde kurulu olması gerekmektedir. CUDA destekli bütün ekran kartı sürücülerinin kurulum dosyaları içinde CUDA C sürücüsü de bulunmaktadır. Gereken sürücülerin güncel hallerine üretici firmanın internet sitesinden ulaşmak mümkündür.

72 59 CUDA sürücüleri, yazılan programlarda bulunan paralel programlama fonksiyonlarının ikili veya assembly kod blokları haline çevrilmesini sağlayan C diliyle kodlanmış API ler bulundurmaktadır. Bu API ler, ekran kartı üzerinde veriler için alan ayırma, var olan verileri silme, ekran kartının ve sistemin yönetilmesi gibi görevleri yerine getirebilecek fonksiyonları içermektedirler. NVCC ile Derleme NVCC, içinde barındırdığı komut işleme argümanları ile yazılan programların daha kolay derlenmesini sağlayan bir derleyicidir. Yazılan bir program içerisinde hem CPU üzerinde çalıştırılması gereken hem de GPU üzerinde çalıştırılması gereken kodlar bulunabilir. NVCC Şekil 3.30 da görüldüğü gibi farklı işlemler yapan kod bloklarının birbirinden ayrılmasını sağlamaktadır. Programda bulunan ve CPU tarafından derlenmesi gereken kodları CPU üzerinde çalışacak herhangi bir derleyiciye gönderme işlemini yapmaktadır. Ayrıca paralel çalışması gereken kodları assembly veya binary kodlar haline çevirerek GPU üzerinde C benzeri bir derleyici ile derlenmesini sağlamaktadır.

73 60 Şekil NVCC ile program derleme (Ruetsch et al. 2008) CUDA C program bloklarının derleyici tarafından tanınmasını sağlayan bir takım komutlar bulunmaktadır. Ayrıca CUDA C tarafından ANCI C ye eklenen komutların programcı tarafından kullanılırken dikkat edilmesi gereken bazı kısıtlamaları vardır. Eklenen komutlar ve kısıtlamaları aşağıdaki gibidir. device ile tanımlanan fonksiyonlar sadece GPU lar üzerinde çalışmakta ve sadece GPU lar üzerinde çalışan fonksiyonlar tarafından çağrılabilmektedirler. Ayrıca device belirteci ile genel belleğe yerleştirilecek değişkenlerin tanımlamaları da yapılmaktadır.

74 61 device belirteci kullanılarak oluşturulan değişkenler genel hafıza içinde bulunmaktadır. Bu tür değişkenlerin hafızada bulunma süresi çalıştığı uygulamanın süresi ile sınırlıdır. global ile tanımlanan fonksiyonlar sadece GPU lar üzerinde çalışmakta ve sadece CPU üzerinde çalışan fonksiyonlar tarafından çağrılabilmektedirler. host ile belirtilen fonsiyonlar sadece CPU tarafından çalıştırılmakta ve sadece CPU üzerinde çalışan fonksiyonlar tarafından çağrılmaktadırlar. Tanımlanan fonksiyon herhangi bir belirteç ile başlamıyorsa derleyici tarafından host fonksiyonu olarak kabul edilmektedir. shared_ ile paylaşılan bellekte yer alacak olan değişkenler tanımlanmaktadır. constant ile değişmez belleğe yerleştirilecek değişkenler tanımlanmaktadır. Bu tür değişkenlerin yaşam süresi uygulamanın yaşam süresi ile sınırlıdır. CUDA tarafından eklenen fonksiyon tanımlama ve değişken tanımlama belirteçlerinin kullanımında dikkat edilmesi gereken kısıtlamalar aşağıdaki gibidir. device ve global belirteçleri ile hazırlanan fonksiyonlar özyinelemeli fonksiyonları desteklememektedir. Ayrıca bu belirteçlerin kullanıldığı fonksiyonların gövde bölümünde statik değişkenler tanımlanamamaktadır. device ve global belirteçleri ile hazırlanan fonksiyonlarda bellekte dinamik yer ayrılma işlemi yapılamamaktadır. Ayrıca dizileri parametre olarak kabul etmemektedirler. global ve host belirteçleri bir arada kullanılmamaktadır. global belirteci ile hazırlanan fonksiyonlar void değer döndürmek zorundadır. global belirteci ile hazırlanan fonksiyonlar senkron olarak çalışmaktadırlar. Bloklar işlerini tamamlayana kadar beklemektedirler. global belirteci ile tanımlanan fonksiyonlar boyutu 256 byte ile sınırlı olan parametrelerini paylaşımlı bellek yolu ile aygıta iletmektedirler.

75 62 constant, shared ve device belirteçleri ile tanımlanmış değişkenler extern belirteci kullanılarak harici olarak tanımlanamazlar. shared belirteci ile tanımlanan değişkenlere ilk değer ataması yapılamamaktadır. CUDA C ile GPU lar üzerinde uygulama geliştirmek isteyen yazılımcıların C veya C++ deneyimlerinin bulunması gerekmektedir. Öte yandan, GPU lar üzerinde CUDA C ile paralel uygulamalar geliştirmek isteyen yazılımcıların paralel programlama, grafik programlama gibi deneyimlerinin olmasına gerek yoktur. Örnek 5; int main (void) { printf ( Merhaba Dünya ); return 0; } Örnek 5 te verilen kod bloğunda sadece ANSI (Amerikan Ulusal Standartlar Enstitüsü) C kodları bulunmaktadır. Kod bloğu içerisinde herhangi bir CUDA C belirteci bulunmadığı için NVIDIA derleyicisi olan NVCC (Nvidia CUDA Derleyicisi) herhangi bir derleme işlemi yapmamaktadır. Bu kod bloğunun Örnek 6 da gösterildiği gibi değiştirilmesi durumunda kod bloğunun derlenmesi, NVCC derleyicisi ve ANSI C derleyicisi tarafından paylaşılacaktır. Örnek 6; global void kernel(void) { } int main(void) { kernel<<<1,1>>>(); printf( Merhaba dünya ); return 0;

76 63 } Örnek 6 da görüldüğü gibi global belirteci kullanılarak GPU üzerinde paralel işlem yapılacağı vurgulanmaktadır. Bu durumda NVCC derleyicisi yukarıda verilen kodu CPU üzerinde ve GPU üzerinde çalıştırılmak üzere iki bölüme ayırmaktadır. Program içinde bulunan global belirteci ile başlayan fonksiyon NVCC tarafından derlenmektedir. Programın geri kalan kısmı olan main() fonksiyonu standart C fonksiyonu olduğu için ve herhangi bir CUDA C belirteci kullanılmadığı için CPU üzerinde kullanılan gcc veya Microsoft Visual C derleyicisi tarafından derlenmektedir. Yukarıdaki örnekte CPU tarafından çalıştırılan kod bloğunda bulunan <<<..>>> belirteci CPU tarafından çalıştırılan fonksiyon içerisinden GPU üzerinde çalışan fonksiyonun çağırılacağını belirtmektedir. GPU lar üzerinde paralel programlama yapılırken hafıza yönetiminin iyi bilinmesi gerekmektedir. Paralel programlamada kullanılacak değişken ve parametreler hafıza bölgelerini işaret ettiğinden dolayı pointer (işaretçi) olarak tanımlanmaktadırlar. CPU fonksiyonlarında tanımlanan değişkenler CPU hafıza bölgesini, GPU fonksiyonlarında kullanılan değişkenler GPU hafıza bölgesini göstermektedirler. ANSI C programlama dili kullanıldığında hafıza üzerinde işlemler malloc(), free() ve memcpy() fonksiyonları aracılığı ile yapılmaktaydı. CUDA C tarafından hafıza üzerinde alan açmak, bilgi kopyalamak ve silmek gibi işlemlerin yapılabilmesi için cudamalloc(), cudafree(), cudamemcpy() fonksiyonları ANSI C programlama diline eklenmiştir. GPU hafızası üzerinde alan ayırma ver serbest bırakma işlemleri Örnek 7 deki gibi yapılmaktadır.

77 64 Örnek 7: cudamalloc(void **pointer, size_t nbytes) cudamemset(void *pointer, int value, size_t count) cudafree(void *pointer) int n = 1024; int nbytes = 1024*sizeof(int); int *d_a = 0; cudamalloc((void**)&d_a, nbytes); cudamemset(d_a, 0, nbytes); cudafree(d_a); Paralel programlama esnasında CPU hafızasından GPU hafızasına veya GPU hafızasından CPU hafızasına bilgi kopyalama işlemleri aşağıda gösterildiği gibi yapılmaktadır. cudamemcpy(void *dst, void *src, size_t nbytes,enum cudamemcpykind direction); Bilgi kopyalama işleminde kullanılan cudamemcpy() fonksiyonunun almış olduğu parametrelerden *dst parametresi bilginin kopyalanacağı hedef değişken işaretçisini göstermektedir. Aynı şekilde *src işaretçisi ile de kopyalanacak bilginin kopyalanacağı değişken işaret edilmektedir. Bilgi kopyalama işlemi iki farklı hafıza arasında yapıldığından dolayı bu kopyalama işleminin yönünü belirtmek için cudamemcpykind direction parametresi kullanılmaktadır. Bu parametrenin alabileceği değerler aşağıdaki gibidir. cudamemcpyhosttodevice parametresi kullanılarak kopyalama işleminin CPU hafızasından GPU hafızasına yapılacağı belirtilmektedir. cudamemcpydevicetohost parametresi kullanılarak kopyalama işleminin GPU hafızasından CPU hafızasına yapılacağı belirtilmektedir. cudamemcpydevicetodevice parametresi kullanılarak kopyalama işleminin GPU hafızasından GPU hafızasına yapılacağı belirtilmektedir.

78 65 CUDA C belirteçleri kullanılarak yazılan fonksiyonların CPU tarafından çağrılması ve kullanılacak blok ve kanal sayısının belirtilmesi aşağıdaki şekilde yapılmaktadır. kernel<<<dim3 grid, dim3 block>>>( ) GPU üzerinde bulunan ve aygıtı temsil eden Grid in kaç tane bloktan oluşturulacağı ve bloklar üzerinde kaç tane işlem kanalının bulunacağı <<<..>>> belirteçleri arasında gösterilmektedir. Ayrıca oluşturulan düzende bulunan blokların sıra değeri dim3 blockidx ve işlem kanallarının bulundukları blok içerisindeki sıra değerleri de threadidx parametreleri ile belirlenmektedir. CUDA C eklentileri olan global ve device fonksiyon belirteçleri ile oluşturulan fonksiyon bloklarında bu değerler derleyici tarafından otomatik olarak tanımlanmakta ve herhangi bir yeni tanımlama yapmadan kullanılabilmektedirler. Şekil CUDA bellek bölgelerine erişim (Nvidia 2008) Şekil 3.31 de görüldüğü gibi Grid üzerinde bulunan bir işlem kanalına ulaşabilmek için blockidx.x*blockdim.x+ threadidx.x formülü kullanılmaktadır.

79 66 Örnek 8: global void topla(int*a, int*b, int*c) { *c = *a + *b; } int main(void) { int a, b, c int *dev_a, *dev_b, *dev_c; int size = sizeof(int); cudamalloc((void**)&dev_a, size); cudamalloc((void**)&dev_b, size); cudamalloc((void**)&dev_c, size); a = 2; b = 7; cudamemcpy(dev_a, &a, size, cudamemcpyhosttodevice); cudamemcpy(dev_b, &b, size, cudamemcpyhosttodevice); topla<<< 1, 1 >>>(dev_a, dev_b, dev_c); cudamemcpy(&c, dev_c, size, cudamemcpydevicetohost); cudafree(dev_a); cudafree(dev_b); cudafree(dev_c); return0; } Örnek 8 de bulunan kod bloğunda iki sayının toplanıp sonucunun hesaplanması işlemi yaptırılmaktadır. Başlangıçta toplama işlemine tabi tutulacak değişkenler ve sonucun tutulacağı değişkenler hem CPU tarafı için hem de GPU tarafı için tanımlanmaktadır. Tanımlama işlemlerinden sonra GPU hafızası üzerinde bu değişkenler için hafıza alanı ayırma işlemi yapılmaktadır. GPU tarafında çalışacak fonksiyonun hata vermemesi için

80 67 GPU hafızasında ayrılan alanlara değerlerin kopyala işlemi cudamemcpy() fonksiyonu tarafından yapılmaktadır. Hafızada alan ayırma ve ayrılan alanlara değerlerin kopyalanması işleminden sonra global belirteci ile oluşturulan topla fonksiyonu Grid ve Blok değerleri belirlenerek parametreler ile birlikte çağrılmaktadır. GPU üzerinde çalışmakta olan topla() fonksiyonu hafızada bulunan iki değişken değerini toplayıp üçüncü değişkenin bulunduğu hafıza alanına kopyalamaktadır. global fonksiyonlar geriye void değer döndürmek zorunda olduklarından dolayı ANSI C de tanımlı olan return belirteci burada kullanılmamaktadır. GPU hafızasına kopyalanan sonuç değeri CPU tarafından cudamemcpy() fonksiyonu kullanılarak CPU hafızasında bulunan değere aktarılır ve son olarak GPU hafızasında ayrılan alanlar cudafree() fonksiyonu ile serbest bırakılır CUDA kurulumu ve visual studio platformunda kullanımı Visual Studio platformu üzerinde CUDA kullanılarak programlama yapılması için öncelikle Visual Studio platformunun sisteme kurulması gerekmektedir. Ardından NVIDIA firmasının kurumsal sitesinden gerekli olan CUDA kurulum dosyalarının indirilip sisteme kurulması gerekmektedir. Gerekli bütün programların kurulumunun tamamlandığından emin olunduktan sonra Visual Studio platformu üzerinde boş bir Console Application Projesi oluşturulmalıdır. CUDA C kodlarının derlenmesi için oluşan projeye eklenecek program dosyalarının.cu uzantılı olması gerekmektedir. Bu yüzden oluşturulan boş projenin Solution Explorer penceresindeki proje menüsünün içinde bulunan Source Files dosyasına fare aracılığı ile sağ tıklanır ve karşılaşılan menüde Add New Item yolu izlenerek Şekil 3.32 de görüldüğü gibi Cuda_program.cu program dosyası eklenir.

81 68 Şekil Visual Studio platformunda CUDA programı oluşturma Program kodlarının yazılacağı dosya projeye eklendikten sonra programı çalıştıracak derleyici belirlenmelidir. Uygulama kodlarının CUDA derleyicisi tarafından derlenebilmesi için Şekil 3.33 te görüldüğü Build Customizations sekmesi tıklanarak karşılaşılan pencereden sistemde kurulu olan CUDA derleyicisi seçilmelidir. Şekil CUDA derleyicisinin seçilmesi

82 69 Derleyici ayarları yapıldıktan sonra.cu uzantılı olarak oluşturulan program dosyasının bir CUDA C program dosyası olduğu Visual Studio platformuna bildirilmelidir. Bu işlemi yapabilmek için oluşturulan.cu uzantılı dosyaya sağ fare tuşu ile tıklandıktan sonra karşılaşılan menüden Properties sekmesi seçilmelidir. Properties sekmesi seçildikten sonra karşılaşılan pencereden Şekil 3.34 te görüldüğü gibi Item Type kısmından CUDA C/C++ seçeneği seçilerek kaydedilmelidir. Şekil Program dosyasında CUDA C ayarlaması Yukarıda belirtilen adımlar gerçekleştirildikten sonra ve CUDA C programlarını yazmadan önce cuda.lib, cudaart.lib, cublas.lib ve gerekliyse diğer CUDA kütüphane dosyaları Project Properties Configuration Properties Linker Input yolu izlenerek Şekil 3.35 te görüldüğü gibi projeye eklenmelidir.

83 70 Şekil Gerekli CUDA kütüphanelerinin uygulamaya eklenmesi Gerekli CUDA kütüphanelerinin projeye tanımlama işlemi yapıldıktan sonra Visual Studio platformu kullanılarak GPU lar üzerinde CUDA teknolojisi ile paralel programlama yapmak mümkün olmaktadır CUDA nın grafik uygulamalarında kullanımı OpenGL veya Direct3D gibi grafik kütüphaneler tarafından üretilen bilgileri CUDA hafızası üzerinde haritalamak mümkündür. Bu grafik kaynaklarının CUDA üzerinde işlenmeden önce bir kaynak olarak CUDA ya kayıt edilmesi gerekmektedir. CUDA ya bir grafik kaynağını kayıt etmek için geriye pointer bir değer döndüren cudagraphicsresource() fonksiyonu kullanılmaktadır. CUDA ya kaynak kaydetme işlemi yüksek işlem potansiyeline sahip olduğundan dolayı her kaynağın sadece bir defa kaydedilmesi gerekmektedir. Kaydedilen bir CUDA grafik kayıtçısının kaydının silinmesi için cudagraphicsunregisterresource() fonksiyonu kullanılmaktadır. Bir grafik kaynağı CUDA ya kaydedildikten sonra bu grafik kaynağındaki cudagraphicsmapresources() ve cudagraphicsunmapresources() fonksiyonları kullanılarak birçok kez haritalama işlemine tabi tutulabilmekte ve haritalama değerleri ortadan kaldırılabilmektedir. Kayıt edilen grafik kaynağı ile yapılacak işlem

84 71 performanslarının artırılması için bu kaynağın sadece okuma veya sadece yazma işlemlerinde kullanılacağını belirtmek için cudagraphicsresourcesetmapflags() fonksiyonu kullanılmaktadır (Nvidia 2014) CUDA ve OpenGL birlikteliği CUDA ve OpenGL birlikteliğinin sağlanması için program bloğu içerisinde bütün fonksiyon çağırma işlemlerinden önce cudaglsetgldevice() fonksiyonu kullanılarak sistemde var olan CUDA sürücüsünün tanımlanması gerekmektedir. OpenGL kaynak verileri Şekil 3.36 da görüldüğü gibi CUDA hafızası üzerine OpenGL buffer, texture ve render buffer nesneleri olarak haritalanmaktadırlar. Bir buffer nesnesi CUDA üzerine cudagraphicsglregisterbuffer() fonksiyonu kullanılarak kaydedilmektedir. Bir buffer nesnesi CUDA ya kaydedildikten sonra aygıt hafızasında bir işaretçi olarak görülmektedir. Bundan dolayı cudamemcpy() fonksiyonu kullanılarak kayıt edilen bilgiler üzerinde okuma ya da yazma işlemleri yapılabilmektedir (Nvidia 2014). Şekil CUDA ve OpenGL işbirliği Bu tez kapsamında oluşturulan OpenGL doku verilerinin piksel değerleri PixelBufferObject (PBO) nesnesine yüklenmekte ve bu nesne CUDA aygıtına kaydedildikten sonra PBO üzerinde bulunan bütün nokta değerlerinin CUDA işlem kanalları tarafından işlenmesi sağlanmaktadır. OpenGL kullanılarak yapılan bir

85 72 uygulamadaki bilgilerin CUDA üzerinde işlenme işlemleri Şekil 3.37 de görüldüğü gibi 5 adımdan oluşmaktadır. Şekil CUDA ve OpenGL programlama algoritması (Binstock 2010) NVIDIA GeForce 9500 GT ekran kartı özellikleri Bu tez kapsamında Şekil 3.16 da görüldüğü üzere NVIDIA ekran kartı üretici firması tarafından 21 Şubat 2008 tarihinde piyasaya sürülen GeForce 9500 GT ekran kartı kullanılmıştır. Bu ekran kartına ait özellikler Çizelge 3.2 de ayrıntılı olarak gösterilmektedir.

86 73 Çizelge 3.3. GeFrorce 9500 GT Ekran kartı özellikleri GPU Özellikleri Hafıza Özellikleri CUDA Cores 32 Memory Clock 800 (GDDR3) and 500 (DDR2) MHz Graphics Clock 550 MHz Standard Memory 256/512 MB (MHz) Config Processor Clock 1400MHz Memory Interface 128-bit (MHz) Width Texture Fill Rate (billion/sec 8.8 Memory Bandwidth (GB/sec) 25.6 (GDDR3) and 16.0 (DDR2) Destek Verilen Teknolojiler Görüntü Desteği OpenGL 2.1 Multi Monitor Yes Teknolojiler SLI, CUDA, PhysX Maximum Digital Resolution 2560x1600 Maximum VGA Resolution 2048x1536 Standard Display Connectors HDMI Dual Link DVI Single Link DVI Yes Standart Kart Boyutları Sıcaklık ve Güç Özellikleri Length inches Maximum GPU Temperature (in C) Height inches Maximum Graphics Card Power (W) Width Single-slot Minimum System Power Requirement (W) 105 C 50 W 350 W

87 Yöntem Tez kapsamında, ilk olarak tek bir işlemci (CPU) üzerinde çalışan seri animasyon programı geliştirilmiştir. Geliştirilen seri animasyon programını paralleştirmek için CUDA teknolojisinden faydalanılmıştır. Oluşturulan seri programı CUDA mimarisi ile ederek paralelleştirmek için ortak hafıza yöntemi kullanılmıştır. OpenGL ve CUDA mimarisi arasındaki işbirliğinin sağlanabilmesi için öncelikle kullanılacak ortak hafıza bölgesinin (PBO) OpenGL tarafından CUDA ya kaydedilmesi ve CUDA tarafından işlenebilecek duruma getirilmesi gerekmektedir. Grafik uygulamalarında birden fazla PBO kullanılabilmektedir. Bu uygulamada gönderilecek ve tutulacak görüntüleri işaret eden tek bir PBO kullanılmaktadır. OpenGL veri hafızası farklı özelliklerde verileri tutabilecek şekilde birden fazla bölüme ayrılabilmektedir. Bahsedilen bu bölümlerden en sık kullanılan ARB_pixel_buffer_object ve ARB_vertex_buffer_object eklentileri büyük benzerlikler göstermektedir. Bu eklentiler sadece koordinat bilgilerinin değil aynı zamanda piksel bilgilerinin de veri havuzunda depolanmasını sağlamaktadır. Piksel değerlerinin depolanma işlemini sağlayan veri havuzu PBO olarak isimlendirilmektedir. Bu veri havuzu bütün koordinat bilgilerini, kütüphane bilgilerini ve bunlara ek olarak 2 adet anahtar değeri içermektedir. Bu anahtar değerlerin yardımı ile depolanacak bilgilerin sistem hafızasında en uygun yere depolanması kontrol edilmektedir. Ayrıca Şekil 3.38 de gösterildiği gibi anahtar değerler piksel değerlerin PBO ya yüklenmesini belirten GL_PIXEL_PACK_BUFFER_ARB ve piksel değerlerinin PBO dan alınmasını sağlayan GL_PIXEL_UNPACK_BUFFER_ARB değerlerini almaktadır (Ahn 2014).

88 75 Şekil OpenGL veri havuzu yapısı (Ahn 2014) OpenGL ile CUDA arasında işbirliği yapılması durumunda PBO nun kullanılması temelde 2 avantaj içermektedir. Bu yöntem sayesinde nesne ile hafızaya doğrudan erişim sağlanmakta ve herhangi bir CPU işlem çevrimine girmeden hafızaya bilgi yükleme ve hafızadan bilgi alma işlemleri gerçekleştirilmektedir. Ayrı PBO lar ile sistem hafızası arasında veri transferi asenkron olarak yapılabilmekte ve bu özellik veri aktarımı esnasında büyük bir avantaj sağlamaktadır (Ahn 2014). Şekil PBO kullanmadan veri aktarım işlemi (Ahn 2014) Şekil 3.39 da görüldüğü gibi görüntü bilgisi öncelikle sistem hafızasına yüklenmekte ve ardından glteximage2d() fonksiyonu kullanılarak OpenGL doku nesnesine yüklenme işlemi yapılmaktadır. Doku verisi OpenGL tarafından işlenmeye başlamadan önce CPU tarafından iki işlem döngüsü süresince kullanılmaktadır. Bu durum görüntünün hızlı bir şekilde işlenme performansında dezavantaj oluşturmaktadır.

89 76 Şekil PBO kullanarak veri aktarım işlemi (Ahn 2014) Şekil 3.40 da görüldüğü gibi doku bilgisi OpenGL kontrolünde bulunan PBO ya doğrudan yüklenmektedir. Veri transfer işleminin bu şekilde yapılması durumda CPU yalnızca doku bilgisinin ilk olarak PBO ya yüklenmesi işlemini yapmaktadır. Ayrıca doku bilgisinin PBO dan doku nesnesine transfer edilmesi işlemine karışmamaktadır. Bu durumda bilgininin doku nesnesine transfer işlemi tamamen OpenGL sürücüsü tarafından doğrudan hafızaya erişim metodu kullanılarak yapılmakta ve performans artışı sağlanmaktadır (Ahn 2014). CUDA ile OpenGL arasında işbirliğinin sağlanması için, ekran kartı üzerinde bulunan dâhili hafızada oluşturulan PBO nesnesinin CUDA işlemcileri tarafından kullanılabilmesi amacıyla kayıt/tanıtma işlemi yapılmaktadır. Kayıt işlemi tamamlandıktan sonra, OpenGL tarafından oluşturulan ve PBO ya aktarılan doku nesneleri CUDA C derleyicisi tarafından alınıp GPU işlemcileri üzerinde paralel olarak çalıştırılmaktadır. Bu işlem sonucunda oluşturulan doku nesneleri binlerce küçük işlemci üzerinde çalıştırılmaktadır. Ayrıca, üretilen doku bilgileri tekrar OpenGL veri havuzlarına yüklenerek ekrana yansıtılmaktadır.

90 77 4. ARAŞTIRMA YÖNTEMLERİ 4.1. Problemin Seri ve Paralel Çözümü Tezin bu bölümünde, C++ programlama dili ve OpenGL grafik ara yüz oluşturma kütüphanesi kullanılarak seri programlama mantığı ile yapılan animasyon uygulaması anlatılmaktadır. Ayrıca hazırlanan bu seri programın NVIDIA GeForce 9500 GT ekran kartı ile CUDA mimarisinden faydalanılarak görüntü kalitesini artırmak için paralel programlama mantığı ile oluşturulan animasyon uygulamasından bahsedilmektedir Problemin seri çözümü Herhangi bir paralel işlem platformu kullanılmadan hazırlanan uygulamalar merkezi işlemci üzerinde seri olarak yürütülmektedirler. Seri çalıştırılma mantığına göre yazılmış uygulamalarda verilerin hafızalara yüklenmesi ve bütün hesaplama işlemleri tek bir işlemci üzerinden gerçekleştirilmektedir. Bu uygulamanın ilk adımı olan seri hesaplama bölümünde verilerin GPU hafızasına yüklenmesi, eklemlerin oluşturulması ve doku haritalama esnasında meydana gelen matematiksel hesaplama işlemleri CPU tarafından yapılmaktadır OpenGL ile grafik ortamı hazırlanması Bu bölümde 13 eklemden oluşan robot animasyon uygulamasının OpenGL kullanılarak grafik tabanlı animasyon ortamı hazırlanmıştır. OpenGL ile nesneler oluşturulurken ilkel nesnelerden faydalanılmaktadır. Ortam oluşturma işlemleri öncelikle OpenGL penceresinin ilkleme işleminin çağırılması ile başlamakta sonrasında pencere boyutu, pozisyonu ve görüntü derinliğinin belirlenmesi işlemleri ile devam etmektedir. Oluşturulan ekranda takip eden adımlarda tasarlanacak robotların üzerine hareket edecekleri zemin tasarımı GLUT kütüphanesinde tanımlı GL_QUARDS nesnesi kullanılarak hazırlanmaktadır. OpenGL uygulamasının başlangıç ayarlamaları Şekil 4.1 de görüldüğü gibi yapılmaktadır.

91 78 Şekil 4.1. Grafik uygulama ortamının hazırlanması Şekil 4.1 de görüldüğü gibi öncelikle pencere oluşturma ve görüntü derinlik ayarlamaları yapılmaktadır. Bu işlemler sonrasında oluşturulan grafik penceresinde görüntülerin daha anlaşılır ve görülebilir olması için uygulanacak doku haritalama ve ışıklandırma işlemleri Şekil 4.2 de gösterildiği gibi init() fonksiyonu altında tanımlanarak çağrılmaktadır.

92 79 Şekil 4.2. Işıklandırma ve doku haritalama ayarlamaları Grafik ekranı için gereken başlangıç işlemleri yapıldıktan sonra 2 boyutlu zemin oluşturma işlemleri Şekil 4.3 te görüldüğü gibi GL_QUARDS nesnesi kullanılarak yapılmaktadır. Şekil 4.3. OpenGL ile zemin oluşturma

93 80 Görüntü penceresi ve zemin için gereken OpenGL kodları yazıldıktan sonra programın derlenmesi sonucu Şekil 4.3 deki ekran çıktısı oluşmaktadır. Şekil 4.4. Ekran çıktısı görüntüsü OpenGL ile robot oluşturulması Tezin bu bölümünde OpenGL ile insan benzeri robotlar oluşturulmakta ve bu robotların sayıları artırılarak hem merkezi işlem biriminde hem de genel amaçlı GPU lar üzerinde çalıştırılmaktadır. Oluşturulan robot sayısı arttıkça işlem yoğunluğu artmakta ve bu işlem yoğunluğu beraberinde işlenmesi gereken grafiksel bilgi miktarını da artırmaktadır. Bu durumda işlem performanslarında değişiklikler oluşmaktadır. OpenGL ile robot tasarımı yapılırken ilkel nesneler kullanılarak bir fonksiyon haline getirilen ve GLUT Kütüphanesi altında bulunan 3 boyutlu küp oluşturma fonksiyonu olan glutsolidcube() komutu kullanılmaktadır. Kullanılan küp nesnelerinin birleşiminden robot oluşturulmaktadır. Yapılan robot uygulaması farklı boyuttaki küplerden oluşan 13 eklemden meydana gelmektedir. Bu eklemlerden üst kolu oluşturma kodu Şekil 4.5 te görülmektedir. Robotun kalan diğer eklemleri de koordinat ve boyut değerleri farklı olmak koşulu ile Şekil 4.5 te gösterildiği gibi yapılmaktadır.

94 81 Şekil 4.5. OpenGL ile robot eklemi oluşturma komutları Bütün eklemler için gerekli olan OpenGL kodları yazıldıktan sonra 13 eklemden oluşan bir robotun görünümü Şekil 4.6 daki gibi olmaktadır. Şekil 4.6. OpenGL ile robot tasarımı Robot animasyon işlemleri Animasyonlar çeşitli yazılımlar kullanılarak oluşturulan hareketli görüntülerdir. OpenGL de animasyon işlemleri klavye veya fare araçları kullanılarak görüntü

95 82 penceresinden verilen komutlar doğrultusunda yapılmaktadır. Bu uygulama kapsamında oluşturulan robotlara yürüme yanında ayak ve kolların kaldırılması, kolların yana doğru kaldırılıp indirilmesi ve kollar açılarak çömelme ve kalkma şeklinde 4 tür hareket yaptırılmaktadır. Bu animasyon hareketlerinin yapılması için klavye kontrollerinden faydalanılmaktadır. Ayrıca yine klavye kontrolleri kullanılarak oluşturulan bütün eksenlerin x, y ve z yönlerinde döndürülme işlemi gerçekleştirilmektedir. Klavye kontrollerinin dışında fare aracı kullanılarak da x ekseni yönünde hareket ve istenilen noktada hareketin durdurulması gibi işlemler gerçekleştirilmektedir. Yapılan uygulamada klavye ve fare araçlarının kontrollerinin kullanımı Şekil 4.7 de gösterilmektedir. Şekil 4.7. Klavye ve fare araçlarından bilgi girişi kontrolü Kullanıcıdan klavye ya da fare aracı kullanılarak alınan giriş bilgileri doğrultusunda robotlara uygulan animasyon hareketleri Şekil 4.8 de gösterilmektedir.

96 83 Şekil 4.8. Robot hareketleri Doku haritalama işlemleri Oluşturulan nesnelerin daha gerçekçi görülebilmesi için grafik uygulamalarının çoğunda doku haritalama işlemi yapılmaktadır. Bu uygulama kapsamında oluşturulan ortam ve nesneler üzerinde 800*800 boyutunda oluşturulan bir dizi üzerine her işlem yapıldığında doldurulan renk değerleri kullanılarak doku haritalama işlemi yapılmaktadır. OpenGL de nesneler sürekli yenilenerek oluşturulmakta ve her defasında OpenGL tarafından kullanılan ve arka planda bulunan veri havuzundaki veriler ile görüntü havuzundaki veriler değiştirilerek pencerede son oluşturulan veriler gösterilmektedir. Bütün nesneler üzerinde sayısallaştırılmış renk kodlarını oluşturan kod bloğu Şekil 4.9 da gösterilmektedir.

97 84 Şekil 4.9. Doku bilgisi oluşturma Oluşturulan doku bilgisi, görüntü penceresi üzerinde bulunan bütün nesnelere uygulanmakta ve görüntünün her yenilenme işlemi sırasında Şekil 4.9 daki fonksiyon ile 800*800 boyutunda bir veri kümesi oluşturulmaktadır. Bu veri kümesinin doku olarak pencere üzerindeki bütün nesnelere uygulanması sonucu oluşan ekran görüntüsü Şekil 4.10 da gösterilmektedir.

98 85 Şekil Doku haritalama işlemi Merkezi işlem birimi (CPU) üzerinde fps ölçümü Grafik tabanlı uygulamalarda performans ölçütleri olarak oluşturulan görüntülerin hareket hızları ve görüntü kalitesindeki performansları dikkate alınmaktadır. Bu uygulamada oluşturulan görüntülerin kalitesinin ve görüntüdeki netlik oranının artırılması hedeflenmektedir. Bir grafik uygulamasındaki görüntünün kalitesi ölçülürken saniyede oluşturulan frame (görüntü karesi) sayısı dikkate alınmaktadır. Bu ölçüm yapılırken bir OpenGL kütüphanesi olan GLUT tan faydalanılmaktadır. GLUT kütüphanesi sistemin birçok özelliğini sorgulamak için gerekli fonksiyonları sunmaktadır. Bu fonksiyonlardan glutget() fonksiyonu milisaniyedeki işlem sayısını göstermektedir. Bu fonksiyonun prototipi ve parametre özellikleri aşağıda verilmektedir. int glutget(glenum state); //State: İstenilen bilgi değeri

99 86 Bu fonksiyon ile oluşturulan pencere koordinatları veya bilgi havuzu derinliği gibi birçok sistem değeri çağrılabilmektedir. Bu tez kapsamında glutget() fonksiyonu kullanılarak işlem sonrasında geçen süre ve bu süre içinde oluşturulan görüntü karesi sayısı elde edilmektedir. Geçen zamanı ölçmek için kullanılan fonksiyon aşağıdaki gibidir. int zaman; zaman=glutget(glut_elapsed_time); Grafik uygulamalarında geçen zaman olarak bir saniyede oluşturulan ortalama frame sayısı dikkate alınmaktadır. Oluşturulan görüntülerde işlem akışı sırasında görüntü dönüşümü veya sisteme işlenmesi gibi farklı işlemler olabilmektedir. Bu yüzden her frame in oluşma süresi değişkenlik göstermektedir. Saniyede oluşturulan görüntü karesinin hesaplama işlemi Şekil 4.11 de gösterilmektedir. Şekil FPS hesaplama kod bloğu

100 87 Şekil 4.11 deki kod bloğunda belirtildiği gibi ölçüme öncelikle frame sayısı artırılarak başlanmaktadır. GLUT fonksiyonu olan glutget(glut_elapsed_time) kullanılarak işlem anındaki süre bir değişken içerisinde tutulmakta ve sıfır değerinden başlanılan bir değer ile başlangıçta karşılaştırılmaktadır. Bu uygulamada FPS (Frame Per Second- Saniyede Oluşturulan Görüntü Karesi) değeri dikkate alınmaktadır. Bir saniye 1000 mili saniyeye karşılık geldiği için ve sistem görüntü oluşumunu milisaniyeler içinde yaptığından dolayı başlangıç süresi ile geçen süre arasındaki farkın 1000 mili saniyeden yüksek olması dikkate alınmakta ayrıca bu koşulun sağlanması durumunda frame sayısı sıfırlanmakta ve geçen sürede oluşturulan frame sayısı gösterilmektedir Problemin CUDA ile Paralel Çözümü Uygulamanın ilk bölümünde sadece OpenGL kütüphaneleri ve Visual Studio C++ kullanılarak merkezi işlem birimi üzerinde yapılan çalışmalar anlatılmaktadır. Bundan sonraki bölümde CUDA ve OpenGL işbirliğinden bahsedilmektedir. Bu bölümdeki öncelik, iş birliğinin sağlanabilmesi için OpenGL tarafından PBO (Pixel Buffer Object- Piksel Tampon Nesnesi) nesnesinin CUDA ya kaydedilmesi ve CUDA tarafından işlenebilecek duruma getirilmesidir. Ayrıca CUDA ve OpenGL birlikteliği tez kapsamında bulunan Yöntem başlığı altında ayrıntılı olarak anlatılmıştır. Bu uygulamada gönderilecek ve tutulacak görüntüleri işaret eden tek bir PBO kullanılmaktadır. Şekil 4.12 de PBO oluşturma ve CUDA ya tanıtılma kodları gösterilmektedir.

101 88 Şekil PBO oluşturma ve CUDA ya tanıtılma kodları Gereken veri havuzu tanımlama ve CUDA ya tanıtılma işlemleri yapıldıktan sonra Şekil 4.13 de görüldüğü gibi cudaglmapbufferobject() fonksiyonu kullanılarak daha önceden tanıtılmış PBO nesnesi CUDA sürücüsü üzerinde haritalanmakta ve GPU işlemcileri üzerinde çalışacak fonksiyon çağrılmaktadır. GPU üzerindeki işlemler tamamlandıktan sonra haritalanmış görüntü bilgisi serbest bırakılmaktadır. Şekil PBO bilgisinin CUDA üzerinde haritalanması GPU lar üzerinde işlenecek verilerin CUDA ya tanıtılma işlemleri ve sürücü üzerinde haritalama işlemleri yapıldıktan sonra bu işlemler için kaç adet blok oluşturulacağı ve

102 89 her blokta kaç tane thread (işlem kanalı) çalıştırılacağı belirtilmektedir. Bu uygulama içerisinde 800*800 boyutunda bir görüntü alanı oluşturulmakta ve bunlar 800*800 adet thread üzerinde çalıştırılmaktadır. Oluşturulan her bir blokta 256 adet thread çalışması mantıksal olarak belirlenmektedir. Şekil 4.14 de blok ve thread sayılarının belirlenme işlemi gösterilmektedir. Şekil Blok ve thread belirleme GPU üzerinde çalışacak thread ve blok sayıları belirlendikten sonra <<<..>>() belirteç yapısı kullanılarak threadlar üzerinde paralel olarak çalıştırılacak çekirdek fonksiyonu çağrılmaktadır. Çekirdek fonksiyonun çalışması ile Şekil 4.14 de görüldüğü gibi her biri 256 thread içeren 2500 blok üzerinde PBO ya yüklenen doku bilgisi işlenmektedir. Bu durum sonucunda eskisinden çok daha kaliteli bir görüntü elde edilebilmektedir. Tutarlı bir performans analizi yapılabilmesi için CPU üzerinde kullanılan doku verisi oluşturma fonksiyonunun aynısı GPU lar üzerinde de çalıştırılmıştır. İstenilen amaçlar doğrultusunda bu fonksiyonların programcı tarafından değiştirilerek farklı problemlerin çözümünde kullanılması mümkündür.

103 90 5. TARTIŞMA ve SONUÇ Tezin bu bölümünde OpenGL uygulamasının merkezi işlemci birimi üzerinde ve NVIDIA CUDA teknolojisi kullanılarak merkezi işlem birimine ek olarak kullanılan ekran kartı üzerinde bulunan genel amaçlı işlemciler üzerinde çalıştırılması sonucu elde edilen FPS (Frame Per Second-Saniye Başına Oluşturulan Görüntü Karesi) değerlerinin ölçümleri ile grafiksel analizleri sunulmaktadır. Oluşturulan görüntü kalitesinin analizi yapılırken kullanılacak işlem birimleri üzerinde işlenmesi istenilen görüntü bilgisi miktarı adım adım artırılmakta ve bu durumda oluşan verilerin analizi yapılmaktadır Test Ortamı Uygulamanın testlerinin yapıldığı platform özellikleri aşağıda belirtilmektedir. Intel Core 2 Quad CPU Q GHz 4 GB 800 Mhz DDR2 bellek. NVIDIA GeForce 9500GT grafik kartı. Windows 7 Ultimate işletim sistemi. CUDA SDK Versiyon 5.0 Visual Studio Bit (x86) Mimarisi Test sonuçları çoğunlukla kullanılan grafik kartından etkilenmektedir. Bu yüzden kullanılan diğer sistem gereksinimlerinin sabit kalması durumunda ekran kartının değiştirilmesi performans analizinde doğrudan değişikliklere sebep olacaktır.

104 Analiz Sonuçları Performans analizinin ilk adımında, robot nesnelerinin ekranda oluşumundan önce hazırlanan grafik ortamın analizi yapılmaktadır. Çizelge 5.1 de grafiksel ortamın oluşumu sonrasında merkezi işlem biriminin ve merkezi işlem birimi ile GPU ların beraber çalışması sonucu oluşan FPS değerleri gösterilmektedir. Çizelge 5.1. Grafik ortamın hazırlanması aşamasında oluşan frame sayıları Durum Başlangıç Aşaması Ekran Oluşum Aşaması Kararlı Durum CPU Frame Sayısı CPU + GPU Frame Sayısı Performans Farkı (%) Elde edilen veriler doğrultusunda performans analizi grafiksel olarak Şekil 5.1 de gösterilmektedir.

105 CPU Frame Sayısı CPU + GPU Frame Sayısı Performans Farkı (%) Şekil 5.1. Grafik ortamı oluşturulma analizi Şekil 5.1 den de anlaşılacağı üzere başlangıç aşamasında işletim sistemi tarafından yapılması gereken ortam hazırlama, kullanılacak kütüphane dosyalarının yüklenmesi ve kullanıcı arabirimi ile yapılacak giriş/çıkış gibi işlemler dolayısı ile oluşturulan frame sayısı düşük seviyede başlamaktadır. Ayrıca oluşturulan her frame in oluşum süreleri o anki yapılacak başka bir işlem veya dışarıdan talep edilen ek bir görev olması durumunda değişiklik göstermektedir. Öta yandan doku haritalama noktasında CUDA çözümü ile elde edilen performans iyileştirmesinin %33 ile başlayıp %164 e kadar arttığı görülmektedir. Şekil 5.2 de görüldüğü gibi sadece CPU üzerinde gerçekleştirilen doku haritalama bölümüne dikkat edildiğinde renkler arası geçiş katmanlarında pürüzlerin oluştuğu fark edilmektedir. Bunun aksine GPU işlemcilerinin işlem akışına dâhil olması durumda oluşan görüntü pürüzlerinin ortadan kalktığı ve daha canlı, daha pürüzsüz görüntünün oluştuğu gözlemlenmektedir.

106 93 Merkezi İşlem Birimi ve GPU üzerinde oluşturulan Görüntü Kesiti Merkezi İşlem Birimi üzerinde oluşturulan Görüntü Kesiti Şekil 5.2. Grafik ortamın görüntü kesiti Grafik uygulamalarında görüntü performansı analizi yapılırken gerek merkezi işlem biriminin gerekse GPU ların üzerinde çalıştırılan veri miktarına dikkat edilmektedir. Uygulamanın sonraki performans analizlerinde, hazırlanacak robot nesnelerinin oluşturulması ve hareket ettirilmesi sonucu kullanılan işlem birimlerinin anlık oluşturmuş olduğu frame sayıları dikkate alınmaktadır. Pencere üzerinde bulunan bütün yüzeyler işlem birimleri tarafından doku haritalama işlemine tabi tutulmaktadır. Bir yüzey için hesaplanan koordinat sayısı ve haritalanacak yüzey sayısı aşağıda belirtilmektedir. TK=H.P.E.R YS=Y.E.R

107 94 Her bir eklemin sahip olduğu hareket adım sayısı =H Her bir adımın içermiş olduğu öteleme ve pozisyon koordinat sayısı=p Her bir eklemde bulunan yüzey sayısı=y Bir robot için hesaplanan koordinat sayısı=tk Bir robot için hesaplanan yüzey sayısı=ys Her bir robotta bulunan eklem sayısı=e Oluşturulacak robot sayısı=r Bir robot oluşumu için hesaplanan eklem ve koordinat sayılarının aldığı değerler aşağıda belirtilmektedir. H=8 P=6 Y=6 E=13 R=1 Oluşturulacak robot sayılarının ilk adımda 70, ikinci adımda 140 ve üçüncü adımda 210 olacak şekilde işlemcilere grafik verisi yüklenerek yapılan performans analizi, çizelge ve grafiksel analizleri sırası ile aşağıda gösterilmektedir adet robot kullanımı Bu adımda oluşturulan ortamın doku verilerine ek olarak 70 adet robota ait yüzeylerin de doku haritalama işlemi yapılmaktadır. Oluşturulan her robot 13 adet eklemden oluşmakta ve her eklemin 8 farklı hareket için yön ve açı koordinat değeri bulunmaktadır. Robot sayısına göre işlemcilerin ek olarak doku haritalama işlemi yapması gereken yüzey miktarı şöyledir; TK= YS=

108 95 Çizelge 5.2 de 70 adet robotun oluşturulması sonucunda oluşan frame sayıları gösterilmektedir. Çizelge adet robot hazırlanması aşamasında oluşan frame sayıları Durum Başlangıç Aşaması Ekran Oluşum Aşaması Kararlı Durum CPU Frame Sayısı CPU + GPU Frame Sayısı Performans Farkı (%) Kayıt edilmiş veriler doğrultusunda 70 adet robot için performans analizi grafiksel olarak Şekil 5.3 te gösterilmektedir CPU Frame Sayısı CPU + GPU Frame Sayısı Performans Farkı (%) Şekil adet robot için performans analizi

109 96 Yukarıda belirtildiği gibi fps değerleri ekranda doku modellemesi yapılacak yüzey miktarına göre değişkenlik göstermektedir. Önceki aşamalarda belirtildiği gibi başlangıç aşamasında işletim sistemi tarafından yapılan ortam hazırlama işlemleri nedeni ile fps değeri düşük bir değerden başlamış ve ardından sadece zemin ve duvarlardan oluşan ekran görüntüsü elde edilmiştir. Grafik ortamı hazırlandıktan sonra kullanıcı taraflı olarak klavyeden verilen komut doğrultusunda ekranda 70 adet robot oluşturulmuştur. Yetmiş adet robotun herbiri için 13 eklem ve her eklemde 6 yüzeyden oluşan doku yüzeyi bulunmaktadır. Yüzey miktarı artıkça işlenecek veri miktarı artmakta ve beraberinde fps değerlerinin düşüşünü getirmektedir adet robot kullanımı Bu adımda ortam hazırlama işlemlerine ek olarak 140 adet robot oluşumu sonucunda meydana gelen frame sayıları karşılaştırmalı olarak gösterilmektedir. Çizelge 5.3 te 140 adet robot oluşturulması durumunda üretilen frame sayıları gösterilmektedir. Robot sayısına göre işlemcilerin ek olarak doku haritalama işlemi yapması gereken robot sayısı bir önceki adıma göre iki katına çıkarılarak 140 adet olarak belirlenmiştir. Oluşturulan robotlar bir önceki adımda oluşturulanlar ile aynı yüzey ve eklem özelliklerine sahiptirler. Bu durumda modelleme yapılacak yüzey oranı oluşturulacak robot sayısı ile orantılı olarak iki katına çıkmaktadır.

110 97 Çizelge adet robot hazırlanması aşamasında oluşan frame sayıları Durum Başlangıç Aşaması Ekran Oluşum Aşaması Kararlı Durum CPU Frame Sayısı CPU + GPU Frame Sayısı Performans Farkı (%) Elde edilen veriler doğrultusunda 140 adet robot için performans analizi grafiksel olarak Şekil 5.4 te gösterilmektedir. Bu veriler 70 adet robot oluşumunda elde edilen verilerle ile benzerlik göstermektedir. Sonraki etapta robot sayısı iki katına çıkarıldığı için doku haritalama yapılacak yüzey miktarı artmaktadır. 70 robotun doku haritalama işleminin merkezi işlemci üzerinde yapılması durumda fps değerinde ve aynı işlemlerin merkezi işlemci birimine ek olarak GPU üzerinde yapılması durumunda fps değerinde kararlı bir hal almakta ve bu durumda oluşturulan görüntü kalitesinde % lık bir iyileşme gözlenmektedir. Ekranda bulunan robotlara 70 adet robotun eklenmesi sonucunda işlenecek veri miktarı artmakta ve fps değerleri merkezi işlemci üzerinde 140 adet robot için değerine ve GPU üzerinde 140 adet robot için değerine düşerek kararlı duruma gelmektedir. Sonuç olarak fps değerlerinde GPU için yaklaşık olarak , CPU için ise lük bir azalma olduğu görülmektedir. Böylelikle 140 adet robot için fps değerlerine bakıldığı zaman kararlı durumda sadece CPU kullanımı ve CPU ile GPU nun beraber kullanımı arasında % luk bir performans artışı olduğu gözlemlenmektedir.

111 CPU Frame Sayısı CPU + GPU Frame Sayısı Performans Farkı (%) Şekil adet robot için karşılaştırmalı performans analizi adet robot kullanımı Bu adımda ortam hazırlama işlemlerine ek olarak 210 adet robot oluşumu sonucunda meydana gelen frame sayıları karşılaştırmalı olarak gösterilmektedir. Çizelge 5.4 te 210 adet robot oluşturulması durumunda üretilen frame sayıları gösterilmektedir. Doku haritalaması yapılacak robot sayısı bir önceki aşamadan 70 adet daha fazladır. Bu durumda ek olarak 5460 yüzeye daha doku haritalama işlemi yapılmaktadır. Elde edilen verilerden görüldüğü üzere, önceki durumlarda olduğu gibi, başlangıç aşamasındaki doku haritalama işleminin fps değerleri hem CPU ve CPU+GPU üzerinde düşük seviyeden başlamaktadır. 210 adet robota doku haritalama işlemi CPU üzerinde yapılırken fps değeri değerinde kararlı duruma geçmekte ve aynı işlem GPU üzerinde yapıldığında fps dğeri değerine çıkmakta ve görüntü kalitesi % oranında artmaktadır. TK= YS=

112 99 Çizelge adet robot hazırlanması aşamasında oluşan frame sayıları Durum Başlangıç Aşaması Ekran Oluşum Aşaması Kararlı Durum CPU Frame Sayısı CPU + GPU Frame Sayısı Performans Farkı (%) Kayıt edilmiş veriler doğrultusunda 210 adet robot için performans analizi grafiksel olarak Şekil 5.5 te gösterilmektedir CPU Frame Sayısı CPU + GPU Frame Sayısı Performans Farkı (%) Şekil adet robot için karşılaştırmalı performans analizi

113 100 Yapılan performans analizlerinden de görüldüğü gibi haritalanması gereken yüzey sayısı arttıkça oluşturulan anlık frame sayısı düşmektedir. Ayrıca frame oluşumu esnasında dışarıdan verilen komutlar doğrultusunda robotlar gruplara özel atanmış hareketler yapmaktadır. Uygulamanın hem başlangıç aşamasında hem de robotların sisteme eklenme aşamasında animasyon hareketleri uygulanmış ve performans analizi yapılırken hesaba katılmıştır. Yapılan bu performans analizleri ve elde edilen fps değerleri doğrultusunda, oluşturulan uygulamada nesnelerin hareket ettirilmesinin doku haritalama performansı üzerinde kayda değer bir değişiklik meydana getirmediği görülmüştür. Şekil 5.6 da 210 adet robotun CPU üzerinde işlenmesi sonrasında oluşturulan ekran görüntüsü gösterilmektedir. Şekil 5.6. CPU üzerinde çalışan 210 robotlu ekran görüntüsü Şekil 5.7 de 210 adet robotun CPU üzerinde işlenmesi sonrasında oluşturulan ekran görüntüsü gösterilmektedir.

114 101 Şekil 5.7. CPU ve GPU üzerinde çalışan 210 robotlu ekran görüntüsü OpenGL ile doku haritalama işlemi ekranda bulunan yüzeylerin istenilen resim veya herhangi bir görüntü dizisi ile kaplanması olarak özetlenebilmektedir. Bu uygulama kapsamında ana renklerin sayısal değerlere dönüştürülerek bir dizi içinde tutularak doku haritalamada kullanılma işlemi yapılmakta ve aynı zamanda uygulamanın bir animasyon özelliği taşıması için herbir nesneye hareket koordinatları verilmektedir. Bu koordinatlar doğrultusunda ve kullanıcı taraflı verilecek komutlar ile ekranda oluşturulan robotlar birbirinden bağımsız dört grup halinde ve birbirinden farklı hareketler yapmaktadır. Bu hareketler ve doku haritalama işlemlerindeki değişen veri miktarına göre fps değerleri ölçülerek analizler yapılmıştır. Bu ölçümler yapılırken görüntü oluşumu sonrasında ekranda bulunan nesnelerin animasyon özelliği de başlatılmış ve bu hareketlerin fps değerleri üzerinde önemli ölçüde bir değişime sebep olmadığı görülmüştür. Bu değerlerin sadece ekrandaki yüzey miktarı ile ilişkili olduğu gözlenmiştir. Aynı zamanda ekrandaki robot miktarı ve koordinat sayısı artıkça robotların hareket hızlarında bir yavaşlama olduğu görülmektedir. Bu uygulamanın ileriki aşamalarında OpenGL tabanlı uygulamalarda görüntü netliği ile birlikte animasyon uygulamalarındaki hareket hızlarında meydana gelen yavaşlama problemi üzerinde çalışılması düşünülmektedir.