Blender V5.3
geometry_nodes_repeat_zone.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2024 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
10
12#include "BKE_node_runtime.hh"
14
16
17#include "BLT_translation.hh"
18
19#include "BLI_array_utils.hh"
20
22
24
25namespace blender::nodes {
26
27using bke::SocketValueVariant;
28
35class RepeatBodyNodeExecuteWrapper : public lf::GraphExecutorNodeExecuteWrapper {
36 public:
37 const bNode *repeat_output_bnode_ = nullptr;
39
40 void execute_node(const lf::FunctionNode &node,
41 lf::Params &params,
42 const lf::Context &context) const override
43 {
44 GeoNodesUserData &user_data = *static_cast<GeoNodesUserData *>(context.user_data);
45 const int iteration = lf_body_nodes_->index_of_try(const_cast<lf::FunctionNode *>(&node));
46 const LazyFunction &fn = node.function();
47 if (iteration == -1) {
48 /* The node is not a loop body node, just execute it normally. */
49 fn.execute(params, context);
50 return;
51 }
52
53 /* Setup context for the loop body evaluation. */
54 bke::RepeatZoneComputeContext body_compute_context{
55 user_data.compute_context, *repeat_output_bnode_, iteration};
56 GeoNodesUserData body_user_data = user_data;
57 body_user_data.compute_context = &body_compute_context;
58 body_user_data.verbose_log = should_log_verbose_in_context(user_data,
59 body_compute_context.hash());
60
61 GeoNodesLocalUserData body_local_user_data{body_user_data};
62 lf::Context body_context{context.storage, &body_user_data, &body_local_user_data};
63 fn.execute(params, body_context);
64 }
65};
66
70class RepeatZoneSideEffectProvider : public lf::GraphExecutorSideEffectProvider {
71 public:
72 const bNode *repeat_output_bnode_ = nullptr;
74
76 const lf::Context &context) const override
77 {
78 GeoNodesUserData &user_data = *static_cast<GeoNodesUserData *>(context.user_data);
79 const GeoNodesCallData &call_data = *user_data.call_data;
80 if (!call_data.side_effect_nodes) {
81 return {};
82 }
83 const ComputeContextHash &context_hash = user_data.compute_context->hash();
84 const Span<int> iterations_with_side_effects =
86 {context_hash, repeat_output_bnode_->identifier});
87
89 for (const int i : iterations_with_side_effects) {
90 if (i >= 0 && i < lf_body_nodes_.size()) {
91 lf_nodes.append(lf_body_nodes_[i]);
92 }
93 }
94 return lf_nodes;
95 }
96};
97
101 lf::Graph graph;
102 std::optional<LazyFunctionForLogicalOr> or_function;
103 std::optional<RepeatZoneSideEffectProvider> side_effect_provider;
104 std::optional<RepeatBodyNodeExecuteWrapper> body_execute_wrapper;
105 std::optional<lf::GraphExecutor> graph_executor;
107 void *graph_executor_storage = nullptr;
111};
112
113class LazyFunctionForRepeatZone : public LazyFunction {
114 private:
115 const bNodeTree &btree_;
116 const bke::bNodeTreeZone &zone_;
117 const bNode &repeat_output_bnode_;
118 const ZoneBuildInfo &zone_info_;
119 const ZoneBodyFunction &body_fn_;
120
121 public:
123 const bke::bNodeTreeZone &zone,
124 ZoneBuildInfo &zone_info,
125 const ZoneBodyFunction &body_fn)
126 : btree_(btree),
127 zone_(zone),
128 repeat_output_bnode_(*zone.output_node()),
129 zone_info_(zone_info),
130 body_fn_(body_fn)
131 {
132 debug_name_ = "Repeat Zone";
133
134 initialize_zone_wrapper(zone, zone_info, body_fn, true, inputs_, outputs_);
135 /* Iterations input is always used. */
136 inputs_[zone_info.indices.inputs.main[0]].usage = lf::ValueUsage::Used;
137 }
138
139 void *init_storage(LinearAllocator<> &allocator) const override
140 {
141 return allocator.construct<RepeatEvalStorage>().release();
142 }
143
144 void destruct_storage(void *storage) const override
145 {
146 RepeatEvalStorage *s = static_cast<RepeatEvalStorage *>(storage);
147 if (s->graph_executor_storage) {
148 s->graph_executor->destruct_storage(s->graph_executor_storage);
149 }
150 std::destroy_at(s);
151 }
152
153 void execute_impl(lf::Params &params, const lf::Context &context) const override
154 {
155 const ScopedNodeTimer node_timer{context, repeat_output_bnode_};
156
157 auto &user_data = *static_cast<GeoNodesUserData *>(context.user_data);
158 auto &local_user_data = *static_cast<GeoNodesLocalUserData *>(context.local_user_data);
159
160 const NodeGeometryRepeatOutput &node_storage = *static_cast<const NodeGeometryRepeatOutput *>(
161 repeat_output_bnode_.storage);
162 RepeatEvalStorage &eval_storage = *static_cast<RepeatEvalStorage *>(context.storage);
163
164 const int iterations_usage_index = zone_info_.indices.outputs.input_usages[0];
165 if (!params.output_was_set(iterations_usage_index)) {
166 /* The iterations input is always used. */
167 params.set_output(iterations_usage_index, true);
168 }
169
170 if (!eval_storage.graph_executor) {
171 /* Create the execution graph in the first evaluation. */
173 params, eval_storage, node_storage, user_data, local_user_data);
174 }
175
176 /* Execute the graph for the repeat zone. */
177 lf::RemappedParams eval_graph_params{*eval_storage.graph_executor,
178 params,
179 eval_storage.input_index_map,
180 eval_storage.output_index_map,
181 eval_storage.multi_threading_enabled};
182 lf::Context eval_graph_context{
183 eval_storage.graph_executor_storage, context.user_data, context.local_user_data};
184 eval_storage.graph_executor->execute(eval_graph_params, eval_graph_context);
185 }
186
195 void initialize_execution_graph(lf::Params &params,
196 RepeatEvalStorage &eval_storage,
197 const NodeGeometryRepeatOutput &node_storage,
198 GeoNodesUserData &user_data,
199 GeoNodesLocalUserData &local_user_data) const
200 {
201 const int num_repeat_items = node_storage.items_num;
202 const int num_border_links = body_fn_.indices.inputs.border_links.size();
203
204 /* Number of iterations to evaluate. */
205 const int iterations = std::max<int>(
206 0,
207 params.get_input<SocketValueVariant>(zone_info_.indices.inputs.main[0])
208 .ensure_type<int>());
209
210 if (iterations >= 10) {
211 /* Constructing and running the repeat zone has some overhead so that it's probably worth
212 * trying to do something else in the meantime already. */
214 }
215
216 /* Show a warning when the inspection index is out of range. */
217 if (node_storage.inspection_index > 0) {
218 if (node_storage.inspection_index >= iterations) {
219 if (eval_log::NodeTreeLogger *tree_logger = local_user_data.try_get_tree_logger(user_data))
220 {
221 tree_logger->node_warnings.append(
222 *tree_logger->allocator,
223 {repeat_output_bnode_.identifier,
224 {NodeWarningType::Info, N_("Inspection index is out of range")}});
225 }
226 }
227 }
228
229 /* Take iterations input into account. */
230 const int main_inputs_offset = 1;
231 const int body_inputs_offset = 1;
232
233 lf::Graph &lf_graph = eval_storage.graph;
234
237
238 for (const int i : inputs_.index_range()) {
239 const lf::Input &input = inputs_[i];
240 lf_inputs.append(&lf_graph.add_input(*input.type, this->input_name(i)));
241 }
242 for (const int i : outputs_.index_range()) {
243 const lf::Output &output = outputs_[i];
244 lf_outputs.append(&lf_graph.add_output(*output.type, this->output_name(i)));
245 }
246
247 /* Create body nodes. */
248 VectorSet<lf::FunctionNode *> &lf_body_nodes = eval_storage.lf_body_nodes;
249 for ([[maybe_unused]] const int i : IndexRange(iterations)) {
250 lf::FunctionNode &lf_node = lf_graph.add_function(*body_fn_.function);
251 lf_body_nodes.add_new(&lf_node);
252 }
253
254 /* Create nodes for combining border link usages. A border link is used when any of the loop
255 * bodies uses the border link, so an "or" node is necessary. */
256 Array<lf::FunctionNode *> lf_border_link_usage_or_nodes(num_border_links);
257 eval_storage.or_function.emplace(iterations);
258 for (const int i : IndexRange(num_border_links)) {
259 lf::FunctionNode &lf_node = lf_graph.add_function(*eval_storage.or_function);
260 lf_border_link_usage_or_nodes[i] = &lf_node;
261 }
262
263 const bool use_index_values = zone_.input_node()->output_socket(0).is_directly_linked();
264
265 if (use_index_values) {
266 eval_storage.index_values.reinitialize(iterations);
267 threading::parallel_for(IndexRange(iterations), 1024, [&](const IndexRange range) {
268 for (const int i : range) {
269 eval_storage.index_values[i].emplace<int>(i);
270 }
271 });
272 }
273
274 /* Handle body nodes one by one. */
275 static const SocketValueVariant static_unused_index{-1};
276 for (const int iter_i : lf_body_nodes.index_range()) {
277 lf::FunctionNode &lf_node = *lf_body_nodes[iter_i];
278 const SocketValueVariant *index_value = use_index_values ?
279 &eval_storage.index_values[iter_i] :
280 &static_unused_index;
281 lf_node.input(body_fn_.indices.inputs.main[0]).set_default_value(index_value);
282 for (const int i : IndexRange(num_border_links)) {
283 lf_graph.add_link(*lf_inputs[zone_info_.indices.inputs.border_links[i]],
284 lf_node.input(body_fn_.indices.inputs.border_links[i]));
285 lf_graph.add_link(lf_node.output(body_fn_.indices.outputs.border_link_usages[i]),
286 lf_border_link_usage_or_nodes[i]->input(iter_i));
287 }
288
289 /* Handle reference sets. */
290 for (const auto &item : body_fn_.indices.inputs.reference_sets.items()) {
291 lf_graph.add_link(*lf_inputs[zone_info_.indices.inputs.reference_sets.lookup(item.key)],
292 lf_node.input(item.value));
293 }
294 }
295
296 static bool static_true = true;
297
298 /* Handle body nodes pair-wise. */
299 for (const int iter_i : lf_body_nodes.index_range().drop_back(1)) {
300 lf::FunctionNode &lf_node = *lf_body_nodes[iter_i];
301 lf::FunctionNode &lf_next_node = *lf_body_nodes[iter_i + 1];
302 for (const int i : IndexRange(num_repeat_items)) {
303 lf_graph.add_link(
304 lf_node.output(body_fn_.indices.outputs.main[i]),
305 lf_next_node.input(body_fn_.indices.inputs.main[i + body_inputs_offset]));
306 /* TODO: Add back-link after being able to check for cyclic dependencies. */
307 // lf_graph.add_link(lf_next_node.output(body_fn_.indices.outputs.input_usages[i]),
308 // lf_node.input(body_fn_.indices.inputs.output_usages[i]));
309 lf_node.input(body_fn_.indices.inputs.output_usages[i]).set_default_value(&static_true);
310 }
311 }
312
313 /* Handle border link usage outputs. */
314 for (const int i : IndexRange(num_border_links)) {
315 lf_graph.add_link(lf_border_link_usage_or_nodes[i]->output(0),
316 *lf_outputs[zone_info_.indices.outputs.border_link_usages[i]]);
317 }
318
319 if (iterations > 0) {
320 {
321 /* Link first body node to input/output nodes. */
322 lf::FunctionNode &lf_first_body_node = *lf_body_nodes[0];
323 for (const int i : IndexRange(num_repeat_items)) {
324 lf_graph.add_link(
325 *lf_inputs[zone_info_.indices.inputs.main[i + main_inputs_offset]],
326 lf_first_body_node.input(body_fn_.indices.inputs.main[i + body_inputs_offset]));
327 lf_graph.add_link(
328 lf_first_body_node.output(
329 body_fn_.indices.outputs.input_usages[i + body_inputs_offset]),
330 *lf_outputs[zone_info_.indices.outputs.input_usages[i + main_inputs_offset]]);
331 }
332 }
333 {
334 /* Link last body node to input/output nodes. */
335 lf::FunctionNode &lf_last_body_node = *lf_body_nodes.as_span().last();
336 for (const int i : IndexRange(num_repeat_items)) {
337 lf_graph.add_link(lf_last_body_node.output(body_fn_.indices.outputs.main[i]),
338 *lf_outputs[zone_info_.indices.outputs.main[i]]);
339 lf_graph.add_link(*lf_inputs[zone_info_.indices.inputs.output_usages[i]],
340 lf_last_body_node.input(body_fn_.indices.inputs.output_usages[i]));
341 }
342 }
343 }
344 else {
345 /* There are no iterations, just link the input directly to the output. */
346 for (const int i : IndexRange(num_repeat_items)) {
347 lf_graph.add_link(*lf_inputs[zone_info_.indices.inputs.main[i + main_inputs_offset]],
348 *lf_outputs[zone_info_.indices.outputs.main[i]]);
349 lf_graph.add_link(
350 *lf_inputs[zone_info_.indices.inputs.output_usages[i]],
351 *lf_outputs[zone_info_.indices.outputs.input_usages[i + main_inputs_offset]]);
352 }
353 for (const int i : IndexRange(num_border_links)) {
354 static bool static_false = false;
355 lf_outputs[zone_info_.indices.outputs.border_link_usages[i]]->set_default_value(
356 &static_false);
357 }
358 }
359
360 lf_outputs[zone_info_.indices.outputs.input_usages[0]]->set_default_value(&static_true);
361
362 /* The graph is ready, update the node indices which are required by the executor. */
363 lf_graph.update_node_indices();
364
365 // std::cout << "\n\n" << lf_graph.to_dot() << "\n\n";
366
367 /* Create a mapping from parameter indices inside of this graph to parameters of the repeat
368 * zone. The main complexity below stems from the fact that the iterations input is handled
369 * outside of this graph. */
370 eval_storage.output_index_map.reinitialize(outputs_.size() - 1);
371 eval_storage.input_index_map.resize(inputs_.size() - 1);
372 array_utils::fill_index_range<int>(eval_storage.input_index_map, 1);
373
374 Vector<const lf::GraphInputSocket *> lf_graph_inputs = lf_inputs.as_span().drop_front(1);
375
376 const int iteration_usage_index = zone_info_.indices.outputs.input_usages[0];
378 eval_storage.output_index_map.as_mutable_span().take_front(iteration_usage_index));
380 eval_storage.output_index_map.as_mutable_span().drop_front(iteration_usage_index),
381 iteration_usage_index + 1);
382
383 Vector<const lf::GraphOutputSocket *> lf_graph_outputs = lf_outputs.as_span().take_front(
384 iteration_usage_index);
385 lf_graph_outputs.extend(lf_outputs.as_span().drop_front(iteration_usage_index + 1));
386
387 eval_storage.body_execute_wrapper.emplace();
388 eval_storage.body_execute_wrapper->repeat_output_bnode_ = &repeat_output_bnode_;
389 eval_storage.body_execute_wrapper->lf_body_nodes_ = &lf_body_nodes;
390 eval_storage.side_effect_provider.emplace();
391 eval_storage.side_effect_provider->repeat_output_bnode_ = &repeat_output_bnode_;
392 eval_storage.side_effect_provider->lf_body_nodes_ = lf_body_nodes;
393
394 eval_storage.graph_executor.emplace(lf_graph,
395 std::move(lf_graph_inputs),
396 std::move(lf_graph_outputs),
397 nullptr,
398 &*eval_storage.side_effect_provider,
399 &*eval_storage.body_execute_wrapper);
400 eval_storage.graph_executor_storage = eval_storage.graph_executor->init_storage(
401 eval_storage.allocator);
402
403 /* Log graph for debugging purposes. */
404 const bNodeTree &btree_orig = *DEG_get_original(&btree_);
405 if (btree_orig.runtime->logged_zone_graphs) {
406 std::lock_guard lock{btree_orig.runtime->logged_zone_graphs->mutex};
407 btree_orig.runtime->logged_zone_graphs->graph_by_zone_id.lookup_or_add_cb(
408 repeat_output_bnode_.identifier, [&]() { return lf_graph.to_dot(); });
409 }
410 }
411
412 std::string input_name(const int i) const override
413 {
414 return zone_wrapper_input_name(zone_info_, zone_, inputs_, i);
415 }
416
417 std::string output_name(const int i) const override
418 {
419 return zone_wrapper_output_name(zone_info_, zone_, outputs_, i);
420 }
421};
422
424 const bNodeTree &btree,
425 const bke::bNodeTreeZone &zone,
426 ZoneBuildInfo &zone_info,
427 const ZoneBodyFunction &body_fn)
428{
429 return scope.construct<LazyFunctionForRepeatZone>(btree, zone, zone_info, body_fn);
430}
431
432} // namespace blender::nodes
volatile int lock
#define output
const ComputeContextHash & hash() const
constexpr IndexRange()=default
destruct_ptr< T > construct(Args &&...args)
T & construct(Args &&...args)
constexpr int64_t size() const
Definition BLI_span.hh:256
int64_t index_of_try(const Key &key) const
void append(const T &value)
void reinitialize(const int64_t new_size)
Span< T > as_span() const
std::string output_name(const int i) const override
void * init_storage(LinearAllocator<> &allocator) const override
void initialize_execution_graph(lf::Params &params, RepeatEvalStorage &eval_storage, const NodeGeometryRepeatOutput &node_storage, GeoNodesUserData &user_data, GeoNodesLocalUserData &local_user_data) const
LazyFunctionForRepeatZone(const bNodeTree &btree, const bke::bNodeTreeZone &zone, ZoneBuildInfo &zone_info, const ZoneBodyFunction &body_fn)
std::string input_name(const int i) const override
void destruct_storage(void *storage) const override
void execute_impl(lf::Params &params, const lf::Context &context) const override
void execute_node(const lf::FunctionNode &node, lf::Params &params, const lf::Context &context) const override
Vector< const lf::FunctionNode * > get_nodes_with_side_effects(const lf::Context &context) const override
#define storage(slot, qualifiers)
void fill_index_range(MutableSpan< T > span, const T start=0)
void initialize_zone_wrapper(const bNodeTreeZone &zone, ZoneBuildInfo &zone_info, const ZoneBodyFunction &body_fn, const bool expose_all_reference_sets, Vector< lf::Input > &r_inputs, Vector< lf::Output > &r_outputs)
bool should_log_verbose_in_context(const GeoNodesUserData &user_data, const ComputeContextHash hash)
LazyFunction & build_repeat_zone_lazy_function(ResourceScope &scope, const bNodeTree &btree, const bke::bNodeTreeZone &zone, ZoneBuildInfo &zone_info, const ZoneBodyFunction &body_fn)
std::string zone_wrapper_output_name(const ZoneBuildInfo &zone_info, const bNodeTreeZone &zone, const Span< lf::Output > outputs, const int lf_socket_i)
std::string zone_wrapper_input_name(const ZoneBuildInfo &zone_info, const bNodeTreeZone &zone, const Span< lf::Input > inputs, const int lf_socket_i)
void parallel_for(const IndexRange range, const int64_t grain_size, const Function &function, const TaskSizeHints &size_hints=detail::TaskSizeHints_Static(1))
Definition BLI_task.hh:69
T * DEG_get_original(T *id)
const GeoNodesSideEffectNodes * side_effect_nodes
eval_log::NodeTreeLogger * try_get_tree_logger(const GeoNodesUserData &user_data) const
MultiValueMap< std::pair< ComputeContextHash, int32_t >, int > iterations_by_iteration_zone
std::optional< LazyFunctionForLogicalOr > or_function
VectorSet< lf::FunctionNode * > lf_body_nodes
std::optional< lf::GraphExecutor > graph_executor
std::optional< RepeatBodyNodeExecuteWrapper > body_execute_wrapper
std::optional< RepeatZoneSideEffectProvider > side_effect_provider
struct blender::nodes::ZoneFunctionIndices::@342054057300321050315260123310012173322070035365 inputs