// requires traits::is_future<Future>
std::size_t auto_chunk_size(
std::vector<Future>& workitems,
F1 && f1, FwdIter& first, std::size_t& count)
{
std::size_t test_chunk_size = count / 100;
if (0 == test_chunk_size) return 0;
boost::uint64_t t = hpx::util::high_resolution_clock::now();
add_ready_future(workitems, f1, first, test_chunk_size);
t = (hpx::util::high_resolution_clock::now() - t) / test_chunk_size;
std::advance(first, test_chunk_size);
count -= test_chunk_size;
// return chunk size which will create 80 microseconds of work
return t == 0 ? 0 : (std::min)(count, (std::size_t)(80000 / t));
}
// requires traits::is_future<Future>
std::vector<hpx::util::tuple<FwdIter, std::size_t> >
get_bulk_iteration_shape(
ExPolicy policy, std::vector<Future>& workitems, F1 && f1,
FwdIter& first, std::size_t& count, std::size_t chunk_size)
{
typedef typename ExPolicy::executor_parameters_type parameters_type;
typedef executor_parameter_traits<parameters_type> traits;
typedef hpx::util::tuple<FwdIter, std::size_t> tuple_type;
typedef typename ExPolicy::executor_type executor_type;
std::size_t const cores = executor_traits<executor_type>::
processing_units_count(policy.executor(), policy.parameters());
bool variable_chunk_sizes = traits::variable_chunk_size(
policy.parameters(), policy.executor());
std::vector<tuple_type> shape;
if (!variable_chunk_sizes || chunk_size != 0)
{
if (chunk_size == 0)
{
auto test_function =
[&]() -> std::size_t
{
std::size_t test_chunk_size = count / 100;
if (test_chunk_size == 0)
return 0;
add_ready_future(workitems, f1, first, test_chunk_size);
std::advance(first, test_chunk_size);
count -= test_chunk_size;
return test_chunk_size;
};
chunk_size = traits::get_chunk_size(policy.parameters(),
policy.executor(), test_function, count);
}
if (chunk_size == 0)
chunk_size = (count + cores - 1) / cores;
shape.reserve(count / chunk_size + 1);
while (count != 0)
{
std::size_t chunk = (std::min)(chunk_size, count);
shape.push_back(hpx::util::make_tuple(first, chunk));
count -= chunk;
std::advance(first, chunk);
}
}
else
{
while (count != 0)
{
chunk_size = traits::get_chunk_size(
policy.parameters(), policy.executor(),
[](){ return 0; }, count);
if (chunk_size == 0)
chunk_size = (count + cores - 1) / cores;
std::size_t chunk = (std::min)(chunk_size, count);
shape.push_back(hpx::util::make_tuple(first, chunk));
count -= chunk;
std::advance(first, chunk);
}
}
return shape;
}
