Organizing tasks in a threadpool

Question

This is a design rather than a code related question. It concerns threadpools, specifically how to organize the execution of the tasks. I am using C++ and Boost thread in a cross platform scenario.

I have groups of tasks that I need to parallelize. X number of groups fire off x number of subtasks. All subtasks must be completed in order for a group to be complete in its turn, but it does not matter in what order the subtasks are completed as long as the group can determine when all subtasks belonging to it are finished. The main thread must wait for all groups to complete in a similar fashion to how a group waits for its subtasks. In other words, it is not important in what order the groups complete as long as the main thread can determine when they're all done.

To put it a different way:

1. All groups wait for their respective subtasks to finish. It is not important in what order the subtasks finish as long as the group can figure out when they're all completed.

2. The main thread waits for all groups to complete. It is not important in what order they complete, as long as the main thread can detect when all groups are completed. In other words it is the same exact concept as for the group specific subtasks.

All this must be done with N threads in a pool, plus the main thread so N+1 threads all in total. N must be configurable to any arbitrary value.

If it helps, a task is simply a function that needs to be invoked from one of the N threads.

Does anyone have any tips for how I might implement this?

Answer 1

Create two classes:

• CThreadGroup: Launches a number of threads and waits for them to finish (using join).
• CMainThread: Launches a series of this class (CThreadGroup) and waits for them to finish (using join). Takes as an inout parameter the number of CThreadGroup to launch and how many subthread CThreadGroup launches

Declare one object of type CMainThread in the main.

Here is the prototype of the classes:

Main thread

#include "ThreadGroup.h"
#include <mutex>
class CMainThread
{
    std::vector<CThreadGroup> vThreadGroups;
    std::vector<std::thread> vThreads;
    const unsigned int nbMainThreads;
    const unsigned int nbSubthreads;

public:
    CMainThread(unsigned int nbMainThreads, 
                unsigned int nbSubthreads);
    ~CMainThread(void);
};


#include <thread>
#include <vector>
class CThreadGroup
{
    const unsigned int nbThreads;
public:
    CThreadGroup(unsigned int nbThreads);
    ~CThreadGroup(void);
};

Thread Group

#include <thread>
#include <vector>
class CThreadGroup
{
    const unsigned int nbThreads;
public:
    CThreadGroup(unsigned int nbThreads);
    ~CThreadGroup(void);
};

Here are the cpp files

CMainThread::CMainThread(unsigned int nbMainThreads_, 
                         unsigned int nbSubthreads_):
nbMainThreads(nbMainThreads_),
nbSubthreads(nbSubthreads_)
{
    std::mutex mut;
    for (unsigned int i=0;i<nbMainThreads;++i)
    {
        vThreads.push_back(std::thread([&]{
            CThreadGroup currThread(nbSubthreads);
            std::lock_guard<std::mutex> lock(mut);
            vThreadGroups.push_back(currThread);
        }));
    }

    for (auto it=vThreads.begin(); it!=vThreads.end(); ++it)
    {
        it->join();
    }
} 

Thread Group

CThreadGroup::CThreadGroup(unsigned int nbThreads_):
nbThreads(nbThreads_)
{
    std::vector<std::thread> vThreads;
    for (unsigned int i=0;i<nbThreads;++i)
    {
        vThreads.push_back(std::thread([i]{std::this_thread::sleep_for(std::chrono::seconds(i));}));
    }

    for (auto it=vThreads.begin(); it!=vThreads.end(); ++it)
    {
        it->join();
    } 
}

Hope that helps,