• Moved everything to "./include/thread_pool"
• Main include file is now: <thread_pool/thread_pool.hpp>
• Everything is now in the tp namespace
• Added optional boost::future compatiblity with THREAD_POOL_USE_BOOST macro
• Added make install command to CMakeFiles.txt
• Adapted tests and benchmarks to new changes
• Use header guards in place of #pragma once
• Prepend THREAD_POOL_ to all header guards
• Automatic clang-format on every file

@inkooboo , @SuperV1234 : Please see below and share any comments. Once this looks good, I can run some cross platform tests, we can merge, and I will look at adding basic CI tests (this can be run by hunter for each release by default if the package is accompanied with an example build test).

• add TSettings template parameter to ThreadPool to specify task_size at compile time, and for forward API stability, updated internal code...
• include updates from discussion in https://github.com/inkooboo/thread-pool-cpp/pull/5
• add explicit project(thread-pool-cpp VERSION 1.1.0) : 1.0.0 used in previous hunter release
• add cmake platform checks for thread_local and various fallbacks (FATAL_ERROR if no found)
• use internal ATTRIBUTE_TLS macro for portability (see above): this allows thread-pool-cpp to be functional on many incomplete c++11 platforms w/ lambda initialization extensions
• add THREAD_POOL_CPP_BUILD_{TEST,BENCHMARKS} to manage tests
• minor compiler error/warning fixes
• bump cmake_minimum_required(VERSION 3.3) for more modern cmake policy defaults
• add cmake package config installation for clean find_package use (see example below)
• remove boost dependency from example, per discussion with @inkooboo
• add ThreadPool process() api back for packaged_task interface
• manage tests with CTest (can deploy-on-success, etc)

Test project /Users/dhirvonen/devel/elucideye/drishti/src/3rdparty/thread-pool-cpp/_builds/xcode
    Start 1: FixedFunctionTest
1/2 Test #1: FixedFunctionTest ................   Passed    0.00 sec
    Start 2: ThreadPoolTest
2/2 Test #2: ThreadPoolTest ...................   Passed    0.01 sec

The current installation path and package config files look like this:

tree _install/xcode/  <== `i.e., /usr/local, etc`
_install/xcode/
├── include
│   └── thread_pool
│       ├── fixed_function.hpp
│       ├── mpsc_bounded_queue.hpp
│       ├── thread_pool.hpp
│       └── worker.hpp
└── lib
    └── cmake
        └── thread-pool-cpp
            ├── thread-pool-cppConfig.cmake
            ├── thread-pool-cppConfigVersion.cmake
            └── thread-pool-cppTargets.cmake

With this configuration, the project can be installed and included using:

find_package(thread-pool-cpp CONFIG REQUIRED)
target_link_libraries(my_exe thread-pool-cpp::thread-pool-cpp)

It will also support automatic package management through hunter if used in a project w/ a top level HunterGate() command with one additional line. The previous include path addition allows both direct/submodule use and post install (package) use with similar #include syntax:

if(MY_USE_LOCAL_THREAD_POOL_CPP)
  add_subdirectory(src/3rdparty/thread-pool-cpp)
  add_library(thread-pool-cpp::thread-pool-cpp ALIAS thread-pool-cpp)
else() # use hunter
  hunter_add_package(thread-pool-cpp)
  find_package(thread-pool-cpp CONFIG REQUIRED)
endif()

target_link_libraries(my_exe thread-pool-cpp::thread-pool-cpp)

I need to prefer new tasks over old tasks in the queue. Is it possible to change the mpmc queue to post to the front of the queue, or to add a new method post_front()?

Dear Andrey

do you have any manual or sample for the usage of your thread pool implementation? I can not find anything here, about how can i use it or the architecture and options that exist in your pool and what is the exact behavior of all these things.

Regards,

I wanted to share some results relating to the performance of this thread pool when all member threads are idle. These results are caused by the waiting loop in threads that are idle.

Though its probably not a great idea to run 500 threads on a machine with 8 logical cores, a large number of threads can be needed for blocking i/o operations, and the idle CPU usage overhead can burden and drain the battery life of client applications.

I need to use the ThreadPoolOptions to set the thread count and the queue size. Since the ThreadPool's ctor only accepts the ThreadPoolOptions, I met an "multiple definition of" error when linking in my program. May you remove the implementation of ThreadPoolOptions to antoher .cpp file or add a ctor in ThreadPool to control the queue size and thread count?

I am interested in using this with c++11 projects. It seems the only feature requiring c++14 is the capture-by-move initialization for the packaged_task lambda assignment here:

