 Bővítmény rendszer  Az OpenGL bővítményeihez hasonló  A specifikiáció természetes fejlődése ▪ Gyártó specifikus bővítmény ▪ Általános bővítmények.

Slides:



Advertisements
Hasonló előadás
C# nyelvi áttekintő A „Programozás C# nyelven (Illés Zoltán)”
Advertisements

2010/2011 ősz Klár Gergely  A DirectX egy alacsonyszintű API gyűjtemény  Multimédiás alkalmazások futtatására, írására szolgál  Részei.
 Folyékony anyagok  Füstszerű jelenségek  Felhők  Festékek.
CUDA.
1 Hernyák Zoltán Programozási Nyelvek II. Eszterházy Károly Főiskola Számítástudományi tsz.
Objective- C Bereczki Gréta Tamara
Objective-C Memória kezelés
2D grafikus rendszerek Szirmay-Kalos László. 2D grafikus editor: GUI, use-case, dinamikus modell L L L R LD LU MouseLDown első pont MouseLDown második...
Bevezetés.  A számítógépes grafika inkrementális képszintézis algoritmusának hardver realizációja  Teljesítménykövetelmények:  Animáció: néhány nsec.
 Adat- és feladat párhuzamos modell  Az ISO C99 szabvány részhalmaza  párhuzamos kiegészítésekkel  Numerikus műveletek az IEEE754 alapján  Beágyazott.
 CUDA mint architektúra  Párhuzamos feldolgozásra optimalizált architektúra  CUDA mint GPGPU keretrendszer  Runtime és Driver API  CUDA C/C++  NVCC.
GPGPU labor I. OpenGL, Cg.
 Fény fotonok szimulációja  Nem változtatja meg a frekvenciát ütközéskor  Homogén és inhomogén közegben.
Dinamikus tömbök.
10. előadás (2004. április 20.) A C előfordító (folytatás) Néhány hasznos compiler opció Egy tanulságos könyvtári függvény Változó hosszúságú argumentum.
11. előadás (2005. május 10.) A make segédprogram Alacsony szintű műveletek és bitmezők Fájl, katalógus rendszer hívások 1.
6. előadás (2005. április 5.) Struktúrák Úniók Új adattípus definíálása Dinamikus memória foglalás 1.
7. előadás (2005. április 12.) Láncolt lista File kezelés 1.
Programozás II. 3. Gyakorlat C++ alapok.
UNIVERSITY OF SZEGED D epartment of Software Engineering UNIVERSITAS SCIENTIARUM SZEGEDIENSIS Programozás II. 6. Gyakorlat const, static, dinamikus 2D.
Mutatók, tömbök, függvények
Számítógépes grafika OpenGL 1. gyakorlat.
6. előadás Parametrikus polimorfizmus. Generikus programozás. Az Ada sablonok.
Számítógépes Grafika 2. gyakorlat Programtervező informatikus (esti) 2011/2012 őszi félév.
Számítógépes grafika 3. gyakorlat.
Programozási Nyelvek (C++) Gyakorlat Gyak 02.
Szoftvertechnológia alapjai Java előadások Förhécz András, doktorandusz tárgy honlap:
Nikházy László Ureczky Bálint Konzulens: dr. Horváth Gábor
Hernyák Zoltán Programozási Nyelvek II.
A D programozási nyelv Angeli Dávid. Nagy vonalakban  C++  
Javascript Microsoft által készített kiegészítése Statikus típusosság Nagy projektek Windows 8 fejlesztésénél WinRT egy részét ebben írták Nyílt forráskódú,
 Kvantált kép fényesség értékei: G [ 0, Gmax ]  G fényességű pontok száma: P(G)
GPGPU A grafikus hardver általános célú felhasználása
Miért is jók a rétegek?  Ha alkalmazást készítünk, nem akarunk IP csomagok küldésével bajlódni Ethernet keretekkel foglalkozni Implementálni megbízható.
UNIVERSITY OF SZEGED D epartment of Software Engineering UNIVERSITAS SCIENTIARUM SZEGEDIENSIS Programozás II. 4. Gyakorlat Függvény paraméterek, dinamikus.
 OpenCL platform  Számító eszközök  OpenCL kontextusok  Parancs sorok  Szinkronizáció  Memória objektumok  OpenCL programok  OpenCL függvények.
