Jacques Lucke
e6ca054590
This adds a new `ParallelMultiFunction` which wraps another multi-function and evaluates it with multiple threads. The speeds up field evaluation quite a bit (the effect is most noticeable when the number of evaluations and the field is large). There are still other single-threaded performance bottlenecks in field evaluation that will need to be solved separately. Most notably here is the process of copying the computed data into the position attribute in the Set Position node. Differential Revision: https://developer.blender.org/D12457
96 lines
3.6 KiB
C++
96 lines
3.6 KiB
C++
/*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version 2
|
|
* of the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
*/
|
|
|
|
#include "FN_multi_function_parallel.hh"
|
|
|
|
#include "BLI_task.hh"
|
|
|
|
namespace blender::fn {
|
|
|
|
ParallelMultiFunction::ParallelMultiFunction(const MultiFunction &fn, const int64_t grain_size)
|
|
: fn_(fn), grain_size_(grain_size)
|
|
{
|
|
this->set_signature(&fn.signature());
|
|
|
|
threading_supported_ = true;
|
|
for (const int param_index : fn.param_indices()) {
|
|
const MFParamType param_type = fn.param_type(param_index);
|
|
if (param_type.data_type().category() == MFDataType::Vector) {
|
|
/* Vector parameters do not support threading yet. */
|
|
threading_supported_ = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ParallelMultiFunction::call(IndexMask full_mask, MFParams params, MFContext context) const
|
|
{
|
|
if (full_mask.size() <= grain_size_ || !threading_supported_) {
|
|
fn_.call(full_mask, params, context);
|
|
return;
|
|
}
|
|
|
|
threading::parallel_for(full_mask.index_range(), grain_size_, [&](const IndexRange mask_slice) {
|
|
Vector<int64_t> sub_mask_indices;
|
|
const IndexMask sub_mask = full_mask.slice_and_offset(mask_slice, sub_mask_indices);
|
|
if (sub_mask.is_empty()) {
|
|
return;
|
|
}
|
|
const int64_t input_slice_start = full_mask[mask_slice.first()];
|
|
const int64_t input_slice_size = full_mask[mask_slice.last()] - input_slice_start + 1;
|
|
const IndexRange input_slice_range{input_slice_start, input_slice_size};
|
|
|
|
MFParamsBuilder sub_params{fn_, sub_mask.min_array_size()};
|
|
ResourceScope &scope = sub_params.resource_scope();
|
|
|
|
/* All parameters are sliced so that the wrapped multi-function does not have to take care of
|
|
* the index offset. */
|
|
for (const int param_index : fn_.param_indices()) {
|
|
const MFParamType param_type = fn_.param_type(param_index);
|
|
switch (param_type.category()) {
|
|
case MFParamType::SingleInput: {
|
|
const GVArray &varray = params.readonly_single_input(param_index);
|
|
const GVArray &sliced_varray = scope.construct<GVArray_Slice>(varray, input_slice_range);
|
|
sub_params.add_readonly_single_input(sliced_varray);
|
|
break;
|
|
}
|
|
case MFParamType::SingleMutable: {
|
|
const GMutableSpan span = params.single_mutable(param_index);
|
|
const GMutableSpan sliced_span = span.slice(input_slice_start, input_slice_size);
|
|
sub_params.add_single_mutable(sliced_span);
|
|
break;
|
|
}
|
|
case MFParamType::SingleOutput: {
|
|
const GMutableSpan span = params.uninitialized_single_output(param_index);
|
|
const GMutableSpan sliced_span = span.slice(input_slice_start, input_slice_size);
|
|
sub_params.add_uninitialized_single_output(sliced_span);
|
|
break;
|
|
}
|
|
case MFParamType::VectorInput:
|
|
case MFParamType::VectorMutable:
|
|
case MFParamType::VectorOutput: {
|
|
BLI_assert_unreachable();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
fn_.call(sub_mask, sub_params, context);
|
|
});
|
|
}
|
|
|
|
} // namespace blender::fn
|