Algoritmusok vizsgálata hierarchikus memóriájú rendszerekben
|
|
- Ödön Krisztián Varga
- 8 évvel ezelőtt
- Látták:
Átírás
1 Algoritmusok vizsgálata hierarchikus memóriájú rendszerekben Horváth Gábor december Bevezetés Klasszikusan az algoritmusok futási idejét asszimptotikusan szokás vizsgálni. Kellően nagy méretű bemenetek esetén az asszimptotikusan gyorsabb algoritmus lesz a jó választás. Kisebb méretű bemeneteknél viszont nem ritka, hogy az asszimptotikusan rosszabb futási idejű algoritmus teljesít jobban. Sok esetben a programozó előre tudja, hogy egy adott algoritmusnak várhatóan mekkora méretű bemenetei lesznek. Jó példa erre a felhasználó és a program közti interakciókat érintő algoritmusok egy része, hiszen egy reális korlátot lehet mondani akár a képernyőn megjelenítendő grafikus vezérlők számára, mert bizonyos méret felett a felhasználó nem is tudná feldolgozni azt az információmennyiséget amit a képernyőn lát. Ilyen esetekben az algoritmusok összehasonlítására egy lehetséges módszer bizonyos lépések várható számának az összehasonlítása, például várhatóan hány értékadást hajt végre az algoritmus. Ez a modell viszont azt feltételezi, hogy az értékadások ugyanannyi időt vesznek igénybe függetlenül attól, hogy mikor történnek és milyen értéket írnak felül. A mai architektúrák azonban a teljesítmény növelése érdekében bonyolult gyorsítótárazási megoldásokat használnak. Ahogy az az alábbi táblázatból [3] is látható, csupán azzal, hogy az adat amit épp el akarunk érni, nem csak a memóriában található meg, hanem éppen az első szintű gyorsítótárban is, 200-szor gyorsabban érhető el. Ha csupán egy-egy változó elérése lenne jelentősen gyorsabb, akkor nem befolyásolná jelentősen az algoritmus futási idejét a gyorsítótár, azonban különböző mechanizmusok segítségével a processzor megpróbálja kikövetkeztetni, hogy milyen mintában olvassuk az adatokat a memóriából, és ezáltal megpróbálja előre betölteni a gyorsítótárba azokat az adatokat amikre szükségünk lehet. Ebből kifolyólag amennyiben az algoritmusunk egyszerű mintát követve olvassa az ada- L1 cache reference Branch mispredict L2 cache reference Mutex lock/unlock Main memory reference Read 1 MB sequentially from memory Disk seek Read 1 MB sequentially from disk 0.5 ns 5 ns 7 ns 25 ns 100 ns 250,000 ns 10,000,000 ns 20,000,000 ns 1
2 tokat (lehetőleg sorfolytonosan akár előre akár hátrafelé), a hivatkozott változók túlnyomó többsége a gyorsítótárban lesz addigra, mire hivatkozni vagy írni akarjuk őket. Az egyes műveletek idejét érintő változásokra az algoritmus futási ideje még érzékenyebb lehet. Például, ha egy vonal megjelenítését végző rutin kétszeresére gyorsul, egy táblázatot kirajzoló rutin akár négyszeres gyorsulást is mutathat. A cache-ek elérésénél még gyorsabb a registerek elérése, azonban a registerekkel azért nincs értelme foglalkozni az algoritmusok teljesítményének a vizsgálatakor, mert a fordítók ma már lineáris időben meg tudják állapítani azok közel optimális felhasználását [4]. A program változóinak a helyét, illetve azoknak az elérési mintázatát viszont nem tudják ma sem átrendezni a fordítók, ezért sebességkritikus alkalmazások esetén a programozónak kell erre gondolnia. 2. Mérések metodológiája A méréseimhez a programokat C++ nyelven [2] írom meg, és a gcc fordító es változatával fordítom le. A kódokat a C++11-es szabvány szerint fordítom és az O3 kapcsolóval optimalizálom. A mérésekhez felhasznált laptopom egy Dell Inspiron N5110, Core i7-2630qm [5] processzorral és 8GB DDR3-mas RAM-mal. Az előbb említett CPU 4 magos, 8 szálat támogat hardveresen, 6 MB 3. szintű közös gyorsítótárral (továbbiakban cache), valamit processzormagonként 256KB 2. szintű és 32 KB 1. szintű cache-el rendelkezik. Nyelvnek azért a C++-t választottam, mivel ebben a programozónak nagy befolyása van a program memória és utasítás kiosztásra. A forrásfájlokban egymás mellett megtalálható függvényekből a generált binárisban a függvényekből generált kód is egymás mellett lesz. A mérések során a mérendő kódrészletet egy-egy függvénybe ágyazom ahol a függvény futási idejét mérem. A függvény, aminek az idejét mérem, nem hozhatja létre a saját adatszerkezeteit, hiszen akkor ez is a mérés része lenne. Ehelyett azokat a függvény futtatása előtt hozom létre. Ebben az esetben azonban ha ugyanazt a függvényt többször futtatom és mérem az eredményeket, akkor a CPU cacheben maradhattak az előző futásból adatok, ez torzítja a mérés pontosságát. Ebből kifolyólag minden futás előtt meghívok egy kódrészletet ami a CPU cache-t kiüríti. Hogy életszerű legyen a mérés, ezért a programokat mindig úgy fordítom le, hogy a fordító optimalizációs lehetőségei be vannak kapcsolva. Ez azonban egy veszélyt is magában rejt, mégpedig azt, hogy a cache ürítését végző kódot a fordító kioptimalizálja, az nem fut le, hiszen nincs megfigyelhető mellékhatása a kódnak a program működésére. unsigned flush_cpu_cache_fn () { // Reset the cache with 20 mb data read constexpr const int size = 20*1024*1024; static volatile char * data = new char [ size ]{}; unsigned ret = 0; for ( unsigned i = 0; i < size ; ++i) ret += data [ i]; } return ret ; template <... > void benchmark (...) { //... static unsigned (* volatile flush_cpu_cache )() = flush_cpu_cache_fn ; //... 2
3 } A cache felülírásához egy 20MB méretű adatot olvasok végig. Ez a mai CPUk cache méretét nézve elég kell, hogy legyen, ahhoz, hogy annak jelentős része felülíródjon. Azért, hogy az olvasást ne optimalizálhassa ki a fordító, egy volatile mutatón keresztül olvasom az adatot, ami a C++ szabványban annyit jelent, hogy a fordítónak arra kell számítania hogy külső program is módosíthatja az adott memóriaterületet. Így hiába van a fordítónak statikus ismerete a tömb elemeiről, nem transzformálhatja ki az olvasást más műveletté. Hasonlóan annak céljából, hogy a fordító a függvény meghívását ne eliminálja, az egy volatile függvénymutatón keresztül kerül meghívásra. Mivel a fordítónak feltételeznie kell, hogy egy külső program bármikor átállíthatja a mutatót egy olyan függvényre aminek megfigyelhető mellékhatása lenne, ezért nem eliminálhatja a hívást. A mérésnél az összes futás után a futás sorszámához tartozó indexel egy tömbbe eltárolom a futás idejét amit nanomásodpercben mérek. A mért függvénynek tetszőleges számú paramétere lehet, amit a mérő függvény továbbít neki perfect forwarding-ot használva. Ez C++-ban a lehető leghatékonyabb paramétertovábbítás, így a mérés idejében minimális torzítást jelent a paraméterátadás ideje. A mérések megismétlésének a száma az bemeneti paramétere a mérő függvénynek. template < typename Func, typename... Args > BenchmarkResult benchmark ( unsigned sample_num, Func f, Args &&... args ) { //... } for ( unsigned i = 0; i < sample_num ; ++i) { } flush_cpu_cache (); auto start = chrono :: steady_clock :: now (); f( forward <Args >( args )...) ; times [ i] = chrono :: duration_cast < chrono :: nanoseconds >( chrono :: steady_clock :: now () - start ). count (); //... A mérések lefutása után a futási időket tartalmazó tömbben lévő adatokból a függvény kiszámolja a futási idők átlagát (tapasztalati várható értéket), valamint a korrigált tapasztalati szórását. A szórás alapján eldöntöm, hogy az adott mért értéket elfogadom-e, vagy a mintaszámot valamint a mért függvény bemenetének a méretét állítva megismétlem-e a mérést. std :: cout << benchmark (100, row_major ) << std :: endl ; A mérést végző függvény használata kifejezetten egyszerű és kényelmes, minden fejezetben az ismertetett kódokhoz tartozó mérést hasonló módszerekkel végeztem el. A fenti példában egy row major paraméter nélküli függvény futási ideje lesz mérve 100 alkalommal, majd az eredményt kiírja a szabványos kimenetre. 3. Memória bejárási minták Az első példában egy egészeket tartalmazó mátrixban számolom meg a páratlan számokat. Egy mátrix bejárására számtalan lehetőség van, de a leggyakrabban sorfolytonos illetve oszlopfolytonos bejárást szokás alkalmazni, mivel ezeket a legegy- 3
4 szerűbb implementálni és gyakran nincs kikötés az elemek meglátogatásának a sorrendjére. Ezzel a két bejárással valósítottam meg a számlálást, a mátrixot pedig egyetlen sorfolytonos vektorként tároltam el. std :: vector <int > matrix ( m_size * m_size ); int traverse_matrix ( Traversal t) { int ret = 0; if ( t == RowMajor ) { for ( int i = 0; i < m_size ; ++i) for ( int j = 0; j < m_size ; ++j) ret += matrix [ m_size * i + j] % 2; } else { for ( int i = 0; i < m_size ; ++i) for ( int j = 0; j < m_size ; ++j) ret += matrix [ m_size * j + i] % 2; } return ret ; } A fenti kódon futtatott mérési eredményem a 1 grafikonon látható. Futási idő (ns) Sorfolytonos Oszlopfolytonos Input méret (sor/oszlop szám) 1. ábra. Páratlan elemek számlálása mátrixban A grafikonból jól látszik, hogy a sorfolytonos bejárás közel kétszer olyan gyors mint az oszlopfolytonos. Nem történt változtatás az algoritmusban, csupán a memóriában az adatok elérési sorrendje változott. Abban az esetben, ha a mátrixot nem csak olvasnánk, hanem írnánk is, akkor még drasztikusabb különbségek jelennének meg, a méréseim során akár közel háromszoros különbséget is tapasztaltam. Klasszikus módszerekkel számolva a két algoritmus futási ideje az egyszerű cache független modellben azonos lenne. Sorfolytonos esetben a memória elérése is sorfolytonosan történik, ezért a CPU prefetchere (előtöltője) szépen sorban betölti a cache-be azokat a memóriacímeket amikre előreláthatólag szükség lesz. Mivel a prefetcher működése nagyon egyszerű, ezért a bonyolultabb mintázatokat (például konstans mennyiséggel való lépegetést a memóriában) nem képes felismerni. Ez a jelenség nem csak mátrixoknál lép fel. Tegyük fel, hogy rendelkezünk egy tömbbel, ami rekordokat tartalmaz. Abban az esetben ha a rekordok egyik mezőjén akarunk módosítást végezni, akkor a tömbön való végigiterálás közben a mátrix oszlopfolytonos bejárásához hasonló mintázatban olvassuk illetve módosítjuk 4
5 a memóriát. Ez a programozási minta objektum orientált programozás esetén gyakran előfordul. A leghatékonyabb szimulációs eljárásoknál valamint a játékiparban is gyakori optimalizációnak számít, amikor a rekordok tömbjéből tömbök rekordját csinálnak. Ebben az esetben ha az egyik attribútumnak megfelelő tömbön akarunk valamilyen transzformációt elvégezni, akkor a mátrix sorfolytonos bejárásához hasonló mintában fogjuk olvasni illetve írni a memóriát. // Array of structs struct Point { int x, y, z; }; Point points [200000]; // Struct of arrays struct Points { int x [200000]; int y [200000]; int z [200000]; }; Points pts ; Az előbbi kódrészlet szemlélteti a különbséget a rekordok tömbje és a tömbök rekordja között. Ez az optimalizációs lehetőség népszerű, viszont az emberi gondolkodáshoz a rekordok tömbje közelebb áll. Ezért aktív kutatási terület, hogy hogyan lehet ipari kódbázisok esetén az egyik reprezentációról a másikra transzformálni a kódot automatizált eszközökkel emberi beavatkozás nélkül. Sajnos az iparban használt nyelvek komplexitása miatt ez nem egy egyszerű feladat. 4. Folytonos és csúcs alapú adatszerkezetek A C++-ban két gyakran használat adatszerkezet a list és a vector. Az előbbi az egy két irányban láncolt lista, az utóbbi pedig egy olyan tömb, ami dinamikusan tud nőni és számon tartja a saját méretét. Mind a listában mind a vektorban a lineáris keresés asszimptotikusan ugyan úgy kellene, hogy viselkedjen, hiszen O(n) műveletet végzünk várhatóan, ahol n az adatszerkezet hossza. A következő mérésben feltöltöttem egy-egy vektort és listát 1..n egész számokkal, majd véletlenszerűen összekevertem ezeket a számokat. Ezután egy véletlenszerűen kiválasztott számot kerestem lineáris keresést használva. A 2 grafikon mutatja a mérési eredményeket. Látható az adatokból, hogy igen jelentős a vektorban és a listában való keresés ideje között az eltérés, pedig asszimptotikusan megegyezik a két műveletigény. Az a jelenség oka, hogy még a vektorban a keresés sorfolytonos memóriaolvasást jelent, addig a láncolt listában az elemek a memóriában véletlenszerűen helyezkednek el, így nem valószínű, hogy a következőnek hivatkozott elem a cache-ben található. A lista jelentősen lassabb, mivel a bejárás minden lépése várhatóan memória olvasással fog járni, még a vektor esetében a következő elem a cache-ben megtalálható lesz hála a prefetch mechanizmusnak. A mért adatok alapján ráadásul az az ember benyomása, hogy a listán a keresés sokkal rosszabb a lineárisnál. Tipikusan hasonló jelenség zajlik le, ha a lista helyett egy tetszőleges másik láncolt adatszerkezetet tekintünk. Ezért teljesítménykritikus alkalmazások esetén sokszor kerülendő az olyan szótárak, halmazok használata, amik fák segítségével 5
6 Vektor Lista Futási idő (ns) Input méret (hossz) 2. ábra. Véletlen elem keresése vannak implementálva. A C++ szabványnak is az egyik legnagyobb kritikája teljesítmény szempontjából az, hogy a szabványos könyvtárban lévő unordered map, ami egy hasító tábla implementáció, láncolva tárolja a vödrökben az elemeket. Sok alkalmazás esetén gyorsabb egy nyílt címzést alkalmazó hasító tábla. Hasonló okokból gyakran hatékonyabbak azok az algoritmusok, amik kevés adat mozgatást végeznek, tehát helyben végzik a módosításokat. Ilyen például a quick sort, ami helyben rendez egy tömböt. Azáltal, hogy az adatok nem kerülnek mozgatásra, kevesebbszer invalidálódik a cache. A Fortran gyors nyelv hírében áll, viszont a gyorsaságának pont az az egyik oka, hogy tipikusan a Fortran programokban sorfolytonos memóriaterülettel rendelkező adatszerkezeteket szoktak használni. 5. Adatszerkezetek az algoritmusok ellen A mai modern processzorok a cache-selésen túl számos trükköt alkalmaznak a sebesség növelésére. Ilyen például az out of order execution, ami azt jelenti, hogy a processzor a pipeline-ban lévő utasítások sorrendjét megváltoztathatja, ha ez nem okoz változást a program szemantikájában. Az átrendezés azért lehet előnyös, mert a processzor külön áramköröket tartalmazhat a különböző utasítások elvégzésére, és az utasítások feldolgozásának a sorrendjétől függhet, hogy párhuzamosan hány ilyen különböző feladatokat ellátó áramkör tud dolgozni egyszerre. Egy másik gyakori módszer a vektor utasítások használata. A vektor utasítások olyan utasítások, amik egy adott műveletet több értéken végeznek el egyszerre. Két szám összeadása helyett például képes lehet a processzor egy vektorutasítással négy számpárt összeadni, aminek az eredménye négy új szám lesz. Az ilyen utasítások végrehajtásának az ideje megegyezik a hagyományos utasításokéval, csupán ugyanannyi idő alatt, a munka többszörösét képes elvégezni. Ezen felül olyan speciális utasításkészletek is megjelentek, mint például az FMA, amivel képesek vagyunk két számot összeszorozni, majd egy harmadikat hozzáadni a szorzás eredményéhez, mindezt ugyanannyi idő alatt, mint amennyit a szorzás vett 6
7 volna igénybe. Elsőre elég ezoterikusnak hangozhat ez az utasítás, ugyanakkor elég gyakran előfordul ez a művelet, például a skaláris szorzásban is. Részben a fenti technológiák miatt, ma már nem ritka, hogy egy kellően optimalizált kód esetében a teljesítményt már nem a processzor sebessége korlátozza, hanem az, hogy milyen gyorsan tudjuk az algoritmus számára az adatokat betölteni a memóriából. Ebben az esetben algoritmikusan már nincs értelme javítani a programunkon, a memória elérési mintázatot kell optimalizálni. Ebből adódóan egy kellően gyors algoritmus esetén már csak az adatok memóriában való elhelyezkedésétől függ a program teljesítménye. Éppen ezért, egyre nagyobb figyelmet kapnak az adatszerkezetek, hiszen az nagyban befolyásolják az adatok elhelyezkedését. Chandler Carruth Google alkalmazott egy nagyon élvezetes előadásban foglalja ezt össze [7]. 6. Utasítás gyorsítótár A ma használt számítógépekben a memóriában nem csupán az adatok találhatóak, amiket a programok feldolgoznak, hanem a programok utasításai maguk is. Ezt könnyű elfelejteni. A processzor működése közben nem csupán az adatokat, hanem az utasításokat is a memóriából tölti be. Éppen ezért, hasonlóan mint az adatoknál, az utasításoknál is gyorsítótárazási mechanizmusok működnek. Ezek a mechanizmusok sokszor kifinomultabbak, mint az adatok esetén. Például egy függvény meghívásakor a processzor már ismeri azt is, hogy a függvényből való visszatérés után hol fog folytatódni a végrehajtás, így a megfelelő utasításokat be tudja tölteni a gyorsítótárba előre. Alacsony szintű nyelvek esetén, mint amilyen a C és a C++, a generált kódban azok a függvények lesznek egymáshoz közel, amik a forráskódban is közel voltak. Ezáltal az egymást gyakran hívó függvényeket egymáshoz közel helyezve növelhetjük az alkalmazás teljesítményét. Egy egyszerű mérést végeztem az utasítások gyorsítótárazásával kapcsolatban. A feladat az volt, hogy számoljuk meg, hány prím szám van egy adott felső korlátig, kétszer. Az első esetben leírtam egymás alá kétszer ugyanazt a kódot. A második esetben viszont egy függvényt hívtam meg kétszer. Az eredmények a 3 grafikonon láthatóak. Az időt most logaritmikus skálán ábrázoltam. A függvényhívásos megoldás egyértelműen jobb teljesítményt nyújtott, mint a kódduplikálással járó megoldás. Ebben az esetben nem jött ki drasztikus különbség, és ahogy a bement nőtt, úgy ez a különbség arányaiban csökkent. A különbség apróságának az egyik oka az, hogy a tesztprogram maga kicsi, ezért az összes utasítás befért az L2 cache-be. Nagyobb programok esetén sokkal drasztikusabb különbségek mérhetőek. Gyakran előfordul ipari alkalmazásokban, hogy polimorfikus gyűjteményeket használnak a programozók. Ez azt jelenti, hogy egy olyan gyűjteményt hoznak létre, ami egy adott típusra mutató mutatókat vagy referenciákat tartalmaz, de ezek a mutatók vagy referenciák valójában az adott típus altípusainak a példányaira mutatnak. Ilyenkor sokszor virtuális függvényhívás segítségével kerül meghívásra a dinamikus típushoz tartozó megfelelő művelet. Abban az esetben, ha a gyűjteményben a típusok váltakozva szerepelnek, minden alkalommal, amikor az egyik elemen meghívunk egy virtuális tagfüggvényt, az jó eséllyel olyan függvényt fog meghívni, ami jelenleg nincs bent az utasítás gyorsítótárban. Éppen ezért egy lehetséges optimalizáció az, ha a 7
8 10 6 Duplikált kód Két függvényhívás Futási idő (ns) Input méret (felső korlát) 3. ábra. Prímek számolása kétszer gyűjteményben lévő elemeket a típusuk szerint rendezzük. Ebben az esetben az azonos típusú elemek egymás mellé kerülnek, így maximálisan kihasználják a processzor által végzett gyorsítótárazást. A [6] cikkben olvasható, hogy a Microsoft fejlesztői képesek voltak a Windows CE operációs rendszer hálózati teljesítményét több mint háromszorosára növelni azáltal, hogy az kódjukat úgy írták újra, hogy figyelembe vették az utasítás gyorsítótárazást is. 7. Problémák párhuzamos és elosztott rendszerekben Párhuzamos és elosztott rendszerekben még nagyobb jelentősége van az adatok lokalitásának. Elsősorban több processzormaggal rendelkező rendszerekről fogok beszélni, mivel manapság ezek a legelterjedtebb konfigurációk. A processzor L1 gyorsítótára fel van osztva cache line-nak nevezett egységekre. Minden alkalommal, amikor a memóriából valami beolvasásra kerül, vagy kiíródik oda, az egy teljes cache line lesz. Vegyük elő újra azt a feladatot, hogy számoljuk meg egy mátrixban hány páratlan elem található. Ebben az esetben párhuzamosítsuk a megoldást. Az itt bemutatott példa és a mérések mind Herb Suttertől származnak [11]. A kód (4) egy thread poolt fog használni. Mindegyik szál meg fogja számolni a mátrix hozzá tartozó részében, hogy hány páratlan szám található. Van egy tömb, aminek minden eleme az egyik szálhoz van rendelve. Elindítjuk az összes dolgozó szálat, majd megvárjuk, hogy mind befejezze a munkát. A munkájuk végeztével pedig összeadjuk a tömbben található számokat, így megkapva a végeredményt. A mérés eredménye a 5 grafikonon látható. A teljesítmény több magon sok esetben romlott, és 24 processzormag használatával sem érhető el még a kétszeres teljesítmény sem. Pedig a probléma maga jól párhuzamosítható. Mi az oka? Az, hogy a processzorok egyszerre egy cache line méretével megegyező szeletet olvasnak ki a memóriából, vagy írnak be. Ebből kifolyólag, bár minden szál külön memóriaterüle- 8
9 int result [P]; for ( int p = 0; p < P; ++p ) pool. run ( [&,p] { result [ p] = 0; int chunksize = DIM / P + 1; int mystart = p * chunksize ; int myend = min ( mystart + chunksize, DIM ); for ( int i = mystart ; i < myend ; ++i ) for ( int j = 0; j < DIM ; ++j ) if( matrix [ i* DIM + j] % 2!= 0 ) ++ result [p]; } ); pool. join (); odds = 0; for ( int p = 0; p < P; ++p ) odds += result [ p]; 4. ábra. Párhuzamos számlálás mátrixon: első változat tre írja a saját eredményét, a processzorok erről nem tudnak. Csak azt látják, hogy mindegyik szál ugyanazt a cache line-t használja, ezért annak érdekében, hogy a memóriában lévő érték konzisztens maradjon minden szál számára, minden módosítás után szinkronizálják az értéket a processzormagok cache-ei között. Ennek az az eredménye, hogy az a cache line, amiben a tömb található, folyamatosan másolgatva lesz a memória és az egyes processzorok gyorsítótára között, holott erre nem lenne szükség. A processzormagok pedig a legtöbb idejüket azzal töltik, hogy várják, hogy a memóriából megkapják a friss értékeket. Ezt a jelenséget hívják hamis megosztásnak (False Sharing). Az előző kód könnyen kijavítható (6) azáltal, hogy minden szál külön számára elkülönített memóriaterületen tartja számon a saját eredményeit, majd a végén lesznek ezek összesítve egy közös memóriaterületen. A javításnak hála immár lineárisan fog skálázódni a teljesítmény a felhasznált processzormagok függvényében (7). Párhuzamos rendszerek fejlesztésekor tehát különösen nagy figyelmet kell fordítanunk az adatok lokalitására, ugyanis ez lehet a kulcsa a skálázhatóságnak. Sajnos sok esetben a fejlesztőknek máig szükségük van alacsony szintű ismeretekre a azokról az eszközökről, amikre fejlesztenek. 9
10 5. ábra. False Sharing int result [P]; for ( int p = 0; p < P; ++p ) pool. run ( [&,p] { int count = 0; int chunksize = DIM / P + 1; int mystart = p * chunksize ; int myend = min ( mystart + chunksize, DIM ); for ( int i = mystart ; i < myend ; ++i ) for ( int j = 0; j < DIM ; ++j ) if( matrix [ i* DIM + j] % 2!= 0 ) ++ count ; result [ p] = count ; } ); 6. ábra. Párhuzamos számlálás mátrixon: javított változat 10
11 7. ábra. False Sharing megoldva 11
12 8. Összefoglalás Az esszében bemutattam a modern informatika számos vívmányát, amivel egyre jobb teljesítményt érnek el az alkalmazások, és amit felhasználva egyre hatékonyabb kódot tudnak generálni a fordító programok. Összegyűjtöttem néhány optimalizációs technikát és vezérelvet, amik támpontot adhatnak, mikor teljesítmény kritikus alkalmazást fejlesztünk. Általánosságban véve ma már nem igaz az, hogy egy kódrészlet assembly kódját vizsgálva meg lehet állapítani, hogy mennyire gyors. Az új utasításkészletek miatt, számos esetben a hosszabb assembly kód lesz a gyorsabb. Az informatika egy dinamikusan változó és fejlődő terület, ezt türközi az is, ha valaki más fordítóval, más operációs rendszeren vagy másik processzor architektúrán ismétli meg az általam végzett méréseket, akár lényegesen eltérő eredményt is kaphat. Ebből kifolyólag nem dolgoztak ki az asszimptotikus analízishez hasonló módszertant az algoritmusok hatékonyságának a vizsgálatára a modern architektúrákon. Mivel a változás nem lassul, ezért hasonló módszertanra megjelenésére a közeljövőben sem számítok. A legtöbb szakember egyedül azt a tanácsot tudja adni, hogy minél több mérést végezzünk az adott programon, és ezt minél több környezetben ismételjük meg. Gyakran kaphatunk az első intuíciónknak ellent mondó eredményt. Az alacsony szintű optimalizáció célja nem csupán a hatékonyság lehet. A mai processzorok úgy takarítanak meg energiát, hogy amikor nincs sok munkájuk, képesek korlátozni az órajelüket, vagy akár magokat teljesen lekapcsolni. Éppen ezért az áramfogyasztás visszaszorítására is az optimalizáció jelenleg az egyetlen eszközünk. Ez főleg nagy szerverparkok és mobilalkalmazások esetén lényeges. Az előbbi esetben a költségek jelentős részét már nem a fejlesztők bére hanem a szerverfarm áramellátása jelenti, a másik esetben pedig a felhasználói élmény drasztikus romlásához vezet, ha egy alkalmazás hamar lemeríti a készüléket. Emellett a hatékony alkalmazásokat, a megspórolt energiából adódóan környezetbarát alkalmazásoknak is tekinthetjük. Hivatkozások [1] Lattner, C.: LLVM and Clang: Next Generation Compiler Technology, The BSD Conference, [2] Stroustrup, B.: The C++ Programming Language Addison-Wesley Publishing Company, fourth edition, [3] Norvig, P.: Latency numbers every programmer should know [4] Poletto, M., Sarkar, V.: Linear Scan Register Allocation [5] Intel i7-2630qm specification: Intel-Core-i7-2630QM-Processor-6M-Cache-up-to-2_90-GHz [6] Importance of the Instruction Cache memory-is-not-free-more-on-vista.html 12
13 [7] Carruth, C.: Efficiency with Algorithms, Performance with Data Structures, [8] Is Parallel Programming Hard, And, If So, What Can You Do About It?, perfbook/perfbook.html [9] Drepper, U.: What every programmer should know about memory, [10] Meyers, S.: CPU Caches and Why You Care, [11] Sutter, H.: Eliminate False sharing 13
ISA szimulátor objektum-orientált modell (C++)
Budapesti Műszaki és Gazdaságtudományi Egyetem ISA szimulátor objektum-orientált modell (C++) Horváth Péter Elektronikus Eszközök Tanszéke 2015. február 12. Horváth Péter ISA szimulátor objektum-orientált
RészletesebbenHatékony memóriakezelési technikák. Smidla József Operációkutatási Laboratórium január 16.
Hatékony memóriakezelési technikák Smidla József Operációkutatási Laboratórium 2014. január 16. 1 Tartalom A cache áthidalása Cache optimalizálás Adatszerkezetek tervezése A programkód szerkezete Prefetch
RészletesebbenAlkalmazott modul: Programozás 4. előadás. Procedurális programozás: iteratív és rekurzív alprogramok. Alprogramok. Alprogramok.
Eötvös Loránd Tudományegyetem Informatikai Kar Alkalmazott modul: Programozás 4. előadás Procedurális programozás: iteratív és rekurzív alprogramok Giachetta Roberto groberto@inf.elte.hu http://people.inf.elte.hu/groberto
RészletesebbenProgramozá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
Részletesebbenelektronikus adattárolást memóriacím
MEMÓRIA Feladata A memória elektronikus adattárolást valósít meg. A számítógép csak olyan műveletek elvégzésére és csak olyan adatok feldolgozására képes, melyek a memóriájában vannak. Az információ tárolása
RészletesebbenPé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
RészletesebbenSzámítógép felépítése
Alaplap, processzor Számítógép felépítése Az alaplap A számítógép teljesítményét alapvetően a CPU és belső busz sebessége (a belső kommunikáció sebessége), a memória mérete és típusa, a merevlemez sebessége
RészletesebbenIsmerkedjünk tovább a számítógéppel. Alaplap és a processzeor
Ismerkedjünk tovább a számítógéppel Alaplap és a processzeor Neumann-elvű számítógépek főbb egységei A részek feladatai: Központi egység: Feladata a számítógép vezérlése, és a számítások elvégzése. Operatív
Részletesebben1. Alapok. Programozás II
1. Alapok Programozás II Elérhetőség Név: Smidla József Elérhetőség: smidla dcs.uni-pannon.hu Szoba: I916 2 Irodalom Bjarne Stroustrup: A C++ programozási nyelv 3 Irodalom Erich Gamma, Richard Helm, Ralph
RészletesebbenBevezetés a programozásba Előadás: Tagfüggvények, osztály, objektum
Bevezetés a programozásba 2 1. Előadás: Tagfüggvények, osztály, objektum Ismétlés int main() { string s; s; s= bla ; cout
RészletesebbenBevezeté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
RészletesebbenProgramozá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
RészletesebbenBevezetés a programozásba I 10. gyakorlat. C++: alprogramok deklarációja és paraméterátadása
Pázmány Péter Katolikus Egyetem Információs Technológiai Kar Bevezetés a programozásba I 10. gyakorlat C++: alprogramok deklarációja és paraméterátadása 2011.11.22. Giachetta Roberto groberto@inf.elte.hu
RészletesebbenFelvételi vizsga mintatételsor Informatika írásbeli vizsga
BABEȘ BOLYAI TUDOMÁNYEGYETEM MATEMATIKA ÉS INFORMATIKA KAR A. tételsor (30 pont) Felvételi vizsga mintatételsor Informatika írásbeli vizsga 1. (5p) Egy x biten tárolt egész adattípus (x szigorúan pozitív
RészletesebbenBevezeté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
RészletesebbenSzámítógép architektúra
Budapesti Műszaki Főiskola Regionális Oktatási és Innovációs Központ Székesfehérvár Számítógép architektúra Dr. Seebauer Márta főiskolai tanár seebauer.marta@roik.bmf.hu Irodalmi források Cserny L.: Számítógépek
RészletesebbenSzimuláció RICHARD M. KARP és AVI WIGDERSON. (Készítette: Domoszlai László)
Szimuláció RICHARD M. KARP és AVI WIGDERSON A Fast Parallel Algorithm for the Maximal Independent Set Problem című cikke alapján (Készítette: Domoszlai László) 1. Bevezetés A következőkben megadott algoritmus
RészletesebbenOpenCL 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
RészletesebbenProgramozás alapjai gyakorlat. 4. gyakorlat Konstansok, tömbök, stringek
Programozás alapjai gyakorlat 4. gyakorlat Konstansok, tömbök, stringek Házi ellenőrzés (f0069) Valósítsd meg a linuxos seq parancs egy egyszerűbb változatát, ami beolvas két egész számot, majd a kettő
RészletesebbenProgramozás BMEKOKAA146. Dr. Bécsi Tamás 5. előadás
Programozás BMEKOKAA146 Dr. Bécsi Tamás 5. előadás Tömbök átméretezése public static void Resize( ref T[] array, int newsize ) Példa: int[] a=new int[20]; Array.Resize(ref a, 22); 2016. 10. 19.
RészletesebbenPodoski Péter és Zabb László
Podoski Péter és Zabb László Bevezető Algoritmus-vizualizáció témakörében végeztünk kutatásokat és fejlesztéseket Felmértük a manapság ismert eszközök előnyeit és hiányosságait Kidolgoztunk egy saját megjelenítő
RészletesebbenFlynn féle osztályozás Single Isntruction Multiple Instruction Single Data SISD SIMD Multiple Data MISD MIMD
M5-. A lineáris algebra párhuzamos algoritmusai. Ismertesse a párhuzamos gépi architektúrák Flynn-féle osztályozását. A párhuzamos lineáris algebrai algoritmusok között mi a BLAS csomag célja, melyek annak
RészletesebbenAmortizációs költségelemzés
Amortizációs költségelemzés Amennyiben műveleteknek egy M 1,...,M m sorozatának a futási idejét akarjuk meghatározni, akkor egy lehetőség, hogy külön-külön minden egyes művelet futási idejét kifejezzük
RészletesebbenFejlett programozási nyelvek C++ Iterátorok
Fejlett programozási nyelvek C++ Iterátorok 10. előadás Antal Margit 2009 slide 1 Témakörök I. Bevezetés II. Iterátor definíció III. Iterátorok jellemzői IV. Iterátorkategóriák V. Iterátor adapterek slide
RészletesebbenSZÁMÍTÓGÉP ARCHITEKTÚRÁK
SZÁMÍTÓGÉP ARCHITEKTÚRÁK Az utasítás-pipeline szélesítése Horváth Gábor, Belső Zoltán BME Hálózati Rendszerek és Szolgáltatások Tanszék ghorvath@hit.bme.hu, belso@hit.bme.hu Budapest, 2018-05-19 1 UTASÍTÁSFELDOLGOZÁS
RészletesebbenClang 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
RészletesebbenMintavételes szabályozás mikrovezérlő segítségével
Automatizálási Tanszék Mintavételes szabályozás mikrovezérlő segítségével Budai Tamás budai.tamas@sze.hu http://maxwell.sze.hu/~budait Tartalom Mikrovezérlőkről röviden Programozási alapismeretek ismétlés
RészletesebbenTartalom Keresés és rendezés. Vektoralgoritmusok. 1. fejezet. Keresés adatvektorban. A programozás alapjai I.
Keresés Rendezés Feladat Keresés Rendezés Feladat Tartalom Keresés és rendezés A programozás alapjai I. Hálózati Rendszerek és Szolgáltatások Tanszék Farkas Balázs, Fiala Péter, Vitéz András, Zsóka Zoltán
RészletesebbenBevezetés a Programozásba II 11. előadás. Adatszerkezetek megvalósítása. Adatszerkezetek megvalósítása Adatszerkezetek
Pázmány Péter Katolikus Egyetem Információs Technológiai és Bionikai Kar Bevezetés a Programozásba II 11. előadás 2014.05.12. Giachetta Roberto groberto@inf.elte.hu http://people.inf.elte.hu/groberto Adatszerkezetek
RészletesebbenBevezeté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
RészletesebbenAdatszerkezetek Tömb, sor, verem. Dr. Iványi Péter
Adatszerkezetek Tömb, sor, verem Dr. Iványi Péter 1 Adat Adat minden, amit a számítógépünkben tárolunk és a külvilágból jön Az adatnak két fontos tulajdonsága van: Értéke Típusa 2 Adat típusa Az adatot
Részletesebben8. gyakorlat Pointerek, dinamikus memóriakezelés
8. gyakorlat Pointerek, dinamikus memóriakezelés Házi ellenőrzés Egy számtani sorozat első két tagja A1 és A2. Számítsa ki a sorozat N- dik tagját! (f0051) Egy mértani sorozat első két tagja A1 és A2.
RészletesebbenGPU 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
RészletesebbenProgramozá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
RészletesebbenKeresés és rendezés. A programozás alapjai I. Hálózati Rendszerek és Szolgáltatások Tanszék Farkas Balázs, Fiala Péter, Vitéz András, Zsóka Zoltán
Keresés Rendezés Feladat Keresés és rendezés A programozás alapjai I. Hálózati Rendszerek és Szolgáltatások Tanszék Farkas Balázs, Fiala Péter, Vitéz András, Zsóka Zoltán 2016. november 7. Farkas B., Fiala
RészletesebbenOperációs rendszerek. 9. gyakorlat. BASH recap, reguláris kifejezések UNIVERSITAS SCIENTIARUM SZEGEDIENSIS UNIVERSITY OF SZEGED
UNIVERSITAS SCIENTIARUM SZEGEDIENSIS UNIVERSITY OF SZEGED BASH recap, reguláris kifejezések Operációs rendszerek 9. gyakorlat Szegedi Tudományegyetem Természettudományi és Informatikai Kar Csuvik Viktor
Részletesebben1. 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 (
RészletesebbenOperációs rendszerek. 9. gyakorlat. Reguláris kifejezések - alapok, BASH UNIVERSITAS SCIENTIARUM SZEGEDIENSIS UNIVERSITY OF SZEGED
UNIVERSITAS SCIENTIARUM SZEGEDIENSIS UNIVERSITY OF SZEGED Reguláris kifejezések - alapok, BASH Operációs rendszerek 9. gyakorlat Szegedi Tudományegyetem Természettudományi és Informatikai Kar Csuvik Viktor
RészletesebbenBevezeté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
RészletesebbenTömbök kezelése. Példa: Vonalkód ellenőrzőjegyének kiszámítása
Tömbök kezelése Példa: Vonalkód ellenőrzőjegyének kiszámítása A számokkal jellemzett adatok, pl. személyi szám, adószám, taj-szám, vonalkód, bankszámlaszám esetében az elírásból származó hibát ún. ellenőrző
RészletesebbenUgrólisták. RSL Insert Example. insert(22) with 3 flips. Runtime?
Ugrólisták Ugrólisták Ugrólisták Ugrólisták RSL Insert Example insert(22) with 3 flips 13 8 29 20 10 23 19 11 2 13 22 8 29 20 10 23 19 11 2 Runtime? Ugrólisták Empirical analysis http://www.inf.u-szeged.hu/~tnemeth/alga2/eloadasok/skiplists.pdf
RészletesebbenProgramozá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
RészletesebbenBevezeté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
RészletesebbenOsztott algoritmusok
Osztott algoritmusok A benzinkutas példa szimulációja Müller Csaba 2010. december 4. 1. Bevezetés Első lépésben talán kezdjük a probléma ismertetésével. Adott két n hosszúságú bináris sorozat (s 1, s 2
Részletesebbenend function Az A vektorban elõforduló legnagyobb és legkisebb értékek indexeinek különbségét.. (1.5 pont) Ha üres a vektor, akkor 0-t..
A Név: l 2014.04.09 Neptun kód: Gyakorlat vezető: HG BP MN l 1. Adott egy (12 nem nulla értékû elemmel rendelkezõ) 6x7 méretû ritka mátrix hiányos 4+2 soros reprezentációja. SOR: 1 1 2 2 2 3 3 4 4 5 6
Részletesebbensallang avagy Fordítótervezés dióhéjban Sallai Gyula
sallang avagy Fordítótervezés dióhéjban Sallai Gyula Az előadás egy kis példaprogramon keresztül mutatja be fordítók belső lelki világát De mit is jelent, az hogy fordítóprogram? Mit csinál egy fordító?
RészletesebbenKé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
RészletesebbenMár megismert fogalmak áttekintése
Interfészek szenasi.sandor@nik.bmf.hu PPT 2007/2008 tavasz http://nik.bmf.hu/ppt 1 Témakörök Polimorfizmus áttekintése Interfészek Interfészek kiterjesztése Eseménykezelési módszerek 2 Már megismert fogalmak
RészletesebbenAdatszerkezetek Adatszerkezet fogalma. Az értékhalmaz struktúrája
Adatszerkezetek Összetett adattípus Meghatározói: A felvehető értékek halmaza Az értékhalmaz struktúrája Az ábrázolás módja Műveletei Adatszerkezet fogalma Direkt szorzat Minden eleme a T i halmazokból
RészletesebbenProgramozás alapjai. 7. előadás
7. előadás Wagner György Általános Informatikai Tanszék Jótanács (1) Tipikus hiba a feladat elkészítésekor: Jótanács (2) Szintén tipikus hiba: a file-ból való törléskor, illetve a file-nak új elemmel való
RészletesebbenAdatszerkezetek 1. Dr. Iványi Péter
Adatszerkezetek 1. Dr. Iványi Péter 1 Adat Adat minden, amit a számítógépünkben tárolunk és a külvilágból jön Az adatnak két fontos tulajdonsága van: Értéke Típusa 2 Adat típusa Az adatot kódoltan tároljuk
RészletesebbenAdatbázis-kezelő rendszerek. dr. Siki Zoltán
Adatbázis-kezelő rendszerek I. dr. Siki Zoltán Adatbázis fogalma adatok valamely célszerűen rendezett, szisztéma szerinti tárolása Az informatika elterjedése előtt is számos adatbázis létezett pl. Vállalati
RészletesebbenFeladat. Bemenő adatok. Bemenő adatfájlok elvárt formája. Berezvai Dániel 1. beadandó/4. feladat 2012. április 13. Például (bemenet/pelda.
Berezvai Dániel 1. beadandó/4. feladat 2012. április 13. BEDTACI.ELTE Programozás 3ice@3ice.hu 11. csoport Feladat Madarak életének kutatásával foglalkozó szakemberek különböző településen különböző madárfaj
Részletesebben3. 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
RészletesebbenDr. Schuster György február / 32
Algoritmusok és magvalósítások Dr. Schuster György OE-KVK-MAI schuster.gyorgy@kvk.uni-obuda.hu 2015. február 10. 2015. február 10. 1 / 32 Algoritmus Alapfogalmak Algoritmus Definíció Algoritmuson olyan
RészletesebbenBonyolultságelmélet. Thursday 1 st December, 2016, 22:21
Bonyolultságelmélet Thursday 1 st December, 2016, 22:21 Tárbonyolultság A futásidő mellett a felhasznált tárterület a másik fontos erőforrás. Ismét igaz, hogy egy Ram-program esetében ha csak a használt
RészletesebbenBevezetés a programozásba I.
Bevezetés a programozásba I. 3. gyakorlat Tömbök, programozási tételek Surányi Márton PPKE-ITK 2010.09.21. ZH! PlanG-ból papír alapú zárthelyit írunk el reláthatólag október 5-én! Tömbök Tömbök Eddig egy-egy
RészletesebbenProgramozási alapismeretek beadandó feladat: ProgAlap beadandó feladatok téma 99. feladat 1
Programozási alapismeretek beadandó feladat: ProgAlap beadandó feladatok téma 99. feladat 1 Készítette: Gipsz Jakab Neptun-azonosító: A1B2C3 E-mail: gipszjakab@vilaghalo.hu Kurzuskód: IP-08PAED Gyakorlatvezető
Részletesebben1. 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"
RészletesebbenAdatszerkezetek 1. előadás
Adatszerkezetek 1. előadás Irodalom: Lipschutz: Adatszerkezetek Morvay, Sebők: Számítógépes adatkezelés Cormen, Leiserson, Rives, Stein: Új algoritmusok http://it.inf.unideb.hu/~halasz http://it.inf.unideb.hu/adatszerk
Részletesebben7. fejezet: Mutatók és tömbök
7. fejezet: Mutatók és tömbök Minden komolyabb programozási nyelvben vannak tömbök, amelyek gondos kezekben komoly fegyvert jelenthetnek. Először is tanuljunk meg tömböt deklarálni! //Tömbök használata
RészletesebbenAdatbázis rendszerek. dr. Siki Zoltán
Adatbázis rendszerek I. dr. Siki Zoltán Adatbázis fogalma adatok valamely célszerűen rendezett, szisztéma szerinti tárolása Az informatika elterjedése előtt is számos adatbázis létezett pl. Vállalati személyzeti
RészletesebbenEgyirányban láncolt lista
Egyirányban láncolt lista A tárhely (listaelem) az adatelem értékén kívül egy mutatót tartalmaz, amely a következő listaelem címét tartalmazza. A láncolt lista első elemének címét egy, a láncszerkezeten
RészletesebbenProgramozás alapjai C nyelv 8. gyakorlat. Mutatók és címek (ism.) Indirekció (ism)
Programozás alapjai C nyelv 8. gyakorlat Szeberényi Imre BME IIT Programozás alapjai I. (C nyelv, gyakorlat) BME-IIT Sz.I. 2005.11.07. -1- Mutatók és címek (ism.) Minden változó és függvény
RészletesebbenAdatszerkezetek Hasító táblák. Dr. Iványi Péter
Adatszerkezetek Hasító táblák Dr. Iványi Péter 1 Hash tábla A bináris fáknál O(log n) a legjobb eset a keresésre. Ha valamilyen közvetlen címzést használunk, akkor akár O(1) is elérhető. A hash tábla a
RészletesebbenSzövegek C++ -ban, a string osztály
Szövegek C++ -ban, a string osztály A string osztály a Szabványos C++ könyvtár (Standard Template Library) része és bár az objektum-orientált programozásról, az osztályokról, csak később esik szó, a string
RészletesebbenBevezetés, a C++ osztályok. Pere László
Programozás módszertan II. p. Programozás módszertan II. Bevezetés, a C++ osztályok Pere László (pipas@linux.pte.hu) PÉCSI TUDOMÁNYEGYETEM TERMÉSZETTUDOMÁNYI KAR INFORMATIKA ÉS ÁLTALÁNOS TECHNIKA TANSZÉK
RészletesebbenProgramozá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
RészletesebbenBevezetés a programozásba I 8. gyakorlat. C++: szövegfolyamok, intelligens tömbök
Pázmány Péter Katolikus Egyetem Információs Technológiai Kar Bevezetés a programozásba I 8. gyakorlat C++: szövegfolyamok, intelligens tömbök 2011.11.08. Giachetta Roberto groberto@inf.elte.hu http://people.inf.elte.hu/groberto
RészletesebbenProgramozá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)
RészletesebbenA memória működése szoftverfejlesztői szemmel. Smidla József Operációkutatási Laboratórium 2013. november 20.
A memória működése szoftverfejlesztői szemmel Smidla József Operációkutatási Laboratórium 2013. november 20. 1 Tartalom A memória felépítése Cache memória Mérési adatok Cache detektáló program 2 Architektúra
RészletesebbenMutatók és címek (ism.) Programozás alapjai C nyelv 8. gyakorlat. Indirekció (ism) Néhány dolog érthetőbb (ism.) Változók a memóriában
Programozás alapjai C nyelv 8. gyakorlat Szeberényi mre BME T Programozás alapjai. (C nyelv, gyakorlat) BME-T Sz.. 2005.11.07. -1- Mutatók és címek (ism.) Minden változó és függvény
RészletesebbenJava és web programozás
Budapesti Műszaki Egyetem 2015. 02. 11. 2. Előadás Mese Néhány programozási módszer: Idők kezdetén való programozás Struktúrált Moduláris Funkcionális Objektum-orientált... Mese Néhány programozási módszer:
Részletesebben10. gyakorlat Struktúrák, uniók, típusdefiníciók
10. gyakorlat Struktúrák, uniók, típusdefiníciók Házi - (f0218) Olvass be 5 darab maximum 99 karakter hosszú szót úgy, hogy mindegyiknek pontosan annyi helyet foglalsz, amennyi kell! A sztringeket írasd
RészletesebbenMagas 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
RészletesebbenProgramozá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
RészletesebbenSAT probléma kielégíthetőségének vizsgálata. masszív parallel. mesterséges neurális hálózat alkalmazásával
SAT probléma kielégíthetőségének vizsgálata masszív parallel mesterséges neurális hálózat alkalmazásával Tajti Tibor, Bíró Csaba, Kusper Gábor {gkusper, birocs, tajti}@aries.ektf.hu Eszterházy Károly Főiskola
RészletesebbenProgramozás alapjai II. (7. ea) C++ Speciális adatszerkezetek. Tömbök. Kiegészítő anyag: speciális adatszerkezetek
Programozás alapjai II. (7. ea) C++ Kiegészítő anyag: speciális adatszerkezetek Szeberényi Imre BME IIT M Ű E G Y E T E M 1 7 8 2 C++ programozási nyelv BME-IIT Sz.I. 2016.04.05. - 1
RészletesebbenSpeciális adatszerkezetek. Programozás alapjai II. (8. ea) C++ Tömbök. Tömbök/2. N dimenziós tömb. Nagyméretű ritka tömbök
Programozás alapjai II. (8. ea) C++ Kiegészítő anyag: speciális adatszerkezetek Szeberényi Imre BME IIT Speciális adatszerkezetek A helyes adatábrázolás választása, a helyes adatszerkezet
RészletesebbenAdatok ábrázolása, adattípusok
Adatok ábrázolása, adattípusok Összefoglalás Adatok ábrázolása, adattípusok Számítógépes rendszerek működés: információfeldolgozás IPO: input-process-output modell információ tárolása adatok formájában
RészletesebbenProgramozás C++ -ban
Programozás C++ -ban 4. Bevezetés az osztályokba 4.1 Az adatokhoz való hozzáférés ellenőrzése Egy C programban a struktúrák minden része mindig elérhető. Ugyanakkor ez nem a legkedvezőbb helyzet. Több
RészletesebbenBevezetés a programozásba I 8. gyakorlat. C++: szövegfolyamok, intelligens tömbök. Adatfolyamok Hibalehetőségek
Pázmány Péter Katolikus Egyetem Információs Technológiai Kar Bevezetés a programozásba I 8. gyakorlat C++: szövegfolyamok, intelligens tömbök 2011.11.08. Giachetta Roberto groberto@inf.elte.hu http://people.inf.elte.hu/groberto
RészletesebbenSzoftver karbantartási lépések ellenőrzése
Szoftverellenőrzési technikák (vimim148) Szoftver karbantartási lépések ellenőrzése Majzik István Budapesti Műszaki és Gazdaságtudományi Egyetem Méréstechnika és Információs Rendszerek Tanszék http://www.inf.mit.bme.hu/
RészletesebbenA processzor hajtja végre a műveleteket. összeadás, szorzás, logikai műveletek (és, vagy, nem)
65-67 A processzor hajtja végre a műveleteket. összeadás, szorzás, logikai műveletek (és, vagy, nem) Két fő része: a vezérlőegység, ami a memóriában tárolt program dekódolását és végrehajtását végzi, az
RészletesebbenSzoftvertechnológia alapjai Java előadások
Szoftvertechnológia alapjai Java előadások Förhécz András, doktorandusz e-mail: fandrew@mit.bme.hu tárgy honlap: http://home.mit.bme.hu/~fandrew/szofttech_hu.html A mai előadás tartalma: Miért pont Java?
RészletesebbenSzámítógép-rendszerek fontos jellemzői (Hardver és Szoftver):
B Motiváció B Motiváció Számítógép-rendszerek fontos jellemzői (Hardver és Szoftver): Helyesség Felhasználóbarátság Hatékonyság Modern számítógép-rendszerek: Egyértelmű hatékonyság (például hálózati hatékonyság)
RészletesebbenBevezeté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;
RészletesebbenProgramozas 1. Strukturak, mutatok
Programozas 1 Strukturak, mutatok Strukturak Tömb: több egyforma típusú változó együttese Struktúra: több különböző típusú de logikailag egybetartozó változó együttese, amelyet az egyszerű kezelhetőség
Részletesebbenés az instanceof operátor
Java VIII. Az interfacei és az instanceof operátor Krizsán Zoltán Miskolci Egyetem Általános Informatikai Tanszék Utolsó módosítás: 2005. 10. 24. Java VIII.: Interface JAVA8 / 1 Az interfészről általában
RészletesebbenProgramozás I. zárthelyi dolgozat
Programozás I. zárthelyi dolgozat 2013. november 11. 2-es szint: Laptopot szeretnénk vásárolni, ezért írunk egy programot, amelynek megadjuk a lehetséges laptopok adatait. A laptopok árát, memória méretét
RészletesebbenJava VIII. Az interfacei. és az instanceof operátor. Az interfészről általában. Interfészek JAVA-ban. Krizsán Zoltán
Java VIII. Az interfacei és az instanceof operátor Krizsán Zoltán Miskolci Egyetem Általános Informatikai Tanszék Utolsó módosítás: 2005. 10. 24. Java VIII.: Interface JAVA8 / 1 Az interfészről általában
RészletesebbenProgramozás I. Matematikai lehetőségek Műveletek tömbökkel Egyszerű programozási tételek & gyakorlás V 1.0 OE-NIK,
Programozás I. Matematikai lehetőségek Műveletek tömbökkel Egyszerű programozási tételek & gyakorlás OE-NIK, 2013 1 Hallgatói Tájékoztató A jelen bemutatóban található adatok, tudnivalók és információk
RészletesebbenMemóriakezelés, dinamikus memóriakezelés
Metódus: függvények és eljárások összefoglaló neve. Memóriakezelés, dinamikus memóriakezelés Nézzük végig, a C++ memóriakezelését. Alapvetően három fő memóriaterületet különböztetünk meg. Végrehajtási
RészletesebbenTorna. A torna.csv UTF-8 kódolású állományban soronként egy versenyző eredményeit tároljuk. Az adatokat pontosvessző választja el egymástól.
Torna A pekingi olimpián tornából hat versenyszámban mérettetik meg magukat a versenyzők. Ennek a versenynek az eredményeit kell feldolgoznia ebben a feladatban. A megoldás során vegye figyelembe a következőket:
RészletesebbenProgramozási technológia
Programozási technológia Generikus osztályok Gyűjtemények Dr. Szendrei Rudolf ELTE Informatikai Kar 2018. Generikus osztályok Javaban az UML paraméteres osztályainak a generikus (sablon) osztályok felelnek
RészletesebbenMaximum kiválasztás tömbben
ELEMI ALKALMAZÁSOK FEJLESZTÉSE I. Maximum kiválasztás tömbben Készítette: Szabóné Nacsa Rozália Gregorics Tibor tömb létrehozási módozatok maximum kiválasztás kódolása for ciklus adatellenőrzés do-while
RészletesebbenBevezetés a programozásba I 3. gyakorlat. PLanG: Programozási tételek. Programozási tételek Algoritmusok
Pázmány Péter Katolikus Egyetem Információs Technológiai Kar Bevezetés a programozásba I 3. gyakorlat PLanG: 2011.09.27. Giachetta Roberto groberto@inf.elte.hu http://people.inf.elte.hu/groberto Algoritmusok
Részletesebben1. Jelölje meg az összes igaz állítást a következők közül!
1. Jelölje meg az összes igaz állítást a következők közül! a) A while ciklusban a feltétel teljesülése esetén végrehajtódik a ciklusmag. b) A do while ciklusban a ciklusmag után egy kilépési feltétel van.
RészletesebbenPá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
RészletesebbenC++ 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
Részletesebben