Blender V5.3
FN_lazy_function.hh
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2023 Blender Authors
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
5#pragma once
6
42
43#include "BLI_cpp_type.hh"
44#include "BLI_function_ref.hh"
46#include "BLI_vector.hh"
47
48#include "PRF_profile.hh"
49
50#include "FN_user_data.hh"
51
52#ifndef NDEBUG
53# include <atomic>
54# include <thread>
55# define FN_LAZY_FUNCTION_DEBUG_THREADS
56#endif
57
58namespace blender {
60
77
78class LazyFunction;
79
104
109class Params {
110 public:
115#ifdef FN_LAZY_FUNCTION_DEBUG_THREADS
116 std::thread::id main_thread_id_;
117 std::atomic<bool> allow_multi_threading_;
118#endif
119
120 Params(const LazyFunction &fn, bool allow_multi_threading_initially);
121
127 void *try_get_input_data_ptr(int index) const;
128
134
141 void *get_output_data_ptr(int index);
142
147 void output_set(int index);
148
153 bool output_was_set(int index) const;
154
159
164 void set_input_unused(int index);
165
169 template<typename T> T extract_input(int index);
170 template<typename T> T &get_input(int index) const;
171 template<typename T> T *try_get_input_data_ptr(int index) const;
172 template<typename T> T *try_get_input_data_ptr_or_request(int index);
173 template<typename T> void set_output(int index, T &&value);
174
180
181 private:
182 void assert_valid_thread() const;
183
189 virtual void *try_get_input_data_ptr_impl(int index) const = 0;
190 virtual void *try_get_input_data_ptr_or_request_impl(int index) = 0;
191 virtual void *get_output_data_ptr_impl(int index) = 0;
192 virtual void output_set_impl(int index) = 0;
193 virtual bool output_was_set_impl(int index) const = 0;
194 virtual ValueUsage get_output_usage_impl(int index) const = 0;
195 virtual void set_input_unused_impl(int index) = 0;
196 virtual bool try_enable_multi_threading_impl();
197};
198
202struct Input {
207 const char *debug_name;
211 const CPPType *type;
222
225 {
226 }
227};
228
229struct Output {
234 const char *debug_name;
238 const CPPType *type = nullptr;
239
241};
242
248 protected:
249 const char *debug_name_ = "unknown";
256
257 public:
258 virtual ~LazyFunction() = default;
259
265 virtual std::string name() const;
266 virtual std::string input_name(int index) const;
267 virtual std::string output_name(int index) const;
268
273 virtual void *init_storage(LinearAllocator<> &allocator) const;
274
278 virtual void destruct_storage(void *storage) const;
279
284 virtual void possible_output_dependencies(int output_index,
285 FunctionRef<void(Span<int>)> fn) const;
286
290 Span<Input> inputs() const;
294 Span<Output> outputs() const;
295
301 void execute(Params &params, const Context &context) const;
302
306 bool always_used_inputs_available(const Params &params) const;
307
318
319 private:
324 virtual void execute_impl(Params &params, const Context &context) const = 0;
325};
326
327/* -------------------------------------------------------------------- */
330
332{
333 return inputs_;
334}
335
337{
338 return outputs_;
339}
340
341inline void LazyFunction::execute(Params &params, const Context &context) const
342{
346 this->execute_impl(params, context);
347}
348
350
351/* -------------------------------------------------------------------- */
354
356 [[maybe_unused]] bool allow_multi_threading_initially)
357 : fn_(fn)
359 ,
360 main_thread_id_(std::this_thread::get_id()),
361 allow_multi_threading_(allow_multi_threading_initially)
362#endif
363{
364}
365
366inline void *Params::try_get_input_data_ptr(const int index) const
367{
368 BLI_assert(index >= 0 && index < fn_.inputs().size());
369 return this->try_get_input_data_ptr_impl(index);
370}
371
373{
374 BLI_assert(index >= 0 && index < fn_.inputs().size());
375 this->assert_valid_thread();
376 return this->try_get_input_data_ptr_or_request_impl(index);
377}
378
379inline void *Params::get_output_data_ptr(const int index)
380{
381 BLI_assert(index >= 0 && index < fn_.outputs().size());
382 this->assert_valid_thread();
383 return this->get_output_data_ptr_impl(index);
384}
385
386inline void Params::output_set(const int index)
387{
388 BLI_assert(index >= 0 && index < fn_.outputs().size());
389 this->assert_valid_thread();
390 this->output_set_impl(index);
391}
392
393inline bool Params::output_was_set(const int index) const
394{
395 BLI_assert(index >= 0 && index < fn_.outputs().size());
396 return this->output_was_set_impl(index);
397}
398
400{
401 BLI_assert(index >= 0 && index < fn_.outputs().size());
402 return this->get_output_usage_impl(index);
403}
404
405inline void Params::set_input_unused(const int index)
406{
407 BLI_assert(index >= 0 && index < fn_.inputs().size());
408 this->assert_valid_thread();
409 this->set_input_unused_impl(index);
410}
411
412template<typename T> inline T Params::extract_input(const int index)
413{
414 this->assert_valid_thread();
415 void *data = this->try_get_input_data_ptr(index);
416 BLI_assert(data != nullptr);
417 T return_value = std::move(*static_cast<T *>(data));
418 return return_value;
419}
420
421template<typename T> inline T &Params::get_input(const int index) const
422{
423 void *data = this->try_get_input_data_ptr(index);
424 BLI_assert(data != nullptr);
425 return *static_cast<T *>(data);
426}
427
428template<typename T> inline T *Params::try_get_input_data_ptr(const int index) const
429{
430 this->assert_valid_thread();
431 return static_cast<T *>(this->try_get_input_data_ptr(index));
432}
433
434template<typename T> inline T *Params::try_get_input_data_ptr_or_request(const int index)
435{
436 this->assert_valid_thread();
437 return static_cast<T *>(this->try_get_input_data_ptr_or_request(index));
438}
439
440template<typename T> inline void Params::set_output(const int index, T &&value)
441{
442 using DecayT = std::decay_t<T>;
443 this->assert_valid_thread();
444 void *data = this->get_output_data_ptr(index);
445 new (data) DecayT(std::forward<T>(value));
446 this->output_set(index);
447}
448
450{
451 this->assert_valid_thread();
452 const bool success = this->try_enable_multi_threading_impl();
453#ifdef FN_LAZY_FUNCTION_DEBUG_THREADS
454 if (success) {
456 }
457#endif
458 return success;
459}
460
461inline void Params::assert_valid_thread() const
462{
463#ifdef FN_LAZY_FUNCTION_DEBUG_THREADS
465 return;
466 }
467 if (main_thread_id_ != std::this_thread::get_id()) {
469 }
470#endif
471}
472
474
475} // namespace fn::lazy_function
476
477namespace lf = fn::lazy_function;
478
479} // namespace blender
#define FN_LAZY_FUNCTION_DEBUG_THREADS
#define PRF_scope_with_name(ui_name, category)
#define PRF_scope_set_dynamic_name(fmt,...)
#define BLI_assert_unreachable()
virtual void possible_output_dependencies(int output_index, FunctionRef< void(Span< int >)> fn) const
void execute(Params &params, const Context &context) const
bool always_used_inputs_available(const Params &params) const
virtual void destruct_storage(void *storage) const
virtual void * init_storage(LinearAllocator<> &allocator) const
virtual std::string input_name(int index) const
virtual std::string output_name(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
ValueUsage get_output_usage(int index) const
Params(const LazyFunction &fn, bool allow_multi_threading_initially)
#define storage(slot, qualifiers)
#define T
BMesh Iterators.
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
BMesh const char void * data
unsigned char uint8_t
Definition BKE_text.h:79
Context(void *storage, UserData *user_data, LocalUserData *local_user_data)
Input(const char *debug_name, const CPPType &type, const ValueUsage usage=ValueUsage::Used)
Output(const char *debug_name, const CPPType &type)