How to iterate through boost thread specific pointers

Question

I have a multi-thread application. Each thread initializes a struct data type in its own local storage. Some elements are being added to the vectors inside the struct type variables. At the end of the program, I would like to iterate through these thread local storages and add all the results together. How can I iterate through the thread specific pointer so that I can add all the results from the multi threads together ?

Thanks in advance.

boost::thread_specific_ptr<testStruct> tss;

size_t x = 10;

void callable(string str, int x) {
    if(!tss.get()){
        tss.reset(new testStruct);
        (*tss).xInt.resize(x, 0);
    }
    // Assign some values to the vector elements after doing some calculations
}

Example:

#include <iostream>
#include <vector>
#include <boost/thread/mutex.hpp>
#include <boost/thread/tss.hpp>
#include <boost/thread.hpp>
#include <boost/asio.hpp>
#include <boost/bind.hpp>

#define NR_THREAD 4
#define SAMPLE_SIZE 500

using namespace std;

static bool busy = false;

struct testStruct{
    vector<int> intVector;
};

boost::asio::io_service ioService;
boost::thread_specific_ptr<testStruct> tsp;
boost::condition_variable cond;
boost::mutex mut;

void callable(int x) {
    if(!tsp.get()){
        tsp.reset(new testStruct);
    }

    (*tsp).intVector.push_back(x);

    if (x + 1 == SAMPLE_SIZE){
        busy = true;
        cond.notify_all();
    }
}

int main() {
    boost::thread_group threads;
    size_t (boost::asio::io_service::*run)() = &boost::asio::io_service::run;
    boost::asio::io_service::work work(ioService);

    for (short int i = 0; i < NR_THREAD; ++i) {
        threads.create_thread(boost::bind(run, &ioService));
    }

    size_t iterations = 10;
    for (int i = 0; i < iterations; i++) {
        busy = false;

        for (short int j = 0; j < SAMPLE_SIZE; ++j) {
            ioService.post(boost::bind(callable, j));
        }

        // all threads need to finish the job for the next iteration
        boost::unique_lock<boost::mutex> lock(mut);
        while (!busy) {
            cond.wait(lock);
        }
        cout << "Iteration: " << i << endl;
    }

    vector<int> sum(SAMPLE_SIZE, 0);    // sum up all the values from thread local storages

    work.~work();
    threads.join_all();

    return 0;
}

Answer 1

So, after I haven given some thought to this issue, I have come up with such a solution:

void accumulateTLS(size_t idxThread){

    if (idxThread == nr_threads)   // Suspend all the threads till all of them are called and waiting here
    {
        busy = true;
    }

    boost::unique_lock<boost::mutex> lock(mut);
    while (!busy)
    {
        cond.wait(lock);
    }

    // Accumulate the variables using thread specific pointer

    cond.notify_one();
}

With boost io_service, the callable function can be changed after the threads are initialized. So, after I have done all the calculations, I am sending jobs(as many as the number of threads) to the io service again with callable function accumulateTLS(idxThread). The N jobs are sent to N threads and the accumulation process is done inside accumulateTLS method.

P.S. instead of work.~work(), work.reset() should be used.