Optimalizace algoritmů Jiří „Fila“ Filipovič PUPworX

Předmět přednášky časová složitost algoritmu časová složitost algoritmu významvýznam často používané metody snižování složitostičasto používané metody snižování složitosti lineární optimalizace lineární optimalizace kdy a kde optimalizovat kdy a kde optimalizovat základní metody, pro pokročilé asi nic nového… základní metody, pro pokročilé asi nic nového…

Složitost algoritmu teorie složitosti je velmi komplexní, bude demonstrován jen velmi zúžený pohled teorie složitosti je velmi komplexní, bude demonstrován jen velmi zúžený pohled složitostní třída popisuje chování algoritmu vzhledem k délce vstupu složitostní třída popisuje chování algoritmu vzhledem k délce vstupu časová vs. prostorová složitostčasová vs. prostorová složitost nejlepší, nejhorší a průměrný případnejlepší, nejhorší a průměrný případ zajímá nás asymptotické chování funkce složitostizajímá nás asymptotické chování funkce složitosti

Vlastnosti složitostních tříd abstrahujeme od konkrétního času běhu algoritmu abstrahujeme od konkrétního času běhu algoritmu nezávislost na CPU, kompilátoru…nezávislost na CPU, kompilátoru… O(g) – třída funkcí rostoucích nejvýše tak rychle jako g O(g) – třída funkcí rostoucích nejvýše tak rychle jako g Zajímá nás asymptotické chování Zajímá nás asymptotické chování T(log 2 n) = O(log n)T(log 2 n) = O(log n) T(3n + 1) = O(n)T(3n + 1) = O(n) T(n 2 - n + 3) = O(n 2 )T(n 2 - n + 3) = O(n 2 )

Tabulka časů log n 0,000001s0,000001s0,000002s0,000003s n0,00001s0,00002s0,00005s0,001s n2n2n2n20,0001s0,0004s0,0025s1s 2n2n2n2n0,001024s1,048576s 35,7 let 3,4∙ let nnnnnnnn 2,8 hodiny 3∙10 12 let 2,8∙10 71 let 3,2∙ let

Určení složitosti - příklad vyhledání prvku v poli vyhledání prvku v poli int hledejSekvencne(int pole[n], int prvek){ for (int i = 0; i < n; i++) if (pole[i] == prvek) return i; return -1; }

Určení složitosti - příklad vyhledání prvku v poli vyhledání prvku v poli int hledejSekvencne(int pole[n], int prvek){ for (int i = 0; i < n; i++) if (pole[i] == prvek) return i; return -1; } jaká je časová složitost? jaká je časová složitost?

Určení složitosti - příklad vyhledání prvku v poli vyhledání prvku v poli int hledejSekvencne(int pole[n], int prvek){ for (int i = 0; i < n; i++) if (pole[i] == prvek) return i; return -1; } jaká je časová složitost? jaká je časová složitost? nejlepší případ O(1)nejlepší případ O(1)

Určení složitosti - příklad vyhledání prvku v poli vyhledání prvku v poli int hledejSekvencne(int pole[n], int prvek){ for (int i = 0; i < n; i++) if (pole[i] == prvek) return i; return -1; } jaká je časová složitost? jaká je časová složitost? nejlepší případ O(1)nejlepší případ O(1) nejhorší případ O(n)nejhorší případ O(n)

Určení složitosti - příklad vyhledání prvku v poli vyhledání prvku v poli int hledejSekvencne(int pole[n], int prvek){ for (int i = 0; i < n; i++) if (pole[i] == prvek) return i; return -1; } jaká je časová složitost? jaká je časová složitost? nejlepší případ O(1)nejlepší případ O(1) nejhorší případ O(n)nejhorší případ O(n) průměr O(n/2) – za jakých předpokladů?průměr O(n/2) – za jakých předpokladů?

Určení složitosti - příklad vyhledání prvku v poli vyhledání prvku v poli int hledejSekvencne(int pole[n], int prvek){ for (int i = 0; i < n; i++) if (pole[i] == prvek) return i; return -1; } jaká je časová složitost? jaká je časová složitost? nejlepší případ O(1)nejlepší případ O(1) nejhorší případ O(n)nejhorší případ O(n) průměr O(n/2) – za jakých předpokladů?průměr O(n/2) – za jakých předpokladů? jde to rychleji? jde to rychleji?

Určení složitosti - příklad int hledejBinarne(int pole[n], int prvek){ int leva = 0; int prava = n; while (leva <= prava){ int stred = (prava-leva)/2 + leva; if (prvek > pole[stred]) leva = stred + 1; else if (prvek < pole[stred]) prava = stred - 1; else return stred; } return -1; }

