FN_lazy_function.hh

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2023 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */
 
#pragma once
 
#include "BLI_cpp_type.hh"
#include "BLI_function_ref.hh"
#include "BLI_generic_pointer.hh"
#include "BLI_linear_allocator.hh"
#include "BLI_vector.hh"
 
#include <atomic>
#include <thread>
 
#ifndef NDEBUG
#  define FN_LAZY_FUNCTION_DEBUG_THREADS
#endif
 
namespace blender::fn::lazy_function {
 
enum class ValueUsage : uint8_t {
  Used,
  Maybe,
  Unused,
};
 
class LazyFunction;
 
class LocalUserData {
 public:
  virtual ~LocalUserData() = default;
};
 
class UserData {
 public:
  virtual ~UserData() = default;
 
  virtual destruct_ptr<LocalUserData> get_local(LinearAllocator<> &allocator);
};
 
struct Context {
  void *storage;
  UserData *user_data;
  LocalUserData *local_user_data;
 
  Context(void *storage, UserData *user_data, LocalUserData *local_user_data)
      : storage(storage), user_data(user_data), local_user_data(local_user_data)
  {
  }
};
 
class Params {
 public:
  const LazyFunction &fn_;
#ifdef FN_LAZY_FUNCTION_DEBUG_THREADS
  std::thread::id main_thread_id_;
  std::atomic<bool> allow_multi_threading_;
#endif
 
 public:
  Params(const LazyFunction &fn, bool allow_multi_threading_initially);
 
  void *try_get_input_data_ptr(int index) const;
 
  void *try_get_input_data_ptr_or_request(int index);
 
  void *get_output_data_ptr(int index);
 
  void output_set(int index);
 
  bool output_was_set(int index) const;
 
  ValueUsage get_output_usage(int index) const;
 
  void set_input_unused(int index);
 
  template<typename T> T extract_input(int index);
  template<typename T> T &get_input(int index) const;
  template<typename T> T *try_get_input_data_ptr(int index) const;
  template<typename T> T *try_get_input_data_ptr_or_request(int index);
  template<typename T> void set_output(int index, T &&value);
 
  bool try_enable_multi_threading();
 
 private:
  void assert_valid_thread() const;
 
  virtual void *try_get_input_data_ptr_impl(int index) const = 0;
  virtual void *try_get_input_data_ptr_or_request_impl(int index) = 0;
  virtual void *get_output_data_ptr_impl(int index) = 0;
  virtual void output_set_impl(int index) = 0;
  virtual bool output_was_set_impl(int index) const = 0;
  virtual ValueUsage get_output_usage_impl(int index) const = 0;
  virtual void set_input_unused_impl(int index) = 0;
  virtual bool try_enable_multi_threading_impl();
};
 
struct Input {
  const char *debug_name;
  const CPPType *type;
  ValueUsage usage;
 
  Input(const char *debug_name, const CPPType &type, const ValueUsage usage = ValueUsage::Used)
      : debug_name(debug_name), type(&type), usage(usage)
  {
  }
};
 
struct Output {
  const char *debug_name;
  const CPPType *type = nullptr;
 
  Output(const char *debug_name, const CPPType &type) : debug_name(debug_name), type(&type) {}
};
 
class LazyFunction {
 protected:
  const char *debug_name_ = "unknown";
  Vector<Input> inputs_;
  Vector<Output> outputs_;
  bool allow_missing_requested_inputs_ = false;
 
 public:
  virtual ~LazyFunction() = default;
 
  virtual std::string name() const;
  virtual std::string input_name(int index) const;
  virtual std::string output_name(int index) const;
 
  virtual void *init_storage(LinearAllocator<> &allocator) const;
 
  virtual void destruct_storage(void *storage) const;
 
  virtual void possible_output_dependencies(int output_index,
                                            FunctionRef<void(Span<int>)> fn) const;
 
  Span<Input> inputs() const;
  Span<Output> outputs() const;
 
  void execute(Params &params, const Context &context) const;
 
  bool always_used_inputs_available(const Params &params) const;
 
  bool allow_missing_requested_inputs() const
  {
    return allow_missing_requested_inputs_;
  }
 