https://github.com/inkooboo/thread-pool-cpp/blob/master/thread_pool/thread_pool.hpp#L117

I'll need to familiarize myself with this. It seems a workaround might be possible in c++11 based on this document ("evil_wrapper"):

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3610.html

I'll take a look. Any suggestions are welcome.

This looks really nice. I'm interested in adding this as a package to the hunter project (ruslo/hunter#251) https://github.com/ruslo/hunter, but I don't see a license anywhere. Are you amenable to a simplified BSD type license (or similar)? Thanks.

The decl of thread_id as inline static causes issues with multiple compilation units under GCC 4.9, for example:

In the test directory create a new file getWorkerIdForCurrentThread.cpp:

#include <worker.hpp>
size_t getWorkerIdForCurrentThread() { return *thread_id(); }
size_t getWorkerIdForCurrentThread2() { return Worker::getWorkerIdForCurrentThread(); }

Declare the new functions at the top of thread_pool.t.cpp:

size_t getWorkerIdForCurrentThread();
size_t getWorkerIdForCurrentThread2();

Update doTest("post job"), add the following line in the lambda after std::packaged_task<int()> ....:

printf("\nThread id(1): %lu, id(2): %lu, id(3): %lu, id(4): %lu\n", 
  Worker::getWorkerIdForCurrentThread(), *thread_id(), 
  getWorkerIdForCurrentThread(), getWorkerIdForCurrentThread2());

Build and run thread_pool.t.cpp as usual, the output will show the new line:

Thread id(1): 7, id(2): 7, id(3): 4294967295, id(4): 7

Compile with -O3 and we get even worse output (due to aggressive inlining):

Thread id(1): 7, id(2): 7, id(3): 4294967295, id(4): 4294967295

In essence getWorkerIdForCurrentThread.cpp contains another instance of tss_id per thread since it was inlined by GCC and is never initialized to a valid value by the thread pool. Now when we call these functions we always see -1ul regardless of the thread we call from.

This limits the usefulness of the thread pool - at best you have to be extremely careful what you call and where when you have multiple CPPs.

Hi, please explain why this is so? https://github.com/inkooboo/thread-pool-cpp/blob/master/include/thread_pool/thread_pool.hpp#L149 It seems a fairly frequent use case is pushing from one thread of a bunch of tasks. I understand the idea of ​​locality, but at first glance it doesn't seem to work? After all, if we push a task from the thread of the thread pool, this does not necessarily mean that its number is equal to its number in the array

Maybe something like this would be work better?

getWorker:
auto idx = current thread id;
if last_idx == idx {
     return last_worker;
}
for (worker : workers) {
     if (idx == worker.idx) {
         last_idx = idx;
         last_worker = worker;
         return worker;
     }
}
Logic with m_next_worker

Or something like this

thread_local worker_index{-1}; // set in worker::start
if (worker_index != -1) {
     return workers[worker_index];
}
Logic with m_next_worker

thread pool call worker's stop method when destruct and set worker's runing flag to false worker's thread proc exit when runing flag is set to false, ignore weather more tasks in its task queue

can worker wait all tasks finish when thread pool destruct

Currently, ThreadPool's destructor does not wait for completion of all tasks posted to it, because Worker relies on m_running_flag to stay in the loop, as a result this flag is set to false as soon as ThreadPool destructor is invoked, as the threads exit without further processing the tasks from the queue.

One solution is to remove m_running_flag from the worker, and instead add a poison task to the queue and each worker reads this poison task and exit but before exiting enqueue it again, so that other workers can exit in similar mannner.

Also, ThreadPool may provide a function called wait() function which will add the poison task. Also, the destructor should call this wait() function.

Hi there,

I'm trying to use this thread-pool "LIB" and before using it, I wanted to make some stress tests on it to identify its limit, its hardening and reliability.

I wrote a really short main function and set a small amount of thread (1) with also a small file queue size (2). The behavior I can see is really strange : Some destructor may be called before constructor :huh: and the same input may be treated by several tasks

Here is the small main.cpp :

#include <iostream>
#include <regex>

#include <vector>
#include <signal.h>
#include <unistd.h>
// #include "logger.h"

#include <future>
#include <utility>

#include "thread_pool.hpp"

static volatile bool         g_theEnd = false ;

