58 if (handled_fields.
add(field)) {
59 fields_to_check.
push(field);
63 while (!fields_to_check.
is_empty()) {
68 [&]<
typename T>(
const T &
v) {
69 if constexpr (std::is_same_v<T, GFieldRef::Input>) {
74 else if constexpr (std::is_same_v<T, GFieldRef::MultiFn>) {
75 for (
const GField &input_field :
v.node->inputs()) {
78 if (handled_fields.
add(input_field)) {
79 fields_to_check.
push(input_field);
83 else if constexpr (std::is_same_v<T, GFieldRef::Value>) {
92 return field_tree_info;
104 for (
const GFieldRef &input_field : field_inputs) {
105 const FieldInput &field_input = *std::get<GFieldRef::Input>(input_field.variant()).node;
106 GVArray varray = context.get_varray_for_input(field_input,
mask, scope);
111 field_context_inputs.
append(std::move(varray));
113 return field_context_inputs;
130 const GVArray &varray = field_context_inputs[input_i];
136 if (found_fields.
add(user)) {
137 fields_to_check.
push(user);
141 while (!fields_to_check.
is_empty()) {
144 if (found_fields.
add(user)) {
145 fields_to_check.
push(user);
161 mf::ProcedureBuilder builder{procedure};
168 const FieldInput &field_input = *std::get<GFieldRef::Input>(input_field.
variant()).node;
169 mf::Variable &variable = builder.add_input_parameter(
171 variable_by_field.
add_new(input_hash, &variable);
175 struct FieldWithIndex {
177 int current_input_index = 0;
184 fields_to_check.
push({field, 0});
185 while (!fields_to_check.
is_empty()) {
186 FieldWithIndex &field_with_index = fields_to_check.
peek();
187 const GFieldRef &field = field_with_index.field;
189 if (variable_by_field.
contains(field_hash)) {
191 fields_to_check.
pop();
196 [&]<
typename T>(
const T &
v) {
197 if constexpr (std::is_same_v<T, GFieldRef::Input>) {
200 else if constexpr (std::is_same_v<T, GFieldRef::MultiFn>) {
204 if (field_with_index.current_input_index < fn_inputs.
size()) {
207 fields_to_check.
push({fn_inputs[field_with_index.current_input_index]});
208 field_with_index.current_input_index++;
216 int param_input_index = 0;
217 int param_output_index = 0;
219 const mf::ParamType param_type =
multi_function.param_type(param_index);
220 const mf::ParamType::InterfaceType interface_type = param_type.interface_type();
221 if (interface_type == mf::ParamType::Input) {
222 const GField &input_field = fn_inputs[param_input_index];
224 variables[param_index] = variable_by_field.
lookup(input_hash);
227 else if (interface_type == mf::ParamType::Output) {
228 const GFieldRef output_field{field_multi_fn, param_output_index};
234 variables[param_index] =
nullptr;
238 mf::Variable &new_variable = procedure.new_variable(param_type.data_type());
239 variables[param_index] = &new_variable;
242 variable_by_field.
add_new(output_hash, &new_variable);
244 param_output_index++;
253 else if constexpr (std::is_same_v<T, GFieldRef::Value>) {
254 const mf::MultiFunction &
fn =
255 procedure.construct_function<mf::CustomMF_GenericConstant>(
256 *
v.type,
v.value,
false);
257 mf::Variable &new_variable = *builder.add_call<1>(
fn)[0];
258 variable_by_field.
add_new(field_hash, &new_variable);
270 for (
const GFieldRef &field : output_fields) {
272 mf::Variable *variable = variable_by_field.
lookup(field_hash);
273 if (!output_variables.
add(variable)) {
276 const mf::MultiFunction ©_fn = scope.
construct<mf::CustomMF_GenericCopy>(
277 variable->data_type());
278 variable = builder.add_call<1>(copy_fn, {variable})[0];
279 output_variables.
add(variable);
281 builder.add_output_parameter(*variable);
284 for (mf::Variable *variable : procedure.variables()) {
285 if (!output_variables.
contains(variable)) {
286 builder.add_destruct(*variable);
290 mf::ReturnInstruction &return_instr = builder.add_return();
292 mf::procedure_optimization::move_destructs_up(procedure, return_instr);
294 procedure.prepare_for_execution();
308 Array<bool> is_output_written_to_dst(fields_to_evaluate.
size(),
false);
309 const int array_size =
mask.min_array_size();
311 if (
mask.is_empty()) {
312 for (
const int i : fields_to_evaluate.
index_range()) {
313 const CPPType &type = fields_to_evaluate[i].cpp_type();
348 for (
const int out_index : fields_to_evaluate.
index_range()) {
349 const GFieldRef &field = fields_to_evaluate[out_index];
352 [&]<
typename T>(
const T &
v) {
353 if constexpr (std::is_same_v<T, GFieldRef::Input>) {
356 const GVArray &varray = field_context_inputs[input_i];
357 varrays[out_index] = varray;
359 else if constexpr (std::is_same_v<T, GFieldRef::MultiFn>) {
362 varying_fields_to_evaluate.
append(field);
363 varying_field_indices.
append(out_index);
366 constant_fields_to_evaluate.
append(field);
367 constant_field_indices.
append(out_index);
370 else if constexpr (std::is_same_v<T, GFieldRef::Value>) {
381 if (!varying_fields_to_evaluate.
is_empty()) {
383 mf::Procedure procedure;
385 procedure, scope, field_tree_info, varying_fields_to_evaluate);
386 mf::ProcedureExecutor procedure_executor{procedure};
388 mf::ParamsBuilder mf_params{procedure_executor, &
mask};
389 mf::ContextBuilder mf_context;
392 for (
const GVArray &varray : field_context_inputs) {
393 mf_params.add_readonly_single_input(varray);
396 for (
const int i : varying_fields_to_evaluate.
index_range()) {
397 const GFieldRef &field = varying_fields_to_evaluate[i];
399 const int out_index = varying_field_indices[i];
404 if (!dst_varray || !dst_varray.
is_span()) {
420 varrays[out_index] = dst_varray;
421 is_output_written_to_dst[out_index] =
true;
426 mf_params.add_uninitialized_single_output(span);
429 procedure_executor.call_auto(
mask, mf_params, mf_context);
433 if (!constant_fields_to_evaluate.
is_empty()) {
435 mf::Procedure procedure;
437 procedure, scope, field_tree_info, constant_fields_to_evaluate);
438 mf::ProcedureExecutor procedure_executor{procedure};
440 mf::ParamsBuilder mf_params{procedure_executor, &
mask};
441 mf::ContextBuilder mf_context;
444 for (
const GVArray &varray : field_context_inputs) {
445 mf_params.add_readonly_single_input(varray);
448 for (
const int i : constant_fields_to_evaluate.
index_range()) {
449 const GFieldRef &field = constant_fields_to_evaluate[i];
455 mf_params.add_uninitialized_single_output({type, buffer, 1});
458 const int out_index = constant_field_indices[i];
462 procedure_executor.call(
mask, mf_params, mf_context);
468 for (
const int out_index : fields_to_evaluate.
index_range()) {
474 const GVArray &computed_varray = varrays[out_index];
476 if (is_output_written_to_dst[out_index]) {
492 BUFFER_FOR_CPP_TYPE_VALUE(type, buffer);
493 mask.slice(range).foreach_segment([&](auto segment) {
494 for (const int i : segment) {
495 computed_varray.get_to_uninitialized(i, buffer);
496 dst_varray.set_by_relocate(i, buffer);
501 varrays[out_index] = dst_varray;
519 varrays[0].get_to_uninitialized(0, r_value);
550 const int field_index = fields_to_evaluate_.append_and_get_index(std::move(field));
551 dst_varrays_.append(dst);
552 output_pointer_infos_.append({});
563 const int field_index = fields_to_evaluate_.append_and_get_index(std::move(field));
564 dst_varrays_.append(
nullptr);
565 output_pointer_infos_.append(OutputPointerInfo{
567 *
static_cast<GVArray *
>(dst) = varray;
574 const int field_index = fields_to_evaluate_.append_and_get_index(std::move(field));
575 dst_varrays_.append(
nullptr);
576 output_pointer_infos_.append({});
586 evaluate_fields(scope, {selection_field}, full_mask, context)[0].typed<bool>();
594 selection_mask_ = selection_field_ ?
599 fields.
reserve(fields_to_evaluate_.size());
600 static constexpr bool true_value =
true;
601 for (
const int i : fields_to_evaluate_.index_range()) {
602 const GField &field = fields_to_evaluate_[i];
603 if (field == selection_field_) {
611 evaluated_varrays_ =
evaluate_fields(scope_, fields, selection_mask_, context_, dst_varrays_);
612 BLI_assert(fields_to_evaluate_.size() == evaluated_varrays_.size());
613 for (
const int i : fields_to_evaluate_.index_range()) {
614 OutputPointerInfo &info = output_pointer_infos_[i];
615 if (info.dst !=
nullptr) {
616 info.set(info.dst, evaluated_varrays_[i], scope_);
619 is_evaluated_ =
true;
638 return selection_mask_;
#define BUFFER_FOR_CPP_TYPE_VALUE(type, variable_name)
#define PRF_scope(category)
#define BLI_assert_unreachable()
#define BLI_assert_unreachable_static_t(T)
#define BLI_assert_msg(a, msg)
static const CPPType & get()
bool is_trivially_destructible
void destruct_indices(void *ptr, const IndexMask &mask) const
void destruct(void *ptr) const
void default_construct_indices(void *ptr, const IndexMask &mask) const
void value_initialize(void *ptr) const
GMutableSpan take_front(const int64_t n) const
const CPPType & type() const
static GVArray from_empty(const CPPType &type)
static GVArray from_single_default(const CPPType &type, int64_t size)
static GVArray from_span(GSpan span)
static GVArray from_single_ref(const CPPType &type, int64_t size, const void *value)
static GVMutableArray from_span(GMutableSpan span)
GMutableSpan get_internal_span() const
static IndexMask from_bools(Span< bool > bools, LinearAllocator<> &memory)
MutableSpan< T > allocate_array(int64_t size)
const Value & lookup(const Key &key) const
void add_new(const Key &key, const Value &value)
bool contains(const Key &key) const
T & construct(Args &&...args)
void add_destruct_call(Func func)
void * allocate_owned(const CPPType &type)
LinearAllocator & allocator()
bool contains(const Key &key) const
constexpr int64_t size() const
constexpr IndexRange index_range() const
constexpr bool is_empty() const
void push(const T &value)
T get_internal_single() const
void append(const T &value)
IndexRange index_range() const
void reserve(const int64_t min_capacity)
int add(GField field, GVArray *varray_ptr)
IndexMask get_evaluated_as_mask(int field_index)
IndexMask get_evaluated_selection_as_mask() const
int add_with_destination(GField field, GVMutableArray dst)
const GVArray & get_evaluated(const int field_index) const
Span< GField > inputs() const
const mf::MultiFunction & multi_function() const
std::variant< Value, Input, MultiFn > Variant
const CPPType & cpp_type() const
const Variant & variant() const
static GFieldRef from_constant(const CPPType &type, const void *value)
bool depends_on_input() const
static GField from_constant(const CPPType &type, const void *value)
const CPPType & cpp_type() const
void copy(const GVArray &src, GMutableSpan dst, exec_mode::Mode mode=exec_mode::parallel)
static Vector< GVArray > get_field_context_inputs(ResourceScope &scope, const IndexMask &mask, const FieldContext &context, const Span< GFieldRef > field_inputs)
static IndexMask index_mask_from_selection(const IndexMask full_mask, const VArray< bool > &selection, ResourceScope &scope)
static FieldTreeInfo preprocess_field_tree(Span< GFieldRef > entry_fields)
static void build_multi_function_procedure_for_fields(mf::Procedure &procedure, ResourceScope &scope, const FieldTreeInfo &field_tree_info, Span< GFieldRef > output_fields)
static IndexMask evaluate_selection(const Field< bool > &selection_field, const FieldContext &context, const IndexMask &full_mask, ResourceScope &scope)
Vector< GVArray > evaluate_fields(ResourceScope &scope, Span< GFieldRef > fields_to_evaluate, const IndexMask &mask, const FieldContext &context, Span< GVMutableArray > dst_varrays={})
static Set< UniqueHash > find_varying_fields(const FieldTreeInfo &field_tree_info, const Span< GVArray > field_context_inputs)
GField make_field_constant_if_possible(GField field)
void evaluate_constant_field(const GField &field, void *r_value)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
ATTR_WARN_UNUSED_RESULT const BMVert * v
bool contains(const GFieldRef &field) const
UniqueHash ensure(const GFieldRef &field)
UniqueHash lookup(const GFieldRef &field) const
Vector< GFieldRef > deduplicated_inputs
VectorSet< UniqueHash > deduplicated_input_hashes
MultiValueMap< UniqueHash, UniqueHash > field_users
FieldHashDeep deep_hashes