c++11 async<>, with unknown number of available cores - c++

Question

My C++ code evaluates very large integrals on timeseries data (t2 >> t1). The integrals are fixed length and currently stored in [m x 2] column array of doubles. Column 1 is time. Column 2 is the signal that's being integrated. The code is running on a quadcore or 8 core machine.
For a machine with k cores, I want to:
Spin off k-1 worker processes (one for each of the remaining cores) to evaluate portions of the integral (trapezoidal integrations) and return their results to the waiting master thread.
Achieve the above without deep copying portions of the original array.
Implement C++11 async template for portability
How can I achieve the above without hardcoding the number of available cores?
I am Currently using VS 2012.
Update for Clarity:
For example, here's the rough psuedo-code
data is [100000,2] double
result = MyIntegrator(data[1:50000,1:2]) + MyIntegrator(data[50001:100000, 1:2]);
I need the MyIntegrator() functions to be evaluated in separate threads. The master thread waits for the two results.

Answer 1

Here is source that does a multi-threaded integration of the problem.
#include <vector>
#include <memory>
#include <future>
#include <iterator>
#include <iostream>
struct sample {
double duration;
double value;
};
typedef std::pair<sample*, sample*> data_range;
sample* begin( data_range const& r ) { return r.first; }
sample* end( data_range const& r ) { return r.second; }
typedef std::unique_ptr< std::future< double > > todo_item;
double integrate( data_range r ) {
double total = 0.;
for( auto&& s:r ) {
total += s.duration * s.value;
}
return total;
}
todo_item threaded_integration( data_range r ) {
return todo_item( new std::future<double>( std::async( integrate, r )) );
}
double integrate_over_threads( data_range r, std::size_t threads ) {
if (threads > std::size_t(r.second-r.first))
threads = r.second-r.first;
if (threads == 0)
threads = 1;
sample* begin = r.first;
sample* end = r.second;
std::vector< std::unique_ptr< std::future< double > > > todo_list;
sample* highwater = begin;
while (highwater != end) {
sample* new_highwater = (end-highwater)/threads+highwater;
--threads;
todo_item item = threaded_integration( data_range(highwater, new_highwater) );
todo_list.push_back( std::move(item) );
highwater = new_highwater;
}
double total = 0.;
for (auto&& item: todo_list) {
total += item->get();
}
return total;
}
sample data[5] = {
{1., 1.},
{1., 2.},
{1., 3.},
{1., 4.},
{1., 5.},
};
int main() {
using std::begin; using std::end;
double result = integrate_over_threads( data_range( begin(data), end(data) ), 2 );
std::cout << result << "\n";
}
it requires some modification to read data in exactly the format you specified.
But you can call it with std::thread::hardware_concurrency() as the number of threads, and it should work.
(In particular, to keep it simple, I have pairs of (duration, value) rather than (time, value), but that is just a minor detail).

Answer 2

What about std::thread::hardware_concurrency()?

Answer 3

Get the number of cores running, usually this can be found with std::thread::hardware_concurrency()
Returns number of concurrent threads supported by the implementation. The value should be considered only a hint.
If this is zero then you can try running specific commands based on the OS.
This seems to be a good way to find out the number of cores.
You'll still need to do testing to determine if multithreading will even give you tangible benefits, remember not to optimize prematurely :)

Answer 4

You could overschedule and see if it hurts your performance. Split your array into small fixed-length intervals (computable in one quant, may be fitting in one cache page) and see how that compares in performance with splitting according to number of CPUs.
Use std::packaged_task and pass it to a thread to make sure that you're not hurt by "launch" configuration.
Next step would be introducing thread pool, but that's more complicated.

Answer 5

You could accept a command-line parameter for the number of worker threads.