#define DEBUG(...)   { printf(__VA_ARGS__) ; printf("\n") ; }
#define INFO(...)    { printf(__VA_ARGS__) ; printf("\n") ; }
#define WARNING(...) { printf(__VA_ARGS__) ; printf("\n") ; }
#define ERROR(...)   { printf(__VA_ARGS__) ; printf("\n") ; }

#define LOG_INIT(a)
#define SET_LOG_LEVEL(a)
#define LOG_END()

//
//
//
void cleanup(void)
{
    // Ask the threads to give up
    g_theEnd = true ;

    INFO("Stop test-thread-pool") ;
    LOG_END() ;
}

//
//
//
class NgapMessageDecode
{
public:
    NgapMessageDecode(int fd) : m_fd(fd)
    {
        DEBUG("Constructor %.8ld, fd=%.2d", this, fd) ;
    }

    virtual ~NgapMessageDecode()
    {
        DEBUG("Destructor  %.8ld, fd=%.2d", this, m_fd) ;
    }

    void operator()()
    {
        DEBUG("Decode %.2d, this=%ld, thread=%.8ld", m_fd, this, pthread_self()) ;
        // sleep(1) ;
    }

private:
    // std::promise<void> *    m_waiter ;
    int                     m_fd ;
};


int main(int argc, char * argv[])
{
    LOG_INIT("test-thread-pool") ;
    SET_LOG_LEVEL(_LOG_DEBUG) ;

    INFO("%s", "") ;
    INFO("Start test-thread-pool") ;

    tp::ThreadPoolOptions   threadPoolOption ;

    threadPoolOption.setThreadCount(1) ;
    threadPoolOption.setQueueSize(2) ;

    tp::ThreadPool  threadPool(threadPoolOption);

    for(int i=0; i<100; i++)
    {
        try
        {
            threadPool.post(NgapMessageDecode(i)) ;
        }
        catch(std::runtime_error & e)
        {
            std::cout << e.what() << std::endl ;
        }
    }
    sleep(1) ;
    cleanup() ;
    return 0 ;
}

The output is :

Start test-thread-pool
Constructor 140734462742560, fd=00
Destructor  140734462742176, fd=00
Destructor  140734462742560, fd=00
Constructor 140734462742560, fd=01
Destructor  140734462742176, fd=01
Destructor  140734462742560, fd=01
Constructor 140734462742560, fd=02
Destructor  140734462742560, fd=02
thread pool queue is full
Constructor 140734462742560, fd=03
Destructor  140734462742560, fd=03
thread pool queue is full
Constructor 140734462742560, fd=04
Destructor  140734462742560, fd=04
thread pool queue is full

How can the Destructor 140734462742176, fd=00 (line2) can be called before the constructor ?

More over, this same Destructor refers to the object where fd==00 whereas the corresponding constructor below refers to fd==01

Thus, how can I got the sequence described in the 3 first lines : Constructor / Destructor / Destructor with the same FD==00

So, I probably missed something or at least misunderstood how I'm supposed to use this "LIB" but I can't find out what's the good practice :/

Branch used : master I can't use the branch round-robin-stealing 'cause it refers to std::exchange that is defined in C++14 and I must stay in C++11

Command to build the main application listed above, to facilitate :

g++ -c   -DLOG -I<path_to_thread-pool-cpp>/include/thread_pool -Wall -Wextra -g -std=c++11 -o main.o main.cpp

g++ -g   -o test-thread-pool main.o -lpthread

All kind of help would be appreciated :+1:

error C2660 “std::packaged_task<int (int)>::operator ()”: The function does not take zero arguments

#include "thread_pool.hpp"
#include  "thread"
#include "future"
#include "functional"
#include "memory"
#include "iostream"
using namespace std;

int f(int j)
{
	return j;
}

int main(int argc, char **argv)
{
	tp::ThreadPool pool;
	//
	std::packaged_task<int(int)> t(f);
	std::future<int> r = t.get_future();
	pool.post(t);
	r.get();
	//while (1);
	getchar();
	return 0;
}

First of all thank you for making this library installable. I use External_Project_Add() for all libraries, it compiles the library in an isolated environment and installs it in the specified directory (if you are interested in more details I can explain).

What I want is a way to disable tests when building the library.

Wrap this block in an if

https://github.com/inkooboo/thread-pool-cpp/blob/af95dd88daa094f67bbd178b639c7282373a3b09/CMakeLists.txt#L11-L22

like this

https://github.com/Microsoft/GSL/blob/5cbde3008aa43a9c5f6c219ee15b8388336d4433/CMakeLists.txt#L71-L75

then I will be able to control that block with -DENABLE_TESTS=ON/OFF