Určení složitosti - příklad časová složitost O(log n) časová složitost O(log n) int hledejBinarne(int pole[n], int prvek){ int leva = 0; int prava = n; while (leva <= prava){ int stred = (prava-leva)/2 + leva; if (prvek > pole[stred]) leva = stred + 1; else if (prvek < pole[stred]) prava = stred - 1; else return stred; } return -1; }

Snížení čas. složitosti některé metody jsou genericky využitelné v mnoha problémech: některé metody jsou genericky využitelné v mnoha problémech: předpočítávánípředpočítávání stromystromy hashehashe heuristikyheuristiky aproximaceaproximace

Předpočítávání použitelné pokud se pohybujeme v relativně malé množině hodnot, které je složité získat použitelné pokud se pohybujeme v relativně malé množině hodnot, které je složité získat typický případ snížení časové složitosti na úkor složitosti prostorové typický případ snížení časové složitosti na úkor složitosti prostorové časová složitost O(1)časová složitost O(1) prostorová je úměrná velikosti předpočítaných datprostorová je úměrná velikosti předpočítaných dat pozor – cache miss je řádově 100x pomalejší než běžná instrukce – něco je dnes snazší počítat, než načítat z RAM pozor – cache miss je řádově 100x pomalejší než běžná instrukce – něco je dnes snazší počítat, než načítat z RAM

Předpočítávání - příklady goniometrické funkce goniometrické funkce Pro nižší přesnost (předpočítá se omezený počet úhlů)Pro nižší přesnost (předpočítá se omezený počet úhlů) dnes je levnější aproximace Taylorovým rozvojemdnes je levnější aproximace Taylorovým rozvojem vesmírný simulátor vesmírný simulátor realistické gravitační polerealistické gravitační pole předpočítávání viditelnosti předpočítávání viditelnosti PVSPVS bourání domů bourání domů složitá fyzika počítána v čase t+nsložitá fyzika počítána v čase t+n

Stromy běžné užití běžné užití vyhledávání prvku (O(log n))vyhledávání prvku (O(log n)) setřídění (O(n log n))setřídění (O(n log n)) při modifikaci problém vyvažování při modifikaci problém vyvažování nevyvážený strom ztrácí požadované vlastnostinevyvážený strom ztrácí požadované vlastnosti užití: užití: setřídění pole čísel, nalezení číslasetřídění pole čísel, nalezení čísla vytvoření prostorové hierarchievytvoření prostorové hierarchie vytvoření obálkové hierarchievytvoření obálkové hierarchie

Stromy - ukázka

Hashe vyhledávání v relativně malé množině prvků z velké domény vyhledávání v relativně malé množině prvků z velké domény slovníkyslovníky prostorové umístění tělesprostorové umístění těles heslahesla aj.aj. cíl – obvykle redukovat složitost vyhledávání na O(1) cíl – obvykle redukovat složitost vyhledávání na O(1)

Hashovací funkce mapuje vstupní klíč do indexu tabulky mapuje vstupní klíč do indexu tabulky hodnoty musí být mapovány rovnoměrně a náhodně hodnoty musí být mapovány rovnoměrně a náhodně pokud má více klíčů stejný hash, prohledávají se tyto hashe sekvenčně (nebo je třeba je setřídit)pokud má více klíčů stejný hash, prohledávají se tyto hashe sekvenčně (nebo je třeba je setřídit) nalezení dobré hashovací funkce je někdy složité až nemožné (stojíme před úkolem zajistit náhodné mapování nenáhodných dat)nalezení dobré hashovací funkce je někdy složité až nemožné (stojíme před úkolem zajistit náhodné mapování nenáhodných dat) hashovací funkci často hledáme pokusem a omylem, některé operace se obecně hodí, využíváme velkých prvočísel hashovací funkci často hledáme pokusem a omylem, některé operace se obecně hodí, využíváme velkých prvočísel

Příklad – hashování prostoru metoda pro první fázi detekce kolizí metoda pro první fázi detekce kolizí prostor je rozdělen regulární mřížkou, podle polohy na mřížce lze zakódovat umístění těles prostor je rozdělen regulární mřížkou, podle polohy na mřížce lze zakódovat umístění těles potenciálně kolidují tělesa se objeví na stejných indexech tabulky potenciálně kolidují tělesa se objeví na stejných indexech tabulky výhodné při velkém množství pohybujících-se objektů výhodné při velkém množství pohybujících-se objektů blíží se O(n) blíží se O(n) zpomaluje nevhodná velikost mřížky, malá tabulkazpomaluje nevhodná velikost mřížky, malá tabulka

