Blender V5.3
FN_multi_function_procedure_test.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: Apache-2.0 */
4
5#include "testing/testing.h"
6
11
12#include "BKE_gtest_base.hh"
13
15
17
19{
26
27 CustomMF_Constant<int> constant_fn{5};
28 auto add_fn = build::SI2_SO<int, int, int>("Add", [](int a, int b) { return a + b; });
29
30 Procedure procedure;
31 ProcedureBuilder builder{procedure};
32
33 auto [var1] = builder.add_call<1>(constant_fn);
34 auto [var2] = builder.add_call<1>(add_fn, {var1, var1});
35 builder.add_destruct(*var1);
36 builder.add_return();
37 builder.add_output_parameter(*var2);
38
39 EXPECT_TRUE(procedure.validate());
40
41 ProcedureExecutor executor{procedure};
42
43 const IndexMask mask(2);
44 ParamsBuilder params{executor, &mask};
45 ContextBuilder context;
46
47 Array<int> output_array(2);
49
50 executor.call(mask, params, context);
51
52 EXPECT_EQ(output_array[0], 10);
53 EXPECT_EQ(output_array[1], 10);
54}
55
57{
65
66 auto add_fn = mf::build::SI2_SO<int, int, int>("add", [](int a, int b) { return a + b; });
67 auto add_10_fn = mf::build::SM<int>("add_10", [](int &a) { a += 10; });
68
69 Procedure procedure;
70 ProcedureBuilder builder{procedure};
71
72 Variable *var1 = &builder.add_single_input_parameter<int>();
73 Variable *var2 = &builder.add_single_input_parameter<int>();
74 auto [var3] = builder.add_call<1>(add_fn, {var1, var2});
75 auto [var4] = builder.add_call<1>(add_fn, {var2, var3});
76 builder.add_call(add_10_fn, {var4});
77 builder.add_destruct({var1, var2, var3});
78 builder.add_return();
79 builder.add_output_parameter(*var4);
80
81 EXPECT_TRUE(procedure.validate());
82
83 ProcedureExecutor executor{procedure};
84
85 const IndexMask mask(3);
86 ParamsBuilder params{executor, &mask};
87 ContextBuilder context;
88
89 Array<int> input_array = {1, 2, 3};
90 params.add_readonly_single_input(input_array.as_span());
92
93 Array<int> output_array(3);
95
96 executor.call(mask, params, context);
97
98 EXPECT_EQ(output_array[0], 17);
99 EXPECT_EQ(output_array[1], 18);
100 EXPECT_EQ(output_array[2], 19);
101}
102
104{
116
117 auto add_10_fn = build::SM<int>("add_10", [](int &a) { a += 10; });
118 auto add_100_fn = build::SM<int>("add_100", [](int &a) { a += 100; });
119
120 Procedure procedure;
121 ProcedureBuilder builder{procedure};
122
123 Variable *var1 = &builder.add_single_mutable_parameter<int>();
124 Variable *var2 = &builder.add_single_input_parameter<bool>();
125
126 ProcedureBuilder::Branch branch = builder.add_branch(*var2);
127 branch.branch_false.add_call(add_10_fn, {var1});
128 branch.branch_true.add_call(add_100_fn, {var1});
129 builder.set_cursor_after_branch(branch);
130 builder.add_call(add_10_fn, {var1});
131 builder.add_destruct({var2});
132 builder.add_return();
133
134 EXPECT_TRUE(procedure.validate());
135
136 ProcedureExecutor procedure_fn{procedure};
137 const IndexMask mask(IndexRange(1, 4));
138 ParamsBuilder params(procedure_fn, &mask);
139
140 Array<int> values_a = {1, 5, 3, 6, 2};
141 Array<bool> values_cond = {true, false, true, true, false};
142
143 params.add_single_mutable(values_a.as_mutable_span());
144 params.add_readonly_single_input(values_cond.as_span());
145
146 ContextBuilder context;
147 procedure_fn.call(mask, params, context);
148
149 EXPECT_EQ(values_a[0], 1);
150 EXPECT_EQ(values_a[1], 25);
151 EXPECT_EQ(values_a[2], 113);
152 EXPECT_EQ(values_a[3], 116);
153 EXPECT_EQ(values_a[4], 22);
154}
155
157{
163
164 int tot_evaluations = 0;
165 const auto add_10_fn = mf::build::SI1_SO<int, int>("add_10", [&](int a) {
166 tot_evaluations++;
167 return a + 10;
168 });
169
170 Procedure procedure;
171 ProcedureBuilder builder{procedure};
172
173 Variable *var1 = &builder.add_single_input_parameter<int>();
174 auto [var2] = builder.add_call<1>(add_10_fn, {var1});
175 builder.add_destruct(*var1);
176 builder.add_return();
177 builder.add_output_parameter(*var2);
178
179 ProcedureExecutor procedure_fn{procedure};
180 IndexMaskMemory memory;
181 const IndexMask mask = IndexMask::from_indices<int>({0, 1, 3, 4}, memory);
182 ParamsBuilder params{procedure_fn, &mask};
183
184 Array<int> values_out = {1, 2, 3, 4, 5};
185 params.add_readonly_single_input_value(1);
186 params.add_uninitialized_single_output(values_out.as_mutable_span());
187
188 ContextBuilder context;
189 procedure_fn.call(mask, params, context);
190
191 EXPECT_EQ(values_out[0], 11);
192 EXPECT_EQ(values_out[1], 11);
193 EXPECT_EQ(values_out[2], 3);
194 EXPECT_EQ(values_out[3], 11);
195 EXPECT_EQ(values_out[4], 11);
196 /* We expect only one evaluation, because the input is constant. */
197 EXPECT_EQ(tot_evaluations, 1);
198}
199
201{
216
217 CustomMF_Constant<int> const_1_fn{1};
218 CustomMF_Constant<int> const_0_fn{0};
219 auto greater_or_equal_fn = mf::build::SI2_SO<int, int, bool>(
220 "greater or equal", [](int a, int b) { return a >= b; });
221 auto double_fn = build::SM<int>("double", [](int &a) { a *= 2; });
222 auto add_1000_fn = build::SM<int>("add 1000", [](int &a) { a += 1000; });
223 auto add_1_fn = build::SM<int>("add 1", [](int &a) { a += 1; });
224
225 Procedure procedure;
226 ProcedureBuilder builder{procedure};
227
228 Variable *var_count = &builder.add_single_input_parameter<int>("count");
229 auto [var_out] = builder.add_call<1>(const_1_fn);
230 var_out->set_name("out");
231 auto [var_index] = builder.add_call<1>(const_0_fn);
232 var_index->set_name("index");
233
234 ProcedureBuilder::Loop loop = builder.add_loop();
235 auto [var_condition] = builder.add_call<1>(greater_or_equal_fn, {var_index, var_count});
236 var_condition->set_name("condition");
237 ProcedureBuilder::Branch branch = builder.add_branch(*var_condition);
238 branch.branch_true.add_destruct(*var_condition);
239 branch.branch_true.add_loop_break(loop);
240 branch.branch_false.add_destruct(*var_condition);
241 builder.set_cursor_after_branch(branch);
242 builder.add_call(double_fn, {var_out});
243 builder.add_call(add_1_fn, {var_index});
244 builder.add_loop_continue(loop);
245 builder.set_cursor_after_loop(loop);
246 builder.add_call(add_1000_fn, {var_out});
247 builder.add_destruct({var_count, var_index});
248 builder.add_return();
249 builder.add_output_parameter(*var_out);
250
251 EXPECT_TRUE(procedure.validate());
252
253 ProcedureExecutor procedure_fn{procedure};
254 IndexMaskMemory memory;
255 const IndexMask mask = IndexMask::from_indices<int>({0, 1, 3, 4}, memory);
256 ParamsBuilder params{procedure_fn, &mask};
257
258 Array<int> counts = {4, 3, 7, 6, 4};
259 Array<int> results(5, -1);
260
261 params.add_readonly_single_input(counts.as_span());
262 params.add_uninitialized_single_output(results.as_mutable_span());
263
264 ContextBuilder context;
265 procedure_fn.call(mask, params, context);
266
267 EXPECT_EQ(results[0], 1016);
268 EXPECT_EQ(results[1], 1008);
269 EXPECT_EQ(results[2], -1);
270 EXPECT_EQ(results[3], 1064);
271 EXPECT_EQ(results[4], 1016);
272}
273
275{
286
287 CreateRangeFunction create_range_fn;
288 ConcatVectorsFunction extend_fn;
290 SumVectorFunction sum_elements_fn;
291 CustomMF_Constant<int> constant_5_fn{5};
292
293 Procedure procedure;
294 ProcedureBuilder builder{procedure};
295
298 builder.add_call(extend_fn, {var_v1, var_v2});
299 auto [var_constant] = builder.add_call<1>(constant_5_fn);
300 builder.add_call(append_fn, {var_v2, var_constant});
301 builder.add_destruct(*var_constant);
302 builder.add_call(extend_fn, {var_v2, var_v1});
303 auto [var_len] = builder.add_call<1>(sum_elements_fn, {var_v2});
304 auto [var_v3] = builder.add_call<1>(create_range_fn, {var_len});
305 builder.add_destruct({var_v1, var_len});
306 builder.add_return();
307 builder.add_output_parameter(*var_v3);
308
309 EXPECT_TRUE(procedure.validate());
310
311 ProcedureExecutor procedure_fn{procedure};
312 IndexMaskMemory memory;
313 const IndexMask mask = IndexMask::from_indices<int>({0, 1, 3, 4}, memory);
314 ParamsBuilder params{procedure_fn, &mask};
315
316 Array<int> v1 = {5, 2, 3};
319
320 int value_10 = 10;
321 v2.append(0, &value_10);
322 v2.append(4, &value_10);
323
324 params.add_readonly_vector_input(v1.as_span());
325 params.add_vector_mutable(v2);
326 params.add_vector_output(v3);
327
328 ContextBuilder context;
329 procedure_fn.call(mask, params, context);
330
331 EXPECT_EQ(v2[0].size(), 6);
332 EXPECT_EQ(v2[1].size(), 4);
333 EXPECT_EQ(v2[2].size(), 0);
334 EXPECT_EQ(v2[3].size(), 4);
335 EXPECT_EQ(v2[4].size(), 6);
336
337 EXPECT_EQ(v3[0].size(), 35);
338 EXPECT_EQ(v3[1].size(), 15);
339 EXPECT_EQ(v3[2].size(), 0);
340 EXPECT_EQ(v3[3].size(), 15);
341 EXPECT_EQ(v3[4].size(), 35);
342}
343
345{
355
356 auto add_10_fn = build::SI1_SO<int, int>("add 10", [](int a) { return a + 10; });
357
358 Procedure procedure;
359 ProcedureBuilder builder{procedure};
360
361 Variable *var_a = &builder.add_single_input_parameter<int>();
362 auto [var_b] = builder.add_call<1>(add_10_fn, {var_a});
363 builder.add_destruct(*var_a);
364 auto [var_c] = builder.add_call<1>(add_10_fn, {var_b});
365 builder.add_destruct(*var_b);
366 auto [var_d] = builder.add_call<1>(add_10_fn, {var_c});
367 builder.add_destruct(*var_c);
368 auto [var_e] = builder.add_call<1>(add_10_fn, {var_d});
369 builder.add_destruct(*var_d);
370 auto [var_out] = builder.add_call<1>(add_10_fn, {var_e});
371 builder.add_destruct(*var_e);
372 builder.add_return();
373 builder.add_output_parameter(*var_out);
374
375 EXPECT_TRUE(procedure.validate());
376
377 ProcedureExecutor procedure_fn{procedure};
378
379 Array<int> inputs = {4, 1, 6, 2, 3};
380 Array<int> results(5, -1);
381
382 IndexMaskMemory memory;
383 const IndexMask mask = IndexMask::from_indices<int>({0, 2, 3, 4}, memory);
384 ParamsBuilder params{procedure_fn, &mask};
385
386 params.add_readonly_single_input(inputs.as_span());
387 params.add_uninitialized_single_output(results.as_mutable_span());
388
389 ContextBuilder context;
390 procedure_fn.call(mask, params, context);
391
392 EXPECT_EQ(results[0], 54);
393 EXPECT_EQ(results[1], -1);
394 EXPECT_EQ(results[2], 56);
395 EXPECT_EQ(results[3], 52);
396 EXPECT_EQ(results[4], 53);
397}
398
399TEST_F(MultiFunctionProcedureTest, OutputBufferReplaced)
400{
401 Procedure procedure;
402 ProcedureBuilder builder{procedure};
403
404 const int output_value = 42;
405 CustomMF_GenericConstant constant_fn(CPPType::get<int>(), &output_value, false);
406 Variable &var_o = procedure.new_variable(DataType::ForSingle<int>());
407 builder.add_output_parameter(var_o);
408 builder.add_call_with_all_variables(constant_fn, {&var_o});
409 builder.add_destruct(var_o);
410 builder.add_call_with_all_variables(constant_fn, {&var_o});
411 builder.add_return();
412
413 EXPECT_TRUE(procedure.validate());
414
415 ProcedureExecutor procedure_fn{procedure};
416
417 Array<int> output(3, 0);
418 IndexMask mask(output.size());
419 mf::ParamsBuilder params(procedure_fn, &mask);
420 params.add_uninitialized_single_output(output.as_mutable_span());
421
422 mf::ContextBuilder context;
423 procedure_fn.call(mask, params, context);
424
425 EXPECT_EQ(output[0], output_value);
426 EXPECT_EQ(output[1], output_value);
427 EXPECT_EQ(output[2], output_value);
428}
429
430} // namespace blender::fn::multi_function::tests
#define output
Span< T > as_span() const
Definition BLI_array.hh:254
MutableSpan< T > as_mutable_span()
Definition BLI_array.hh:259
static const CPPType & get()
static IndexMask from_indices(Span< T > indices, LinearAllocator<> &memory)
constexpr IndexRange()=default
static DataType ForVector(const CPPType &type)
static DataType ForSingle(const CPPType &type)
static ParamType ForMutableVector(const CPPType &base_type)
void add_single_mutable(GMutableSpan ref, StringRef expected_name="")
void add_uninitialized_single_output(T *value, StringRef expected_name="")
void add_readonly_single_input(const T *value, StringRef expected_name="")
void add_readonly_single_input_value(T value, StringRef expected_name="")
Variable & add_input_parameter(DataType data_type, std::string name="")
Vector< Variable * > add_call(const MultiFunction &fn, Span< Variable * > input_and_mutable_variables={})
void add_parameter(ParamType::InterfaceType interface_type, Variable &variable)
CallInstruction & add_call_with_all_variables(const MultiFunction &fn, Span< Variable * > param_variables)
void call(const IndexMask &mask, Params params, Context context) const override
Variable & new_variable(DataType data_type, std::string name="")
#define EXPECT_TRUE(result)
auto SI2_SO(const char *name, ElementFn &&element_fn, const ExecPreset exec_preset=exec_presets::Materialized())
auto SM(const char *name, ElementFn &&element_fn, const ExecPreset exec_preset=exec_presets::AllSpanOrSingle())
auto SI1_SO(const char *name, ElementFn &&element_fn, const ExecPreset exec_preset=exec_presets::Materialized())
TEST_F(MultiFunctionProcedureTest, ConstantOutput)
EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID)
ATTR_WARN_UNUSED_RESULT const BMVert * v2