Hello, Thank you so much for this library. I was wondering why I keep getting an error to push to the pool: all_errors.cpp:244:25: error: no matching function for call to ‘ctpl::thread_pool::push(int)’

I am following your example to the tee and I am still getting this error. Any ideas?

https://github.com/vit-vit/CTPL/blob/437e135dbd94eb65b45533d9ce8ee28b5bd37b6d/ctpl_stl.h#L48 https://github.com/vit-vit/CTPL/blob/437e135dbd94eb65b45533d9ce8ee28b5bd37b6d/ctpl_stl.h#L54 https://github.com/vit-vit/CTPL/blob/437e135dbd94eb65b45533d9ce8ee28b5bd37b6d/ctpl.h#L137

Hi, you have a shadow bug in the link above. It is caused by the default constructor of std::unique_lock. You are not locking your code.

See this video on why it is a bug: https://youtu.be/lkgszkPnV8g?t=2068.

Solution to the bug: Just name it.

Best regards, Jack

It appears the mutex is being locked after pushing the data onto the queue, rather than before. Is this behavior correct?

    template<typename F, typename... Rest>
    auto push(F && f, Rest&&... rest) ->std::future<decltype(f(0, rest...))> {
        auto pck = std::make_shared<std::packaged_task<decltype(f(0, rest...))(int)>>(
            std::bind(std::forward<F>(f), std::placeholders::_1, std::forward<Rest>(rest)...)
        );

        auto _f = new std::function<void(int id)>([pck](int id) {
            (*pck)(id);
        });
        this->q.push(_f); // <-- see here...

        std::unique_lock<std::mutex> lock(this->mutex); // <-- ...and here
        this->cv.notify_one();

        return pck->get_future();
    }

The following program demonstrates the issue. This is using the STL version.

struct A {};

void f(int, A&) {}

int main()
{
	ctpl::thread_pool pool(4);
	
	A a;
	
	// Does not compile
	//f(0,std::move(a));
	
	// So this shouldn't be expected to compile either, yet it does
	//pool.push(f, std::move(a));
}

Sorry for writing this as an issue.

I could not figure out how it is ment to wait for all Tasks to finish. If i use stop - the Threads get deleted and the threadpool ends.

Isn't there something like p.WaitForEverythingDone()? Currently I use this in the main thread: while (p.n_idle() < THREAD_COUNT ) { } But thats not really a good idea to burn 1 cpu core just for waiting?

Hi,

In my code I create a thread pool with only one thread, and then push all the functions that I want to execute. After that, while the functions are being executed by that thread, I use another thread (that doesn't belong to the thread pool) to increase the number of threads in the thread pool, using the resize method. However, the resizing has no effect since the new threads I added do not execute anything, only the first thread (thread 0) executes the functions that are still in the queue.

Does this happen because when I push the functions they are automatically associated with a thread? And in my case, since when I push the functions there is only thread 0 in the thread pool, all functions become associated with that thread?

Also, is there a problem in calling resize from a function outside the thread pool?

Thank you in advance for your help!

Hello there,

So, i have a function with this definition: static void Invoke( int id, std::unique_ptr<BaseService> svc );

And tried to pass it to ctpl "push" method to be queued in thread-pool: pThreadPool->push( std::ref(App::Invoke), std::move( svc ) );

But I get this error:

/home/hadi/CLionProjects/App/App.cpp:211:27: error: no matching member function for call to 'push'
    pThreadPool->push( std::ref(App::Invoke), std::move( svc ) );
    ~~~~~~~~~~~~~^~~~
/home/hadi/CLionProjects/App/include/cptl/ctpl.h:152:14: note: candidate template ignored: substitution failure [with F = std::__1::reference_wrapper<void (int, std::__1::unique_ptr<BaseService, std::__1::default_delete<BaseService> >)>, Rest = <std::__1::unique_ptr<BaseService, std::__1::default_delete<BaseService> >>]: call to implicitly-deleted copy constructor of 'std::__1::unique_ptr<BaseService, std::__1::default_delete<BaseService> >'
        auto push(F && f, Rest&&... rest) ->std::future<decltype(f(0, rest...))> {
             ^                                                        ~~~~
/home/hadi/CLionProjects/App/include/cptl/ctpl.h:171:14: note: candidate function template not viable: requires single argument 'f', but 2 arguments were provided
        auto push(F && f) ->std::future<decltype(f(0))> {
             ^
1 error generated.

I have some questions, maybe someone could help. How to find out how many threads are working at the moment? How know if all threads are terminated? How to terminate a thread from inside of thread and from outside (from another thread)?

Thanks in advance.