Spawn multiple std::thread and reuse it - c++

Question

I am a noob when it comes to threading and need some help / advice.
First of all, can you check if my understanding is correct in the following code:
std::vector<std::unique_ptr<Object>> totalObjects(512);
std::vector<Object*> objectsToUpdate(32);
std::vector<std::thread> threadsPool(32);
int nrObjectsToUpdate; //Varies between 1 and 32 for each update.
findObjectsToUpdate(totalObjects, objectsToUpdate, nrObjectsToUpdate);
for(int i = 0; i < nrObjectsToUpdate; i++)
threadsPool[i] = std::thread(objectsToUpdate[i]->updateTask1());
//All tasks in this step must be completed before
//we can move on to the next, i.e. updateTask2();.
for(int i = 0; i < nrObjectsToUpdate; i++)
threadsPool[i].join();
for(int i = 0; i < nrObjectsToUpdate; i++)
threadsPool[i] = std::thread(objectsToUpdate[i]->updateTask2());
for(int i = 0; i < nrObjectsToUpdate; i++)
threadsPool[i].join();
Should I spawn one thread for each updateTask1() and updateTask2()?
For each update, do I need to create std::thread() all over again? or can I simply reuse it again with some member function?
If I create threads for updateTask1(), is it possible to reuse all thread objects for updateTask2()?, i.e. switching function pointer with some std::thread member function?
Let us say that we create 100 threads and we have a quadcore CPU(4 cores),
will all the CPU cores be busy until all the threads is completed?
I know at least that 4 cores means 4 threads.
Grateful for all the help and explanations that can be given.

Answer 1

The optimal number of threads to use is both application and hardware dependant, therefore how many threads you should spawn depends on your application.
For example, some applications might run well with multiple threads per core because the threads do not interfere with each other (thread X and thread Y on core 1, for example, don't fight for compute resources so there is an advantage gained with multiple threads per core). However, other applications might perform worse with multiple threads per core because using only one thread might require most of the core's resources, so then when using additional threads per core, the threads interfere. You should do some testing to find out what is the best thread configuration for your application. Multithreading is often not straightforward, and the performance results may be surprising.
There are a number of things which you can use to help with determining the number of threads and thread scheduling (you should still do the performance tests though).
You can use unsigned num_cpus = std::thread::hardware_concurrency(); to get the number of available CPUs. While you may know the number of cores for the CPU you're using, maybe you want to run it on another machine for which you don't know the number of cores.
Additionally there is processor affinity, which is essentially pinning certain threads to specific CPUs. By default the OS is allowed to schedule any of the spawned threads to any of the CPUs. Sometimes this results in multiple threads per CPU, and some CPUs not being utilised for some portion of the multi-threaded component. You can explicitly set specific threads to use specific CPUs using pthread_setaffinity_np as follows (do this for each thread you want to pin to a core):
cpu_set_t cpu_set;
CPU_ZERO(&cpu_set);
CPU_SET(i, &cpu_set);
int rc = pthread_setaffinity_np(threadsPool[i].native_handle(),
sizeof(cpu_set_t), &cpu_set);
// Check for error
if (rc != 0)
std::cerr << "pthread_setaffinity_np error: " << rc << "\n";
If I create threads for updateTask1(), is it possible to reuse all thread objects for updateTask2()?, i.e. switching function pointer with some std::thread member function?
Yes you can do this. The logic in your program regarding the use of threads for updateTask1() and updateTask2() is correct, however, syntactically you have made errors when assigning the threads.
threadsPool[i] = std::thread(objectsToUpdate[i]->updateTask1());
Is incorrect. You are wanting to use a member function as the function to spawn for each thread, so you need to pass a reference to the function, as well as the object to bind to, followed by any additional arguments (for the sake of example, I'll add that the updateTask1 function takes the object id i). The assignment of the threads should then look like this:
threadsPool[i] = std::thread(&Object::updateTask1, // Reference to function
objectsToUpdate[i] , // Object to bind to
i ); // Additional argument -- thread number
You can then use the same syntax for updateTask2. Here is a live demo for demonstration, which includes processor affinity.