A tényleges mérőszám függ az adat méretétől, illetve a feltétel összetettségétől.

HATÉKONYSÁGVIZSGÁLAT 1. A HATÉKONYSÁG FOGALMA A specifikációnak megfelelően elkészített, működőképes programjaink általában sok szempontból még nem tökéletesek. A legtöbb kész program javítható, pl. - gyorsabbá tehető - memóriaigénye csökkenthető - programkódja egyszerűbbé tehető. A programok ilyen szempontból történő vizsgálatát hatékonyságvizsgálatnak nevezzük. A hatékonyabbra írás alapfeltétele a program helyes működése, hiszen egy rosszul működő program esetében nincs értelme hatékonyságról beszélni. A hatékonyságvizsgálat már az algoritmuskészítés idején megjelenik, de gyakran az elkészült forráskód hatékonysága is javítható. A hatékonyság vizsgálata több szempontból is fontos, pl. - szűkös erőforrások esetén - költségkímélés céljából - a gyakorlati használhatóság miatt 2. A HATÉKONYSÁGVIZSGÁLAT SZEMPONTJAI 2.1 Végrehajtási idő - Mérése: o a tényleges programfutási idővel. Ez gép, illetve nyelvfüggő lehet! o absztrakt időegységben. Különböző időegységeket rendelhetünk a jellemző műveletekhez: aritmetikai műveletek, értékadás, feltételek kiértékelése. Általában az értékadást, és a feltétel kiértékelést tekintjük időigényes műveletnek. A tényleges mérőszám függ az adat méretétől, illetve a feltétel összetettségétől. Ugyanazon program (tényleges, ill. absztrakt) végrehajtási ideje az egyes futások alkalmával különböző lehet, pl. egy rendezési algoritmus futási ideje általában függ az adatok előrendezettségétől. Ezért beszélhetünk minimális, maximális, ill. átlagos futási időről. 2.2 Helyfoglalás (memóriában, háttértárakon) Két formáját vizsgáljuk: - A program által használt adatok helyfoglalása - A forráskód, illetve a lefordított programkód, futtatható állomány mérete. 1

Sokak szerint a helyfoglalás problémája kevésbé lényeges, hiszen memória és háttértár van bőven. Ennek azonban gyakran ellentmond a mindennapok tapasztalata. 2.3 Bonyolultság Fajtái: - Logikailag bonyolult a program, ha a feladat megoldásához speciális ismeretek is szükségesek (pl. grafikában: mátrix-számítás, interpolációk stb.) - Szerkezetileg bonyolult a program, ha sok döntési csomópontot, illetve egymásba ágyazott struktúrát, esetleg többszörös rekurziót tartalmaz. A szerkezeti bonyolultság jól mérhető (pl. a döntési csomópontok száma, egymásba ágyazott struktúrák mélysége) - Adatszerkezetileg bonyolult a program, ha töbszörösen egymásba ágyazott típusdefiníciókat tartalmaz. Fontos tudnunk, hogy a hatékonyság három említett dimenziója általában egymás ellen dolgozik, azaz mindegyik egyszerre nem javítható. Gyakran az időbeli hatékonyság növekedéséért memóriával, vagy bonyolultabb kóddal fizetünk. 3. A HATÉKONYSÁGVIZSGÁLAT SZINTJEI 3.1 Globális hatékonyság A globális hatékonyság növelése az algoritmus hatékonyabbá tételét jelenti, ez tehát valójában a programtervezés része. Egy program tényleges hatékonyságát alapvetően a globális hatékonyság határozza meg. 3.2 Lokális hatékonyság A programkód egyszerű transzformációit jelenti, általában a program működésének megértése nélkül, mechanikusan is elvégezhető. Jelentősége kisebb, mint a globális hatékonyságé, de nem elhanyagolható. A továbbiakban ezért elsősorban a globális hatékonyságot javító módszerekkel foglalkozunk. 2

