c++ - leak - definitely lost valgrind

Boost thread Leakage C++

Question

¿Podría alguien decirme si la biblioteca del hilo de refuerzo se filtra? Me parece que sí: Google dice que debo compilar con thread boost y pthread que estoy haciendo y que en la versión 1.40 este problema ha sido solucionado pero sigo teniendo fugas. Tenga en cuenta que esto compilará bien, pero se detectan fugas.

#include <boost/thread.hpp>  
#include <boost/date_time.hpp>  

void t1(){}

int main(void){
boost::thread th1(t1);
th1.join();
return 1;
}

Con Valgrind obtengo la siguiente salida

HEAP SUMMARY:
==8209==     in use at exit: 8 bytes in 1 blocks
==8209==   total heap usage: 5 allocs, 4 frees, 388 bytes allocated
==8209== 
==8209== 8 bytes in 1 blocks are still reachable in loss record 1 of 1
==8209==    at 0x4024F20: malloc (vg_replace_malloc.c:236)
==8209==    by 0x4038CCB: boost::detail::get_once_per_thread_epoch() (in /usr/local/lib/libboost_thread.so.1.42.0)
==8209==    by 0x40329D4: ??? (in /usr/local/lib/libboost_thread.so.1.42.0)
==8209==    by 0x4032B26: boost::detail::get_current_thread_data() (in /usr/local/lib/libboost_thread.so.1.42.0)
==8209==    by 0x4033F32: boost::thread::join() (in /usr/local/lib/libboost_thread.so.1.42.0)
==8209==    by 0x804E7C3: main (testboost.cpp)
==8209== 
==8209== LEAK SUMMARY:
==8209==    definitely lost: 0 bytes in 0 blocks
==8209==    indirectly lost: 0 bytes in 0 blocks
==8209==      possibly lost: 0 bytes in 0 blocks
==8209==    still reachable: 8 bytes in 1 blocks
==8209==         suppressed: 0 bytes in 0 blocks

También probé con el código que figura en el siguiente sitio web: http://antonym.org/2009/05/threading-with-boost---part-i-creating-threads.html. Sigue el mismo problema.

Answer 1

Esto está relacionado con el impulso 1_46_1, por lo que puede no ser cierto para la versión que está utilizando. Mira las fuentes de impulso si realmente quieres convencerte a ti mismo. (El detector de fugas en OSX no detecta ninguna fuga cuando ejecuto su código de ejemplo).

Esto no es una fuga real (a menos que haya un error con pthreads, la versión desactualizada de boost que estás usando o tu compilador).

get_once_per_thread_epoch mallocs un nuevo uintmax_t y lo mapea en thread-local-storage con un epoch_tss_key que tiene un destructor asociado que libera los datos mapeados. Por lo tanto, se garantiza que la memoria mallada se liberará.

Realmente no entiendo por qué valgrind está detectando esto como una fuga, pero puede ser porque las funciones de salida pthreads se están ejecutando en algún momento después de las de valgrind. La otra posibilidad es que las funciones pthread se estén filtrando, pero no vi nada en la documentación que sugiera que este sea el caso.