4. Funkcionális primitívek GPUn
|
|
|
- Rezső Török
- 6 évvel ezelőtt
- Látták:
Átírás
1 4. Funkcionális primitívek GPUn
2 GPU API emlékeztető Jelenleg a következő eszközök állnak rendelkezésre GPUs kódok futtatására: DirectX vagy OpenGL vagy Vulkan Compute Shader Ez grafikai célokra van kitalálva, nem tudományos számításokra Nincs teljes körű kontroll a memória elrendezés felett (nem lehet átcastolni memóriát), nincs garantálva a pontosság minden IEEE lebegőpontos műveletre Microsoft C++ AMP leálltak a fejlesztéssel, csak egy demonstráció volt OpenMP, OpenACC és társai: pragma alapú párhuzamosítás a forciklusok előtt, nem túl elegáns OpenCL: A C kernelnyelv nem skálázik, összetett dolgokra és generikusságra nem alkalmas, a 2.1-be tervezett C++ kernelnyelv még sehol nincs implementálva Berényi D. - Nagy-Egri M. F. 2
3 GPU API emlékeztető Jelenleg a következő eszközök állnak rendelkezésre GPUs kódok futtatására: Clang / GCC is tud C/C++ kódokat a megfelelő köztesekre átfordítani AMD HCC stack: csak AMD eszközökön működő, a C++ AMP szabvány továbbfejlesztésére épülő nyelvi kiterjesztés Mi az alábbiakkal fogunk részletesebben foglalkozni: NVIDIA CUDA: C++ nyelvi kiterjesztés, aktívan fejlesztik, azonban csak NVIDIA GPUkon fut (bár vannak kísérletek ennek független eszközökkel való átfordítására KHRONOS SYCL standard és annak a ComputeCpp implementációja Még eléggé béta állapotú, de szintén aktívan fejlesztett könyvtár (NEM nyelvi kiterjesztés!!!) Előnye, hogy elvileg minden OpenCL-t támogató szabványos implementáció fölött képes futni (a gyakorlatban ez jelenleg Intel és AMD eszközöket jelent) Berényi D. - Nagy-Egri M. F. 3
4 CUDA vs SYCL Berényi D. - Nagy-Egri M. F. 4
5 CUDA vs SYCL Hasonlóságok: Mindkét rendszer lehetővé teszi a C++ nyelvi eszközök használatát a GPU-kon. Nyilván azokat a részeket, amiket az eszköz nem támogat, nem lehet használni, ebben a közös probléma az exception handling, ezért lényegében a C++ STL-je nem használható GPUkon. Mindkét rendszer alól lehet a grafikai elemeket használni, így textúrákat, grafikus interopot, vektor regisztereket, stb. Mindkét rendszer single-source, azaz közös forrásfájlban található az eszköz és a gazda oldali kód (ellentétben pl. az OpenCL-el). Berényi D. - Nagy-Egri M. F. 5
6 CUDA vs SYCL Különbségek: A CUDA támogat dinamikus allokációt az eszközoldali kódban, a SYCL nem. A CUDA fordítója az nvcc, amely PTX köztest állít elő A SYCL forráskód először C++ kódra és SPIR / SPIRV köztesre fordul, majd a C++ kódot egy gazda oldali fordító fordítja binárissá, amely a megfelelő OpenCL hívásokkal betölti a köztest. Berényi D. - Nagy-Egri M. F. 6
7 CUDA vs SYCL Különbségek: A CUDA egy nyelvi kiterjesztés, a függvényeket annotálni kell, hogy az eszközön, a gazdaoldalon, vagy mindkettőn lesznek majd meghívva. SYCL-ben ilyen megkülönböztetés nincs. //Ez csak host oldalon hívható: global int sq(int x) return x*x; //Ez csak az eszközön: device int sq(int x) return x*x; //Ez mindkettőn: global device int sq(int x) return x*x; Berényi D. - Nagy-Egri M. F. 7
8 CUDA vs SYCL Különbségek: SYCL-ben nincs megkülönböztetve a kód, nem kell a függvényeket és lambdákat annotálni. A fordító ismeri fel, hogy melyik függvény az, ami majd az eszköz hívás belépési pontja lesz és az abban hivatkozott függvényeket megpróbálja az eszközre is lefordítani. Amíg nem használunk olyan funkcionalitást az eszközoldali kódon belül, amit nem lehet a GPUra lefordítani, addig a fordító szó nélkül feldolgozza a tetszőleges (akár nem is GPUra szánt) kódokat. Berényi D. - Nagy-Egri M. F. 8
9 CUDA vs SYCL Jelenlegi állapot: CUDA 10 (2018 szeptember óta) C++ 14 támogatás az eszközoldali kódban is, helyenként limitációkkal SYCL konform GPUs implementáció: ComputeCpp (2018 október) Clang 6.0 alapú, így a legtöbb c++17 szolgáltatás elérhető benne Berényi D. - Nagy-Egri M. F. 9
10 CUDA vs SYCL Példakódok, SDK: A CUDA példakódokat a CUDA telepítő teszi fel. CUDA dokumentáció SYCL specifikáció Compute Cpp SDK: sok hasznos példakód: Berényi D. - Nagy-Egri M. F. 10
11 CUDA vs SYCL Hibakezelés: CUDA: Error kódokat használ host device const char* cudageterrorname ( cudaerror_t error ) Returns the string representation of an error code enum name. host device const char* cudageterrorstring ( cudaerror_t error ) Returns the description string for an error code. host device cudaerror_t cudagetlasterror ( void ) Returns the last error from a runtime call. host device cudaerror_t cudapeekatlasterror ( void ) Returns the last error from a runtime call. Berényi D. - Nagy-Egri M. F. 11
12 CUDA vs SYCL Hibakezelés: SYCL: Exception-ök int main() try auto plats = cl::sycl::platform::get_platforms(); if (plats.empty()) throw std::runtime_error "No OpenCL platform found." ; catch (cl::sycl::exception e) catch (std::exception e) return 0; Berényi D. - Nagy-Egri M. F. 12
13 Funkcionális primitívek GPU-n A három legfontosabb funkcionális primitív, a map, zip, reduce hatékonyan párhuzamosítható, így ezeket implementáljuk először a GPU-kra. Berényi D. - Nagy-Egri M. F. 13
14 CUDA map A teljes kód itt érhető el: Berényi D. - Nagy-Egri M. F. 14
15 CUDA map Az eszközoldali kód törzse: template<typename F, typename T> global void map(f f, T* src, T* dst) int id = blockidx.x * blockdim.x + threadidx.x; dst[id] = f(src[id]); Berényi D. - Nagy-Egri M. F. 15
16 CUDA map Az eszközoldali kód törzse: Ez a belépési pont a gazdaoldalról lesz hívva. template<typename F, typename T> global void map(f f, T* src, T* dst) int id = blockidx.x * blockdim.x + threadidx.x; dst[id] = f(src[id]); Berényi D. - Nagy-Egri M. F. 16
17 CUDA map Az eszközoldali kód törzse: template<typename F, typename T> global void map(f f, T* src, T* dst) int id = blockidx.x * blockdim.x + threadidx.x; dst[id] = f(src[id]); Az eszközoldalon beépített változók a számítási tartomány paraméterei (mint opencl-ben) Berényi D. - Nagy-Egri M. F. 17
18 CUDA map Az eszközoldali kód törzse: template<typename F, typename T> global void map(f f, T* src, T* dst) int id = blockidx.x * blockdim.x + threadidx.x; dst[id] = f(src[id]); A meghívott f függvénynek device annotáltnak kell lennie! Berényi D. - Nagy-Egri M. F. 18
19 CUDA map A gazdaoldali kód törzse: int main() using T = double; using P = T*; int n = 16; size_t sz = n*sizeof(t); std::vector<t> h_src(n), h_dst(n); P d_src, d_dst; cudamalloc( &d_src, sz ); cudamalloc( &d_dst, sz ); cudamemcpy( d_src, h_src.data(), sz, cudamemcpyhosttodevice); cudamemcpy( d_dst, h_dst.data(), sz, cudamemcpyhosttodevice); Berényi D. - Nagy-Egri M. F. 19
20 CUDA map A gazdaoldali kód törzse: int main() using T = double; using P = T*; int n = 16; size_t sz = n*sizeof(t); std::vector<t> h_src(n), h_dst(n); P d_src, d_dst; cudamalloc( &d_src, sz ); cudamalloc( &d_dst, sz ); Memóriafoglalás az eszközön cudamemcpy( d_src, h_src.data(), sz, cudamemcpyhosttodevice); cudamemcpy( d_dst, h_dst.data(), sz, cudamemcpyhosttodevice); Berényi D. - Nagy-Egri M. F. 20
21 CUDA map A gazdaoldali kód törzse: int main() using T = double; using P = T*; int n = 16; size_t sz = n*sizeof(t); std::vector<t> h_src(n), h_dst(n); P d_src, d_dst; cudamalloc( &d_src, sz ); cudamalloc( &d_dst, sz ); Memória másolás az eszközre cudamemcpy( d_src, h_src.data(), sz, cudamemcpyhosttodevice); cudamemcpy( d_dst, h_dst.data(), sz, cudamemcpyhosttodevice); Berényi D. - Nagy-Egri M. F. 21
22 CUDA map A gazdaoldali kód törzse: int blocksize = 4; int gridsize = (int)ceil((float)n/blocksize); auto sq = [] device (auto const& x) return x*x; ; map<<<gridsize, blocksize>>>(sq, d_src, d_dst); Berényi D. - Nagy-Egri M. F. 22
23 CUDA map A gazdaoldali kód törzse: int blocksize = 4; int gridsize = (int)ceil((float)n/blocksize); A teljes elemszámot felosztjuk 4-es blokkokra auto sq = [] device (auto const& x) return x*x; ; map<<<gridsize, blocksize>>>(sq, d_src, d_dst); Berényi D. - Nagy-Egri M. F. 23
24 CUDA map A gazdaoldali kód törzse: Itt adjuk át a méreteket az eszköznek: a blokkok számát és az egy blokkon belüli szálak számát int blocksize = 4; int gridsize = (int)ceil((float)n/blocksize); auto sq = [] device (auto const& x) return x*x; ; map<<<gridsize, blocksize>>>(sq, d_src, d_dst); Berényi D. - Nagy-Egri M. F. 24
25 CUDA map A gazdaoldali kód törzse: Az eszköz oldalon alkalmazandó lambda int blocksize = 4; int gridsize = (int)ceil((float)n/blocksize); auto sq = [] device (auto const& x) return x*x; ; map<<<gridsize, blocksize>>>(sq, d_src, d_dst); Berényi D. - Nagy-Egri M. F. 25
26 CUDA map A gazdaoldali kód törzse: cudamemcpy( h_dst.data(), d_dst, sz, cudamemcpydevicetohost ); cudafree(d_src); cudafree(d_dst); Berényi D. - Nagy-Egri M. F. 26
27 CUDA map A gazdaoldali kód törzse: cudamemcpy( h_dst.data(), d_dst, sz, cudamemcpydevicetohost ); cudafree(d_src); cudafree(d_dst); Az eszközoldali hívás után a memóriát vissza kell másolni a gazda oldalra Berényi D. - Nagy-Egri M. F. 27
28 CUDA map A gazdaoldali kód törzse: cudamemcpy( h_dst.data(), d_dst, sz, cudamemcpydevicetohost ); cudafree(d_src); cudafree(d_dst); Ha végeztünk az eszköz oldali memóriát fel kell szabadítani Berényi D. - Nagy-Egri M. F. 28
29 CUDA map Fordítás: Ha CMAKE-el szeretnénk fordítani, nézzük meg az itteni példát. Paranssorból kézzel: nvcc -std=c expt-extended-lambda map.cu Berényi D. - Nagy-Egri M. F. 29
30 CUDA map Fordítás: Ha CMAKE-el szeretnénk fordítani, nézzük meg az itteni példát. Paranssorból kézzel: nvcc -std=c expt-extended-lambda map.cu A lambdák annotálásához szükséges kiterjesztés engedélyezése Berényi D. - Nagy-Egri M. F. 30
31 CUDA zip A teljes kód itt érhető el: Berényi D. - Nagy-Egri M. F. 31
32 CUDA zip A zip teljesen hasonló a map-hoz: template<typename F, typename T> global void zip(f f, T* src1, T* src2, T* dst) int id = blockidx.x * blockdim.x + threadidx.x; dst[id] = f(src1[id], src2[id]); Berényi D. - Nagy-Egri M. F. 32
33 És most ugyan ez SYCL-ben! Berényi D. - Nagy-Egri M. F. 33
34 SYCL map A teljes kód itt érhető el: Berényi D. - Nagy-Egri M. F. 34
35 SYCL map A sycl használatához be kell includolni a sycl.hpp-t: // SYCL include #include <CL/sycl.hpp> Berényi D. - Nagy-Egri M. F. 35
36 SYCL map A map függvény belsejét külön függvényben írtuk meg: template<typename F, typename RA, typename WA> void map(f f, RA src, WA dst, cl::sycl::id<1> id) dst[id] = f(src[id]); Berényi D. - Nagy-Egri M. F. 36
37 SYCL map A map függvény belsejét külön függvényben írtuk meg: template<typename F, typename RA, typename WA> void map(f f, RA src, WA dst, cl::sycl::id<1> id) dst[id] = f(src[id]); Nincs semmilyen extra annotáció, szemben a CUDA-val Berényi D. - Nagy-Egri M. F. 37
38 SYCL map A map függvény belsejét külön függvényben írtuk meg: template<typename F, typename RA, typename WA> void map(f f, RA src, WA dst, cl::sycl::id<1> id) dst[id] = f(src[id]); Az itteni megvalósításban a bemenő argumentumok accessorok, és a szálazonosító is argumentumként jön a függvénybe (nincsenek beépített változók, mint CUDA-ban) Berényi D. - Nagy-Egri M. F. 38
39 SYCL map A SYCL kód gazda oldali része: cl::sycl::queue queue cl::sycl::gpu_selector() ; cl::sycl::buffer<t, 1> b_src(h_src.data(), n); cl::sycl::buffer<t, 1> b_dst(h_dst.data(), n); cl::sycl::range<1> r(n); Berényi D. - Nagy-Egri M. F. 39
40 SYCL map A SYCL kód gazda oldali része: cl::sycl::queue queue cl::sycl::gpu_selector() ; cl::sycl::buffer<t, 1> b_src(h_src.data(), n); cl::sycl::buffer<t, 1> b_dst(h_dst.data(), n); cl::sycl::range<1> r(n); Parancslista létrehozása, ami most az első GPU eszközt próbálja meg kiválasztani Berényi D. - Nagy-Egri M. F. 40
41 SYCL map A SYCL kód gazda oldali része: cl::sycl::queue queue cl::sycl::gpu_selector() ; cl::sycl::buffer<t, 1> b_src(h_src.data(), n); cl::sycl::buffer<t, 1> b_dst(h_dst.data(), n); cl::sycl::range<1> r(n); Bufferek létrehozása az adatokhoz Berényi D. - Nagy-Egri M. F. 41
42 SYCL map A SYCL kód gazda oldali része: auto sq = [](auto const& x) return x*x; ; queue.submit([&](cl::sycl::handler& cgh) auto a_src = b_src.get_access<cl::sycl::access::mode::read>(cgh); auto a_dst = b_dst.get_access<cl::sycl::access::mode::write>(cgh); cgh.parallel_for<class Map>(r, [=](cl::sycl::id<1> i) map(sq, a_src, a_dst, i); ); ); Berényi D. - Nagy-Egri M. F. 42
43 SYCL map A SYCL kód gazda oldali része: auto sq = [](auto const& x) return x*x; ; queue.submit([&](cl::sycl::handler& cgh) auto a_src = b_src.get_access<cl::sycl::access::mode::read>(cgh); auto a_dst = b_dst.get_access<cl::sycl::access::mode::write>(cgh); cgh.parallel_for<class Map>(r, [=](cl::sycl::id<1> i) map(sq, a_src, a_dst, i); ); ); Semmilyen annotáció nem kell a lambdához sem Berényi D. - Nagy-Egri M. F. 43
44 SYCL map A SYCL kód gazda oldali része: auto sq = [](auto const& x) return x*x; ; queue.submit([&](cl::sycl::handler& cgh) auto a_src = b_src.get_access<cl::sycl::access::mode::read>(cgh); auto a_dst = b_dst.get_access<cl::sycl::access::mode::write>(cgh); cgh.parallel_for<class Map>(r, [=](cl::sycl::id<1> i) map(sq, a_src, a_dst, i); ); ); Hozzáférést kérünk a bufferekhez Berényi D. - Nagy-Egri M. F. 44
45 SYCL map A SYCL kód gazda oldali része: auto sq = [](auto const& x) return x*x; ; queue.submit([&](cl::sycl::handler& cgh) auto a_src = b_src.get_access<cl::sycl::access::mode::read>(cgh); auto a_dst = b_dst.get_access<cl::sycl::access::mode::write>(cgh); cgh.parallel_for<class Map>(r, [=](cl::sycl::id<1> i) map(sq, a_src, a_dst, i); ); ); Egy parallel_for hívást hajtunk végre a megadott kernel névvel Berényi D. - Nagy-Egri M. F. 45
46 SYCL map A SYCL kód gazda oldali része: auto sq = [](auto const& x) return x*x; ; queue.submit([&](cl::sycl::handler& cgh) auto a_src = b_src.get_access<cl::sycl::access::mode::read>(cgh); auto a_dst = b_dst.get_access<cl::sycl::access::mode::write>(cgh); cgh.parallel_for<class Map>(r, [=](cl::sycl::id<1> i) map(sq, a_src, a_dst, i); ); ); Átveszünk mindent érték szerint, ideértve az accessorokat is Berényi D. - Nagy-Egri M. F. 46
47 SYCL map A SYCL kód gazda oldali része: auto sq = [](auto const& x) return x*x; ; queue.submit([&](cl::sycl::handler& cgh) auto a_src = b_src.get_access<cl::sycl::access::mode::read>(cgh); auto a_dst = b_dst.get_access<cl::sycl::access::mode::write>(cgh); cgh.parallel_for<class Map>(r, [=](cl::sycl::id<1> i) map(sq, a_src, a_dst, i); ); ); Argumentumként kapjuk a szálazonosítót Berényi D. - Nagy-Egri M. F. 47
48 SYCL map A SYCL kód gazda oldali része: auto sq = [](auto const& x) return x*x; ; queue.submit([&](cl::sycl::handler& cgh) auto a_src = b_src.get_access<cl::sycl::access::mode::read>(cgh); auto a_dst = b_dst.get_access<cl::sycl::access::mode::write>(cgh); cgh.parallel_for<class Map>(r, [=](cl::sycl::id<1> i) map(sq, a_src, a_dst, i); ); ); Meghívjuk a korábban megírt függvényünket. Berényi D. - Nagy-Egri M. F. 48
49 SYCL fordítás A ComputeCpp-vel, CMAKE-el történő fordításhoz, nézzük meg ezt a példakódot: Amihez szükség van a FindComputeCpp CMAKE modulra, aminek a legfrissebb verziója innen tölthető le: Berényi D. - Nagy-Egri M. F. 49
50 SYCL fordítás Ha nem akarunk CMAKE-el fordítani, akkor parancssorból kb. így fest a dolog: Először a compute++ fordító kiszedi a cpp fáljból a SYCL specifikus részeket és legenerál egy úgynevezett integration headert (esetünkben main.cpp.sycl): /opt/codeplay/computecpp/latest/bin/compute++ -std=c++14 -O2 -mllvm -inline-threshold=1000 -sycl -emit-llvm -intelspirmetadata -isystem /opt/codeplay/computecpp/latest/include/ -I/opt/Codeplay/ComputeCpp/latest/include/ -I/usr/include -o main.cpp.sycl -c main.cpp Ezután a szokásos módon lefordítjuk a forrásfáljt, CSAK hozzá kell adni a generált headert includeként expliciten!: g++ -isystem /opt/codeplay/computecpp/latest/include -O3 -DNDEBUG -include main.cpp.sycl -std=gnu++14 -o main.o -c main.cpp Végül linkelünk (a Wl, -rpath varázslásról bővebben itt): g++ -O3 -DNDEBUG main.o -o SYCL_app rdynamic /opt/codeplay/computecpp/latest/lib/libcomputecpp.so -lopencl -Wl,-rpath,/opt/Codeplay/ComputeCpp/latest/lib Berényi D. - Nagy-Egri M. F. 50
51 SYCL zip A teljes kód itt: Berényi D. - Nagy-Egri M. F. 51
52 Redukciók GPU-n Berényi D. - Nagy-Egri M. F. 52
53 Redukciók GPU-n A korábban bevezetett primitívek között a foldl/r szerepelt mint redukciós primitív: foldl :: (a -> b -> a) -> a -> f b -> a Ezzel az a probléma, hogy nem párhuzamosítható, mert explicit végrehajtási sorrendet ír elő. Berényi D. - Nagy-Egri M. F. 53
54 Redukciók GPU-n A korábban bevezetett primitívek között a foldl/r szerepelt mint redukciós primitív: foldl :: (a -> b -> a) -> a -> f b -> a Ha megváltoztatjuk a szignatúrát, és feltételezzük, hogy a bináris művelet asszociatív és kommutatív, akkor lehetőségünk nyílik átrendezni és párhuzamosítani a műveletet: reduce :: (a -> a -> a) -> f a -> a Berényi D. - Nagy-Egri M. F. 54
55 Redukciók GPU-n A redukciót a következő logikával végezzük el: Az első globális memóriából történő olvasásnál két elemet olvasunk be, eltolva a blokk mérettel (koaleszkált memória hozzáférés) Berényi D. - Nagy-Egri M. F. 55
56 Redukciók GPU-n A redukciót a következő logikával végezzük el: Az első globális memóriából történő olvasásnál két elemet olvasunk be, eltolva a blokk mérettel (koaleszkált memória hozzáférés) ezeket azonnal redukáljuk és letároljuk a lokális (shared) memóriában. Berényi D. - Nagy-Egri M. F. 56
57 Redukciók GPU-n A redukciót a következő logikával végezzük el: Az első globális memóriából történő olvasásnál két elemet olvasunk be, eltolva a blokk mérettel (koaleszkált memória hozzáférés) ezeket azonnal redukáljuk és letároljuk a lokális (shared) memóriában. A további redukciót is ugyan itt végezzük, minden lépésben felezve az eltolást (a megosztott memória bank-conflictjainak elkerülésére) Berényi D. - Nagy-Egri M. F. 57
58 Redukciók GPU-n A redukciót a következő logikával végezzük el: Az első globális memóriából történő olvasásnál két elemet olvasunk be, eltolva a blokk mérettel (koaleszkált memória hozzáférés) ezeket azonnal redukáljuk és letároljuk a lokális (shared) memóriában. A további redukciót is ugyan itt végezzük, minden lépésben felezve az eltolást (a megosztott memória bank-conflictjainak elkerülésére) Végeredményben minden munkacsoport (blokk) egyetlen értéket fog előállítani. Ennek a redukálását vagy gazda oldalon végezzük, vagy egy külön kernel indításban. Berényi D. - Nagy-Egri M. F. 58
59 CUDA reduce A teljes kód itt: Berényi D. - Nagy-Egri M. F. 59
60 CUDA reduce template<typename F, typename T> global void reduce(f f, T* src, T* dst) extern shared T tmp[]; auto t = threadidx.x; auto i = blockidx.x * (2*blockDim.x) + threadidx.x; tmp[t] = f( src[i], src[i+blockdim.x] ); syncthreads(); for(auto s=blockdim.x/2; s > 0; s >>= 1) if(t < s) tmp[t] = f(tmp[t], tmp[t + s]); syncthreads(); if(t == 0) dst[blockidx.x] = tmp[0]; Berényi D. - Nagy-Egri M. F. 60
61 CUDA reduce template<typename F, typename T> Lokális memória bevezetése, global void reduce(f f, T* src, T* dst) a mérete a hívó oldalról jön. extern shared T tmp[]; auto l = threadidx.x; auto i = blockidx.x * (2*blockDim.x) + threadidx.x; tmp[l] = f( src[i], src[i+blockdim.x] ); syncthreads(); for(auto s=blockdim.x/2; s > 0; s >>= 1) if(l < s) tmp[l] = f(tmp[l], tmp[l + s]); syncthreads(); if(l == 0) dst[blockidx.x] = tmp[0]; Berényi D. - Nagy-Egri M. F. 61
62 CUDA reduce template<typename F, typename T> global void reduce(f f, T* src, T* dst) Lokális (blokkon belüli) szálindex extern shared T tmp[]; auto l = threadidx.x; auto i = blockidx.x * (2*blockDim.x) + threadidx.x; tmp[l] = f( src[i], src[i+blockdim.x] ); syncthreads(); for(auto s=blockdim.x/2; s > 0; s >>= 1) if(l < s) tmp[l] = f(tmp[l], tmp[l + s]); syncthreads(); if(l == 0) dst[blockidx.x] = tmp[0]; Berényi D. - Nagy-Egri M. F. 62
63 CUDA reduce template<typename F, typename T> Globális szálazonosító, de global void reduce(f f, T* src, T* dst) kétszeresére felhízlalt blokkmérettel az eltolás miatt extern shared T tmp[]; auto l = threadidx.x; auto i = blockidx.x * (2*blockDim.x) + threadidx.x; tmp[l] = f( src[i], src[i+blockdim.x] ); syncthreads(); for(auto s=blockdim.x/2; s > 0; s >>= 1) if(l < s) tmp[l] = f(tmp[l], tmp[l + s]); syncthreads(); if(l == 0) dst[blockidx.x] = tmp[0]; Berényi D. - Nagy-Egri M. F. 63
64 CUDA reduce template<typename F, typename T> global void reduce(f f, T* src, T* dst) extern shared T tmp[]; auto l = threadidx.x; auto i = blockidx.x * (2*blockDim.x) + threadidx.x; tmp[l] = f( src[i], src[i+blockdim.x] ); syncthreads(); for(auto s=blockdim.x/2; s > 0; s >>= 1) if(l < s) tmp[l] = f(tmp[l], tmp[l + s]); syncthreads(); if(l == 0) dst[blockidx.x] = tmp[0]; Berényi D. - Nagy-Egri M. F. 64 Első redukció a globális olvasáskor, a két elem között egy blokkméret eltolás van
65 CUDA reduce template<typename F, typename T> global void reduce(f f, T* src, T* dst) extern shared T tmp[]; auto l = threadidx.x; auto i = blockidx.x * (2*blockDim.x) + threadidx.x; tmp[l] = f( src[i], src[i+blockdim.x] ); syncthreads(); for(auto s=blockdim.x/2; s > 0; s >>= 1) if(l < s) tmp[l] = f(tmp[l], tmp[l + s]); syncthreads(); if(l == 0) dst[blockidx.x] = tmp[0]; Lokális memóriát írtunk, és most olvasni fogjuk, ezért szinkronizálni kell a szálakat! Berényi D. - Nagy-Egri M. F. 65
66 CUDA reduce template<typename F, typename T> global void reduce(f f, T* src, T* dst) extern shared T tmp[]; auto l = threadidx.x; auto i = blockidx.x * (2*blockDim.x) + threadidx.x; tmp[l] = f( src[i], src[i+blockdim.x] ); syncthreads(); for(auto s=blockdim.x/2; s > 0; s >>= 1) if(l < s) tmp[l] = f(tmp[l], tmp[l + s]); syncthreads(); if(l == 0) dst[blockidx.x] = tmp[0]; Egyre csökkenő eltolással további redukció a lokális memóriában Minden lépés végén szinkronizáció! Berényi D. - Nagy-Egri M. F. 66
67 CUDA reduce template<typename F, typename T> global void reduce(f f, T* src, T* dst) extern shared T tmp[]; auto l = threadidx.x; auto i = blockidx.x * (2*blockDim.x) + threadidx.x; tmp[l] = f( src[i], src[i+blockdim.x] ); syncthreads(); for(auto s=blockdim.x/2; s > 0; s >>= 1) if(l < s) tmp[l] = f(tmp[l], tmp[l + s]); syncthreads(); if(l == 0) dst[blockidx.x] = tmp[0]; Berényi D. - Nagy-Egri M. F. 67 Végül egyetlen szál visszaírja a lokális memória elejéről a kimenő tömbbe a blokk eredményét
68 CUDA reduce Gazdaoldali felparaméterezés: int n = 256; int blocksize = 16; size_t gridsize = (size_t)ceil((float)n/2/blocksize); reduce<<<gridsize, blocksize, blocksize*sizeof(t)>>>(sum, d_src, d_dst); Berényi D. - Nagy-Egri M. F. 68
69 CUDA reduce Gazdaoldali felparaméterezés: Minden szál 2 értéket olvas a globális memóriából, ezért a teljes méretet itt felezni kell! int n = 256; int blocksize = 16; size_t gridsize = (size_t)ceil((float)n/2/blocksize); reduce<<<gridsize, blocksize, blocksize*sizeof(t)>>>(sum, d_src, d_dst); Berényi D. - Nagy-Egri M. F. 69
70 CUDA reduce Gazdaoldali felparaméterezés: int n = 256; int blocksize = 16; size_t gridsize = (size_t)ceil((float)n/2/blocksize); reduce<<<gridsize, blocksize, blocksize*sizeof(t)>>>(sum, d_src, d_dst); Itt kell megadni a lokális memória méretét byte-okban Berényi D. - Nagy-Egri M. F. 70
71 SYCL reduce Hogy fest ugyanez SYCL-ben? A teljes kód itt: Berényi D. - Nagy-Egri M. F. 71
72 SYCL reduce template<typename F, typename RA, typename RWA, typename WA> void reduce(f f, RA src, RWA tmp, WA dst, cl::sycl::nd_item<1> id) auto g = id.get_group().get(0); auto bs = id.get_local_range().get(0); auto l = id.get_local().get(0); auto i = g * bs * 2 + l; tmp[l] = f( src[i], src[i+bs] ); id.barrier(cl::sycl::access::fence_space::local_space); for(auto s=bs/2; s > 0; s >>= 1) if(l < s) tmp[l] = f(tmp[l], tmp[l + s]); id.barrier(cl::sycl::access::fence_space::local_space); if(l == 0) dst[g] = tmp[0]; Berényi D. - Nagy-Egri M. F. 72
73 SYCL reduce template<typename F, typename RA, typename RWA, typename WA> void reduce(f f, RA src, RWA tmp, WA dst, cl::sycl::nd_item<1> id) auto g = id.get_group().get(0); auto bs = id.get_local_range().get(0); auto l = id.get_local().get(0); auto i = g * bs * 2 + l; tmp[l] = f( src[i], src[i+bs] ); id.barrier(cl::sycl::access::fence_space::local_space); A lokális memóriát is accessorral érjük el, mint a buffereket! for(auto s=bs/2; s > 0; s >>= 1) if(l < s) tmp[l] = f(tmp[l], tmp[l + s]); id.barrier(cl::sycl::access::fence_space::local_space); if(l == 0) dst[g] = tmp[0]; Berényi D. - Nagy-Egri M. F. 73
74 SYCL reduce template<typename F, typename RA, typename RWA, typename WA> void reduce(f f, RA src, RWA tmp, WA dst, cl::sycl::nd_item<1> id) auto g = id.get_group().get(0); auto bs = id.get_local_range().get(0); auto l = id.get_local().get(0); auto i = g * bs * 2 + l; tmp[l] = f( src[i], src[i+bs] ); Mivel most lokális index is van, nd_item-et használunk id.barrier(cl::sycl::access::fence_space::local_space); for(auto s=bs/2; s > 0; s >>= 1) if(l < s) tmp[l] = f(tmp[l], tmp[l + s]); id.barrier(cl::sycl::access::fence_space::local_space); if(l == 0) dst[g] = tmp[0]; Berényi D. - Nagy-Egri M. F. 74
75 SYCL reduce template<typename F, typename RA, typename RWA, typename WA> void reduce(f f, RA src, RWA tmp, WA dst, cl::sycl::nd_item<1> id) auto g = id.get_group().get(0); auto bs = id.get_local_range().get(0); auto l = id.get_local().get(0); auto i = g * bs * 2 + l; tmp[l] = f( src[i], src[i+bs] ); id.barrier(cl::sycl::access::fence_space::local_space); Ez az indexelés pontosan a CUDA-s megvalósítást másolja minden méretet és indexet az nd_item-ből tudunk lekérni for(auto s=bs/2; s > 0; s >>= 1) if(l < s) tmp[l] = f(tmp[l], tmp[l + s]); id.barrier(cl::sycl::access::fence_space::local_space); if(l == 0) dst[g] = tmp[0]; Berényi D. - Nagy-Egri M. F. 75
76 SYCL reduce template<typename F, typename RA, typename RWA, typename WA> void reduce(f f, RA src, RWA tmp, WA dst, cl::sycl::nd_item<1> id) auto g = id.get_group().get(0); auto bs = id.get_local_range().get(0); auto l = id.get_local().get(0); auto i = g * bs * 2 + l; tmp[l] = f( src[i], src[i+bs] ); Szintén az nd_item-en keresztül történik a szinkronizáció is. id.barrier(cl::sycl::access::fence_space::local_space); for(auto s=bs/2; s > 0; s >>= 1) if(l < s) tmp[l] = f(tmp[l], tmp[l + s]); id.barrier(cl::sycl::access::fence_space::local_space); if(l == 0) dst[g] = tmp[0]; Berényi D. - Nagy-Egri M. F. 76
77 SYCL reduce Gazdaoldali kód: size_t n = 256, local_count = 16; cl::sycl::nd_range<1> r(n/2, local_count); queue.submit([&](cl::sycl::handler& cgh) auto a_src = b_src.get_access<cl::sycl::access::mode::read>(cgh); auto a_dst = b_dst.get_access<cl::sycl::access::mode::write>(cgh); cl::sycl::accessor<t, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local> a_tmp(cl::sycl::range<1>(local_count), cgh); ); cgh.parallel_for<class Reduce>(r, [=](cl::sycl::nd_item<1> i) reduce(sum, a_src, a_tmp, a_dst, i); ); Berényi D. - Nagy-Egri M. F. 77
78 SYCL reduce Gazdaoldali kód: size_t n = 256, local_count = 16; cl::sycl::nd_range<1> r(n/2, local_count); queue.submit([&](cl::sycl::handler& cgh) auto a_src = b_src.get_access<cl::sycl::access::mode::read>(cgh); auto a_dst = b_dst.get_access<cl::sycl::access::mode::write>(cgh); cl::sycl::accessor<t, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local> a_tmp(cl::sycl::range<1>(local_count), cgh); Itt hozzuk létre az nd_range-t, ami a globális méretet és a blokkméretet írja le. ); cgh.parallel_for<class Reduce>(r, [=](cl::sycl::nd_item<1> i) reduce(sum, a_src, a_tmp, a_dst, i); ); Berényi D. - Nagy-Egri M. F. 78
79 SYCL reduce Gazdaoldali kód: size_t n = 256, local_count = 16; cl::sycl::nd_range<1> r(n/2, local_count); queue.submit([&](cl::sycl::handler& cgh) auto a_src = b_src.get_access<cl::sycl::access::mode::read>(cgh); auto a_dst = b_dst.get_access<cl::sycl::access::mode::write>(cgh); cl::sycl::accessor<t, 1, cl::sycl::access::mode::read_write, cl::sycl::access::target::local> a_tmp(cl::sycl::range<1>(local_count), cgh); Ez az accessor a lokális memóriához ad hozzáférést. A típusa a használatát, a konstruktora a méretet adja meg. ); cgh.parallel_for<class Reduce>(r, [=](cl::sycl::nd_item<1> i) reduce(sum, a_src, a_tmp, a_dst, i); ); Berényi D. - Nagy-Egri M. F. 79
80 GPU Reduce A redukció még sokkal tovább optimalizálható a belső for ciklus kifejtésével. Érdemes elolvasni ezt a redukció optimalizálásának gondolatmenetéről. Berényi D. - Nagy-Egri M. F. 80
81 GPU Reduce A most ismertetett konstrukcióban kihasználtuk, hogy a bináris művelet kommutatív és asszociatív! Ha nem asszociatív, akkor csak foldolni tudunk. Ha asszociatív, de nem kommutatív, akkor párhuzamosíthatunk, de a memóriahozzáférés nem lesz ideális Berényi D. - Nagy-Egri M. F. 81
Videókártya - CUDA kompatibilitás: CUDA weboldal: Példaterületek:
Hasznos weboldalak Videókártya - CUDA kompatibilitás: https://developer.nvidia.com/cuda-gpus CUDA weboldal: https://developer.nvidia.com/cuda-zone Példaterületek: http://www.nvidia.com/object/imaging_comp
Párhuzamos és Grid rendszerek
Párhuzamos és Grid rendszerek (10. ea) GPGPU Szeberényi Imre BME IIT Az ábrák egy része az NVIDIA oktató anyagaiból és dokumentációiból származik. Párhuzamos és Grid rendszerek BME-IIT
OpenCL - The open standard for parallel programming of heterogeneous systems
OpenCL - The open standard for parallel programming of heterogeneous systems GPU-k általános számításokhoz GPU Graphics Processing Unit Képalkotás: sok, általában egyszerű és független művelet < 2006:
Magas szintű optimalizálás
Magas szintű optimalizálás Soros kód párhuzamosítása Mennyi a várható teljesítmény növekedés? Erős skálázódás (Amdahl törvény) Mennyire lineáris a skálázódás a párhuzamosítás növelésével? S 1 P 1 P N GPGPU
CUDA haladó ismeretek
CUDA haladó ismeretek CUDA környezet részletei Többdimenziós indextér használata Megosztott memória használata Atomi műveletek használata Optimalizálás Hatékonyság mérése Megfelelő blokkméret kiválasztása
Pénzügyi algoritmusok
Pénzügyi algoritmusok A C++ programozás alapjai Tömbök (3. rész) Konstansok Kivételkezelés Tömbök 3. Többdimenziós tömbök Többdimenziós tömbök int a; Többdimenziós tömbök int a[5]; Többdimenziós tömbök
OpenCL alapú eszközök verifikációja és validációja a gyakorlatban
OpenCL alapú eszközök verifikációja és validációja a gyakorlatban Fekete Tamás 2015. December 3. Szoftver verifikáció és validáció tantárgy Áttekintés Miért és mennyire fontos a megfelelő validáció és
Bevezetés a programozásba. 8. Előadás: Függvények 2.
Bevezetés a programozásba 8. Előadás: Függvények 2. ISMÉTLÉS Helló #include using namespace std; int main() cout
Programozás C++ -ban 2007/7
Programozás C++ -ban 2007/7 1. Másoló konstruktor Az egyik legnehezebben érthető fogalom C++ -ban a másoló konstruktor, vagy angolul "copy-constructor". Ez a konstruktor fontos szerepet játszik az argumentum
Grafikus kártyák, mint olcsó szuperszámítógépek - I.
(1) Grafikus kártyák, mint olcsó szuperszámítógépek - I. tanuló szeminárium Jurek Zoltán, Tóth Gyula SZFKI, Röntgendiffrakciós csoport (2) Vázlat I. Motiváció Beüzemelés C alapok CUDA programozási modell,
Készítette: Trosztel Mátyás Konzulens: Hajós Gergely
Készítette: Trosztel Mátyás Konzulens: Hajós Gergely Monte Carlo Markov Chain MCMC során egy megfelelően konstruált Markov-lánc segítségével mintákat generálunk. Ezek eloszlása követi a céleloszlást. A
Bevezetés a programozásba 2
Bevezetés a programozásba 2 7. Előadás: STL konténerek, sablonok http://digitus.itk.ppke.hu/~flugi/ Vector int int main() { vector v(10); int int sum=0; for for (int i=0;i
Programozás II. 2. Dr. Iványi Péter
Programozás II. 2. Dr. Iványi Péter 1 C++ Bjarne Stroustrup, Bell Laboratórium Első implementáció, 1983 Kezdetben csak precompiler volt C++ konstrukciót C-re fordította A kiterjesztés alapján ismerte fel:.cpp.cc.c
3. Osztályok II. Programozás II
3. Osztályok II. Programozás II Bevezető feladat Írj egy Nevsor osztályt, amely legfeljebb adott mennyiségű nevet képes eltárolni. A maximálisan tárolható nevek számát a konstruktorban adjuk meg. Az osztályt
Eichhardt Iván GPGPU óra anyagai
OpenCL modul 1. óra Eichhardt Iván iffan@caesar.elte.hu GPGPU óra anyagai http://cg.inf.elte.hu/~gpgpu/ OpenCL API és alkalmazása Gyakorlati példák (C/C++) Pl.: Képfeldolgozás Párhuzamos tervezési minták
GPU Lab. 14. fejezet. OpenCL textúra használat. Grafikus Processzorok Tudományos Célú Programozása. Berényi Dániel Nagy-Egri Máté Ferenc
14. fejezet OpenCL textúra használat Grafikus Processzorok Tudományos Célú Programozása Textúrák A textúrák 1, 2, vagy 3D-s tömbök kifejezetten szín információk tárolására Főbb különbségek a bufferekhez
Mechatronika és mikroszámítógépek 2017/2018 I. félév. Bevezetés a C nyelvbe
Mechatronika és mikroszámítógépek 2017/2018 I. félév Bevezetés a C nyelvbe A C programozási nyelv A C egy általános célú programozási nyelv, melyet Dennis Ritchie fejlesztett ki Ken Thompson segítségével
Programozás I. 3. gyakorlat. Szegedi Tudományegyetem Természettudományi és Informatikai Kar
Programozás I. 3. gyakorlat Szegedi Tudományegyetem Természettudományi és Informatikai Kar Antal Gábor 1 Primitív típusok Típus neve Érték Alap érték Foglalt tár Intervallum byte Előjeles egész 0 8 bit
Kivételkezelés a C++ nyelvben Bevezetés
Kivételkezelés a C++ nyelvben Bevezetés Miskolci Egyetem Általános Informatikai Tanszék Kivételkezelés a C++ nyelvben CPP9 / 1 Hagyományos hibakezelés Függvény visszatérési értéke (paramétere) hátrányai:
GPU Lab. 4. fejezet. Fordítók felépítése. Grafikus Processzorok Tudományos Célú Programozása. Berényi Dániel Nagy-Egri Máté Ferenc
4. fejezet Fordítók felépítése Grafikus Processzorok Tudományos Célú Programozása Fordítók Kézzel assembly kódot írni nem érdemes, mert: Egyszerűen nem skálázik nagy problémákhoz arányosan sok kódot kell
CUDA alapok CUDA projektek. CUDA bemutató. Adatbányászat és Webes Keresés Kutatócsoport SZTAKI
SZTAKI 2010 Tartalom 1 2 Tartalom 1 2 GPU-k és a CUDA El zmények grakus kártyák: nagy párhuzamos számítási kapacitás eredetileg csak grakus m veleteket tudtak végezni GPU-k és a CUDA El zmények grakus
Dinamikus csatolású függvénykönyvtár készítése és használata Plugin-szerű betöltés Egyszeű C++ osztályok készítése
FEJLETT PROGRAMOZÁSI NYELVEK, 2009 2. GYAKORLAT - Linux alatti C/C++ programozás Cél: Dinamikus csatolású függvénykönyvtár készítése és használata Plugin-szerű betöltés Egyszeű C++ osztályok készítése
Diplomamunka. Miskolci Egyetem. GPGPU technológia kriptográfiai alkalmazása. Készítette: Csikó Richárd VIJFZK mérnök informatikus
Diplomamunka Miskolci Egyetem GPGPU technológia kriptográfiai alkalmazása Készítette: Csikó Richárd VIJFZK mérnök informatikus Témavezető: Dr. Kovács László Miskolc, 2014 Köszönetnyilvánítás Ezúton szeretnék
Eichhardt Iván GPGPU óra anyagai
OpenCL modul 1. óra Eichhardt Iván iffan@caesar.elte.hu GPGPU óra anyagai http://cg.inf.elte.hu/~gpgpu/ OpenCL API és alkalmazása Gyakorlati példák (C/C++) Pl.: Képfeldolgozás Párhuzamos programozás elméleti
GPGPU-k és programozásuk Dezső, Sima Sándor, Szénási
GPGPU-k és programozásuk Dezső, Sima Sándor, Szénási GPGPU-k és programozásuk írta Dezső, Sima és Sándor, Szénási Szerzői jog 2013 Typotex Kivonat A processzor technika alkalmazásának fejlődése terén napjaink
A verem (stack) A verem egy olyan struktúra, aminek a tetejéről kivehetünk egy (vagy sorban több) elemet. A verem felhasználása
A verem (stack) A verem egy olyan struktúra, aminek a tetejére betehetünk egy új (vagy sorban több) elemet a tetejéről kivehetünk egy (vagy sorban több) elemet A verem felhasználása Függvény visszatérési
Clang Static Analyzer belülről
Clang Static Analyzer belülről Nagy Donát 2015. október 6. Áttekintés 1 Clang Static Analyzer kívülről 2 A statikus elemzés folyamata 3 Az eszköz felépítése 4 Egy checker felépítése Rövid definíciók Clang
Jurek Zoltán, Tóth Gyula
Grafikus kártyák, mint olcsó szuperszámítógépek II. rész: GPU nap 2010, MTA RMKI Budapest, 2010. június 4. Tartalom 1 A CUDA futtatási modellje Implementáció 2 Make it work. - A működő párhuzamos kódig
Google Summer of Code OpenCL image support for the r600g driver
Google Summer of Code 2015 OpenCL image support for the r600g driver Képek: http://www.google-melange.com a Min szeretnék dolgozni? Kapcsolatfelvétel a mentorral Project proposal Célok Miért jó ez? Milestone-ok
Programozás C nyelven FELÜLNÉZETBŐL elhullatott MORZSÁK. Sapientia EMTE
Programozás C nyelven FELÜLNÉZETBŐL elhullatott MORZSÁK Sapientia EMTE 2015-16 1 Felülnézet 1 Feltételes fordítás #if, #else, #elif, #endif, #ifdef, #ifndef stb. Felülnézet 2 #include: hatására a preprocesszor
Függvény pointer. Feladat: Egy tömbben soroljunk fel függvényeket, és hívjuk meg valahányszor.
Függvény pointer Több feladat közül futási időben döntöm el, hogy melyiket hajtom végre. A függvényre mutató pointer a függvény kódjának a címére mutat, azon keresztül meghívhatom a függvényt. A pointernek
1. Bevezetés szeptember 9. BME Fizika Intézet. Szám. szim. labor ea. Tőke Csaba. Tudnivalók. feladat. Tematika. Moodle Házi feladatok
Számítógépes szimulációk 1. Bevezetés BME Fizika Intézet 2015. szeptember 9. Bevezetés A félév menete C-ismétlés, 1. rész Oktatók: Nagyfalusi Balázs: nagyfalusi@phy.bme.hu, F3 211. : tcsaba@eik.bme.hu,
A függvény kód szekvenciáját kapcsos zárójelek közt definiáljuk, a { } -ek közti részt a Bash héj kód blokknak (code block) nevezi.
Függvények 1.Függvények...1 1.1.A függvény deníció szintaxisa... 1..Függvények érték visszatérítése...3 1.3.Környezettel kapcsolatos kérdések...4 1.4.Lokális változók használata...4 1.5.Rekurzív hívások...5.kód
Miről lesz ma szó? A PROGAMOZÁS ALAPJAI 1. Dinamikus változók. Dinamikus változók. Dinamikus változók. Dinamikus változók. 7.
Miről lesz ma szó? A PROGAMOZÁS ALAPJAI 1 Vitéz András egyetemi adjunktus BME Híradástechnikai Tanszék vitez@hit.bme.hu Dinamikus memóriakezelés Dinamikus tömbök Dinamikus stringek Program kapcsolata a
1.1. A forrásprogramok felépítése Nevek és kulcsszavak Alapvető típusok. C programozás 3
Darvay Zsolt Típusok és nevek a forráskódban Állandók és változók Hatókörök és az előfeldolgozó Bevitel és kivitel Kifejezések Utasítások Mutatók Függvények Struktúrák és típusok Állománykezelés C programozás
Programozás C és C++ -ban
Programozás C és C++ -ban 2. További különbségek a C és C++ között 2.1 Igaz és hamis A C++ programozási nyelv a C-hez hasonlóan definiál néhány alap adattípust: char int float double Ugyanakkor egy új
Bevezetés a programozásba. 9. Előadás: Rekordok
Bevezetés a programozásba 9. Előadás: Rekordok ISMÉTLÉS Függvényhívás #include #include #include #include using using namespace namespace std; std; double double terulet(double
1. Template (sablon) 1.1. Függvénysablon Függvénysablon példányosítás Osztálysablon
1. Template (sablon) 1.1. Függvénysablon Maximum függvény megvalósítása függvénynév túlterheléssel. i n l i n e f l o a t Max ( f l o a t a, f l o a t b ) { return a>b? a : b ; i n l i n e double Max (
GPGPU-k és programozásuk
GPGPU-k és programozásuk Szénási Sándor Augusztus 2013 (1.1 verzió) Szénási Sándor Tartalomjegyzék 1. Bevezetés 2. Programozási modell 1. CUDA környezet alapjai 2. Fordítás és szerkesztés 3. Platform modell
Programozás II gyakorlat. 4. Öröklődés
Programozás II gyakorlat 4. Öröklődés Feladat Egy játékfejlesztő cég olyan programot fejleszt, amely nyilvántartja az alkalmazottai adatait. Tároljuk minden személy: Nevét (legfeljebb 50 karakter) Születési
Mobil Informatikai Rendszerek
Mobil Informatikai Rendszerek Android NDK Native Development Kit 2016. november 27. Sicz-Mesziár János sicz- m e s z i a r. j a n o s @ nik.uni - obuda.hu NDK Native Development Kit Egy set of tools, amely
Felhasználó által definiált adattípus
Felhasználó által definiált adattípus C++ Izsó Tamás 2017. február 24. Izsó Tamás Felhasználó által definiált adattípus/ 1 Irodalom Izsó Tamás Felhasználó által definiált adattípus/ 2 Programtervezési
2011.11.29. JUnit. JUnit használata. IDE támogatás. Parancssori használat. Teszt készítése. Teszt készítése
Tartalom Integrált fejlesztés Java platformon JUnit JUnit használata Tesztelési technikák Demo 2 A specifikáció alapján teszteljük a program egyes részeit, klasszikus V-modell szerint Minden olyan metódust,
Programozás alapjai gyakorlat. 2. gyakorlat C alapok
Programozás alapjai gyakorlat 2. gyakorlat C alapok 2016-2017 Bordé Sándor 2 Forráskód, fordító, futtatható állomány Először megírjuk a programunk kódját (forráskód) Egyszerű szövegszerkesztőben vagy fejlesztőkörnyezettel
Grafikus kártyák, mint olcsó szuperszámítógépek - II.
GPU, mint szuperszámítógép II. ( 1 ) Grafikus kártyák, mint olcsó szuperszámítógépek - II. tanuló szeminárium Jurek Zoltán, Tóth Gyula SZFKI, Röntgendiffrakciós csoport GPU, mint szuperszámítógép II. (
AliROOT szimulációk GPU alapokon
AliROOT szimulációk GPU alapokon Nagy Máté Ferenc & Barnaföldi Gergely Gábor Wigner FK ALICE Bp csoport OTKA: PD73596 és NK77816 TARTALOM 1. Az ALICE csoport és a GRID hálózat 2. Szimulációk és az AliROOT
OpenGL Compute Shader-ek. Valasek Gábor
OpenGL Compute Shader-ek Valasek Gábor Compute shader OpenGL 4.3 óta része a Core specifikációnak Speciális shaderek, amikben a szokásos GLSL parancsok (és néhány új) segítségével általános számítási feladatokat
Programozás alapjai. 5. előadás
5. előadás Wagner György Általános Informatikai Tanszék Cserélve kiválasztásos rendezés (1) A minimum-maximum keresés elvére épül. Ismétlés: minimum keresés A halmazból egy tetszőleges elemet kinevezünk
Programozás II. 4. Dr. Iványi Péter
Programozás II. 4. Dr. Iványi Péter 1 inline függvények Bizonyos függvények annyira rövidek, hogy nem biztos hogy a fordító függvényhívást fordít, hanem inkább az adott sorba beilleszti a kódot. #include
Gregorics Tibor Modularizált programok C++ nyelvi elemei 1
Gregorics Tibor Modularizált programok C++ nyelvi elemei 1 Függvények és paraméterátadás A függvény egy olyan programblokk, melynek végrehajtását a program bármelyik olyan helyéről lehet kezdeményezni
KÉPFELDOLGOZÓ ALGORITMUSOK FEJLESZTÉSE GRAFIKUS HARDVER KÖRNYEZETBEN
KÉPFELDOLGOZÓ ALGORITMUSOK FEJLESZTÉSE GRAFIKUS HARDVER KÖRNYEZETBEN Takács Gábor Konzulens: Vajda Ferenc PhD, adjunktus 1 TARTALOMJEGYZÉK: Budapesti Műszaki és Gazdaságtudományi Egyetem A kutatási projekt
GPGPU és számítások heterogén rendszereken
GPGPU és számítások heterogén rendszereken Eichhardt Iván eichhardt.ivan@sztaki.mta.hu ELTE-s GPGPU óra anyagai http://cg.inf.elte.hu/~gpgpu/ Gyors bevezetés a Párhuzamosságról OpenCL API Gyakorlati példák
C++ Standard Template Library (STL)
Programozási Nyelvek és Fordítóprogramok Tanszék Programozási Nyelvek I. Témák 1 STL alapok 2 STL fogalmak 3 Konténerek 4 Iterátorok 5 Funktorok C++ STL Ne fedezzük fel újra spanyolviaszt! Sok adatszerkezet/algoritmus
GPGPU alapok. GPGPU alapok Grafikus kártyák evolúciója GPU programozás sajátosságai
GPGPU alapok GPGPU alapok Grafikus kártyák evolúciója GPU programozás sajátosságai Szenasi.sandor@nik.uni-obuda.hu GPGPU alapok GPGPU alapok Grafikus kártyák evolúciója GPU programozás sajátosságai Szenasi.sandor@nik.uni-obuda.hu
Programozás I. 5. Előadás: Függvények
Programozás I 5. Előadás: Függvények Függvény Egy alprogram Egy C program általában több kisméretű, könnyen értelmezhető függvényből áll Egy függvény megtalálható minden C programban: ez a main függvény
Programozás 1. Dr. Iványi Péter
Programozás 1. Dr. Iványi Péter 1 C nyelv B.W. Kernighan és D.M. Ritchie, 1978 The C Programming language 2 C nyelv Amerikai Szabványügy Hivatal (ANSI), 1983 X3J11 bizottság a C nyelv szabványosítására
Bevezetés a programozásba Előadás: A const
Bevezetés a programozásba 2 6. Előadás: A const ISMÉTLÉS Interface - Implementation struct Particle { int x,y; unsigned char r,g,b; void rajzol(); }; }; void Particle::rajzol() { gout
GPU Lab. 5. fejezet. A C++ fordítási modellje. Grafikus Processzorok Tudományos Célú Programozása. Berényi Dániel Nagy-Egri Máté Ferenc
5. fejezet A C++ fordítási modellje Grafikus Processzorok Tudományos Célú Programozása Kódtól a végrehajtásig Végrehajtás előtt valamikor létre kell jönnie az adott architektúrára jellemző bináris utasításoknak.
Programozási nyelvek (ADA)
Programozási nyelvek (ADA) Kozsik Tamás előadása alapján Készítette: Nagy Krisztián 1. előadás Hasznos weboldal http://kto.web.elte.hu Program felépítése Programegységek (program unit) eljárások (procedure)
Bevezetés a programozásba Előadás: Objektumszintű és osztályszintű elemek, hibakezelés
Bevezetés a programozásba 2 7. Előadás: Objektumszű és osztályszű elemek, hibakezelés ISMÉTLÉS Osztály class Particle { public: Particle( X, X, Y); virtual void mozog( ); ); virtual void rajzol( ) const;
C programozás. 6 óra Függvények, függvényszerű makrók, globális és
C programozás 6 óra Függvények, függvényszerű makrók, globális és lokális változók 1.Azonosítók A program bizonyos összetevőire névvel (azonosító) hivatkozunk Első karakter: _ vagy betű (csak ez lehet,
1. Bevezetés A C++ nem objektumorientált újdonságai 3
Előszó xiii 1. Bevezetés 1 2. A C++ nem objektumorientált újdonságai 3 2.1. A C és a C++ nyelv 3 2.1.1. Függvényparaméterek és visszatérési érték 3 2.1.2. A main függvény 4 2.1.3. A bool típus 4 2.1.4.
Kivételek, kivételkezelés a C++ nyelvben
2009. Kivételek, kivételkezelés a C++ nyelvben Haladó C++ programozás Kurucz Attila ELTE - IK 2009.06.09. Tartalomjegyzék Tartalomjegyzék... 2 Mi a kivételkezelés?... 3 Alapfogalmak... 3 Kivétel... 3 Try
Járműfedélzeti rendszerek II. 3. előadás Dr. Bécsi Tamás
Járműfedélzeti rendszerek II. 3. előadás Dr. Bécsi Tamás 5.3. Mutatók,tömbök A mutató vagy pointer olyan változó, amely egy másik változó címét tartalmazza. A C nyelvű programokban gyakran használják a
OPENCV TELEPÍTÉSE SZÁMÍTÓGÉPES LÁTÁS ÉS KÉPFELDOLGOZÁS. Tanács Attila Képfeldolgozás és Számítógépes Grafika Tanszék Szegedi Tudományegyetem
OPENCV TELEPÍTÉSE SZÁMÍTÓGÉPES LÁTÁS ÉS KÉPFELDOLGOZÁS Tanács Attila Képfeldolgozás és Számítógépes Grafika Tanszék Szegedi Tudományegyetem OpenCV Nyílt forráskódú szoftver (BSD licensz) Számítógépes látás,
1. Mi a fejállományok szerepe C és C++ nyelvben és hogyan használjuk őket? 2. Milyen alapvető változókat használhatunk a C és C++ nyelvben?
1. Mi a fejállományok szerepe C és C++ nyelvben és hogyan használjuk őket? 2. Milyen alapvető változókat használhatunk a C és C++ nyelvben? 3. Ismertesse a névtér fogalmát! 4. Mit értünk a "változó hatóköre"
Programozás. (GKxB_INTM021) Dr. Hatwágner F. Miklós április 4. Széchenyi István Egyetem, Gy r
Programozás (GKxB_INTM021) Széchenyi István Egyetem, Gy r 2018. április 4. Számok rendezése Feladat: Fejlesszük tovább úgy a buborék rendez algoritmust bemutató példát, hogy a felhasználó adhassa meg a
GPGPU. GPU-k felépítése. Valasek Gábor
GPGPU GPU-k felépítése Valasek Gábor Tartalom A mai órán áttekintjük a GPU-k architekturális felépítését A cél elsősorban egy olyan absztrakt hardvermodell bemutatása, ami segít megérteni a GPU-k hardveres
Függvények. Programozás I. Hatwágner F. Miklós november 16. Széchenyi István Egyetem, Gy r
Programozás I. Széchenyi István Egyetem, Gy r 2014. november 16. Áttekintés kel kapcsolatos fogalmak deklaráció Több, kompatibilis változat is elképzelhet. Meg kell el znie a fv. hívását. Mindenképp rögzíti
Kivételek kezelése (exception handling) Hibakezelés old style. Kivételkezelés
Kivételek kezelése (exception handling) Hibakezelés old style class Szamolo { void szamol( String s, int i ) { int d; if (i!= 0) d = (i+1)/i; else if (s!= null) d = s.length(); else if (i > 10) // applikációs
5-6. ea Created by mrjrm & Pogácsa, frissítette: Félix
2. Adattípusonként különböző regisztertér Célja: az adatfeldolgozás gyorsítása - különös tekintettel a lebegőpontos adatábrázolásra. Szorzás esetén karakterisztika összeadódik, mantissza összeszorzódik.
C++ programok fordítása
C++, 1/ 33 C++ programok fordítása Pataki Norbert 2012. február 24. C++, 2/ 33 Információk Pataki Norbert, patakino@elte.hu http://patakino.web.elte.hu/levelezo Jegy: gyakorlat, Szűgyi Zalán C++, 3/ 33
Bevezetés a programozásba I.
Bevezetés a programozásba I. 9. gyakorlat Intelligens tömbök, mátrixok, függvények Surányi Márton PPKE-ITK 2010.11.09. C++-ban van lehetőség (statikus) tömbök használatára ezeknek a méretét fordítási időben
Alprogramok, paraméterátadás
ELTE Informatikai Kar, Programozási Nyelvek és Fordítóprogramok Tanszék October 24, 2016 Programozási nyelvek Alprogramok Függvények, eljárások Metódusok Korutinok stb. Alprogramok Alprogram: olyan nyelvi
Java I. A Java programozási nyelv
Java I. A Java programozási nyelv története,, alapvető jellemzői Miskolci Egyetem Általános Informatikai Tanszék Utolsó módosítás: 2007. 02. 12. Java I.: Történet, jellemzők, JDK JAVA1 / 1 Egy kis történelem
117. AA Megoldó Alfréd AA 117.
Programozás alapjai 2. (inf.) pót-pótzárthelyi 2011.05.26. gyak. hiányzás: kzhpont: MEG123 IB.028/117. NZH:0 PZH:n Minden beadandó megoldását a feladatlapra, a feladat után írja! A megoldások során feltételezheti,
Adat- és feladat párhuzamos modell Az ISO C99 szabvány részhalmaza
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 és mobil eszközök támogatása OpenGL, OpenGL ES adatcsere
A CUDA előnyei: - Elszórt memória olvasás (az adatok a memória bármely területéről olvashatóak) PC-Vilag.hu CUDA, a jövő technológiája?!
A CUDA (Compute Unified Device Architecture) egy párhuzamos számításokat használó architektúra, amelyet az NVIDIA fejlesztett ki. A CUDA valójában egy számoló egység az NVIDIA GPU-n (Graphic Processing
Programozás 6. Dr. Iványi Péter
Programozás 6. Dr. Iványi Péter 1 Előfeldolgozás része Makrók A forrás kódban elvégzi a helyettesítéseket a fordító Csak egyszer végez helyettesítést Nem olyan makrók, mint a LISP vagy Scheme esetén Csak
Operációs rendszerek III.
A WINDOWS NT memóriakezelése Az NT memóriakezelése Memóriakezelő feladatai: Logikai-fizikai címtranszformáció: A folyamatok virtuális címterének címeit megfelelteti fizikai címeknek. A virtuális memóriakezelés
Újrakonfigurálható technológiák nagy teljesítményű alkalmazásai
Újrakonfigurálható technológiák nagy teljesítményű alkalmazásai GPU-k, GPGPU CUDA Szántó Péter BME MIT, FPGA Laboratórium GPU-k Graphics Processing Unit 2 fő feladat Objektumok transzformációja a lokális
Az UPPAAL egyes modellezési lehetőségeinek összefoglalása. Majzik István BME Méréstechnika és Információs Rendszerek Tanszék
Az UPPAAL egyes modellezési lehetőségeinek összefoglalása Majzik István BME Méréstechnika és Információs Rendszerek Tanszék Résztvevők együttműködése (1) Automaták interakciói üzenetküldéssel Szinkron
Programozási nyelvek Java
-en objektumot tárolunk. Automatikus változók Programozási nyelvek Java Kozsik Tamás előadása alapján Készítette: Nagy Krisztián 3. előadás - végrehajtási vermen (execution stack) jönnek létre - alprogramok
Bevezetés a programozásba II. 8. Előadás: Osztályok, objektumok, osztályszintű metódusok
Bevezetés a programozásba II 8. Előadás: Osztályok, objektumok, osztályszintű metódusok vektor.h #ifndef VEKTOR_H #define VEKTOR_H class Vektor { int meret, *mut; public: Vektor(int meret); int szamlal(int
Kivételkezelés, beágyazott osztályok. Nyolcadik gyakorlat
Kivételkezelés, beágyazott osztályok Nyolcadik gyakorlat Kivételkezelés Nem minden hibát lehet fordítási időben megtalálni Korábban (pl. C-ben) a hibakezelést úgy oldották meg, hogy a függvény hibakódot
LabView Academy. 4. óra párhuzamos programozás
LabView Academy 4. óra párhuzamos programozás Ellenőrző kérdések Hogyan lehet letiltani az automatikus hibakezelés funkciót? a) Engedélyezzük az Execution highlighting ot b) A subvi error out cluster-jét
Programozási nyelvek Java
statikus programszerkezet Programozási nyelvek Java Kozsik Tamás előadása alapján Készítette: Nagy Krisztián 2. előadás csomag könyvtárak könyvtárak forrásfájlok bájtkódok (.java) (.class) primitív osztály
Programozási nyelvek JAVA EA+GY 1. gyakolat
Programozási nyelvek JAVA EA+GY 1. gyakolat EÖTVÖS LORÁND TUDOMÁNYEGYTEM INFORMATIKAI KAR PROGRAMOZÁSI NYELVEK ÉS FORDÍTÓPROGRAMOK TANSZÉK 2018/2019. tavaszi félév Tartalom 1 A Java alapjai 2 Java program
Programozás I. gyakorlat
Programozás I. gyakorlat 1. gyakorlat Alapok Eszközök Szövegszerkesztő: Szintaktikai kiemelés Egyszerre több fájl szerkesztése pl.: gedit, mcedit, joe, vi, Notepad++ stb. Fordító: Szöveges file-ban tárolt
A programozás alapjai
A programozás alapjai Változók A számítógép az adatokat változókban tárolja A változókat alfanumerikus karakterlánc jelöli. A változóhoz tartozó adat tipikusan a számítógép memóriájában tárolódik, szekvenciálisan,
Újrakonfigurálható technológiák nagy teljesítményű alkalmazásai
Újrakonfigurálható technológiák nagy teljesítményű alkalmazásai GPU-k, GPGPU CUDA Szántó Péter BME MIT, FPGA Laboratórium GPU-k Graphics Processing Unit 2 fő feladat Objektumok transzformációja a lokális
A PROGAMOZÁS ALAPJAI 1. Függvény mint függvény paramétere. Függvény mint függvény paramétere. Függvény mint függvény paramétere
2012. április 10. A PROGAMOZÁS ALAPJAI 1 Vitéz András egyetemi adjunktus BME Híradástechnikai Tanszék vitez@hit.bme.hu Miről lesz ma szó? alaki szabályok használata - mintapélda használata - mintapélda
Programozás C++ -ban
8. Dinamikus objektumok Programozás C++ -ban Ahhoz hogy általános prolémákat is meg tudjunk oldani, szükség van arra, hogy dinamikusan hozhassunk létre vagy szüntethessünk meg objektumokat. A C programozási
C vagy C++? Programozási Nyelvek és Fordítóprogramok Tanszék. Pataki Norbert. Programozási Nyelvek I.
Programozási Nyelvek és Fordítóprogramok Tanszék Programozási Nyelvek I. Témák 1 Bevezetés 2 A C++ alapfilozófiája 3 Névterek/namespace-ek 4 Függvények 5 Referenciák C++-ban Motiváció A C és a C++ nyelv
Java II. I A Java programozási nyelv alapelemei
Java II. I A Java programozási nyelv alapelemei Miskolci Egyetem Általános Informatikai Tanszék Utolsó módosítás: 2008. 02. 19. Java II.: Alapelemek JAVA2 / 1 A Java formalizmusa A C, illetve az annak
Az osztályok csomagokba vannak rendezve, minden csomag tetszőleges. Könyvtárhierarhiát fed: Pl.: java/util/scanner.java
Függvények, csomagok Csomagok Az osztályok csomagokba vannak rendezve, minden csomag tetszőleges számú osztályt tartalmazhat Pl.: java.util.scanner Könyvtárhierarhiát fed: Pl.: java/util/scanner.java Célja:
Python tanfolyam Python bevezető I. rész
Python tanfolyam Python bevezető I. rész Mai tematika Amiről szó lesz (most): Interpretált vs. fordított nyelvek, GC Szintakszis Alaptípusok Control flow: szekvencia, szelekció, iteráció... Függvények
Mérnöki programozás 7. Szerkesztette: dr. Vass Péter Tamás
Mérnöki programozás 7 Szerkesztette: dr. Vass Péter Tamás Függvények Függvény (function) egyedi azonosítónévvel ellátott számítási egység. A függvények formájában kidolgozott programkódok viszonylag egyszerűbb
A C programozási nyelv I. Bevezetés
A C programozási nyelv I. Bevezetés Miskolci Egyetem Általános Informatikai Tanszék A C programozási nyelv I. (bevezetés) CBEV1 / 1 A C nyelv története Dennis M. Ritchie AT&T Lab., 1972 rendszerprogramozás,
GPGPU programozás lehetőségei. Nagy Máté Ferenc Budapest ALICE ELTE TTK Fizika MSc 2011 e-science Café
GPGPU programozás lehetőségei Nagy Máté Ferenc Budapest ALICE ELTE TTK Fizika MSc 2011 e-science Café Vázlat Egy, (kettő,) sok. Bevezetés a sokszálas univerzumba. A párhuzamosok a végtelenben találkoznak,