optymalizacja czasowa programów

Transkrypt

Wprowadzenie
Wybór kodu do optymalizacji
Przykłady optymalizacji czasowej
Pozostałe czynniki uboczne warunkujące wydajność programów
Inżynieria oprogramowania:
optymalizacja czasowa programów
Zdzisław Sroczyński
Politechnika Śląska
Instytut Matematyki
Wydział Matematyki Stosowanej
Inżynieria oprogramowania: optymalizacja czasowa programów
Wprowadzenie
▶ Priorytet: poprawność i niezawodność programów
Wprowadzenie
▶ Warunki przeprowadzenia optymalizacji programu:
Wprowadzenie
program wielokrotnego użycia
Wprowadzenie
optymalizacja przewidziana w celach projektu
Wprowadzenie
określone wymogi na sprawność programu
Wprowadzenie

istotna poprawa wydajności po optymalizacji
Wprowadzenie

ograniczenie ryzyka wprowadzenia nowych błędów
Wprowadzenie

▶ Sposoby optymalizacji czasowej programów:
ponowny projekt z wykorzystaniem ulepszonych
algorytmów lub nowych struktur danych
Wprowadzenie

usprawnienie fragmentów programu bez modyfikacji
algorytmu jako całości
Wprowadzenie

usprawnienie fragmentów programu bez
modyfikacji algorytmu jako całości
Wprowadzenie
▶ Stosunek kosztów do wartości planowanych
usprawnień
Wprowadzenie
usprawnień
▶ Czynniki istotne podczas optymalizacji czasowej:
Wprowadzenie
usprawnień
profil dynamiczny programu – procent czasu zużywany
przez poszczególne fragmenty
Wprowadzenie
usprawnień
stopień (procent) optymalizacji możliwy do osiągnięcia w
poszczególnych fragmentach
Wprowadzenie
usprawnień
celowość optymalizacji (rzadko używane funkcje, czas
reakcji systemu w systemach czasu rzeczywistego)
Wprowadzenie
usprawnień
liczba osobogodzin koniecznych do wykonania
optymalizacji w poszczególnych fragmentach –
opłacalność optymalizacji
Wprowadzenie
usprawnień
liczba osobogodzin koniecznych do wykonania
optymalizacji w poszczególnych fragmentach –
opłacalność optymalizacji
Wprowadzenie
▶ Wybór fragmentu pozwalającego na istotną
optymalizację
Wprowadzenie
optymalizację
▶ region krytyczny – stosunkowo niewielki (10%)
fragment programu, który zajmuje większą część
czasu wykonania (90%)
Wprowadzenie
optymalizację
▶ reguła 90–10 (jedna z wielu)
Wprowadzenie
optymalizację
▶ metody znajdowania regionów krytycznych:
Wprowadzenie
optymalizację
automatyczne wyznaczenie profilu dynamicznego (za
pomocą programu/modułu profilera)
Wprowadzenie
optymalizację
pomiar czasu wykonywania fragmentów programu
(głównie podprogramów – funkcji, metod)
Wprowadzenie
optymalizację
pomiar czasu wykonywania fragmentów programu
(głównie podprogramów – funkcji, metod)
generowanie histogramu z wykorzystaniem przerwań
sprzętowych
Wprowadzenie
Raport profilera:
Wprowadzenie
pomiar.php: czas wykonania programu w PHP
<?php
$_licznik =0;
function pomiar_start ( )
{
global $_licznik ;
l i s t ( $usec , $sec ) = e x p l o d e ( ’ ’ , m i c r o t i m e ( ) ) ;
$_licznik =(( float ) $usec + ( float ) $sec ) ;
}
function pomiar_stop ( $napis )
{
global $_licznik ;
l i s t ( $usec , $sec ) = e x p l o d e ( ’ ’ , m i c r o t i m e ( ) ) ;
$czas =(( float ) $usec + ( float ) $sec )−$_licznik ;
p r i n t f ( ’%s − Czas w y k o n a n i a : %.4 f ’ , $napis , $czas ) ;
}
?>
Wprowadzenie
▶ Oszacowanie możliwych rezultatów optymalizacji
Wprowadzenie
▶ Wykorzystanie heurystyki i doświadczenia
programisty, przegląd możliwych do zastosowania
optymalizacji
Wprowadzenie
optymalizacji
▶ Złożoność algorytmów czynnikiem utrudniającym
wybór fragmentu do optymalizacji
Wprowadzenie
optymalizacji
zależność czasu wykonania od rozmiaru i/lub jakości
danych wejściowych
Wprowadzenie
optymalizacji
danych wejściowych
złożoność optymistyczna, pesymistyczna, średnia
Wprowadzenie
optymalizacji
danych wejściowych
testy i pomiary powinny być wykonywane dla różnych
zestawów danych, np. z określeniem odchylenia
standardowego
Wprowadzenie
optymalizacji
danych wejściowych
testy i pomiary powinny być wykonywane dla różnych
zestawów danych, np. z określeniem odchylenia
standardowego
Wprowadzenie
▶ Zależność od translatora i konkretnego języka
programowania (pseudokod)
Wprowadzenie
▶ Zwijanie - wykonywanie czynności na etapie
kompilacji, np. inicjalizacja zmiennych, wyliczanie
wartości wyrażeń zawierających wyłącznie stałe,
użycie dyrektyw kompilacji warunkowej.
Wprowadzenie
▶ Zmniejszanie siły operacji - zastąpienie operacji
czasochłonnych operacjami szybszymi, np.
zastąpienie potęgowania mnożeniem:
Wprowadzenie
▶ Zmniejszanie siły operacji - zastąpienie operacji
czasochłonnych operacjami szybszymi, np.
zastąpienie potęgowania mnożeniem:
Zmniejszanie siły operacji
w := a ˆ 3 ;
w := a * a * a ;
w :=2 * b ;
w := b+b ;
Wprowadzenie
▶ Usuwanie wyrażeń nadmiarowych - obliczanie
powtarzających się wyrażeń jednorazowo z
zapamiętaniem w zmiennej pomocniczej:
Wprowadzenie
Usuwanie wyrażeń nadmiarowych
x := s q r t ( z ) / s i n ( y ) + 1 6 ;
w := s q r t ( z ) ;
u := fn ( s q r t ( z ) / s i n ( y ) ) ;
Wprowadzenie
x := s q r t ( z ) / s i n ( y ) + 1 6 ;
w := s q r t ( z ) ;
u := fn ( s q r t ( z ) / s i n ( y ) ) ;
Usuwanie wyrażeń
nadmiarowych - poprawka
p1
p2
x
w
u
:=
:=
:=
:=
:=
sqrt (z) ;
p1 / s i n ( y ) ;
p2 + 1 6 ;
p1 ;
fn ( p2 ) ;
Wprowadzenie
x := s q r t ( z ) / s i n ( y ) + 1 6 ;
w := s q r t ( z ) ;
u := fn ( s q r t ( z ) / s i n ( y ) ) ;
Usuwanie wyrażeń
nadmiarowych - poprawka
p1
p2
x
w
u
:=
:=
:=
:=
:=
sqrt (z) ;
p1 / s i n ( y ) ;
p2 + 1 6 ;
p1 ;
fn ( p2 ) ;
Usuwanie wyrażeń
nadmiarowych - poprawka 2
w
pom
x
u
:=
:=
:=
:=
sqrt (z) ;
w / sin (y) ;
pom + 1 6 ;
fn ( pom ) ;
Wprowadzenie
▶ Usuwanie wyrażeń niezmienniczych - jednokrotne
wyliczenie przed pętlą wartości wyrażeń, które nie
zależą od wartości zmiennej sterującej, ani innych
zmiennych modyfikowanych w ciele pętli:
Wprowadzenie
Usuwanie wyrażeń niezmienniczych
f o r i := 1 t o 100 do
t [ i ] := s i n ( y ) * t [ i ] ;
Wprowadzenie
Usuwanie wyrażeń niezmienniczych
f o r i := 1 t o 100 do
t [ i ] := s i n ( y ) * t [ i ] ;
Usuwanie wyrażeń niezmienniczych - poprawka
pom := s i n ( y ) ;
f o r i := 1 t o 100 do
t [ i ] := pom * t [ i ] ;
Wprowadzenie
PHP - usuwanie wyrażeń niezmienniczych
<?php
i n c l u d e ( ’ p o m i a r . php ’ ) ;
pomiar_start ( ) ;
ob start () ;
f o r ( $j =1; $j <=100;$j++)
f o r ( $i =1; $i <=3600; $i++)
echo ’ Kąt w s t o p n i a c h : ’ . $i . ’ = Kąt w r a d i a n a c h :
ob clean () ;
pomiar_stop ( ’ W a r i a n t 1 − P o w t a r z a n i e o b l i c z e ń ’ ) ;
’ . ( $i * 3 . 1 4 / 1 8 0 ) . ’ ’ ;
pomiar_start ( ) ;
ob start () ;
$strd = 3 . 1 4 / 1 8 0 ;
f o r ( $j =1; $j <=100;$j++)
f o r ( $i =1; $i <=3600; $i++)
echo ’ Kąt w s t o p n i a c h : ’ . $i . ’ = Kąt w r a d i a n a c h : ’ . ( $i * $strd ) . ’ ’ ;
ob clean () ;
pomiar_stop ( ’ W a r i a n t 2 − Bez p o w t a r z a n i a o b l i c z e ń ’ ) ;
?>
Wprowadzenie
▶ Rozszczepianie - podział pętli w przypadku, gdy
wewnątrz pętli występuje warunek niezależny od
zmiennej sterującej:
Wprowadzenie
Rozszczepianie
f o r i := 1 t o nmax do
i f dodawanie=true t h e n
a := a + n
else
a := a − n ;
Wprowadzenie
Rozszczepianie
a := a + n
else
a := a − n ;
Rozszczepianie - poprawka
a := a + n
else
a := a − n ;
Wprowadzenie
▶ Rozwijanie pętli - zwiększenie kroku pętli
zmniejszające liczbę sprawdzeń warunku:
Wprowadzenie
Rozwijanie pętli
i :=0;
w h i l e ( i < 3 0 0 ) do
begin
a [ i ] := 0 ;
i := i + 1 ;
end ;
Wprowadzenie
Rozwijanie pętli
i :=0;
w h i l e ( i < 3 0 0 ) do
begin
a [ i ] := 0 ;
i := i + 1 ;
end ;
Rozwijanie pętli - poprawka
i :=0;
w h i l e ( i < 3 0 0 ) do
begin
a [ i ] := 0 ;
a [ i +1] := 0 ;
a [ i +2] := 0 ;
i := i + 3 ;
end ;
Wprowadzenie
▶ Łączenie pętli - polega na połączeniu ciał pętli o
identycznych ograniczeniach zmiennej sterującej:
Wprowadzenie
Łączenie pętli
f o r i := 1 t o 100 do
t [ i ]:=0;
f o r i := 1 t o 100 do
w [ i ]:=0;
Wprowadzenie
Łączenie pętli
f o r i := 1 t o 100 do
t [ i ]:=0;
f o r i := 1 t o 100 do
w [ i ]:=0;
Łączenie pętli - poprawka
f o r i := 1 t o 100 do
begin
t [ i ]:=0;
w [ i ]:=0;
end ;
Wprowadzenie
▶ Reorganizacja pętli - pętle zewnętrzne powinny być
powtarzane możliwie najmniej razy:
Wprowadzenie
Reorganizacja pętli (startów: 2101, zamknięć: 12100)
f o r i := 1 t o 100 do { s t a r t 1 r a z }
f o r j := 1 t o 20 do { s t a r t 100 r a z y }
f o r z := 1 t o 5 do { s t a r t 2000 r a z y }
t [i , j , z ]:=0;
{ z a m k n i ę c i e 10000 r a z y }
{ z a m k n i e c i e d l a j 2000 r a z y }
{ z a m k n i e c i e d l a i 100 r a z y }
Wprowadzenie
Reorganizacja pętli (startów: 2101, zamknięć: 12100)
f o r i := 1 t o 100 do { s t a r t 1 r a z }
f o r j := 1 t o 20 do { s t a r t 100 r a z y }
f o r z := 1 t o 5 do { s t a r t 2000 r a z y }
t [i , j , z ]:=0;
{ z a m k n i ę c i e 10000 r a z y }
{ z a m k n i e c i e d l a j 2000 r a z y }
{ z a m k n i e c i e d l a i 100 r a z y }
Reorganizacja pętli - popr. (startów: 106, zamkn.: 10105)
f o r z := 1 to 5 do {start 1 raz}
f o r j := 1 to 20 do {start 5 razy}
f o r i := 1 to 100 do {start 100 razy}
t [i , j , z ]:=0;
{zamknięcie 10000 razy}
{zamkniecie dla j 100 razy}
{zamkniecie dla z 5 razy}
Wprowadzenie
PHP - reorganizacja pętli
<?php
pomiar_start ( ) ;
f o r ( $i= 1 ; $i <=1000; $i++)
f o r ( $j =1; $j <=200;$j++)
f o r ( $z =1; $z<=5;$z++)
$t [ i ] [ j ] [ z ] = 0 ;
pomiar_stop ( ’ W a r i a n t 1 − d u z e p r z e b i e g i w zewn .
pomiar_start ( ) ;
f o r ( $z =1; $z<=5;$z++)
f o r ( $j =1; $j <=200;$j++)
f o r ( $i= 1 ; $i <=1000; $i++)
$t [ i ] [ j ] [ z ] = 0 ;
pomiar_stop ( ’ W a r i a n t 2 − male p r z e b i e g i w zewn .
?>
petli ’) ;
petli ’) ;
Wprowadzenie
▶ Optymalizacja instrukcji warunkowych:
Wprowadzenie
dla rozłącznych warunków użycie członu else
Wprowadzenie
dla translatora sprawdzającego warunki złożone tylko do
momentu, w którym znana jest wartość wyrażenia:
Wprowadzenie
– dla operatora oraz/and najpierw człony zwykle fałszywe
Wprowadzenie
– dla operatora lub/or najpierw człony zwykle prawdziwe
Wprowadzenie
Optymalizacja instrukcji warunkowych
i f x = 1 t h e n p1 ;
i f x = 2 t h e n p2 ;
i f x = 2 t h e n p3 ;
Wprowadzenie
Optymalizacja instrukcji warunkowych
i f x = 1 t h e n p1 ;
i f x = 2 t h e n p2 ;
i f x = 2 t h e n p3 ;
Optymalizacja instrukcji warunkowych - poprawka
i f x = 1 t h e n p1
else
i f x = 2 t h e n p2
else
i f x = 2 t h e n p3 ;
Wprowadzenie
▶ Odwołania do elementów tablic – podstawienie pod
zmienną prostą wielokrotnie wykorzystywanego
elementu tablicy:
Wprowadzenie
elementu tablicy:
Odwołania do elementów tablic
x := t [ i ] + t [ i ] + t [ i ] ;
f o r i := 1 t o 100 do
t [ i ] := w [ k + 2 * j ] ;
Wprowadzenie
elementu tablicy:
Odwołania do elementów tablic
x := t [ i ] + t [ i ] + t [ i ] ;
f o r i := 1 t o 100 do
t [ i ] := w [ k + 2 * j ] ;
Odwołania do elementów tablic - poprawka
p i := t [ i ] ; x := p i + p i + p i ;
wp := w [ k + 2 * j ] ;
f o r i := 1 t o 100 do
t [ i ] := wp ;
Wprowadzenie
▶ Odwołania do pól rekordów/struktur/obiektów –
duża zależność od translatora.
Wprowadzenie
▶ Rozwijanie funkcji – umieszczenie ciała funkcji w
miejsce jej wywołania (jeśli wywoływanie następuje
w niewielu miejscach).
Wprowadzenie
▶ Optymalizacje translatora – optymalizacja kodu w
opcjach kompilatora, konieczność ponownego
testowania po włączeniu optymalizacji.
Wprowadzenie
▶ Optymalizacje translatora – optymalizacja kodu w
opcjach kompilatora, konieczność ponownego
testowania po włączeniu optymalizacji.
▶ Negatywny wpływ na przejrzystość kodu – niektóre
z optymalizacji.
Wprowadzenie
▶ operacje wejścia-wyjścia (dla języków skryptowych,
webowych - np. PHP)
Wprowadzenie
▶ operacje wejścia-wyjścia (dla języków skryptowych,
webowych - np. PHP)
PHP - różne metody przetwarzania tekstu
<?php
pomiar_start ( ) ;
$tab=a r r a y ( ) ;
f o r ( $i =0; $i <100000; $i++) $tab [ ] = ” Z a w a r t o ś ć z m i e n n e j $ i ” ;
pomiar_stop ( ’ W a r i a n t 1 − C u d z y s ł o w y ’ ) ;
pomiar_start ( ) ;
$tab=a r r a y ( ) ;
f o r ( $i =0; $i <100000; $i++) $tab [ ] = ’ Z a w a r t o ś ć z m i e n n e j
pomiar_stop ( ’ W a r i a n t 2 − A p o s t r o f y ’ ) ;
’ . $i . ’ ’ ;
?>
Wprowadzenie
PHP - funkcje wyjściowe dla tekstów
<?php
pomiar_start ( ) ;
ob start () ;
f o r ( $i =0; $i <100000; $i++) p r i n t f ( ’ Z a w a r t o ś ć z m i e n n e j
ob clean () ;
pomiar_stop ( ’ W a r i a n t 1 − p r i n t f ’ ) ;
pomiar_start ( ) ;
ob start () ;
f o r ( $i =0; $i <100000; $i++) p r i n t ( ’ Z a w a r t o ś ć z m i e n n e j
ob clean () ;
pomiar_stop ( ’ W a r i a n t 2 − p r i n t ’ ) ;
pomiar_start ( ) ;
ob start () ;
f o r ( $i =0; $i <100000; $i++) echo ( ’ Z a w a r t o ś ć z m i e n n e j
ob clean () ;
pomiar_stop ( ’ W a r i a n t 3 − e c h o ’ ) ;
’ . $i . ’ ’ ) ;
’ . $i . ’ ’ ) ;
’ . $i . ’ ’ ) ;
?>
Wprowadzenie
▶ buforowanie operacji we/wy, mapowanie plików w
pamięci operacyjnej
Wprowadzenie
▶ narzut wprowadzany przez system operacyjny/inne
oprogramowanie (np. antywirusowe)
Wprowadzenie
▶ obciążenie wynikające z wielozadaniowości i
wielodostępu – wpływ niedeterministyczny
Wprowadzenie
▶ działanie pamięci wirtualnej i dynamicznej
gospodarki pamięcią (odśmiecacz - garbage collector
w C#, Java)
Wprowadzenie
▶ działanie pamięci wirtualnej i dynamicznej
gospodarki pamięcią (odśmiecacz - garbage collector
w C#, Java)
Wprowadzenie
▶ listy wbudowane w bibliotekę standardową ArrayList
Wprowadzenie
▶ listy oparte na Generykach (Templates) List<T>
Wprowadzenie
▶ tablice zmiennych prostych
Wprowadzenie
▶ tablice dynamiczne (o ile istnieją w danym języku)
Wprowadzenie
▶ inne specyficzne typy danych (np. Variant, typy
anonimowe var)
Wprowadzenie
▶ inne specyficzne typy danych (np. Variant, typy
anonimowe var)
Wprowadzenie
Dziękuję za uwagę
Następny temat:
optymalizacja pamięciowa programów