 private:
  virtual void execute_impl(Params &params, const Context &context) const = 0;
};
 
/* -------------------------------------------------------------------- */
inline Span<Input> LazyFunction::inputs() const
{
  return inputs_;
}
 
inline Span<Output> LazyFunction::outputs() const
{
  return outputs_;
}
 
inline void LazyFunction::execute(Params &params, const Context &context) const
{
  BLI_assert(this->always_used_inputs_available(params));
  this->execute_impl(params, context);
}
 
/* -------------------------------------------------------------------- */
inline Params::Params(const LazyFunction &fn,
                      [[maybe_unused]] bool allow_multi_threading_initially)
    : fn_(fn)
#ifdef FN_LAZY_FUNCTION_DEBUG_THREADS
      ,
      main_thread_id_(std::this_thread::get_id()),
      allow_multi_threading_(allow_multi_threading_initially)
#endif
{
}
 
inline void *Params::try_get_input_data_ptr(const int index) const
{
  BLI_assert(index >= 0 && index < fn_.inputs().size());
  return this->try_get_input_data_ptr_impl(index);
}
 
inline void *Params::try_get_input_data_ptr_or_request(const int index)
{
  BLI_assert(index >= 0 && index < fn_.inputs().size());
  this->assert_valid_thread();
  return this->try_get_input_data_ptr_or_request_impl(index);
}
 
inline void *Params::get_output_data_ptr(const int index)
{
  BLI_assert(index >= 0 && index < fn_.outputs().size());
  this->assert_valid_thread();
  return this->get_output_data_ptr_impl(index);
}
 
inline void Params::output_set(const int index)
{
  BLI_assert(index >= 0 && index < fn_.outputs().size());
  this->assert_valid_thread();
  this->output_set_impl(index);
}
 
inline bool Params::output_was_set(const int index) const
{
  BLI_assert(index >= 0 && index < fn_.outputs().size());
  return this->output_was_set_impl(index);
}
 
inline ValueUsage Params::get_output_usage(const int index) const
{
  BLI_assert(index >= 0 && index < fn_.outputs().size());
  return this->get_output_usage_impl(index);
}
 
inline void Params::set_input_unused(const int index)
{
  BLI_assert(index >= 0 && index < fn_.inputs().size());
  this->assert_valid_thread();
  this->set_input_unused_impl(index);
}
 
template<typename T> inline T Params::extract_input(const int index)
{
  this->assert_valid_thread();
  void *data = this->try_get_input_data_ptr(index);
  BLI_assert(data != nullptr);
  T return_value = std::move(*static_cast<T *>(data));
  return return_value;
}
 
template<typename T> inline T &Params::get_input(const int index) const
{
  void *data = this->try_get_input_data_ptr(index);
  BLI_assert(data != nullptr);
  return *static_cast<T *>(data);
}
 
template<typename T> inline T *Params::try_get_input_data_ptr(const int index) const
{
  this->assert_valid_thread();
  return static_cast<T *>(this->try_get_input_data_ptr(index));
}
 
template<typename T> inline T *Params::try_get_input_data_ptr_or_request(const int index)
{
  this->assert_valid_thread();
  return static_cast<T *>(this->try_get_input_data_ptr_or_request(index));
}
 
template<typename T> inline void Params::set_output(const int index, T &&value)
{
  using DecayT = std::decay_t<T>;
  this->assert_valid_thread();
  void *data = this->get_output_data_ptr(index);
  new (data) DecayT(std::forward<T>(value));
  this->output_set(index);
}
 
inline bool Params::try_enable_multi_threading()
{
  this->assert_valid_thread();
  const bool success = this->try_enable_multi_threading_impl();
#ifdef FN_LAZY_FUNCTION_DEBUG_THREADS
  if (success) {
    allow_multi_threading_ = true;
  }
#endif
  return success;
}
 
inline void Params::assert_valid_thread() const
{
#ifdef FN_LAZY_FUNCTION_DEBUG_THREADS
  if (allow_multi_threading_) {
    return;
  }
  if (main_thread_id_ != std::this_thread::get_id()) {
    BLI_assert_unreachable();
  }
#endif
}
 
}  // namespace blender::fn::lazy_function
 
namespace blender {
namespace lf = fn::lazy_function;
}