14

Valgrind は、次のコードでリークされたブロックを報告しています。明らかに、スレッドごとに 1 つです。

#include <iostream>
#include <thread>
#include <mutex>
#include <list>
#include <chrono>

std::mutex cout_mutex;

struct Foo
{
    Foo() 
    { 
        std::lock_guard<std::mutex> lock( cout_mutex );
        std::cout << __PRETTY_FUNCTION__ << '\n'; 
    }

    ~Foo() 
    { 
        std::lock_guard<std::mutex> lock( cout_mutex );
        std::cout << __PRETTY_FUNCTION__ << '\n'; 
    }

    void 
    hello_world() 
    { 
        std::lock_guard<std::mutex> lock( cout_mutex );
        std::cout << __PRETTY_FUNCTION__ << '\n'; 
    }
};

void
hello_world_thread()
{
    thread_local Foo foo;

    // must access, or the thread local variable may not be instantiated
    foo.hello_world();

    // keep the thread around momentarily
    std::this_thread::sleep_for( std::chrono::milliseconds( 100 ) );
}

int main()
{
    for ( int i = 0; i < 100; ++i )
    {
        std::list<std::thread> threads;

        for ( int j = 0; j < 10; ++j )
        {
            std::thread thread( hello_world_thread );
            threads.push_back( std::move( thread ) );
        }

        while ( ! threads.empty() )
        {
            threads.front().join();
            threads.pop_front();
        }
    }
}

コンパイラのバージョン:

$ g++ --version
g++ (GCC) 4.8.1
Copyright (C) 2013 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

GCC ビルド オプション:

--enable-shared
--enable-threads=posix
--enable-__cxa_atexit
--enable-clocale=gnu
--enable-cxx-flags='-fno-omit-frame-pointer -g3'
--enable-languages=c,c++
--enable-libstdcxx-time=rt
--enable-checking=release
--enable-build-with-cxx
--disable-werror
--disable-multilib
--disable-bootstrap
--with-system-zlib

プログラムのコンパイル オプション:

g++ -std=gnu++11 -Og -g3 -Wall -Wextra -fno-omit-frame-pointer thread_local.cc

valgrind バージョン:

$ valgrind --version
valgrind-3.8.1

Valgrind オプション:

valgrind --leak-check=full --verbose ./a.out > /dev/null

valgrind 出力の末尾:

==1786== HEAP SUMMARY:
==1786==     in use at exit: 24,000 bytes in 1,000 blocks
==1786==   total heap usage: 3,604 allocs, 2,604 frees, 287,616 bytes allocated
==1786== 
==1786== Searching for pointers to 1,000 not-freed blocks
==1786== Checked 215,720 bytes
==1786== 
==1786== 24,000 bytes in 1,000 blocks are definitely lost in loss record 1 of 1
==1786==    at 0x4C29969: operator new(unsigned long, std::nothrow_t const&) (vg_replace_malloc.c:329)
==1786==    by 0x4E8E53E: __cxa_thread_atexit (atexit_thread.cc:119)
==1786==    by 0x401036: hello_world_thread() (thread_local.cc:34)
==1786==    by 0x401416: std::thread::_Impl<std::_Bind_simple<void (*())()> >::_M_run() (functional:1732)
==1786==    by 0x4EE4830: execute_native_thread_routine (thread.cc:84)
==1786==    by 0x5A10E99: start_thread (pthread_create.c:308)
==1786==    by 0x573DCCC: clone (clone.S:112)
==1786== 
==1786== LEAK SUMMARY:
==1786==    definitely lost: 24,000 bytes in 1,000 blocks
==1786==    indirectly lost: 0 bytes in 0 blocks
==1786==      possibly lost: 0 bytes in 0 blocks
==1786==    still reachable: 0 bytes in 0 blocks
==1786==         suppressed: 0 bytes in 0 blocks
==1786== 
==1786== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 2 from 2)
--1786-- 
--1786-- used_suppression:      2 dl-hack3-cond-1
==1786== 
==1786== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 2 from 2)

コンストラクタとデストラクタは、スレッドごとに 1 回実行されました。

$ ./a.out | grep 'Foo::Foo' | wc -l
1000

$ ./a.out | grep hello_world | wc -l
1000

$ ./a.out | grep 'Foo::~Foo' | wc -l
1000

ノート：

  • 作成されるスレッドの数を変更すると、リークしたブロックの数はスレッドの数と一致します。
  • コードは、GCC がそのように実装されている場合、リソースの再利用 (つまり、リークされたブロック) を許可するような方法で構造化されています。
  • valgrind スタックトレースから、thread_local.cc:34 は次の行です。thread_local Foo foo;
  • sleep_for() 呼び出しのため、プログラムの実行には約 10 秒ほどかかります。

このメモリ リークが GCC にあるのか、設定オプションの結果なのか、それともプログラムのバグなのか、考えはありますか?

4

2 に答える 2

3

リークは動的初期化に起因するようです。

を使用した例を次に示しますint。

thread_local int num=4; //static initialization

最後の例は漏れません。2スレッドで試してみましたが、漏れはまったくありませんでした。

でも今 ：

int func()
{
    return 4;
}
thread_local int num2=func(); //dynamic initialization

この 1 つのリーク ！2つのスレッドでtotal heap uage: 8 allocs, 6 frees, 428 bytes allocated...

次のような回避策を使用することをお勧めします。

thread_local Foo *foo = new Foo; //dynamic initialization

スレッド実行の最後に行うことを忘れないでください:

delete foo;

しかし、1 つの問題としての最後の例:削除する前にスレッドがエラーで終了した場合はどうなるでしょうか? また漏れ…

大した解決策はないようです。g++たぶん、それについて開発者に報告する必要がありますか？

于 2013-07-16T10:37:55.490 に答える
0

thread_local を削除して、次のコードを使用してみてください

    void
    hello_world_thread()
    {
        Foo foo;

        // must access, or the thread local variable may not be instantiated
        foo.hello_world();

        // keep the thread around momentarily
        std::this_thread::sleep_for( std::chrono::milliseconds( 100 ) );
    }

hello_world_thread 内の foo は、すべてのスレッドのローカル スタックにある必要があります。したがって、すべてのスレッドが独自の foo のコピーを保持します。thread_local として明示的にマークする必要はありません。静的または名前空間レベルの変数のようなものがあるが、各変数にすべてのスレッドの独自のコピーを保持させたい場合は、thread_local をコンテキストで使用する必要があります。

よろしくカジャル

于 2013-07-16T09:00:03.093 に答える