2. gyakorlat DirectX 2007/2008 tavasz Klár Gergely
CUDA C/C++ programozás Textúra memória A segédanyag készítése a TÁMOP A/ Nemzeti Kiválóság Program című kiemelt projekt keretében.
CUDA C/C++ programozás Egyéb eszköztárak vegyesen A segédanyag készítése a TÁMOP A/ Nemzeti Kiválóság Program című kiemelt projekt.
CUDA C/C++ programozás
CUDA C/C++ programozás GPU tulajdonságainak lekérdezése A segédanyag készítése a TÁMOP A/ Nemzeti Kiválóság Program című kiemelt.
A Visual Basic nyelvi elemei
CUDA C/C++ programozás Atomikus műveletek A segédanyag készítése a TÁMOP A/ Nemzeti Kiválóság Program című kiemelt projekt keretében.
Függvények a C nyelvben 1 Függvényeket a következő esetekben szokás írni: Ha ugyanazt a tevékenységet többször is el kell végeznünk ugyanolyan típusú,
CUDA C/C++ programozás CUDA C bevezetés A segédanyag készítése a TÁMOP A/ Nemzeti Kiválóság Program című kiemelt projekt keretében.
Vizualizáció és képszintézis Sugárkövetés (Dart + GLSL) Szécsi László.
Képek, képfeldolgozás Szirmay-Kalos László.
Függvények, mutatók Csernoch Mária. Függvények függvény definíciója az értelmezési tartomány tetszőleges eleméhez hozzárendel egy értéket –függvény helyettesítési.
Opencms modul fejlesztés Krizsán Zoltán. Modulok fajtái Nincs előírás, csak tipikus tennivalók: –Content type: új típus(oka)t vezet be. –Template: új.
Grafikus szoftver Szirmay-Kalos László. Interaktív programok felépítése input csővezeték output csővezeték.
Krizsán Zoltán, iit C# osztályok 2 Adattagok  Osztály hatáskörben definiált változó.  Formája: [attribútum] [módosító] típus azonosító [=kezdő érték][,
Google Summer of Code 2015 OpenCL image support for the r600g driver.
Bevezetés.  Miért …  … egyszálúan programozunk?  … probléma ez?  Hogyan …  … változik ez?  … tudjuk kihasználni?  Megéri-e párhuzamosítani?
Szécsi László 3D Grafikus Rendszerek 15. előadás
GPGPU – CUDA 1..
OpenCL bővítmények.
OpenGL 2. gyakorlat Valasek Gábor
Vizualizáció és képszintézis
Görbék, felületek.
Lineáris egyenletrendszerek megoldása
OpenCL bevezetés II..
GPGPU – CUDA 2..
OpenGL II.
Nikházy László Ureczky Bálint Konzulens: dr. Horváth Gábor
OpenGL kiterjesztések (extensions)
OpenGL V.
Bevezetés GPGPU Alkalmazások.
Az objektum-orientáltság
CUDA – OpenGL.
Függvénysablonok használata
Előadás másolata:

 Bővítmény rendszer  Az OpenGL bővítményeihez hasonló  A specifikiáció természetes fejlődése ▪ Gyártó specifikus bővítmény ▪ Általános bővítmények ▪ Core szabvány  Textúra támogatás (Image support)  Együttműködés a grafikus API-val  OpenCL C++ binding

 Image object  1D / 2D / 3D textúrák  4 elemű vektorok  Lineáris interpoláció  Címzési módok  Textúra támogatás  CL_DEVICE_IMAGE_SUPPORT cl_int clGetDeviceInfo(...)

 Image object létrehozása  image formátum  pitch: egy sor tárolásához szükséges byte méret ▪ 0 ha a host_pointer NULL ▪ >= szélesség * elem méret byteban ha a host_pointer adott ▪ csak a betöltéshez szükséges, a belső formátum más lehet! cl_mem clCreateImage2D(...) cl_mem clCreateImage3D(...)

 Textúra formátum leírás  Csatorna sorrend  CL_R, CL_A  CL_INTENSITY  CL_LUMINANCE  CL_RG, CL_RA  CL_RGB  CL_RGBA, CL_ARGB, CL_BGRA typedef struct _cl_image_format { cl_channel_order image_channel_order; cl_channel_type image_channel_data_type; } cl_image_format;

 Textúra adat formátum  CL_SNORM_INT8 / 16  CL_UNORM_INT8 / 16  CL_UNORM_SHORT_565 / 555  CL_UNORM_INT_  CL_SIGNED_INT8 / 16 / 32  CL_UNSIGNED_INT8 / 16 / 32  CL_HALF_FLOAT  CL_FLOAT

 Támogatott formátumok lekérdezése  image_type: 2D/3D image object  image_formats: a támogatott formátumok listája cl_int clGetSupportedImageFormats(cl_context context, cl_mem_flags flags, cl_mem_object_type image_type, cl_uint num_entries, cl_image_format* image_formats, cl_uint* num_image_formats)

 Olvasás Image objektumból  Irás Image objektumba  origin[3]: kezdő koordináták  region[3]: másolandó méret  row_pitch / slice_pitch: reprezentációs méret cl_int clEnqueueReadImage(...) cl_int clEnqueueWriteImage(...)

 Másolás Image objektumok között  src_origin[3]: forrás koordináták  dst_origin[3]: cél koordináták  region[3]: másolandó terület mérete  Másolás Image és Buffer objektum között cl_int clEnqueueCopyImage(...) cl_int clEnqueueCopyImageToBuffer(...) cl_int clEnqueueCopyBufferToImage(...)

 Sampler objektum  normalized_coords: címzési mód  addressing_mode: túlcímzés kezelése ▪ REPEAT, CLAMP_TO_EDGE, CLAMP, NONE  filter_mode: textúra szűrés ▪ NEAREST, LINEAR cl_sampler clCreateSampler(cl_context context, cl_bool normalized_coords, cl_addressing_mode addressing_mode, cl_filter_mode filter_mode, cl_int* errcode_ret)

 Referencia számláló növelése / csökkentése  Sampler információk lekérdezése  CPU oldalon létrehozott sampler tulajdonságai cl_int clRetainSampler(cl_sampler sampler) cl_int clReleaseSampler(cl_sampler sampler) cl_int clGetSamplerInfo(cl_sampler sampler, cl_sampler_info param_name, size_t param_value_size, void* param_value, size_t *param_value_size_ret)

 Image object  Csak olvasható: __read_only  Csak írható: __write_only  Olvasás és írás nem támogatott egyszerre!  Sampler object  Host oldalon létrehozott sampler  Globális konstans sampler const sampler_t samplerName = NORMALIZED_COORDS | ADDRESS_MODE | FILTER_MODE;

 Olvasás az Image objektumból  4 elemű vektor az Image típusának megfelelően  {f, i, ui}: float, int, unsigned int  coord: a sampler címzésének megfelelő koordináták read_image{f,i,ui}(image2d_t image, sampler_t sampler, coord)

 Írás Image objektumba  {f, i, ui}: float, int, unsigned int  coord: cél koordináták  color: a beírandó színvektor void write_image{f,i,ui}(image2d_t image, coord, color)

 Image objektum információk  Image dimenziók  Image formátum int get_image_width(image{2,3}d_t image) int get_image_height(image{2,3}d_t image) int get_image_depth(image3d_t image) int{2,4} get_image_dim(image{2,3}d_t image) int get_image_channel_data_type(image{2,3}d_t image) int get_image_channel_order(image{2,3}d_t image)

 Célja az átjárás megteremtése  OpenGL és DirectX támogatás  Megoszthatóak ▪ Általános buffer objektumok (pl. vertex buffer) ▪ Textúrák ▪ Render bufferek  A megosztandó objektumokat a grafikus API hozza létre ▪ OpenCL-beli használat előtt zárolni kell  Az objektum használata kizárólagos!

 OpenGL és OpenCL kontextus megosztás  GL_SHARING_EXTENSION  OpenGL kontextus információk ▪ CL_CURRENT_DEVICE_FOR_GL_CONTEXT_KHR ▪ CL_DEVICES_FOR_GL_CONTEXT_KHR cl_int clGetGLContextInfoKHR(const cl_context_properties *props, cl_gl_context_info param_name, size_t param_value_size, void* param_value, size_t* param_value_size_ret)

 OpenGL és OpenCL kontextus megosztás  OpenCL kontextus létrehozás ▪ Tulajdonságok: ▪ CL_GL_CONTEXT_KHR: OpenGL kontextus ▪ CL_WGL_HDC_KHR: az OpenGL kontextus HDC-je ▪ CL_CONTEXT_PLATFORM: platform_id cl_context clCreateContext(const cl_context_properties *props, cl_uint num_devices, const cl_device_id *devices, void (*pfn_notify)(...), void *user_data, cl_int *errcode_ret)

 Kontextus megosztása InitGL(); cl_platform platform = createPlatform(); cl_device_id device_id = createDevice(platform, CL_DEVICE_TYPE_GPU); cl_context sharedContext = 0; if(CheckSharingSupport(device_id)){ cl_context_properties props[] = { CL_GL_CONTEXT_KHR, (cl_context_properties)wglGetCurrentContext(), CL_WGL_HDC_KHR, (cl_context_properties)wglGetCurrentDC(), CL_CONTEXT_PLATFORM, (cl_context_properties)platform, 0 }; sharedContext = clCreateContext(props, 1, &device_id, NULL, NULL, &err); }

 Buffer objektumok megosztása  Image objektumok megosztása cl_mem clCreateFromGLBuffer(cl_context context, cl_mem_flags flags, GLuint bufobj, cl_int* errcode_ret) cl_mem clCreateFromGLTexture2D(cl_context context, cl_mem_flags flags, GLenum texture_target, GLint miplevel, GLuint texture, cl_int* errcode_ret)

 Render buffer megosztása  Az OpenCL objektumok tulajdonságai  Létrehozáskor aktuális értékek alapján  Nem követik az OpenGL objektum változásait! ▪ Amennyiben változik újra meg kell osztani! cl_mem clCreateFromGLRenderBuffer(cl_context context, cl_mem_flags flags, GLuint renderbuffer, cl_int* errcode_ret)

 Buffer objektum megosztása  OpenGL vertex buffer mint OpenCL memória objektum GLuint vbo; glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); glBufferData(GL_ARRAY_BUFFER, size, 0, GL_DYNAMIC_DRAW); cl_mem vboCL; vboCL = clCreateFromGLBuffer(sharedContext, CL_MEM_WRITE_ONLY, vbo, NULL);

 Objektum lefoglalása  Objektum felszabadítása  Minden használat előtt le kell foglalni  Használat után fel kell szabadítani cl_int clEnqueueAcquireGLObjects(cl_command_queue command, cl_uint num_objects, const cl_mem* mem_objects,...) cl_mem clEnqueueReleaseGLObjects(cl_command_queue command, cl_uint num_objects, const cl_mem* mem_objects,...)

 Szinkronizáció OpenGL és OpenCL között  Nincs explicit szinkronizáció! ▪ Szüksége lenne mindkét API támogatására  Mindkét API oldalán a csővezeték kiürítése ▪ OpenGL: glFinish() ▪ OpenCL: clFinish()  Implementáció függően más megoldás is lehet ▪ glFlush() és clEnqueueBarrier()

 Buffer objektum használata  OpenGL vertex buffer mint OpenCL memória objektum // OpenGL hívások glFinish(); clEnqueueAcquireGLObjects(command, 1, &vboCL, 0, NULL, NULL); // Kernel paraméterek beállítása és kernel végrehajtás clFinish(); clEnqueueReleaseGLObjects(commands, 1, &vboCL, 0, NULL, NULL); // OpenGL hívások

 Wrapper osztályok az OpenCL API fölé  Direkt módon használja a C API-t  cl::Context context(CL_DEVICE_TYPE_GPU); std::vector devices = context.getInfo(); cl::Program::Sources source(1, std::make_pair(srcString, srcSize)); cl::Program program(context, source); program.build(devices); cl::CommandQueue command(context, devices[0]); cl::Buffer data(context, CL_MEM_READ_WRITE, size); cl::Kernel kernel(program, „kernel”); cl::KernelFunctor func = kernel.bind(command, cl::NDRange(count)); func(data, count).wait();...

 CUDA mint architektúra  Párhuzamos feldolgozásra optimalizált architektúra  CUDA mint GPGPU keretrendszer  Runtime és Driver API  CUDA C/C++  NVCC fordító  CUDA ecosystem  CUBLAS  CUFFT  CUSPARSE  CURAND  Thrust

 Driver API  Alacsony szintű hívások  Hasonló koncepcióra épül mint az OpenCL ▪ Device, Context, Module, Function ▪ Heap memory, CUDA Array, Texture, Surface  Runtime API  Magas szintű felületet nyújt a programozáshoz  Támogatja a host és device függvények keverését  Automatikus keretrendszer menedzsment

 Támogatja a C/C++ szabvány jelentős részét  Adatgyűjtő osztályok  Osztályok származtatása  Osztály sablonok  Függvény sablonok  Funktorok  Nem támogatja  Futásidejű típus információk (RTTI)  Kivételek  C++ Standard Library

 A fordítás menete  A forráskód szétválasztása host és device kódra  A host kód kiegészítése CUDA specifikus kódrészekkel ▪ A továbbiakban a host fordító dolgozik vele  A device kód fordítása a megfelelő architektúrára ▪ Az NVIDIA device fordító hozza létre belőle a binárist  A host és device binárisok összeszerkesztése

#include __global__ void square(int* dataGPU, int dataSize){ int index = blockIdx.x * blockDim.x + threadIdx.x; dataGPU[index] = dataGPU[index] * dataGPU[index] } int main(int argc, char* argv[]){ const int dataSize = 1024; int* dataCPU = (int*)malloc(sizeof(int)*dataSize); for(int i = 0; i < dataSize; ++i){ dataCPU[i] = i; } int* dataGPU; cudaMalloc(&dataGPU, sizeof(int)*dataSize); cudaMemcpy(dataGPU, dataCPU, sizeof(int)*dataSize, cudaMemcpyHostToDevice); int threadsPerBlock = 256; int blocksPerGrid = 4; square >>(dataGPU, dataSize); cudaMemcpy(dataCPU, dataGPU, sizeof(int)*dataSize, cudaMemcpyDeviceToHost); int wrongCount = 0; for(int i = 0; i < dataSize; ++i){ if(dataCPU[i] != i * i) wrongCount++; } printf(„Number of wrong squares: %d\n”, wrongCount); cudaFree(dataGPU); }