4. A VÉGREHAJTÁSI IDŐ CSÖKKENTÉSE A program végrehajtási idejét lényegében a ciklusok, illetve a rekurzív eljárások határozzák meg. Azok a programsorok, amelyek csak egyszer kerülnek végrehajtásra, nem sokban befolyásolják a program futási idejét. Ezért a legfontosabb feladat a ciklusok végrehajtási idejének a csökkentése, amely történhet - a ciklusmag végrehajtási számának, illetve - a ciklusmag végrehajtási idejének a csökkentésével. 4.1 A ciklusmag végrehajtási számának a csökkentése, módszerek 4.1.1 A ciklus által vizsgált sorozat elemszámának a csökkentése Példa: Döntsük el egy pozitív egész számról, hogy prím-e! A megoldást az eldöntés tételének alkalmazásával adjuk meg Megfeleltetés: [m..n]<->[2..n-1] T(I) <-> I osztója N-nek Függvény Prim(N:egész):logikai I:=2 Ciklus amíg (I<=N-1) és nem (I osztója N-nek) I:=I+1 Prim:=(I>N-1) Függvény vége A megoldás időben sokkal hatékonyabbá tehető, ha felismerjük, hogy elég N feléig, sőt N gyökéig vizsgálni. A hatékonyabbra írt megoldás: Függvény Prim(N:egész):logikai I:=2 Ciklus amíg (I*I<=N) és nem (I osztója N-nek) I:=I+1 Prim:=(I*I>N) Függvény vége Megjegyzés: Az I*I <=N feltétel egyenértékű az I <= Gyök(N) feltétellel, de lokálisan hatékonyabb, mert a szorzás gyorsabb művelet, mint a gyökvonás. 4.1.2 A vizsgált sorozat(ok) speciális tulajdonságainak a kihasználása Gyakran hatékonyabb megoldáshoz vezet, ha kihasználjuk a vizsgált, ill. feldolgozandó sorozat(ok) valamely speciális tulajdonságát, pl. rendezettségét. - Rendezett sorozatban lineáris keresés helyett alkalmazhatjuk a logaritmikus keresést. - Rendezett sorozatok unióját, metszetét az egyszerű unió, metszet algoritmus helyett öszszefuttatással végezhetjük 3

Mindkét esetben lényegesen csökken a ciklusok végrehajtásának száma. (A ciklusmagokban minden esetben két-két elem összehasonlítása történik) 4.1.3 A bemenő adatok átrendezése a feldolgozás igényeinek megfelelően Gyakoriság szerinti keresés. Ha egy sorozatban többször kell lineárisan keresnünk, akkor javíthatjuk a keresések átlagos végrehajtási idejét, ha a már keresett elemeket a sorozatban előre léptetjük, azaz minden keresés után megcseréljük az előtte lévővel. Sok keresés után a gyakran keresett elemeket így szinte azonnal megtaláljuk. 4.1.4 Ciklus indexeléssé transzformálása (eldöntés, keresés esetén) - Prímeldöntés feladata: vegyünk fel egy logikai értékeket tartalmazó P vektort, amely a prím sorszámok esetén igaz, egyébként hamis értékeket tartalmaz. (Ezt elvégezhetjük pl. az Eratosztenészi-szita módszerével) Ekkor Prim(N)=P(N). Akkor célszerű alkalmazni, ha egy feladatban sokszor kell a prímeldöntést elvégeznünk. - Tegyük fel, hogy egy osztály tanulóit úgy osztották be, hogy az ABC minden betűjével pontosan egy név kezdődjön, pl. Adorján, Ábel, Bakos, Czipauer stb. Ekkor a tanulók adatait tartalmazó vektorban a név szerinti keresés rendkívül egyszerű: a Nev nevű tanuló sorszáma: Pos(Nev[1],MagyarABC), tehát minden létező név 1 lépésben megtalálható. 4.1.5 Matematikai összefüggések felhasználása 1. Példa: határozzuk meg két pozitív egész szám legnagyobb közös osztóját! 1. megoldás: elvégezzük a számok prímtényezős felbontását, majd a közös prímtényezőket az előforduló kisebbik hatványon összeszorozzuk. Hatékonysága nem jó, mivel a prímtényezős felbontás hosszadalmas. 2. megoldás: Euklideszi algoritmussal lényegesen csökkenthető a lépések száma Pl. 14850 DIV 2940 = 5 (Maradék 150) 2940 Div 150 =19 (Maradék 90) 150 Div 90 = 1 (Maradék 60) 90 Div 60 = 1 (Maradék 30) 60 Div 30 = 2 (Maradék 0) Tehát a legnagyobb közös osztó az utolsó nem 0 maradék: 30 2. Példa: Adjuk össze az egész számokat A és B között. Hatékony megoldás: összegzés tétel helyett alkalmazzuk a számtani sorozat összegképletét. 4

