View as presentation
→ Slide 1

Profilowanie programów i odpluskwianie pamięci

→ Slide 2

Profilowanie

↓ Slide 3

Techniki profilowania

↓ Slide 4

Instrumentacja

Instrumentacja polega na dodawaniu do kodu instrukcji służących do uzyskania informacji o wydajności aplikacji

Instrumentacja pozwala na:

Lecz nic nie jest za darmo…

↓ Slide 5

Rodzaje instrumentacji

↓ Slide 6

Event-based profile

↓ Slide 7

Matody statystyczne

→ Slide 8

Sposoby raportowania

↓ Slide 9

Wynik działania

↓ Slide 10

Call graph

Źródło: wikipedia.org

→ Slide 11

Narzędzia do profilowania

→ Slide 12

gprof

↓ Slide 13

Użycie gprof

↓ Slide 14

Przykład

void func2(void)
{
   int i = 0;
   for(;i<0xffffff;i++);
   return;
}
 
void func1(void)
{
   int i = 0;
   for(;i<0xfffffff;i++);
   func2();
   return;
}
 
int main(void)
{
   int i = 0;
   for(;i<0xfffffff;i++);
   func1();
 
   for(i=0 ; i< 3 ; i++) func2();
   return 0;
}
↓ Slide 15

Profil płaski

gprof a.out gmon.out
Flat profile:

Each sample counts as 0.01 seconds.
  %   cumulative   self              self     total           
 time   seconds   seconds    calls  ms/call  ms/call  name    
 44.92      0.80     0.80        1   799.52   850.12  func1
 44.92      1.60     0.80                             main
 11.37      1.80     0.20        4    50.60    50.60  func2
↓ Slide 16

Graf wywołań

granularity: each sample hit covers 2 byte(s) for 0.56% of 1.80 seconds

index % time    self  children    called     name
                                                 <spontaneous>
[1]    100.0    0.80    1.00                 main [1]
                0.80    0.05       1/1           func1 [2]
                0.15    0.00       3/4           func2 [3]
-----------------------------------------------
                0.80    0.05       1/1           main [1]
[2]     47.2    0.80    0.05       1         func1 [2]
                0.05    0.00       1/4           func2 [3]
-----------------------------------------------
                0.05    0.00       1/4           func1 [2]
                0.15    0.00       3/4           main [1]
[3]     11.2    0.20    0.00       4         func2 [3]
-----------------------------------------------

Inny przykład (program make): overall-profile.txt sample.png

↓ Slide 17

Ograniczenia

→ Slide 18

Analiza pamięci (Memory debugging tools)

→ Slide 19

Valgrind - brama do Valhalli

↓ Slide 20

Narzędzia valgrind

↓ Slide 21

Uruchamianie

valgrind [opcje valgrind] program [opcje programu]

Przykład: 

valgrind --tool=memcheck ls -l

Nie wymaga dostępu do źródeł programu ale kompilacja z symbolami debbugowania pozwala powiązać wynik z kodem: 

gcc -g kod_programu
↓ Slide 22

Memcheck

↓ Slide 23

Memcheck: wykrywane błędy

↓ Slide 24

Przykład

#include <stdlib.h>
 
void f(void)
{
   int* x = malloc(10 * sizeof(int));
   x[10] = 0;        // problem 1: heap block overrun
}                    // problem 2: memory leak -- x not freed
 
int main(void)
{
   f();
   return 0;
}
gcc -pg -g mem1.c
valgrind --leak-check=yes a.out
==23065== Invalid write of size 4
==23065==    at 0x400670: f (mem1.c:8)
==23065==    by 0x400685: main (mem1.c:13)
==23065==  Address 0x51fd778 is 0 bytes after a block of size 40 alloc'd
==23065==    at 0x4C2AB80: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==23065==    by 0x400663: f (mem1.c:7)
==23065==    by 0x400685: main (mem1.c:13)
==23065== 
==23065== 
==23065== HEAP SUMMARY:
==23065==     in use at exit: 40 bytes in 1 blocks
==23065==   total heap usage: 2 allocs, 1 frees, 1,780 bytes allocated
==23065== 
==23065== 40 bytes in 1 blocks are definitely lost in loss record 1 of 1
==23065==    at 0x4C2AB80: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==23065==    by 0x400663: f (mem1.c:7)
==23065==    by 0x400685: main (mem1.c:13)
==23065==
↓ Slide 25

Wycieki pamięci

==23065== LEAK SUMMARY:
==23065==    definitely lost: 40 bytes in 1 blocks
==23065==    indirectly lost: 0 bytes in 0 blocks
==23065==      possibly lost: 0 bytes in 0 blocks
==23065==    still reachable: 0 bytes in 0 blocks
==23065==         suppressed: 0 bytes in 0 blocks
↓ Slide 26

Cachegrind i Callgrind

↓ Slide 27

KCachegrind

valgrind --toll=callgrind program
kcachegrind
→ Slide 28

Profilowanie kodu w VS2013

↓ Slide 29

Performance Session

Perforamnce Explorer:
konfiguracja sesji,
uruchamianie testów,
porównywanie raportów

↓ Slide 30

Wymagania

↓ Slide 31

Raport

↓ Slide 32

Sampling

↓ Slide 33

Instrumentation

↓ Slide 34

Szczegóły analizy funkcji

↓ Slide 35

Error List

↓ Slide 36

Filtrowanie wyników


Żródło: http://msdn.microsoft.com

↓ Slide 37

CPU and Windows Counters

↓ Slide 38

Memory Allocation and Object Lifetime

↓ Slide 39

Raport

↓ Slide 40

Porównywanie raportów

→ Slide 41

Podsumowanie

→ Slide 42

Więcej informacji