Příklad hashování prostoru Červený objekt se zahashuje do 0000 Červený objekt se zahashuje do 0000 Modrý do 0010 a 0110 Modrý do 0010 a 0110 Žlutý do 0101 a 0110 Žlutý do 0101 a 0110 Zelený do 0100, 0101, 1000 a 1001 Zelený do 0100, 0101, 1000 a 1001 Jsou detekovány potenciální kolize: Jsou detekovány potenciální kolize: Modrý x žlutýModrý x žlutý Žlutý x zelenýŽlutý x zelený

Hashovací tabulka indexhodnota 0000č m m ž 0101 ž z 0110z 0111indexhodnota1000z 1001z

Heuristiky „ořezávání“ nezajímavých větví výpočtu „ořezávání“ nezajímavých větví výpočtu problém s nalezením vhodných kritérií problém s nalezením vhodných kritérií kterou větev zahodit, když nevidíme budoucnost?kterou větev zahodit, když nevidíme budoucnost? užití např. užití např. u pathfindingu (zahazování drahých cest)u pathfindingu (zahazování drahých cest) v deskových hrách (zahazování nevýhodných tahů)v deskových hrách (zahazování nevýhodných tahů)

Aproximace nalezení přibližného výsledku nalezení přibližného výsledku někdy nutnost (fyzika), někdy výrazná časová úspora (LOD, předpočítávání spojitých funkcí, heuristiky) někdy nutnost (fyzika), někdy výrazná časová úspora (LOD, předpočítávání spojitých funkcí, heuristiky) problém obchodního cestujícího: problém obchodního cestujícího: O(n!)O(n!) Pomocí GA – počítáme dokud chceme lepší výsledekPomocí GA – počítáme dokud chceme lepší výsledek

Lineární optimalizace optimalizace „na úrovni programových řádků“ optimalizace „na úrovni programových řádků“ zůstáváme v téže složitostní třídě, rychlost zvyšujeme pouze násobkem zůstáváme v téže složitostní třídě, rychlost zvyšujeme pouze násobkem je dobré znát náročnost běžných programových konstrukcí je dobré znát náročnost běžných programových konstrukcí je dobré znát hardware, na kterém program poběží je dobré znát hardware, na kterém program poběží je dobré znát programové prostředí, náročnost knihovních funkcí atd. je dobré znát programové prostředí, náročnost knihovních funkcí atd.

Volání funkcí volání funkcí představuje určitou režii volání funkcí představuje určitou režii kompilátor umí sám rozhodnout, která funkce bude linkována inlinekompilátor umí sám rozhodnout, která funkce bude linkována inline rychlost volání funkce závisí na počtu a velikosti(!) parametrů rychlost volání funkce závisí na počtu a velikosti(!) parametrů velká data je vhodnější předávat odkazemvelká data je vhodnější předávat odkazem virtuální metody jsou pomalejší virtuální metody jsou pomalejší Nepoužívejte pozdní vazbu u jednoduchých a často volaných metodNepoužívejte pozdní vazbu u jednoduchých a často volaných metod

Výkonnost hardware elementární aritmetické operace +, - a * jsou velmi rychlé, a to i v plovoucí řádové čárce elementární aritmetické operace +, - a * jsou velmi rychlé, a to i v plovoucí řádové čárce neceločíselné dělení je o řád pomalejšíneceločíselné dělení je o řád pomalejší goniometrické funkce jsou pomalejší než dělení goniometrické funkce jsou pomalejší než dělení některé operace lze vektorizovat některé operace lze vektorizovat paměť je škálována – registry, L2 cache, RAM, HDD… paměť je škálována – registry, L2 cache, RAM, HDD… někdy je lepší počítat, než „sahat“ do pamětiněkdy je lepší počítat, než „sahat“ do paměti

Odstranění rekurze rekurze je drahá rekurze je drahá (pře)plnění zásobníku(pře)plnění zásobníku režie s voláním a předáváním parametrůrežie s voláním a předáváním parametrů některé algoritmy jsou v iterační formě špatně čitelné některé algoritmy jsou v iterační formě špatně čitelné neexistuje obecný návod, jak rekurzi odstranit neexistuje obecný návod, jak rekurzi odstranit

