Question

I found a threadpool which doesn’t seem to be in boost yet, but I may be able to use it for now (unless there is a better solution).

I have several million small tasks that I want to execute concurrently and I wanted to use a threadpool to schedule the execution of the tasks. The documentation of the threadpool provides (roughly) this example:

#include "threadpool.hpp"
using namespace boost::threadpool;

// A short task
void task()
{
    // do some work
}

void execute_with_threadpool(int poolSize, int numTasks)
{
    // Create a thread pool.
    pool tp(poolSize);

    for(int i = 0; i++; i < numTasks)
    {
        // Add some tasks to the pool.
        tp.schedule(&task);
    }
    // Leave this function and wait until all tasks are finished.
}

However, the example only allows me to schedule non-member functions (or tasks). Is there a way that I can schedule a member function for execution?

Update:

OK, supposedly the library allows you to schedule a Runnable for execution, but I can’t figure out where is the Runnable class that I’m supposed to inherit from.

template<typename Pool, typename Runnable>
bool schedule(Pool& pool, shared_ptr<Runnable> const & obj);

Update2:

I think I found out what I need to do: I have to make a runnable which will take any parameters that would be necessary (including a reference to the object that has a function which will be called), then I use the static schedule function to schedule the runnable on the given threadpool:

class Runnable
{
private:
    MyClass* _target;
    Data* _data;
public:
    Runnable(MyClass* target, Data* data)
    {
        _target = target;
        _data = data;
    }

    ~Runnable(){}

    void run()
    {
        _target->doWork(_data);
    }
};

Here is how I schedule it within MyClass:

void MyClass::doWork(Data* data)
{
    // do the work
}

void MyClass::produce()
{
    boost::threadpool::schedule(myThreadPool, boost::shared_ptr<Runnable>(new Runnable(myTarget, new Data())));
}

However, the adaptor from the library has a bug in it:

template<typename Pool, typename Runnable>
bool schedule(Pool& pool, shared_ptr<Runnable> const & obj)
{ 
    return pool->schedule(bind(&Runnable::run, obj));
} 

Note that it takes a reference to a Pool but it tries to call it as if it was a pointer to a Pool, so I had to fix that too (just changing the -> to a .).

Answer 1

I think I found out what I need to do: I have to make a runnable which will take any parameters that would be necessary (including a reference to the object that has a function which will be called), then I use the static schedule function to schedule the runnable on the given threadpool:

class Runnable
{
private:
    MyClass* _target;
    Data* _data;
public:
    Runnable(MyClass* target, Data* data)
    {
        _target = target;
        _data = data;
    }

    ~Runnable(){}

    void run()
    {
        _target->doWork(_data);
    }
};

Here is how I schedule it within MyClass:

void MyClass::doWork(Data* data)
{
    // do the work
}

void MyClass::produce()
{
    boost::threadpool::schedule(myThreadPool, boost::shared_ptr<Runnable>(new Runnable(myTarget, new Data())));
}

However, the adaptor from the library has a bug in it:

template<typename Pool, typename Runnable>
bool schedule(Pool& pool, shared_ptr<Runnable> const & obj)
{ 
    return pool->schedule(bind(&Runnable::run, obj));
} 

Note that it takes a reference to a Pool but it tries to call it as if it was a pointer to a Pool, so I had to fix that too (just changing the -> to a .).

However, as it turns out, I can’t use that boost thread pool because I am mixing native C++ (dll), C++/CLI (dll) and .NET code: I have a C++/CLI library that wraps a native C++ library which in tern uses boost::thread. Unfortunately, that results in a BadImageFormatException at runtime (which has previously been discussed by other people):

The problem is that the static boost thread library tries to hook the
native win32 PE TLS callbacks in order to ensure that the thread-local
data used by boost thread is cleaned up correctly. This is not
compatible with a C++/CLI executable.