FN_lazy_function_graph_executor.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_vector.hh"
#include "BLI_vector_set.hh"
 
#include "FN_lazy_function_graph.hh"
 
namespace blender::fn::lazy_function {
 
class GraphExecutorLogger {
 public:
  virtual ~GraphExecutorLogger() = default;
 
  virtual void log_socket_value(const Socket &socket,
                                GPointer value,
                                const Context &context) const;
 
  virtual void log_before_node_execute(const FunctionNode &node,
                                       const Params &params,
                                       const Context &context) const;
 
  virtual void log_after_node_execute(const FunctionNode &node,
                                      const Params &params,
                                      const Context &context) const;
 
  virtual void dump_when_outputs_are_missing(const FunctionNode &node,
                                             Span<const OutputSocket *> missing_sockets,
                                             const Context &context) const;
  virtual void dump_when_input_is_set_twice(const InputSocket &target_socket,
                                            const OutputSocket &from_socket,
                                            const Context &context) const;
};
 
class GraphExecutorSideEffectProvider {
 public:
  virtual ~GraphExecutorSideEffectProvider() = default;
  virtual Vector<const FunctionNode *> get_nodes_with_side_effects(const Context &context) const;
};
 
class GraphExecutorNodeExecuteWrapper {
 public:
  virtual ~GraphExecutorNodeExecuteWrapper() = default;
 
  virtual void execute_node(const FunctionNode &node,
                            Params &params,
                            const Context &context) const = 0;
};
 
class GraphExecutor : public LazyFunction {
 public:
  using Logger = GraphExecutorLogger;
  using SideEffectProvider = GraphExecutorSideEffectProvider;
  using NodeExecuteWrapper = GraphExecutorNodeExecuteWrapper;
 
 private:
  const Graph &graph_;
  Vector<const GraphInputSocket *> graph_inputs_;
  Vector<const GraphOutputSocket *> graph_outputs_;
  Array<int> graph_input_index_by_socket_index_;
  Array<int> graph_output_index_by_socket_index_;
  const Logger *logger_;
  const SideEffectProvider *side_effect_provider_;
  const NodeExecuteWrapper *node_execute_wrapper_;
 
  struct {
    int node_states_array_offset;
    int loaded_inputs_array_offset;
    Array<int> node_states_offsets;
    int total_size;
  } init_buffer_info_;
 
  friend class Executor;
 
 public:
  GraphExecutor(const Graph &graph,
                Vector<const GraphInputSocket *> graph_inputs,
                Vector<const GraphOutputSocket *> graph_outputs,
                const Logger *logger,
                const SideEffectProvider *side_effect_provider,
                const NodeExecuteWrapper *node_execute_wrapper);
 
  void *init_storage(LinearAllocator<> &allocator) const override;
  void destruct_storage(void *storage) const override;
 
  std::string input_name(int index) const override;
  std::string output_name(int index) const override;
 
 private:
  void execute_impl(Params &params, const Context &context) const override;
};
 
}  // namespace blender::fn::lazy_function