Odstranění rekurze - příklad unsigned faktorial(unsigned x){ if (x == 0) if (x == 0) return 1; return 1; else else return x*faktorial(x-1); return x*faktorial(x-1);}

Odstranění rekurze - příklad unsigned faktorial(unsigned x){ if (x == 0) if (x == 0) return 1; return 1; else else return x*faktorial(x-1); return x*faktorial(x-1);} unsigned faktorialOpt(unsigned x, unsigned p = 1){ if (x == 0) if (x == 0) return p; return p; else else return faktorialOpt(x-1, x*p); return faktorialOpt(x-1, x*p);}

Kdy optimalizovat? optimalita kódu je nepřímo úměrná jeho čitelnosti optimalita kódu je nepřímo úměrná jeho čitelnosti nesoustřeďte se na kód na úrovni programových řádků, hledejte úzká hrdla nesoustřeďte se na kód na úrovni programových řádků, hledejte úzká hrdla někdy je úzké hrdlo zjevnéněkdy je úzké hrdlo zjevné někdy zjevné neníněkdy zjevné není nepočítali jsme s tím, že se daný kód volá tak často nepočítali jsme s tím, že se daný kód volá tak často některá funkce trvá déle, než jsme si mysleli některá funkce trvá déle, než jsme si mysleli přehlédli jsme zbytečné volání či nezoptimalizovanou funkci přehlédli jsme zbytečné volání či nezoptimalizovanou funkci je dobré používat profiler – najde chyby rychleji než my je dobré používat profiler – najde chyby rychleji než my

Kdy neoptimalizovat? často optimalizujeme ze zvyku i tam, kde to není nutné často optimalizujeme ze zvyku i tam, kde to není nutné existují třídící algoritmy v O(n 2 ) a O(n log n), má smysl o tom uvažovat u setřídění listiny vítězů, kterých je max. 20?existují třídící algoritmy v O(n 2 ) a O(n log n), má smysl o tom uvažovat u setřídění listiny vítězů, kterých je max. 20? pozná někdo co dělá toto?pozná někdo co dělá toto? while(*s++ = *t++);

Kdy neoptimalizovat? často optimalizujeme ze zvyku i tam, kde to není nutné často optimalizujeme ze zvyku i tam, kde to není nutné existují třídící algoritmy v O(n 2 ) a O(n log n), má smysl o tom uvažovat u setřídění listiny vítězů, kterých je max. 20?existují třídící algoritmy v O(n 2 ) a O(n log n), má smysl o tom uvažovat u setřídění listiny vítězů, kterých je max. 20? pozná někdo co dělá toto?pozná někdo co dělá toto? while(*s++ = *t++); nemachrujte – nikdy nevíte, kdo to po vás bude číst! nemachrujte – nikdy nevíte, kdo to po vás bude číst!

Kdy neoptimalizovat? často optimalizujeme ze zvyku i tam, kde to není nutné často optimalizujeme ze zvyku i tam, kde to není nutné existují třídící algoritmy v O(n 2 ) a O(n log n), má smysl o tom uvažovat u setřídění listiny vítězů, kterých je max. 20?existují třídící algoritmy v O(n 2 ) a O(n log n), má smysl o tom uvažovat u setřídění listiny vítězů, kterých je max. 20? pozná někdo co dělá toto?pozná někdo co dělá toto? while(*s++ = *t++); nemachrujte – nikdy nevíte, kdo to po vás bude číst! nemachrujte – nikdy nevíte, kdo to po vás bude číst! neoptimalizujte části kódu, které se volají současně s výrazně náročnější operacíneoptimalizujte části kódu, které se volají současně s výrazně náročnější operací šetření času CPU při načítání z disku (ovšem pokud nejedete multivláknově) šetření času CPU při načítání z disku (ovšem pokud nejedete multivláknově) výpočty před/po dlouhým cyklem výpočty před/po dlouhým cyklem

Profiler dynamická analýza výkonnosti programu dynamická analýza výkonnosti programu měří, kolik času tráví CPU v jednotlivých funkcích, jak často je volá měří, kolik času tráví CPU v jednotlivých funkcích, jak často je volá obvykle umožňuje přímo diassemblovat jednotlivé řádky kódu obvykle umožňuje přímo diassemblovat jednotlivé řádky kódu dobře použitelný u zpracování dat s nízkou úrovní paralelizace dobře použitelný u zpracování dat s nízkou úrovní paralelizace je dobré připravit profileru různé „scénáře“ je dobré připravit profileru různé „scénáře“

Ukázka

Dotazy?

Děkuji za pozornost.