4.2 A ciklusmag végrehajtási idejének a csökkentése, módszerek E módszerek lényege: a ciklusmagban lévő időigényes műveleteket gyorsabb műveletekre cseréljük. 4.2.1 Elágazás indexeléssé transzformálása Például - Betűszámlálás szövegben: 26 irányú elágazás helyett: Inc(DB[C])+1]), karakter típusú index: DB: Tömb[ A.. Z ]:egész - Korosztályok szerinti számlálás: 0-6, 6-14, 14-18, 18-24: 4 irányú elágazás helyett: Inc(Db[Kor[I] div 2+1]), a végén az első 3 rekesz összege adja a 6 évesig terjedő korosztályba tartozók számát, a második 4 rekesz összege a 6-14 évesek számát, stb. 4.2.2 Kivételes eset kiküszöbölése 1. példa: Keressük egy vektor első T tulajdonságú elemét! Alapmegoldás: lineáris keresés Hatékonyabban: A feladatot megoldhatjuk kiválasztással is, ha az utolsó elem után elhelyezünk egy T tulajdonságú elemet. Ha a kiválasztás a hozzáfűzött elemet adja meg, akkor az eredeti vektorban nincs T tulajdonságú elem. Így egyszerűbb bentmaradási feltételt kell vizsgálni a ciklusban, tehát egy ciklusmag végrehajtási ideje csökken. 2. példa: adott egy M*N-es mátrix, 0, és 1 elemekkel feltöltve. Határozzuk meg, hogy A[I,J]- nek hány egyes szomszédja van! Hatékony megoldás: a mátrixot körbevesszük 0-kal, így nem kell a szélen lévő elemek esetében időigényes vizsgálatokat végeznünk. Két egymásba ágyazott ciklussal összeadjuk az A[I,J]-t körbevevő 3*3-as részmátrix elemeit, majd kivonjuk belőle A[I,J]-t. 4.2.3 Ciklus szétválasztása Ciklus i:=1-től N-ig Ha I<=K akkor B[I]:=X-A[I] különben B[I]:=X+A[I] Elágazás vége Hatékonyabban: a ciklusban lévő feltétel alapján kettéoszthatjuk az 1..N intervallumot, ezért a ciklus ketté választható úgy, hogy a ciklusmagok már ne tartalmazzanak feltételt. Ciklus i:=1-től K-ig B[I]:=X-A[I] 5

Ciklus i:=k+1-től N-ig B[I]:=X+A[I] 4.2.4 Adatok előfeldolgozása Feladat: Rendezzük egy mátrix sorait a sorösszeg szerint növekvően! 1. megoldás: pl. minimumkiválasztásos rendezéssel: Ciklus I:=1-től M.Sor-1-ig Ind:=I Ciklus J:=I+1-től M.Sor-ig Ha SorOsszeg(M,J)<SorOsszeg(M,Ind) Akkor Ind:=J Elágazás vége Ha Ind>I akkor SorCsere(M,I,Ind) Hibája, hogy feleslegesen, többször is kiszámolja ugyanazt a sorösszeget! Hatékonyabb megoldás: rendezés előtt meghatározzuk mindegyik sor összegét egy S vektorban, a feltétel így SorOsszeg(M,J)<SorOsszeg(M,Ind) helyett S[J]<S[Ind] lesz. Ekkor a SorCsere mellett az S megfelelő elemeit is cserélni kell! 4.2.5 Az adatmozgások számának a csökkentése Példa: Beillesztéses rendezés esetén az elemek cseréje helyett léptetünk. 4.2.6 Az adatmozgások kiküszöbölése 1. Példa. Kiválogatás: ha a kiválogatott elemekre később nincs szükség, nem tároljuk őket, hanem azonnal feldolgozzuk. 2. Példa: Az előző mátrixos feladat megoldása még hatékonyabbá tehető, ha a sorok cseréjét csak adminisztráljuk, egy mutató tömbben. (Indexvektoros rendezés) Ciklus I:=1-től M.Sor-ig S[I]:=SorOsszeg(M,I) H[I]:=I Cv. 6

