Blender V5.3
FN_lazy_function_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
10
11#include "BLI_task_c.hh"
12
13#include "BKE_gtest_base.hh"
14
16
18
20 public:
22 {
23 debug_name_ = "Add";
24 inputs_.append({"A", CPPType::get<int>()});
25 inputs_.append({"B", CPPType::get<int>()});
26 outputs_.append({"Result", CPPType::get<int>()});
27 }
28
29 void execute_impl(Params &params, const Context & /*context*/) const override
30 {
31 const int a = params.get_input<int>(0);
32 const int b = params.get_input<int>(1);
33 params.set_output(0, a + b);
34 }
35};
36
38 private:
39 int *dst1_;
40 int *dst2_;
41
42 public:
43 StoreValueFunction(int *dst1, int *dst2) : dst1_(dst1), dst2_(dst2)
44 {
45 debug_name_ = "Store Value";
46 inputs_.append({"A", CPPType::get<int>()});
48 }
49
50 void execute_impl(Params &params, const Context & /*context*/) const override
51 {
52 *dst1_ = params.get_input<int>(0);
53 if (int *value = params.try_get_input_data_ptr_or_request<int>(1)) {
54 *dst2_ = *value;
55 }
56 }
57};
58
60 private:
61 Vector<const FunctionNode *> side_effect_nodes_;
62
63 public:
65 : side_effect_nodes_(side_effect_nodes)
66 {
67 }
68
70 const Context & /*context*/) const override
71 {
72 return side_effect_nodes_;
73 }
74};
75
77{
78 const AddLazyFunction add_fn;
79 int result = 0;
81 add_fn, nullptr, nullptr, std::make_tuple(30, 5), std::make_tuple(&result));
82 EXPECT_EQ(result, 35);
83}
84
86{
88 int dst1 = 0;
89 int dst2 = 0;
90
91 const AddLazyFunction add_fn;
92 const StoreValueFunction store_fn{&dst1, &dst2};
93
94 Graph graph;
95 FunctionNode &add_node_1 = graph.add_function(add_fn);
96 FunctionNode &add_node_2 = graph.add_function(add_fn);
97 FunctionNode &store_node = graph.add_function(store_fn);
98 GraphInputSocket &graph_input = graph.add_input(CPPType::get<int>());
99
100 graph.add_link(graph_input, add_node_1.input(0));
101 graph.add_link(graph_input, add_node_2.input(0));
102 graph.add_link(add_node_1.output(0), store_node.input(0));
103 graph.add_link(add_node_2.output(0), store_node.input(1));
104
105 const int value_10 = 10;
106 const int value_100 = 100;
107 add_node_1.input(1).set_default_value(&value_10);
108 add_node_2.input(1).set_default_value(&value_100);
109
110 graph.update_node_indices();
111
112 SimpleSideEffectProvider side_effect_provider{{&store_node}};
113
114 GraphExecutor executor_fn{graph, {&graph_input}, {}, nullptr, &side_effect_provider, nullptr};
116 executor_fn, nullptr, nullptr, std::make_tuple(5), std::make_tuple());
117
118 EXPECT_EQ(dst1, 15);
119 EXPECT_EQ(dst2, 105);
120}
121
123 public:
125 {
126 debug_name_ = "Partial Evaluation";
128
129 inputs_.append_as("A", CPPType::get<int>(), ValueUsage::Used);
130 inputs_.append_as("B", CPPType::get<int>(), ValueUsage::Used);
131
132 outputs_.append_as("A*2", CPPType::get<int>());
133 outputs_.append_as("B*5", CPPType::get<int>());
134 }
135
136 void execute_impl(Params &params, const Context & /*context*/) const override
137 {
138 if (!params.output_was_set(0)) {
139 if (int *a = params.try_get_input_data_ptr<int>(0)) {
140 params.set_output(0, *a * 2);
141 }
142 }
143 if (!params.output_was_set(1)) {
144 if (int *b = params.try_get_input_data_ptr<int>(1)) {
145 params.set_output(1, *b * 5);
146 }
147 }
148 }
149
150 void possible_output_dependencies(const int output_index,
151 FunctionRef<void(Span<int>)> fn) const override
152 {
153 /* Each output only depends on the input with the same index. */
154 const int input_index = output_index;
155 fn({input_index});
156 }
157};
158
159TEST_F(LazyFunctionTest, GraphWithCycle)
160{
162
163 Graph graph;
164 FunctionNode &fn_node = graph.add_function(fn);
165
166 GraphInputSocket &input_socket = graph.add_input(CPPType::get<int>());
167 GraphOutputSocket &output_socket = graph.add_output(CPPType::get<int>());
168
169 graph.add_link(input_socket, fn_node.input(0));
170 /* NOTE: This creates a cycle in the graph. However, it should still be possible to evaluate it,
171 * because there is no actual data dependency in the cycle. */
172 graph.add_link(fn_node.output(0), fn_node.input(1));
173 graph.add_link(fn_node.output(1), output_socket);
174
175 graph.update_node_indices();
176
177 GraphExecutor executor_fn{graph, {&input_socket}, {&output_socket}, nullptr, nullptr, nullptr};
178 int result = 0;
180 executor_fn, nullptr, nullptr, std::make_tuple(10), std::make_tuple(&result));
181
182 EXPECT_EQ(result, 10 * 2 * 5);
183}
184
185} // namespace blender::fn::lazy_function::tests
static const CPPType & get()
FunctionNode & add_function(const LazyFunction &fn)
void add_link(OutputSocket &from, InputSocket &to)
GraphOutputSocket & add_output(const CPPType &type, std::string name="")
GraphInputSocket & add_input(const CPPType &type, std::string name="")
const InputSocket & input(int index) const
const OutputSocket & output(int index) const
void set_output(int index, T &&value)
void * try_get_input_data_ptr_or_request(int index)
void * try_get_input_data_ptr(int index) const
void execute_impl(Params &params, const Context &) const override
void execute_impl(Params &params, const Context &) const override
void possible_output_dependencies(const int output_index, FunctionRef< void(Span< int >)> fn) const override
SimpleSideEffectProvider(Span< const FunctionNode * > side_effect_nodes)
Vector< const FunctionNode * > get_nodes_with_side_effects(const Context &) const override
void execute_impl(Params &params, const Context &) const override
TEST_F(LazyFunctionTest, SimpleAdd)
void execute_lazy_function_eagerly(const LazyFunction &fn, UserData *user_data, LocalUserData *local_user_data, std::tuple< Inputs... > inputs, std::tuple< Outputs *... > outputs)
EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID)
void BLI_task_scheduler_init(bool use_flush_denormals_to_zero=true)