c++thread-local

c++ thread local counter implement

I wanna implement a high performance counter in multi-thread process, like this, each thread has a thread local counter named "t_counter" to count query(incr 1/query) and in "timer thread" there is a counter named "global_counter", what I want is each second, global_counter will get each t_counter(s) and add them to global_counter, but I dont know how to get each t_counter value in "timer thread". additional, which section will thread local value lay in main memory ? .data or heap or other? how to dynamic allocate memory size(there maybe 10 thread or 100 thread) ? and does x86-64 use segment register store such value?

Solution

  • Starting with your second question, you can find all the specifications here.

    Summarizing, thread local variables are defined in .tdata / .tbss. Those are somewhat similar to .data, however accessing those is different. These sections are replicated per thread. The actual variable offset is computed at the runtime.

    A variable is identified by an offset in .tdata. Speaking of x86_64 it will use the FS segment register to find the TCB (Thread control block), using the data structures stored there it will locate the thread local storage where the variable is located. Note that all allocations are done lazily if possible.

    Now, regarding your first question - I am not aware of a way to just list all the thread local variables from another thread, and I doubt it is available.

    However, a thread can take a pointer to thread variable, and pass it to another thread. So what you probably need is some registration mechanism.

    Each new thread will register itself to some main store, then unregister on termination. Registration and deregistration are on your responsibility.

    Schematically, it would look like this:

    thread_local int counter = 0;
std::map<std::thread::id, int *> regs;

void register() {
    // Take some lock here or other synchronization, maybe RW lock
    regs[std::this_thread::get_id()] = &counter;
}
void unregister() {
    // Again, some lock or other synchronization
    regs.erase(std::this_thread::get_id());
}

void thread_main() {
    register();
    counter++;
    unregister();
}

void get_sum() {
    // Again, some lock, maybe only read lock
    return std::accumulate(regs.begin(), regs.end(), 0,
        [](int previous, const auto& element)
        { return previous + *element.second; });
}