Ciklus I:=1-től M.Sor-1-ig Ind:=I Ciklus J:=I+1-től M.Sor-ig Ha S(H[J])<S(H[Ind]) Akkor Ind:=J Elágazás vége Ha Ind>I akkor Csere(H[I],H[Ind]) /Csak az indexeket cseréljük! 4.3 Más alapelvű megoldás keresése Gyakran hatékonyabb megoldáshoz jutunk, ha egy feladatot más alapelven kísérelünk megoldani. Példa. - Bin(n,k) : Fakt(N)/(Fakt(K)*(Fakt(N-K)) helyett rekurzív képlettel is megoldható (ld. a rekurziónál) Hatékonysági észrevételek: - Az eredeti képlet csak kis N esetén működik, mert a Fakt függvény gyorsan nő - A képletnek egyszerűsíthető: N*(N-1)* (N-K+1)/Fakt(K)-ra. - A új képlet kiszámításakor a szorzásokat és az osztásokat felváltva és valós típussal célszerű elvégeznünk, emiatt a számítás lassú Hatékonyabb megoldás: (más elven) - Rekurzív függvény gondolata alapján a részeredmények tárolásával hatékony nemrekurzív algoritmus írható. (ld. rekurzió témaköre) 7

5. A HELYFOGLALÁS CSÖKKENTÉSE 5.1 Az adatok mennyiségének a csökkentése 5.1.1 Az indexes változók (vektor, mátrix) kiküszöbölése Példa: Fibonacci sorozat N. elemének kiszámolása (N>=2 esetén) Függvény Fib(N:egész):egész Változó F:Tömb[1..Max]:egész F[0]:=0 F[1]:=1 Ciklus I:=2-től N-ig F[I]:=F[I-1]+F[I-2] Fib:=F[N] Függvény vége Hatékonyabban: vektor helyett 3 segédváltozóval Függvény Fib(N:egész):egész Változó F0,F1,FI:egész F0:=0 F1:=1 Ciklus I:=2-től N-ig FI:=F0+F1 FI:=F1 F1:=F0 Fib:=FI Függvény vége 5.1.2 Adatok speciális tulajdonságainak a kihasználása - Szimmetrikus mátrix esetén elég a mátrix főátló feletti részét, és a főátlót tárolni. (Pl. sorfolytonosan, vektorban. Pl. 2 3 7 1 2 Tárolása vektorban: 2 3 7-1 -2 5 6 1 3 0 3 5 6 7 5 1 3 1 6 3 0 8

Ekkor az elem sorszámából ki kell számolnunk, hogy hányadik sor hányadik elem, pl.. 5. sorszámú elem, a -2 a 2. sor 2. eleme. (Kell írnunk egy címkiszámító függvényt, ami az időbeli hatékonyságot rontja) Hasonlóan valósítható meg a háromszögmátrixok tárolása is. (Valamely átló alatt/fölött csupa 0 elemet tartalmazó mátrixok.) - Hézagosan kitöltött struktúrák, pl. olyan mátrix, amelynek csak a főátlójában van 0-tól különböző elem. (Diagonális mátrix) Tárolása: vektorban. 5.1.3 Adatterületek megosztása Példa. - Szétválogatás helyben, ill. egy vektorban. A T tulajdonságú elemeket a vektor elejére, a nem T tulajdonságúakat a vektor végére tesszük. - Ha egy algoritmus egyszerre két vermet használ, akkor a két verem (statikus megvalósítás) esetén egy vektorban is ábrázolható. Akkor érdemes ezt csinálni, ha az egyik veremből kivett elemet gyakran tesszük át a másik verembe, azaz az összes tárolandó elem száma nagyjából állandó. Lehetséges megoldása: az egyik veremmutató kezdőértéke 0, a másiké N+1, és amikor az egyik nő, akkor a másik csökken. - Egy alsó és egy felső háromszög mátrix tárolása egy négyzetes mátrixban. 5.1.4 Helytakarékos típusok használata - Nevek tárolása esetén string helyett pl. string[40] - Nemek (illetve bármely két állapotú érték tárolása) esetén szövegkonstans ( férfi, nő ), ill. számkód (1, 2) helyett logikai érték. - Szöveges állományban az ismétlődő szóközök helyett Tab karakter. - Hónapok neve helyett elég a sorszám tárolása. - Számítható adatok elhagyása: pl. egy személyi adatokat tartalmazó vektorban nem kell egyszerre tárolni a születési dátumot, és az életkort (redundancia kiküszöbölése) Természetesen, amennyiben helytakarékosság céljából az eredeti adatot kisebb helyigényű adattal helyettesítjük, meg kell oldanunk a kódolás-dekódolás problémáját, pl. a hónap sorszámából elő kell tudnunk állítani a nevét, és viszont. 5.1.5 Rekurzió átírása iterációvá A rekurzív algoritmusok gyakran többszörösen hajtanak végre egy-egy számítást, illetve tevékenységet, ezáltal a részeredemények veremben történő tárolása miatt az ilyen algoritmusok rejtett memóriaigénye nagy. Ezt kiküszöbölhetjük, ha átírjuk az algoritmust iteratívvá. 9

5.1.6 Dinamikus memóriakezelés A dinamikus memóriakezelés alkalmazásával megoldható, hogy a használt adatok menynyiségével arányos mértékben foglaljuk le a memóriát. Pl. egy dinamikusan megvalósított lista adatszerkezet átlagos memóriaigénye (beleértve a mutatók tárolásához szükséges helyet is) kisebb, mint az ugyanolyan típusú elemeket tároló statikus lista memóriaigénye. 5.2 A programkód méretének a csökkentése 5.2.1 A forráskód, ezáltal a futtatható állomány méretének a csökkentése - Többszöri kódleírás helyett alkalmazzunk függvényt. (-> Időben ez kevésbé hatékony; a meghívás és a paraméterátadások miatt). - Adatok előzetes feldolgozása. Ha egy programrészben többször kell ugyanazt a számítást elvégeznünk, akkor előre kiszámítjuk, és a továbbiakban az eredményt tároló változót használjuk fel. A kód méretének csökkentése mellett a végrehajtási időt is csökkenti. - Programkód adattá transzformálása. o A felhasználónak szánt szövegeket, üzeneteket fájlban tárolhatjuk (<-> Időbeli hatékonyság) o Az ábrákat programból történő rajzolása helyett előre megrajzoljuk, fájlban tároljuk. (-> Időben is hatékonyabb) 5.2.2 A lefordított kód méretének a csökkentése: - DLL-ek alkalmazása esetén a programhoz dinamikusan (futási időben) szerkesztődnek hozzá bizonyos rutinok, ezzel az EXE mérete csökken. Ugyanazt a DLL állományt több program is használhatja. 6. BONYOLULTSÁG CSÖKKENTÉSE 6.1 Az algoritmus bonyolultságának a csökkentése 6.1.1 Szerkezeti bonyolultság csökkentése: a feltételek, ill. struktúrák számának és öszszetettségének a csökkentése. - Kivételes esetek kiküszöbölése. Már tárgyalt módszer. A végrehajtási idő mellett a bonyolultságot is csökkenti. Példa: szavak (azaz, szókezdetek) számlálása esetén kivételes eset az első szó. Megoldás: egy szóköz fűzése a szöveg elejére. (-> Elhagyhatjuk az első karaktert vizsgáló feltételeket) - Funkciók elhagyása. Sokszor a programozási tételekkel megadott megoldás nem a leghatékonyabb, mert ezek nem veszik figyelembe az adott feladat specialitásait. 10

Példa: kiválogatás esetén gyakran nem kell tárolnunk az eredményt, csak ki kell íratnunk. Ezzel (az idő, helyfoglalás mellett) bonyolultság szempontjából is hatékonyabb megoldást kapunk, ugyanis nincs külön ciklus a válogatásra, ill. a kiírásra. 6.1.2 Logikai bonyolultság csökkentése: - Típusabsztrakció. Ha egy algoritmusban valamely részlet visszavezethető valamely speciális adatszerkezet alkalmazására, akkor a logikai bonyolultságot csökkenthetjük. Példa: a Hanoi-tornyai feladatban a tornyok vermeknek felelnek meg, és egy korong áthelyezése egy egyszerű Veremből, ill. Verembe műveletet jelent. 6.2 Az adatszerkezet bonyolultságának a csökkentése - Pl. sok vektor helyett rekordot tartalmazó vektor alkalmazása. - Típusdefiníciók esetén ne alkalmazzunk túlságosan mély egymásba ágyazást! - Típusabsztrakcióval (új típusok bevezetésével) az adatszerkezet bonyolultsága is csökkenthető, hiszen így elrejtjük a programozó elől az adott típus kezelésének a részleteit. 7. LOKÁLIS HATÉKONYSÁG NÖVELÉSE - Gyorsabb adattípusok használata, pl. valós helyett egész. - Helytakarékos típus választása: pl. integer helyett shortint. - Gyorsabb műveletek választása: o Szorzás helyett összeadás: pl. 2*a helyett a+a o Függvényhívás helyett művelet: I<=gyök(n) helyett I*I<=N o Kifejezés egyszerűsítése: pl. ½*a helyett 0.5*a - Nyelv lehetőségeinek alkalmazása: pl. többirányú elágazás helyett érték szerinti elágazás - A programkód egyszerű transzformációi: o Ciklustól független utasítások kiemelése a ciklusból. Példa: Ciklusba írt SetColor(Red) o Elágazás minden ágán szereplő utasítások kiemelése. Ha minden ág ugyanúgy kezdődik (végződik), akkor az ismétlődő sorokat ki lehet emelni az elágazás elé (mögé). o Azonos szerkezetű ciklusok összevonása Jellemzően számlálós ciklussal, a tesztelős ciklus esetében körültekintően kell alkalmazni. o Azonos feltételű elágazások összevonása 11