Używanie valgrind do znalezienia wycieku pamięci w mysql klienta C++

Question

Używam valgrind, aby spróbować i wyśledzić wyciek pamięci to klient mysql C++ rozprowadzany z mysql.

W obu przykładach (wynikset.cpp) i mój własny program jest jeden 56-bajtowy blok, który nie został zwolniony. W moim własnym programie prześledziłem przeciek do wywołania do klienta mysql.

Oto wyniki po uruchomieniu testu:

valgrind --leak-check=full --show-reachable=yes ./my-executable 

==29858== Memcheck, a memory error detector 
==29858== Copyright (C) 2002-2009, and GNU GPL'd, by Julian Seward et al. 
==29858== Using Valgrind-3.6.0.SVN-Debian and LibVEX; rerun with -h for copyright info 
==29858== Command: ./my-executable 
==29858== 
==29858== 
==29858== HEAP SUMMARY: 
==29858==  in use at exit: 56 bytes in 1 blocks 
==29858== total heap usage: 693 allocs, 692 frees, 308,667 bytes allocated 
==29858== 
==29858== 56 bytes in 1 blocks are still reachable in loss record 1 of 1 
==29858== at 0x4C284A8: malloc (vg_replace_malloc.c:236) 
==29858== by 0x400D334: _dl_map_object_deps (dl-deps.c:506) 
==29858== by 0x4013652: dl_open_worker (dl-open.c:291) 
==29858== by 0x400E9C5: _dl_catch_error (dl-error.c:178) 
==29858== by 0x4012FF9: _dl_open (dl-open.c:583) 
==29858== by 0x7077BCF: do_dlopen (dl-libc.c:86) 
==29858== by 0x400E9C5: _dl_catch_error (dl-error.c:178) 
==29858== by 0x7077D26: __libc_dlopen_mode (dl-libc.c:47) 
==29858== by 0x72E5FEB: pthread_cancel_init (unwind-forcedunwind.c:53) 
==29858== by 0x72E614B: _Unwind_ForcedUnwind (unwind-forcedunwind.c:126) 
==29858== by 0x72E408F: __pthread_unwind (unwind.c:130) 
==29858== by 0x72DDEB4: pthread_exit (pthreadP.h:265) 
==29858== 
==29858== LEAK SUMMARY: 
==29858== definitely lost: 0 bytes in 0 blocks 
==29858== indirectly lost: 0 bytes in 0 blocks 
==29858==  possibly lost: 0 bytes in 0 blocks 
==29858== still reachable: 56 bytes in 1 blocks 
==29858==   suppressed: 0 bytes in 0 blocks 
==29858== 
==29858== For counts of detected and suppressed errors, rerun with: -v 
==29858== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 8 from 6) 

Mam kilka pytań odnośnie tego:

1. W jaki sposób należy interpretować blok --show-osiągalny?
2. Czy ten blok jest dla mnie przydatny, gdy próbuję zerwać błąd?
3. Jeśli blok nie jest użyteczny, czy valgrind ma inny mechanizm, który pomoże mi prześledzić wyciek?
4. Jeśli nie, czy jest jakieś inne narzędzie (mam nadzieję, że OSS na Linuksie), które pomoże mi to zawęzić?

góry dzięki ..

UPDATE: Oto kod, który znalazłem na moim systemie definicji pthread_exit. Nie jestem pewien, czy jest to faktyczne źródło, które jest wywoływane. Jeśli jednak tak jest, czy ktoś może wyjaśnić, co może być nie tak?

void 
pthread_exit (void *retval) 
{ 
    /* specific to PTHREAD_TO_WINTHREAD */ 

    ExitThread ((DWORD) ((size_t) retval)); /* thread becomes signalled so its death can be waited upon */ 
    /*NOTREACHED*/ 
    assert (0); return; /* void fnc; can't return an error code */ 
} 

Answer 1

Osiągalny po prostu oznacza, że ​​bloki miały ważny wskaźnik ich odniesienie w zakresie, gdy program zakończył, co oznacza, że ​​program wyraźnie nie darmowy wszystko na wyjściu, ponieważ opiera się na podstawowej OS to zrobić. To, czego powinieneś szukać, to zgubione bloki, w których bloki pamięci straciły wszystkie odniesienia do nich i nie można ich już uwolnić.

Tak więc, 56 bajtów zostało prawdopodobnie przydzielonych w głównej, która nie została jawnie zwolniona. Opublikowane informacje nie wskazują na przeciek pamięci. Pokazuje on główne zwalnianie wszystkiego poza tym, co zostało przydzielone, ponieważ główny zakłada, że ​​gdy umrze, cała pamięć zostanie odzyskana przez jądro.

W szczególności jest to pthread (w głównym), który przyjmuje to założenie (co jest prawidłowym założeniem dotyczącym niemal wszystkiego, co znajduje się w produkcji napisanej w ciągu ostatnich 15 lat). Potrzeba uwolnienia bloków, które wciąż mają ważne odniesienie do wyjścia, jest trochę sporna, ale w tym konkretnym pytaniu wystarczy wspomnieć, że założenie zostało poczynione.

Edit

to faktycznie pthread_exit() nie czyszczenia coś na wyjściu, ale jak wytłumaczyć to prawdopodobnie nie trzeba (lub całkiem możliwe nie może) po osiągnięciu tego punktu.