diff options
author | Jacques Lucke <jacques@blender.org> | 2021-04-01 16:55:08 +0300 |
---|---|---|
committer | Jacques Lucke <jacques@blender.org> | 2021-04-01 16:55:23 +0300 |
commit | b5c2c3aba886f521a0cade5b8450683c20843d3a (patch) | |
tree | 46878da186ccb49b2bcc3e1de816476aea5cf750 /source/blender/functions | |
parent | f674976edd884d7a9a409042708f2b1169fd4e98 (diff) |
BLI: rename resource collector to resource scope
Differential Revision: https://developer.blender.org/D10857
Diffstat (limited to 'source/blender/functions')
4 files changed, 75 insertions, 83 deletions
diff --git a/source/blender/functions/FN_multi_function_network_optimization.hh b/source/blender/functions/FN_multi_function_network_optimization.hh index 6d0165643ce..96664fa368e 100644 --- a/source/blender/functions/FN_multi_function_network_optimization.hh +++ b/source/blender/functions/FN_multi_function_network_optimization.hh @@ -18,12 +18,12 @@ #include "FN_multi_function_network.hh" -#include "BLI_resource_collector.hh" +#include "BLI_resource_scope.hh" namespace blender::fn::mf_network_optimization { void dead_node_removal(MFNetwork &network); -void constant_folding(MFNetwork &network, ResourceCollector &resources); +void constant_folding(MFNetwork &network, ResourceScope &scope); void common_subnetwork_elimination(MFNetwork &network); } // namespace blender::fn::mf_network_optimization diff --git a/source/blender/functions/FN_multi_function_params.hh b/source/blender/functions/FN_multi_function_params.hh index 2d3a8dd650e..72ebc0d9b94 100644 --- a/source/blender/functions/FN_multi_function_params.hh +++ b/source/blender/functions/FN_multi_function_params.hh @@ -25,7 +25,7 @@ * the function. `MFParams` is then used inside the called function to access the parameters. */ -#include "BLI_resource_collector.hh" +#include "BLI_resource_scope.hh" #include "FN_generic_vector_array.hh" #include "FN_generic_virtual_vector_array.hh" @@ -35,7 +35,7 @@ namespace blender::fn { class MFParamsBuilder { private: - ResourceCollector resources_; + ResourceScope scope_; const MFSignature *signature_; int64_t min_array_size_; Vector<const GVArray *> virtual_arrays_; @@ -55,13 +55,13 @@ class MFParamsBuilder { template<typename T> void add_readonly_single_input(const T *value, StringRef expected_name = "") { - this->add_readonly_single_input(resources_.construct<GVArrayForSingleValueRef>( + this->add_readonly_single_input(scope_.construct<GVArrayForSingleValueRef>( __func__, CPPType::get<T>(), min_array_size_, value), expected_name); } void add_readonly_single_input(const GSpan span, StringRef expected_name = "") { - this->add_readonly_single_input(resources_.construct<GVArrayForGSpan>(__func__, span), + this->add_readonly_single_input(scope_.construct<GVArrayForGSpan>(__func__, span), expected_name); } void add_readonly_single_input(const GVArray &ref, StringRef expected_name = "") @@ -74,7 +74,7 @@ class MFParamsBuilder { void add_readonly_vector_input(const GVectorArray &vector_array, StringRef expected_name = "") { this->add_readonly_vector_input( - resources_.construct<GVVectorArrayForGVectorArray>(__func__, vector_array), expected_name); + scope_.construct<GVVectorArrayForGVectorArray>(__func__, vector_array), expected_name); } void add_readonly_vector_input(const GVVectorArray &ref, StringRef expected_name = "") { @@ -136,9 +136,9 @@ class MFParamsBuilder { return *vector_arrays_[data_index]; } - ResourceCollector &resources() + ResourceScope &resource_scope() { - return resources_; + return scope_; } private: @@ -177,7 +177,7 @@ class MFParams { template<typename T> const VArray<T> &readonly_single_input(int param_index, StringRef name = "") { const GVArray &array = this->readonly_single_input(param_index, name); - return builder_->resources_.construct<VArrayForGVArray<T>>(__func__, array); + return builder_->scope_.construct<VArrayForGVArray<T>>(__func__, array); } const GVArray &readonly_single_input(int param_index, StringRef name = "") { @@ -202,7 +202,7 @@ class MFParams { const VVectorArray<T> &readonly_vector_input(int param_index, StringRef name = "") { const GVVectorArray &vector_array = this->readonly_vector_input(param_index, name); - return builder_->resources_.construct<VVectorArrayForGVVectorArray<T>>(__func__, vector_array); + return builder_->scope_.construct<VVectorArrayForGVVectorArray<T>>(__func__, vector_array); } const GVVectorArray &readonly_vector_input(int param_index, StringRef name = "") { diff --git a/source/blender/functions/intern/multi_function_network_evaluation.cc b/source/blender/functions/intern/multi_function_network_evaluation.cc index daa0a42963a..86ac4f6a179 100644 --- a/source/blender/functions/intern/multi_function_network_evaluation.cc +++ b/source/blender/functions/intern/multi_function_network_evaluation.cc @@ -37,7 +37,7 @@ #include "FN_multi_function_network_evaluation.hh" -#include "BLI_resource_collector.hh" +#include "BLI_resource_scope.hh" #include "BLI_stack.hh" namespace blender::fn { @@ -70,13 +70,10 @@ class MFNetworkEvaluationStorage { void add_vector_output_from_caller(const MFOutputSocket &socket, GVectorArray &vector_array); /* Get input buffers for function node evaluations. */ - const GVArray &get_single_input__full(const MFInputSocket &socket, ResourceCollector &resources); - const GVArray &get_single_input__single(const MFInputSocket &socket, - ResourceCollector &resources); - const GVVectorArray &get_vector_input__full(const MFInputSocket &socket, - ResourceCollector &resources); - const GVVectorArray &get_vector_input__single(const MFInputSocket &socket, - ResourceCollector &resources); + const GVArray &get_single_input__full(const MFInputSocket &socket, ResourceScope &scope); + const GVArray &get_single_input__single(const MFInputSocket &socket, ResourceScope &scope); + const GVVectorArray &get_vector_input__full(const MFInputSocket &socket, ResourceScope &scope); + const GVVectorArray &get_vector_input__single(const MFInputSocket &socket, ResourceScope &scope); /* Get output buffers for function node evaluations. */ GMutableSpan get_single_output__full(const MFOutputSocket &socket); @@ -87,16 +84,16 @@ class MFNetworkEvaluationStorage { /* Get mutable buffers for function node evaluations. */ GMutableSpan get_mutable_single__full(const MFInputSocket &input, const MFOutputSocket &output, - ResourceCollector &resources); + ResourceScope &scope); GMutableSpan get_mutable_single__single(const MFInputSocket &input, const MFOutputSocket &output, - ResourceCollector &resources); + ResourceScope &scope); GVectorArray &get_mutable_vector__full(const MFInputSocket &input, const MFOutputSocket &output, - ResourceCollector &resources); + ResourceScope &scope); GVectorArray &get_mutable_vector__single(const MFInputSocket &input, const MFOutputSocket &output, - ResourceCollector &resources); + ResourceScope &scope); /* Mark a node as being done with evaluation. This might free temporary buffers that are no * longer needed. */ @@ -277,20 +274,20 @@ BLI_NOINLINE void MFNetworkEvaluator::evaluate_function(MFContext &global_contex /* The function output would be the same for all elements. Therefore, it is enough to call the * function only on a single element. This can avoid many duplicate computations. */ MFParamsBuilder params{function, 1}; - ResourceCollector &resources = params.resources(); + ResourceScope &scope = params.resource_scope(); for (int param_index : function.param_indices()) { MFParamType param_type = function.param_type(param_index); switch (param_type.category()) { case MFParamType::SingleInput: { const MFInputSocket &socket = function_node.input_for_param(param_index); - const GVArray &values = storage.get_single_input__single(socket, resources); + const GVArray &values = storage.get_single_input__single(socket, scope); params.add_readonly_single_input(values); break; } case MFParamType::VectorInput: { const MFInputSocket &socket = function_node.input_for_param(param_index); - const GVVectorArray &values = storage.get_vector_input__single(socket, resources); + const GVVectorArray &values = storage.get_vector_input__single(socket, scope); params.add_readonly_vector_input(values); break; } @@ -309,14 +306,14 @@ BLI_NOINLINE void MFNetworkEvaluator::evaluate_function(MFContext &global_contex case MFParamType::SingleMutable: { const MFInputSocket &input = function_node.input_for_param(param_index); const MFOutputSocket &output = function_node.output_for_param(param_index); - GMutableSpan values = storage.get_mutable_single__single(input, output, resources); + GMutableSpan values = storage.get_mutable_single__single(input, output, scope); params.add_single_mutable(values); break; } case MFParamType::VectorMutable: { const MFInputSocket &input = function_node.input_for_param(param_index); const MFOutputSocket &output = function_node.output_for_param(param_index); - GVectorArray &values = storage.get_mutable_vector__single(input, output, resources); + GVectorArray &values = storage.get_mutable_vector__single(input, output, scope); params.add_vector_mutable(values); break; } @@ -327,20 +324,20 @@ BLI_NOINLINE void MFNetworkEvaluator::evaluate_function(MFContext &global_contex } else { MFParamsBuilder params{function, storage.mask().min_array_size()}; - ResourceCollector &resources = params.resources(); + ResourceScope &scope = params.resource_scope(); for (int param_index : function.param_indices()) { MFParamType param_type = function.param_type(param_index); switch (param_type.category()) { case MFParamType::SingleInput: { const MFInputSocket &socket = function_node.input_for_param(param_index); - const GVArray &values = storage.get_single_input__full(socket, resources); + const GVArray &values = storage.get_single_input__full(socket, scope); params.add_readonly_single_input(values); break; } case MFParamType::VectorInput: { const MFInputSocket &socket = function_node.input_for_param(param_index); - const GVVectorArray &values = storage.get_vector_input__full(socket, resources); + const GVVectorArray &values = storage.get_vector_input__full(socket, scope); params.add_readonly_vector_input(values); break; } @@ -359,14 +356,14 @@ BLI_NOINLINE void MFNetworkEvaluator::evaluate_function(MFContext &global_contex case MFParamType::SingleMutable: { const MFInputSocket &input = function_node.input_for_param(param_index); const MFOutputSocket &output = function_node.output_for_param(param_index); - GMutableSpan values = storage.get_mutable_single__full(input, output, resources); + GMutableSpan values = storage.get_mutable_single__full(input, output, scope); params.add_single_mutable(values); break; } case MFParamType::VectorMutable: { const MFInputSocket &input = function_node.input_for_param(param_index); const MFOutputSocket &output = function_node.output_for_param(param_index); - GVectorArray &values = storage.get_mutable_vector__full(input, output, resources); + GVectorArray &values = storage.get_mutable_vector__full(input, output, scope); params.add_vector_mutable(values); break; } @@ -400,19 +397,19 @@ bool MFNetworkEvaluator::can_do_single_value_evaluation(const MFFunctionNode &fu BLI_NOINLINE void MFNetworkEvaluator::initialize_remaining_outputs( MFParams params, Storage &storage, Span<const MFInputSocket *> remaining_outputs) const { - ResourceCollector resources; + ResourceScope scope; for (const MFInputSocket *socket : remaining_outputs) { int param_index = inputs_.size() + outputs_.first_index_of(socket); switch (socket->data_type().category()) { case MFDataType::Single: { - const GVArray &values = storage.get_single_input__full(*socket, resources); + const GVArray &values = storage.get_single_input__full(*socket, scope); GMutableSpan output_values = params.uninitialized_single_output(param_index); values.materialize_to_uninitialized(storage.mask(), output_values.data()); break; } case MFDataType::Vector: { - const GVVectorArray &values = storage.get_vector_input__full(*socket, resources); + const GVVectorArray &values = storage.get_vector_input__full(*socket, scope); GVectorArray &output_values = params.vector_output(param_index); output_values.extend(storage.mask(), values); break; @@ -796,7 +793,7 @@ GVectorArray &MFNetworkEvaluationStorage::get_vector_output__single(const MFOutp GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__full(const MFInputSocket &input, const MFOutputSocket &output, - ResourceCollector &resources) + ResourceScope &scope) { const MFOutputSocket &from = *input.origin(); const MFOutputSocket &to = output; @@ -810,7 +807,7 @@ GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__full(const MFInputS if (to_any_value != nullptr) { BLI_assert(to_any_value->type == ValueType::OutputSingle); GMutableSpan span = static_cast<OutputSingleValue *>(to_any_value)->span; - const GVArray &virtual_array = this->get_single_input__full(input, resources); + const GVArray &virtual_array = this->get_single_input__full(input, scope); virtual_array.materialize_to_uninitialized(mask_, span.data()); return span; } @@ -825,7 +822,7 @@ GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__full(const MFInputS } } - const GVArray &virtual_array = this->get_single_input__full(input, resources); + const GVArray &virtual_array = this->get_single_input__full(input, scope); void *new_buffer = MEM_mallocN_aligned(min_array_size_ * type.size(), type.alignment(), AT); GMutableSpan new_array_ref(type, new_buffer, min_array_size_); virtual_array.materialize_to_uninitialized(mask_, new_array_ref.data()); @@ -838,7 +835,7 @@ GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__full(const MFInputS GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__single(const MFInputSocket &input, const MFOutputSocket &output, - ResourceCollector &resources) + ResourceScope &scope) { const MFOutputSocket &from = *input.origin(); const MFOutputSocket &to = output; @@ -853,7 +850,7 @@ GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__single(const MFInpu BLI_assert(to_any_value->type == ValueType::OutputSingle); GMutableSpan span = static_cast<OutputSingleValue *>(to_any_value)->span; BLI_assert(span.size() == 1); - const GVArray &virtual_array = this->get_single_input__single(input, resources); + const GVArray &virtual_array = this->get_single_input__single(input, scope); virtual_array.get_single_to_uninitialized(span[0]); return span; } @@ -869,7 +866,7 @@ GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__single(const MFInpu } } - const GVArray &virtual_array = this->get_single_input__single(input, resources); + const GVArray &virtual_array = this->get_single_input__single(input, scope); void *new_buffer = allocator_.allocate(type.size(), type.alignment()); virtual_array.get_single_to_uninitialized(new_buffer); @@ -883,7 +880,7 @@ GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__single(const MFInpu GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__full(const MFInputSocket &input, const MFOutputSocket &output, - ResourceCollector &resources) + ResourceScope &scope) { const MFOutputSocket &from = *input.origin(); const MFOutputSocket &to = output; @@ -897,7 +894,7 @@ GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__full(const MFInput if (to_any_value != nullptr) { BLI_assert(to_any_value->type == ValueType::OutputVector); GVectorArray &vector_array = *static_cast<OutputVectorValue *>(to_any_value)->vector_array; - const GVVectorArray &virtual_vector_array = this->get_vector_input__full(input, resources); + const GVVectorArray &virtual_vector_array = this->get_vector_input__full(input, scope); vector_array.extend(mask_, virtual_vector_array); return vector_array; } @@ -912,7 +909,7 @@ GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__full(const MFInput } } - const GVVectorArray &virtual_vector_array = this->get_vector_input__full(input, resources); + const GVVectorArray &virtual_vector_array = this->get_vector_input__full(input, scope); GVectorArray *new_vector_array = new GVectorArray(base_type, min_array_size_); new_vector_array->extend(mask_, virtual_vector_array); @@ -926,7 +923,7 @@ GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__full(const MFInput GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__single(const MFInputSocket &input, const MFOutputSocket &output, - ResourceCollector &resources) + ResourceScope &scope) { const MFOutputSocket &from = *input.origin(); const MFOutputSocket &to = output; @@ -941,7 +938,7 @@ GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__single(const MFInp BLI_assert(to_any_value->type == ValueType::OutputVector); GVectorArray &vector_array = *static_cast<OutputVectorValue *>(to_any_value)->vector_array; BLI_assert(vector_array.size() == 1); - const GVVectorArray &virtual_vector_array = this->get_vector_input__single(input, resources); + const GVVectorArray &virtual_vector_array = this->get_vector_input__single(input, scope); vector_array.extend({0}, virtual_vector_array); return vector_array; } @@ -956,7 +953,7 @@ GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__single(const MFInp } } - const GVVectorArray &virtual_vector_array = this->get_vector_input__single(input, resources); + const GVVectorArray &virtual_vector_array = this->get_vector_input__single(input, scope); GVectorArray *new_vector_array = new GVectorArray(base_type, 1); new_vector_array->extend({0}, virtual_vector_array); @@ -968,7 +965,7 @@ GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__single(const MFInp } const GVArray &MFNetworkEvaluationStorage::get_single_input__full(const MFInputSocket &socket, - ResourceCollector &resources) + ResourceScope &scope) { const MFOutputSocket &origin = *socket.origin(); Value *any_value = value_per_output_id_[origin.id()]; @@ -977,11 +974,11 @@ const GVArray &MFNetworkEvaluationStorage::get_single_input__full(const MFInputS if (any_value->type == ValueType::OwnSingle) { OwnSingleValue *value = static_cast<OwnSingleValue *>(any_value); if (value->is_single_allocated) { - return resources.construct<GVArrayForSingleValueRef>( + return scope.construct<GVArrayForSingleValueRef>( __func__, value->span.type(), min_array_size_, value->span.data()); } - return resources.construct<GVArrayForGSpan>(__func__, value->span); + return scope.construct<GVArrayForGSpan>(__func__, value->span); } if (any_value->type == ValueType::InputSingle) { InputSingleValue *value = static_cast<InputSingleValue *>(any_value); @@ -990,15 +987,15 @@ const GVArray &MFNetworkEvaluationStorage::get_single_input__full(const MFInputS if (any_value->type == ValueType::OutputSingle) { OutputSingleValue *value = static_cast<OutputSingleValue *>(any_value); BLI_assert(value->is_computed); - return resources.construct<GVArrayForGSpan>(__func__, value->span); + return scope.construct<GVArrayForGSpan>(__func__, value->span); } BLI_assert(false); - return resources.construct<GVArrayForEmpty>(__func__, CPPType::get<float>()); + return scope.construct<GVArrayForEmpty>(__func__, CPPType::get<float>()); } const GVArray &MFNetworkEvaluationStorage::get_single_input__single(const MFInputSocket &socket, - ResourceCollector &resources) + ResourceScope &scope) { const MFOutputSocket &origin = *socket.origin(); Value *any_value = value_per_output_id_[origin.id()]; @@ -1007,7 +1004,7 @@ const GVArray &MFNetworkEvaluationStorage::get_single_input__single(const MFInpu if (any_value->type == ValueType::OwnSingle) { OwnSingleValue *value = static_cast<OwnSingleValue *>(any_value); BLI_assert(value->span.size() == 1); - return resources.construct<GVArrayForGSpan>(__func__, value->span); + return scope.construct<GVArrayForGSpan>(__func__, value->span); } if (any_value->type == ValueType::InputSingle) { InputSingleValue *value = static_cast<InputSingleValue *>(any_value); @@ -1018,15 +1015,15 @@ const GVArray &MFNetworkEvaluationStorage::get_single_input__single(const MFInpu OutputSingleValue *value = static_cast<OutputSingleValue *>(any_value); BLI_assert(value->is_computed); BLI_assert(value->span.size() == 1); - return resources.construct<GVArrayForGSpan>(__func__, value->span); + return scope.construct<GVArrayForGSpan>(__func__, value->span); } BLI_assert(false); - return resources.construct<GVArrayForEmpty>(__func__, CPPType::get<float>()); + return scope.construct<GVArrayForEmpty>(__func__, CPPType::get<float>()); } const GVVectorArray &MFNetworkEvaluationStorage::get_vector_input__full( - const MFInputSocket &socket, ResourceCollector &resources) + const MFInputSocket &socket, ResourceScope &scope) { const MFOutputSocket &origin = *socket.origin(); Value *any_value = value_per_output_id_[origin.id()]; @@ -1036,10 +1033,10 @@ const GVVectorArray &MFNetworkEvaluationStorage::get_vector_input__full( OwnVectorValue *value = static_cast<OwnVectorValue *>(any_value); if (value->vector_array->size() == 1) { GSpan span = (*value->vector_array)[0]; - return resources.construct<GVVectorArrayForSingleGSpan>(__func__, span, min_array_size_); + return scope.construct<GVVectorArrayForSingleGSpan>(__func__, span, min_array_size_); } - return resources.construct<GVVectorArrayForGVectorArray>(__func__, *value->vector_array); + return scope.construct<GVVectorArrayForGVectorArray>(__func__, *value->vector_array); } if (any_value->type == ValueType::InputVector) { InputVectorValue *value = static_cast<InputVectorValue *>(any_value); @@ -1047,16 +1044,15 @@ const GVVectorArray &MFNetworkEvaluationStorage::get_vector_input__full( } if (any_value->type == ValueType::OutputVector) { OutputVectorValue *value = static_cast<OutputVectorValue *>(any_value); - return resources.construct<GVVectorArrayForGVectorArray>(__func__, *value->vector_array); + return scope.construct<GVVectorArrayForGVectorArray>(__func__, *value->vector_array); } BLI_assert(false); - return resources.construct<GVVectorArrayForSingleGSpan>( - __func__, GSpan(CPPType::get<float>()), 0); + return scope.construct<GVVectorArrayForSingleGSpan>(__func__, GSpan(CPPType::get<float>()), 0); } const GVVectorArray &MFNetworkEvaluationStorage::get_vector_input__single( - const MFInputSocket &socket, ResourceCollector &resources) + const MFInputSocket &socket, ResourceScope &scope) { const MFOutputSocket &origin = *socket.origin(); Value *any_value = value_per_output_id_[origin.id()]; @@ -1065,7 +1061,7 @@ const GVVectorArray &MFNetworkEvaluationStorage::get_vector_input__single( if (any_value->type == ValueType::OwnVector) { OwnVectorValue *value = static_cast<OwnVectorValue *>(any_value); BLI_assert(value->vector_array->size() == 1); - return resources.construct<GVVectorArrayForGVectorArray>(__func__, *value->vector_array); + return scope.construct<GVVectorArrayForGVectorArray>(__func__, *value->vector_array); } if (any_value->type == ValueType::InputVector) { InputVectorValue *value = static_cast<InputVectorValue *>(any_value); @@ -1075,12 +1071,11 @@ const GVVectorArray &MFNetworkEvaluationStorage::get_vector_input__single( if (any_value->type == ValueType::OutputVector) { OutputVectorValue *value = static_cast<OutputVectorValue *>(any_value); BLI_assert(value->vector_array->size() == 1); - return resources.construct<GVVectorArrayForGVectorArray>(__func__, *value->vector_array); + return scope.construct<GVVectorArrayForGVectorArray>(__func__, *value->vector_array); } BLI_assert(false); - return resources.construct<GVVectorArrayForSingleGSpan>( - __func__, GSpan(CPPType::get<float>()), 0); + return scope.construct<GVVectorArrayForSingleGSpan>(__func__, GSpan(CPPType::get<float>()), 0); } /** \} */ diff --git a/source/blender/functions/intern/multi_function_network_optimization.cc b/source/blender/functions/intern/multi_function_network_optimization.cc index 6c418dee2c1..4b6b3e81393 100644 --- a/source/blender/functions/intern/multi_function_network_optimization.cc +++ b/source/blender/functions/intern/multi_function_network_optimization.cc @@ -219,7 +219,7 @@ static Vector<MFInputSocket *> find_constant_inputs_to_fold( static void prepare_params_for_constant_folding(const MultiFunction &network_fn, MFParamsBuilder ¶ms, - ResourceCollector &resources) + ResourceScope &scope) { for (int param_index : network_fn.param_indices()) { MFParamType param_type = network_fn.param_type(param_index); @@ -229,8 +229,7 @@ static void prepare_params_for_constant_folding(const MultiFunction &network_fn, case MFDataType::Single: { /* Allocates memory for a single constant folded value. */ const CPPType &cpp_type = data_type.single_type(); - void *buffer = resources.linear_allocator().allocate(cpp_type.size(), - cpp_type.alignment()); + void *buffer = scope.linear_allocator().allocate(cpp_type.size(), cpp_type.alignment()); GMutableSpan array{cpp_type, buffer, 1}; params.add_uninitialized_single_output(array); break; @@ -238,7 +237,7 @@ static void prepare_params_for_constant_folding(const MultiFunction &network_fn, case MFDataType::Vector: { /* Allocates memory for a constant folded vector. */ const CPPType &cpp_type = data_type.vector_base_type(); - GVectorArray &vector_array = resources.construct<GVectorArray>(AT, cpp_type, 1); + GVectorArray &vector_array = scope.construct<GVectorArray>(AT, cpp_type, 1); params.add_vector_output(vector_array); break; } @@ -248,7 +247,7 @@ static void prepare_params_for_constant_folding(const MultiFunction &network_fn, static Array<MFOutputSocket *> add_constant_folded_sockets(const MultiFunction &network_fn, MFParamsBuilder ¶ms, - ResourceCollector &resources, + ResourceScope &scope, MFNetwork &network) { Array<MFOutputSocket *> folded_sockets{network_fn.param_indices().size(), nullptr}; @@ -264,15 +263,15 @@ static Array<MFOutputSocket *> add_constant_folded_sockets(const MultiFunction & const CPPType &cpp_type = data_type.single_type(); GMutableSpan array = params.computed_array(param_index); void *buffer = array.data(); - resources.add(buffer, array.type().destruct_cb(), AT); + scope.add(buffer, array.type().destruct_cb(), AT); - constant_fn = &resources.construct<CustomMF_GenericConstant>(AT, cpp_type, buffer); + constant_fn = &scope.construct<CustomMF_GenericConstant>(AT, cpp_type, buffer); break; } case MFDataType::Vector: { GVectorArray &vector_array = params.computed_vector_array(param_index); GSpan array = vector_array[0]; - constant_fn = &resources.construct<CustomMF_GenericConstantArray>(AT, array); + constant_fn = &scope.construct<CustomMF_GenericConstantArray>(AT, array); break; } } @@ -284,17 +283,15 @@ static Array<MFOutputSocket *> add_constant_folded_sockets(const MultiFunction & } static Array<MFOutputSocket *> compute_constant_sockets_and_add_folded_nodes( - MFNetwork &network, - Span<const MFInputSocket *> sockets_to_compute, - ResourceCollector &resources) + MFNetwork &network, Span<const MFInputSocket *> sockets_to_compute, ResourceScope &scope) { MFNetworkEvaluator network_fn{{}, sockets_to_compute}; MFContextBuilder context; MFParamsBuilder params{network_fn, 1}; - prepare_params_for_constant_folding(network_fn, params, resources); + prepare_params_for_constant_folding(network_fn, params, scope); network_fn.call({0}, params, context); - return add_constant_folded_sockets(network_fn, params, resources, network); + return add_constant_folded_sockets(network_fn, params, scope, network); } class MyClass { @@ -304,7 +301,7 @@ class MyClass { /** * Find function nodes that always output the same value and replace those with constant nodes. */ -void constant_folding(MFNetwork &network, ResourceCollector &resources) +void constant_folding(MFNetwork &network, ResourceScope &scope) { Vector<MFDummyNode *> temporary_nodes; Vector<MFInputSocket *> inputs_to_fold = find_constant_inputs_to_fold(network, temporary_nodes); @@ -313,7 +310,7 @@ void constant_folding(MFNetwork &network, ResourceCollector &resources) } Array<MFOutputSocket *> folded_sockets = compute_constant_sockets_and_add_folded_nodes( - network, inputs_to_fold, resources); + network, inputs_to_fold, scope); for (int i : inputs_to_fold.index_range()) { MFOutputSocket &original_socket = *inputs_to_fold[i]->origin(); |