Geometry Nodes: new evaluation system

This refactors the geometry nodes evaluation system. No changes for the
user are expected. At a high level the goals are:
* Support using geometry nodes outside of the geometry nodes modifier.
* Support using the evaluator infrastructure for other purposes like field evaluation.
* Support more nodes, especially when many of them are disabled behind switch nodes.
* Support doing preprocessing on node groups.

For more details see T98492.

There are fairly detailed comments in the code, but here is a high level overview
for how it works now:
* There is a new "lazy-function" system. It is similar in spirit to the multi-function
  system but with different goals. Instead of optimizing throughput for highly
  parallelizable work, this system is designed to compute only the data that is actually
  necessary. What data is necessary can be determined dynamically during evaluation.
  Many lazy-functions can be composed in a graph to form a new lazy-function, which can
  again be used in a graph etc.
* Each geometry node group is converted into a lazy-function graph prior to evaluation.
  To evaluate geometry nodes, one then just has to evaluate that graph. Node groups are
  no longer inlined into their parents.

Next steps for the evaluation system is to reduce the use of threads in some situations
to avoid overhead. Many small node groups don't benefit from multi-threading at all.
This is much easier to do now because not everything has to be inlined in one huge
node tree anymore.

Differential Revision: https://developer.blender.org/D15914

source/blender/blenkernel/BKE_compute_contexts.hh

@@ -0,0 +1,46 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+
+#pragma once
+
+/**
+ * This file implements some specific compute contexts for concepts in Blender.
+ */
+
+#include "BLI_compute_context.hh"
+
+namespace blender::bke {
+
+class ModifierComputeContext : public ComputeContext {
+ private:
+  static constexpr const char *s_static_type = "MODIFIER";
+
+  /**
+   * Use modifier name instead of something like `session_uuid` for now because:
+   * - It's more obvious that the name matches between the original and evaluated object.
+   * - We might want that the context hash is consistent between sessions in the future.
+   */
+  std::string modifier_name_;
+
+ public:
+  ModifierComputeContext(const ComputeContext *parent, std::string modifier_name);
+
+ private:
+  void print_current_in_line(std::ostream &stream) const override;
+};
+
+class NodeGroupComputeContext : public ComputeContext {
+ private:
+  static constexpr const char *s_static_type = "NODE_GROUP";
+
+  std::string node_name_;
+
+ public:
+  NodeGroupComputeContext(const ComputeContext *parent, std::string node_name);
+
+  StringRefNull node_name() const;
+
+ private:
+  void print_current_in_line(std::ostream &stream) const override;
+};
+
+}  // namespace blender::bke

source/blender/blenkernel/BKE_node_runtime.hh

@@ -21,6 +21,7 @@ struct bNodeType;
 namespace blender::nodes {
 struct FieldInferencingInterface;
 class NodeDeclaration;
+struct GeometryNodesLazyFunctionGraphInfo;
 }  // namespace blender::nodes
 
 namespace blender::bke {
@@ -48,6 +49,15 @@ class bNodeTreeRuntime : NonCopyable, NonMovable {
   /** Information about how inputs and outputs of the node group interact with fields. */
   std::unique_ptr<nodes::FieldInferencingInterface> field_inferencing_interface;
 
+  /**
+   * For geometry nodes, a lazy function graph with some additional info is cached. This is used to
+   * evaluate the node group. Caching it here allows us to reuse the preprocessed node tree in case
+   * its used multiple times.
+   */
+  std::mutex geometry_nodes_lazy_function_graph_info_mutex;
+  std::unique_ptr<nodes::GeometryNodesLazyFunctionGraphInfo>
+      geometry_nodes_lazy_function_graph_info;
+
   /**
    * Protects access to all topology cache variables below. This is necessary so that the cache can
    * be updated on a const #bNodeTree.
@@ -70,6 +80,7 @@ class bNodeTreeRuntime : NonCopyable, NonMovable {
   MultiValueMap<const bNodeType *, bNode *> nodes_by_type;
   Vector<bNode *> toposort_left_to_right;
   Vector<bNode *> toposort_right_to_left;
+  Vector<bNode *> group_nodes;
   bool has_link_cycle = false;
   bool has_undefined_nodes_or_sockets = false;
   bNode *group_output_node = nullptr;
@@ -148,6 +159,12 @@ class bNodeRuntime : NonCopyable, NonMovable {
 
 namespace node_tree_runtime {
 
+/**
+ * Is executed when the depsgraph determines that something in the node group changed that will
+ * affect the output.
+ */
+void handle_node_tree_output_changed(bNodeTree &tree_cow);
+
 class AllowUsingOutdatedInfo : NonCopyable, NonMovable {
  private:
   const bNodeTree &tree_;
@@ -241,6 +258,18 @@ inline blender::Span<bNode *> bNodeTree::all_nodes()
   return this->runtime->nodes;
 }
 
+inline blender::Span<const bNode *> bNodeTree::group_nodes() const
+{
+  BLI_assert(blender::bke::node_tree_runtime::topology_cache_is_available(*this));
+  return this->runtime->group_nodes;
+}
+
+inline blender::Span<bNode *> bNodeTree::group_nodes()
+{
+  BLI_assert(blender::bke::node_tree_runtime::topology_cache_is_available(*this));
+  return this->runtime->group_nodes;
+}
+
 inline bool bNodeTree::has_link_cycle() const
 {
   BLI_assert(blender::bke::node_tree_runtime::topology_cache_is_available(*this));
@@ -413,7 +442,6 @@ inline blender::Span<const bNodeLink *> bNode::internal_links_span() const
 
 inline const blender::nodes::NodeDeclaration *bNode::declaration() const
 {
-  BLI_assert(this->runtime->declaration != nullptr);
   return this->runtime->declaration;
 }
 

source/blender/blenkernel/CMakeLists.txt

@@ -98,6 +98,7 @@ set(SRC
   intern/collision.c
   intern/colorband.c
   intern/colortools.c
+  intern/compute_contexts.cc
   intern/constraint.c
   intern/context.c
   intern/crazyspace.cc
@@ -352,6 +353,7 @@ set(SRC
   BKE_collision.h
   BKE_colorband.h
   BKE_colortools.h
+  BKE_compute_contexts.hh
   BKE_constraint.h
   BKE_context.h
   BKE_crazyspace.h

source/blender/blenkernel/intern/compute_contexts.cc

@@ -0,0 +1,38 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+
+#include "BKE_compute_contexts.hh"
+
+namespace blender::bke {
+
+ModifierComputeContext::ModifierComputeContext(const ComputeContext *parent,
+                                               std::string modifier_name)
+    : ComputeContext(s_static_type, parent), modifier_name_(std::move(modifier_name))
+{
+  hash_.mix_in(s_static_type, strlen(s_static_type));
+  hash_.mix_in(modifier_name_.data(), modifier_name_.size());
+}
+
+void ModifierComputeContext::print_current_in_line(std::ostream &stream) const
+{
+  stream << "Modifier: " << modifier_name_;
+}
+
+NodeGroupComputeContext::NodeGroupComputeContext(const ComputeContext *parent,
+                                                 std::string node_name)
+    : ComputeContext(s_static_type, parent), node_name_(std::move(node_name))
+{
+  hash_.mix_in(s_static_type, strlen(s_static_type));
+  hash_.mix_in(node_name_.data(), node_name_.size());
+}
+
+StringRefNull NodeGroupComputeContext::node_name() const
+{
+  return node_name_;
+}
+
+void NodeGroupComputeContext::print_current_in_line(std::ostream &stream) const
+{
+  stream << "Node: " << node_name_;
+}
+
+}  // namespace blender::bke

source/blender/blenkernel/intern/node.cc

@@ -71,6 +71,7 @@
 #include "NOD_composite.h"
 #include "NOD_function.h"
 #include "NOD_geometry.h"
+#include "NOD_geometry_nodes_lazy_function.hh"
 #include "NOD_node_declaration.hh"
 #include "NOD_shader.h"
 #include "NOD_socket.h"

source/blender/blenkernel/intern/node_runtime.cc

@@ -10,8 +10,22 @@
 #include "BLI_task.hh"
 #include "BLI_timeit.hh"
 
+#include "NOD_geometry_nodes_lazy_function.hh"
+
 namespace blender::bke::node_tree_runtime {
 
+void handle_node_tree_output_changed(bNodeTree &tree_cow)
+{
+  if (tree_cow.type == NTREE_GEOMETRY) {
+    /* Rebuild geometry nodes lazy function graph. */
+    {
+      std::lock_guard lock{tree_cow.runtime->geometry_nodes_lazy_function_graph_info_mutex};
+      tree_cow.runtime->geometry_nodes_lazy_function_graph_info.reset();
+    }
+    blender::nodes::ensure_geometry_nodes_lazy_function_graph(tree_cow);
+  }
+}
+
 static void double_checked_lock(std::mutex &mutex, bool &data_is_dirty, FunctionRef<void()> fn)
 {
   if (!data_is_dirty) {
@@ -36,11 +50,15 @@ static void update_node_vector(const bNodeTree &ntree)
 {
   bNodeTreeRuntime &tree_runtime = *ntree.runtime;
   tree_runtime.nodes.clear();
+  tree_runtime.group_nodes.clear();
   tree_runtime.has_undefined_nodes_or_sockets = false;
   LISTBASE_FOREACH (bNode *, node, &ntree.nodes) {
     node->runtime->index_in_tree = tree_runtime.nodes.append_and_get_index(node);
     node->runtime->owner_tree = const_cast<bNodeTree *>(&ntree);
     tree_runtime.has_undefined_nodes_or_sockets |= node->typeinfo == &NodeTypeUndefined;
+    if (node->is_group()) {
+      tree_runtime.group_nodes.append(node);
+    }
   }
 }
 

source/blender/blenlib/BLI_compute_context.hh

@@ -0,0 +1,173 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+
+#pragma once
+
+/** \file
+ * \ingroup bli
+ *
+ * When logging computed values, we generally want to know where the value was computed. For
+ * example, geometry nodes logs socket values so that they can be displayed in the ui. For that we
+ * can combine the logged value with a `ComputeContext`, which identifies the place where the value
+ * was computed.
+ *
+ * This is not a trivial problem because e.g. just storing storing a pointer to the socket a value
+ * belongs to is not enough. That's because the same socket may correspond to many different values
+ * when the socket is used in a node group that is used multiple times. In this case, not only does
+ * the socket have to be stored but also the entire nested node group path that led to the
+ * evaluation of the socket.
+ *
+ * Storing the entire "context path" for every logged value is not feasible, because that path can
+ * become quite long. So that would need much more memory, more compute overhead and makes it
+ * complicated to compare if two contexts are the same. If the identifier for a compute context
+ * would have a variable size, it would also be much harder to create a map from context to values.
+ *
+ * The solution implemented below uses the following key ideas:
+ * - Every compute context can be hashed to a unique fixed size value (`ComputeContextHash`). While
+ *   technically there could be hash collisions, the hashing algorithm has to be chosen to make
+ *   that practically impossible. This way an entire context path, possibly consisting of many
+ *   nested contexts, is represented by a single value that can be stored easily.
+ * - A nested compute context is build as singly linked list, where every compute context has a
+ *   pointer to the parent compute context. Note that a link in the other direction is not possible
+ *   because the same parent compute context may be used by many different children which possibly
+ *   run on different threads.
+ */
+
+#include "BLI_array.hh"
+#include "BLI_linear_allocator.hh"
+#include "BLI_stack.hh"
+#include "BLI_string_ref.hh"
+
+namespace blender {
+
+/**
+ * A hash that uniquely identifies a specific (non-fixed-size) compute context. The hash has to
+ * have enough bits to make collisions practically impossible.
+ */
+struct ComputeContextHash {
+  static constexpr int64_t HashSizeInBytes = 16;
+  uint64_t v1 = 0;
+  uint64_t v2 = 0;
+
+  uint64_t hash() const
+  {
+    return v1;
+  }
+
+  friend bool operator==(const ComputeContextHash &a, const ComputeContextHash &b)
+  {
+    return a.v1 == b.v1 && a.v2 == b.v2;
+  }
+
+  void mix_in(const void *data, int64_t len);
+
+  friend std::ostream &operator<<(std::ostream &stream, const ComputeContextHash &hash);
+};
+
+static_assert(sizeof(ComputeContextHash) == ComputeContextHash::HashSizeInBytes);
+
+/**
+ * Identifies the context in which a computation happens. This context can be used to identify
+ * values logged during the computation. For more details, see the comment at the top of the file.
+ *
+ * This class should be subclassed to implement specific contexts.
+ */
+class ComputeContext {
+ private:
+  /**
+   * Only used for debugging currently.
+   */
+  const char *static_type_;
+  /**
+   * Pointer to the context that this context is child of. That allows nesting compute contexts.
+   */
+  const ComputeContext *parent_ = nullptr;
+
+ protected:
+  /**
+   * The hash that uniquely identifies this context. It's a combined hash of this context as well
+   * as all the parent contexts.
+   */
+  ComputeContextHash hash_;
+
+ public:
+  ComputeContext(const char *static_type, const ComputeContext *parent)
+      : static_type_(static_type), parent_(parent)
+  {
+    if (parent != nullptr) {
+      hash_ = parent_->hash_;
+    }
+  }
+  virtual ~ComputeContext() = default;
+
+  const ComputeContextHash &hash() const
+  {
+    return hash_;
+  }
+
+  const char *static_type() const
+  {
+    return static_type_;
+  }
+
+  const ComputeContext *parent() const
+  {
+    return parent_;
+  }
+
+  /**
+   * Print the entire nested context stack.
+   */
+  void print_stack(std::ostream &stream, StringRef name) const;
+
+  /**
+   * Print information about this specific context. This has to be implemented by each subclass.
+   */
+  virtual void print_current_in_line(std::ostream &stream) const = 0;
+
+  friend std::ostream &operator<<(std::ostream &stream, const ComputeContext &compute_context);
+};
+
+/**
+ * Utility class to build a context stack in one place. This is typically used to get the hash that
+ * corresponds to a specific nested compute context, in order to look up corresponding logged
+ * values.
+ */
+class ComputeContextBuilder {
+ private:
+  LinearAllocator<> allocator_;
+  Stack<destruct_ptr<ComputeContext>> contexts_;
+
+ public:
+  bool is_empty() const
+  {
+    return contexts_.is_empty();
+  }
+
+  const ComputeContext *current() const
+  {
+    if (contexts_.is_empty()) {
+      return nullptr;
+    }
+    return contexts_.peek().get();
+  }
+
+  const ComputeContextHash hash() const
+  {
+    BLI_assert(!contexts_.is_empty());
+    return this->current()->hash();
+  }
+
+  template<typename T, typename... Args> void push(Args &&...args)
+  {
+    const ComputeContext *current = this->current();
+    destruct_ptr<T> context = allocator_.construct<T>(current, std::forward<Args>(args)...);
+    contexts_.push(std::move(context));
+  }
+
+  void pop()
+  {
+    contexts_.pop();
+  }
+};
+
+}  // namespace blender

source/blender/blenlib/BLI_multi_value_map.hh

@@ -114,6 +114,14 @@ template<typename Key, typename Value> class MultiValueMap {
     return {};
   }
 
+  /**
+   * Get the number of keys.
+   */
+  int64_t size() const
+  {
+    return map_.size();
+  }
+
   /**
    * NOTE: This signature will change when the implementation changes.
    */

source/blender/blenlib/CMakeLists.txt

@@ -53,6 +53,7 @@ set(SRC
   intern/bitmap_draw_2d.c
   intern/boxpack_2d.c
   intern/buffer.c
+  intern/compute_context.cc
   intern/convexhull_2d.c
   intern/cpp_type.cc
   intern/delaunay_2d.cc
@@ -180,6 +181,7 @@ set(SRC
   BLI_compiler_attrs.h
   BLI_compiler_compat.h
   BLI_compiler_typecheck.h
+  BLI_compute_context.hh
   BLI_console.h
   BLI_convexhull_2d.h
   BLI_cpp_type.hh

source/blender/blenlib/intern/compute_context.cc

@@ -0,0 +1,48 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+
+#include "BLI_compute_context.hh"
+#include "BLI_hash_md5.h"
+
+namespace blender {
+
+void ComputeContextHash::mix_in(const void *data, int64_t len)
+{
+  DynamicStackBuffer<> buffer_owner(HashSizeInBytes + len, 8);
+  char *buffer = static_cast<char *>(buffer_owner.buffer());
+  memcpy(buffer, this, HashSizeInBytes);
+  memcpy(buffer + HashSizeInBytes, data, len);
+
+  BLI_hash_md5_buffer(buffer, HashSizeInBytes + len, this);
+}
+
+std::ostream &operator<<(std::ostream &stream, const ComputeContextHash &hash)
+{
+  std::stringstream ss;
+  ss << "0x" << std::hex << hash.v1 << hash.v2;
+  stream << ss.str();
+  return stream;
+}
+
+void ComputeContext::print_stack(std::ostream &stream, StringRef name) const
+{
+  Stack<const ComputeContext *> stack;
+  for (const ComputeContext *current = this; current; current = current->parent_) {
+    stack.push(current);
+  }
+  stream << "Context Stack: " << name << "\n";
+  while (!stack.is_empty()) {
+    const ComputeContext *current = stack.pop();
+    stream << "-> ";
+    current->print_current_in_line(stream);
+    const ComputeContextHash &current_hash = current->hash_;
+    stream << " \t(hash: " << current_hash << ")\n";
+  }
+}
+
+std::ostream &operator<<(std::ostream &stream, const ComputeContext &compute_context)
+{
+  compute_context.print_stack(stream, "");
+  return stream;
+}
+
+}  // namespace blender

source/blender/blenlib/intern/cpp_type.cc

@@ -26,3 +26,4 @@ BLI_CPP_TYPE_MAKE(ColorGeometry4f, blender::ColorGeometry4f, CPPTypeFlags::Basic
 BLI_CPP_TYPE_MAKE(ColorGeometry4b, blender::ColorGeometry4b, CPPTypeFlags::BasicType)
 
 BLI_CPP_TYPE_MAKE(string, std::string, CPPTypeFlags::BasicType)
+BLI_CPP_TYPE_MAKE(StringVector, blender::Vector<std::string>, CPPTypeFlags::None)

source/blender/depsgraph/intern/builder/deg_builder_nodes.cc

@@ -1741,7 +1741,14 @@ void DepsgraphNodeBuilder::build_nodetree(bNodeTree *ntree)
   /* Animation, */
   build_animdata(&ntree->id);
   /* Output update. */
-  add_operation_node(&ntree->id, NodeType::NTREE_OUTPUT, OperationCode::NTREE_OUTPUT);
+  ID *id_cow = get_cow_id(&ntree->id);
+  add_operation_node(&ntree->id,
+                     NodeType::NTREE_OUTPUT,
+                     OperationCode::NTREE_OUTPUT,
+                     [id_cow](::Depsgraph * /*depsgraph*/) {
+                       bNodeTree *ntree_cow = reinterpret_cast<bNodeTree *>(id_cow);
+                       bke::node_tree_runtime::handle_node_tree_output_changed(*ntree_cow);
+                     });
   /* nodetree's nodes... */
   LISTBASE_FOREACH (bNode *, bnode, &ntree->nodes) {
     build_idproperties(bnode->prop);

source/blender/editors/include/UI_interface.hh

@@ -13,7 +13,7 @@
 
 #include "UI_resources.h"
 
-namespace blender::nodes::geometry_nodes_eval_log {
+namespace blender::nodes::geo_eval_log {
 struct GeometryAttributeInfo;
 }
 
@@ -44,12 +44,11 @@ void context_path_add_generic(Vector<ContextPathItem> &path,
 
 void template_breadcrumbs(uiLayout &layout, Span<ContextPathItem> context_path);
 
-void attribute_search_add_items(
-    StringRefNull str,
-    bool can_create_attribute,
-    Span<const nodes::geometry_nodes_eval_log::GeometryAttributeInfo *> infos,
-    uiSearchItems *items,
-    bool is_first);
+void attribute_search_add_items(StringRefNull str,
+                                bool can_create_attribute,
+                                Span<const nodes::geo_eval_log::GeometryAttributeInfo *> infos,
+                                uiSearchItems *items,
+                                bool is_first);
 
 }  // namespace blender::ui
 

source/blender/editors/interface/interface_template_attribute_search.cc

@@ -14,13 +14,15 @@
 
 #include "BLT_translation.h"
 
-#include "NOD_geometry_nodes_eval_log.hh"
+#include "BKE_attribute.hh"
+
+#include "NOD_geometry_nodes_log.hh"
 
 #include "UI_interface.h"
 #include "UI_interface.hh"
 #include "UI_resources.h"
 
-using blender::nodes::geometry_nodes_eval_log::GeometryAttributeInfo;
+using blender::nodes::geo_eval_log::GeometryAttributeInfo;
 
 namespace blender::ui {
 

source/blender/editors/space_node/node_draw.cc

@@ -13,6 +13,7 @@
 #include "DNA_light_types.h"
 #include "DNA_linestyle_types.h"
 #include "DNA_material_types.h"
+#include "DNA_modifier_types.h"
 #include "DNA_node_types.h"
 #include "DNA_screen_types.h"
 #include "DNA_space_types.h"
@@ -29,11 +30,13 @@
 
 #include "BLT_translation.h"
 
+#include "BKE_compute_contexts.hh"
 #include "BKE_context.h"
 #include "BKE_idtype.h"
 #include "BKE_lib_id.h"
 #include "BKE_main.h"
 #include "BKE_node.h"
+#include "BKE_node_runtime.hh"
 #include "BKE_node_tree_update.h"
 #include "BKE_object.h"
 
@@ -65,7 +68,8 @@
 #include "RNA_access.h"
 #include "RNA_prototypes.h"
 
-#include "NOD_geometry_nodes_eval_log.hh"
+#include "NOD_geometry_exec.hh"
+#include "NOD_geometry_nodes_log.hh"
 #include "NOD_node_declaration.hh"
 #include "NOD_socket_declarations_geometry.hh"
 
@@ -74,10 +78,11 @@
 
 #include "node_intern.hh" /* own include */
 
+namespace geo_log = blender::nodes::geo_eval_log;
+
 using blender::GPointer;
+using blender::Vector;
 using blender::fn::GField;
-namespace geo_log = blender::nodes::geometry_nodes_eval_log;
-using geo_log::eNamedAttrUsage;
 
 extern "C" {
 /* XXX interface.h */
@@ -85,6 +90,17 @@ extern void ui_draw_dropshadow(
     const rctf *rct, float radius, float aspect, float alpha, int select);
 }
 
+/**
+ * This is passed to many functions which draw the node editor.
+ */
+struct TreeDrawContext {
+  /**
+   * Geometry nodes logs various data during execution. The logged data that corresponds to the
+   * currently drawn node tree can be retrieved from the log below.
+   */
+  geo_log::GeoTreeLog *geo_tree_log = nullptr;
+};
+
 float ED_node_grid_size()
 {
   return U.widget_unit;
@@ -157,6 +173,12 @@ void ED_node_tag_update_id(ID *id)
 
 namespace blender::ed::space_node {
 
+static void node_socket_add_tooltip_in_node_editor(TreeDrawContext * /*tree_draw_ctx*/,
+                                                   const bNodeTree *ntree,
+                                                   const bNode *node,
+                                                   const bNodeSocket *sock,
+                                                   uiLayout *layout);
+
 static bool compare_nodes(const bNode *a, const bNode *b)
 {
   /* These tell if either the node or any of the parent nodes is selected.
@@ -313,7 +335,11 @@ float2 node_from_view(const bNode &node, const float2 &co)
 /**
  * Based on settings and sockets in node, set drawing rect info.
  */
-static void node_update_basis(const bContext &C, bNodeTree &ntree, bNode &node, uiBlock &block)
+static void node_update_basis(const bContext &C,
+                              TreeDrawContext &tree_draw_ctx,
+                              bNodeTree &ntree,
+                              bNode &node,
+                              uiBlock &block)
 {
   PointerRNA nodeptr;
   RNA_pointer_create(&ntree.id, &RNA_Node, &node, &nodeptr);
@@ -374,7 +400,7 @@ static void node_update_basis(const bContext &C, bNodeTree &ntree, bNode &node,
     const char *socket_label = nodeSocketLabel(socket);
     socket->typeinfo->draw((bContext *)&C, row, &sockptr, &nodeptr, IFACE_(socket_label));
 
-    node_socket_add_tooltip(ntree, node, *socket, *row);
+    node_socket_add_tooltip_in_node_editor(&tree_draw_ctx, &ntree, &node, socket, row);
 
     UI_block_align_end(&block);
     UI_block_layout_resolve(&block, nullptr, &buty);
@@ -506,7 +532,7 @@ static void node_update_basis(const bContext &C, bNodeTree &ntree, bNode &node,
     const char *socket_label = nodeSocketLabel(socket);
     socket->typeinfo->draw((bContext *)&C, row, &sockptr, &nodeptr, IFACE_(socket_label));
 
-    node_socket_add_tooltip(ntree, node, *socket, *row);
+    node_socket_add_tooltip_in_node_editor(&tree_draw_ctx, &ntree, &node, socket, row);
 
     UI_block_align_end(&block);
     UI_block_layout_resolve(&block, nullptr, &buty);
@@ -823,25 +849,16 @@ static void create_inspection_string_for_generic_value(const GPointer value, std
   }
 }
 
-static void create_inspection_string_for_gfield(const geo_log::GFieldValueLog &value_log,
-                                                std::stringstream &ss)
+static void create_inspection_string_for_field_info(const geo_log::FieldInfoLog &value_log,
+                                                    std::stringstream &ss)
 {
-  const CPPType &type = value_log.type();
-  const GField &field = value_log.field();
-  const Span<std::string> input_tooltips = value_log.input_tooltips();
+  const CPPType &type = value_log.type;
+  const Span<std::string> input_tooltips = value_log.input_tooltips;
 
   if (input_tooltips.is_empty()) {
-    if (field) {
-      BUFFER_FOR_CPP_TYPE_VALUE(type, buffer);
-      blender::fn::evaluate_constant_field(field, buffer);
-      create_inspection_string_for_generic_value({type, buffer}, ss);
-      type.destruct(buffer);
-    }
-    else {
-      /* Constant values should always be logged. */
-      BLI_assert_unreachable();
-      ss << "Value has not been logged";
-    }
+    /* Should have been logged as constant value. */
+    BLI_assert_unreachable();
+    ss << "Value has not been logged";
   }
   else {
     if (type.is<int>()) {
@@ -874,11 +891,11 @@ static void create_inspection_string_for_gfield(const geo_log::GFieldValueLog &v
   }
 }
 
-static void create_inspection_string_for_geometry(const geo_log::GeometryValueLog &value_log,
-                                                  std::stringstream &ss,
-                                                  const nodes::decl::Geometry *geometry)
+static void create_inspection_string_for_geometry_info(const geo_log::GeometryInfoLog &value_log,
+                                                       std::stringstream &ss,
+                                                       const nodes::decl::Geometry *socket_decl)
 {
-  Span<GeometryComponentType> component_types = value_log.component_types();
+  Span<GeometryComponentType> component_types = value_log.component_types;
   if (component_types.is_empty()) {
     ss << TIP_("Empty Geometry");
     return;
@@ -895,7 +912,7 @@ static void create_inspection_string_for_geometry(const geo_log::GeometryValueLo
     const char *line_end = (type == component_types.last()) ? "" : ".\n";
     switch (type) {
       case GEO_COMPONENT_TYPE_MESH: {
-        const geo_log::GeometryValueLog::MeshInfo &mesh_info = *value_log.mesh_info;
+        const geo_log::GeometryInfoLog::MeshInfo &mesh_info = *value_log.mesh_info;
         char line[256];
         BLI_snprintf(line,
                      sizeof(line),
@@ -907,7 +924,7 @@ static void create_inspection_string_for_geometry(const geo_log::GeometryValueLo
         break;
       }
       case GEO_COMPONENT_TYPE_POINT_CLOUD: {
-        const geo_log::GeometryValueLog::PointCloudInfo &pointcloud_info =
+        const geo_log::GeometryInfoLog::PointCloudInfo &pointcloud_info =
             *value_log.pointcloud_info;
         char line[256];
         BLI_snprintf(line,
@@ -918,7 +935,7 @@ static void create_inspection_string_for_geometry(const geo_log::GeometryValueLo
         break;
       }
       case GEO_COMPONENT_TYPE_CURVE: {
-        const geo_log::GeometryValueLog::CurveInfo &curve_info = *value_log.curve_info;
+        const geo_log::GeometryInfoLog::CurveInfo &curve_info = *value_log.curve_info;
         char line[256];
         BLI_snprintf(line,
                      sizeof(line),
@@ -928,7 +945,7 @@ static void create_inspection_string_for_geometry(const geo_log::GeometryValueLo
         break;
       }
       case GEO_COMPONENT_TYPE_INSTANCES: {
-        const geo_log::GeometryValueLog::InstancesInfo &instances_info = *value_log.instances_info;
+        const geo_log::GeometryInfoLog::InstancesInfo &instances_info = *value_log.instances_info;
         char line[256];
         BLI_snprintf(line,
                      sizeof(line),
@@ -943,7 +960,7 @@ static void create_inspection_string_for_geometry(const geo_log::GeometryValueLo
       }
       case GEO_COMPONENT_TYPE_EDIT: {
         if (value_log.edit_data_info.has_value()) {
-          const geo_log::GeometryValueLog::EditDataInfo &edit_info = *value_log.edit_data_info;
+          const geo_log::GeometryInfoLog::EditDataInfo &edit_info = *value_log.edit_data_info;
           char line[256];
           BLI_snprintf(line,
                        sizeof(line),
@@ -959,11 +976,11 @@ static void create_inspection_string_for_geometry(const geo_log::GeometryValueLo
 
   /* If the geometry declaration is null, as is the case for input to group output,
    * or it is an output socket don't show supported types. */
-  if (geometry == nullptr || geometry->in_out() == SOCK_OUT) {
+  if (socket_decl == nullptr || socket_decl->in_out() == SOCK_OUT) {
     return;
   }
 
-  Span<GeometryComponentType> supported_types = geometry->supported_types();
+  Span<GeometryComponentType> supported_types = socket_decl->supported_types();
   if (supported_types.is_empty()) {
     ss << ".\n\n" << TIP_("Supported: All Types");
     return;
@@ -1000,43 +1017,37 @@ static void create_inspection_string_for_geometry(const geo_log::GeometryValueLo
   }
 }
 
-static std::optional<std::string> create_socket_inspection_string(const bContext &C,
-                                                                  const bNode &node,
+static std::optional<std::string> create_socket_inspection_string(TreeDrawContext &tree_draw_ctx,
                                                                   const bNodeSocket &socket)
 {
-  const SpaceNode *snode = CTX_wm_space_node(&C);
-  if (snode == nullptr) {
-    return {};
-  };
-
-  const geo_log::SocketLog *socket_log = geo_log::ModifierLog::find_socket_by_node_editor_context(
-      *snode, node, socket);
-  if (socket_log == nullptr) {
-    return {};
-  }
-  const geo_log::ValueLog *value_log = socket_log->value();
+  using namespace blender::nodes::geo_eval_log;
+  tree_draw_ctx.geo_tree_log->ensure_socket_values();
+  ValueLog *value_log = tree_draw_ctx.geo_tree_log->find_socket_value_log(socket);
   if (value_log == nullptr) {
-    return {};
+    return std::nullopt;
   }
-
   std::stringstream ss;
   if (const geo_log::GenericValueLog *generic_value_log =
           dynamic_cast<const geo_log::GenericValueLog *>(value_log)) {
-    create_inspection_string_for_generic_value(generic_value_log->value(), ss);
+    create_inspection_string_for_generic_value(generic_value_log->value, ss);
   }
-  if (const geo_log::GFieldValueLog *gfield_value_log =
-          dynamic_cast<const geo_log::GFieldValueLog *>(value_log)) {
-    create_inspection_string_for_gfield(*gfield_value_log, ss);
+  else if (const geo_log::FieldInfoLog *gfield_value_log =
+               dynamic_cast<const geo_log::FieldInfoLog *>(value_log)) {
+    create_inspection_string_for_field_info(*gfield_value_log, ss);
   }
-  else if (const geo_log::GeometryValueLog *geo_value_log =
-               dynamic_cast<const geo_log::GeometryValueLog *>(value_log)) {
-    create_inspection_string_for_geometry(
+  else if (const geo_log::GeometryInfoLog *geo_value_log =
+               dynamic_cast<const geo_log::GeometryInfoLog *>(value_log)) {
+    create_inspection_string_for_geometry_info(
         *geo_value_log,
         ss,
         dynamic_cast<const nodes::decl::Geometry *>(socket.runtime->declaration));
   }
 
-  return ss.str();
+  std::string str = ss.str();
+  if (str.empty()) {
+    return std::nullopt;
+  }
+  return str;
 }
 
 static bool node_socket_has_tooltip(const bNodeTree &ntree, const bNodeSocket &socket)
@@ -1046,34 +1057,42 @@ static bool node_socket_has_tooltip(const bNodeTree &ntree, const bNodeSocket &s
   }
 
   if (socket.runtime->declaration != nullptr) {
-    const blender::nodes::SocketDeclaration &socket_decl = *socket.runtime->declaration;
+    const nodes::SocketDeclaration &socket_decl = *socket.runtime->declaration;
     return !socket_decl.description().is_empty();
   }
 
   return false;
 }
 
-static char *node_socket_get_tooltip(const bContext &C,
-                                     const bNodeTree &ntree,
-                                     const bNode &node,
-                                     const bNodeSocket &socket)
+static char *node_socket_get_tooltip(const bContext *C,
+                                     const bNodeTree *ntree,
+                                     const bNode *UNUSED(node),
+                                     const bNodeSocket *socket)
 {
+  SpaceNode *snode = CTX_wm_space_node(C);
+  TreeDrawContext tree_draw_ctx;
+  if (snode != nullptr) {
+    if (ntree->type == NTREE_GEOMETRY) {
+      tree_draw_ctx.geo_tree_log = geo_log::GeoModifierLog::get_tree_log_for_node_editor(*snode);
+    }
+  }
+
   std::stringstream output;
-  if (socket.runtime->declaration != nullptr) {
-    const blender::nodes::SocketDeclaration &socket_decl = *socket.runtime->declaration;
+  if (socket->runtime->declaration != nullptr) {
+    const blender::nodes::SocketDeclaration &socket_decl = *socket->runtime->declaration;
     blender::StringRef description = socket_decl.description();
     if (!description.is_empty()) {
       output << TIP_(description.data());
     }
   }
 
-  if (ntree.type == NTREE_GEOMETRY) {
+  if (ntree->type == NTREE_GEOMETRY && tree_draw_ctx.geo_tree_log != nullptr) {
     if (!output.str().empty()) {
       output << ".\n\n";
     }
 
     std::optional<std::string> socket_inspection_str = create_socket_inspection_string(
-        C, node, socket);
+        tree_draw_ctx, *socket);
     if (socket_inspection_str.has_value()) {
       output << *socket_inspection_str;
     }
@@ -1083,35 +1102,44 @@ static char *node_socket_get_tooltip(const bContext &C,
   }
 
   if (output.str().empty()) {
-    output << nodeSocketLabel(&socket);
+    output << nodeSocketLabel(socket);
   }
 
   return BLI_strdup(output.str().c_str());
 }
 
+static void node_socket_add_tooltip_in_node_editor(TreeDrawContext *UNUSED(tree_draw_ctx),
+                                                   const bNodeTree *ntree,
+                                                   const bNode *node,
+                                                   const bNodeSocket *sock,
+                                                   uiLayout *layout)
+{
+  if (!node_socket_has_tooltip(*ntree, *sock)) {
+    return;
+  }
+
+  SocketTooltipData *data = MEM_cnew<SocketTooltipData>(__func__);
+  data->ntree = ntree;
+  data->node = node;
+  data->socket = sock;
+
+  uiLayoutSetTooltipFunc(
+      layout,
+      [](bContext *C, void *argN, const char *UNUSED(tip)) {
+        SocketTooltipData *data = static_cast<SocketTooltipData *>(argN);
+        return node_socket_get_tooltip(C, data->ntree, data->node, data->socket);
+      },
+      data,
+      MEM_dupallocN,
+      MEM_freeN);
+}
+
 void node_socket_add_tooltip(const bNodeTree &ntree,
                              const bNode &node,
                              const bNodeSocket &sock,
                              uiLayout &layout)
 {
-  if (!node_socket_has_tooltip(ntree, sock)) {
-    return;
-  }
-
-  SocketTooltipData *data = MEM_new<SocketTooltipData>(__func__);
-  data->ntree = &ntree;
-  data->node = &node;
-  data->socket = &sock;
-
-  uiLayoutSetTooltipFunc(
-      &layout,
-      [](bContext *C, void *argN, const char *UNUSED(tip)) {
-        const SocketTooltipData *data = static_cast<SocketTooltipData *>(argN);
-        return node_socket_get_tooltip(*C, *data->ntree, *data->node, *data->socket);
-      },
-      data,
-      MEM_dupallocN,
-      MEM_freeN);
+  node_socket_add_tooltip_in_node_editor(nullptr, &ntree, &node, &sock, &layout);
 }
 
 static void node_socket_draw_nested(const bContext &C,
@@ -1178,7 +1206,7 @@ static void node_socket_draw_nested(const bContext &C,
       but,
       [](bContext *C, void *argN, const char *UNUSED(tip)) {
         SocketTooltipData *data = (SocketTooltipData *)argN;
-        return node_socket_get_tooltip(*C, *data->ntree, *data->node, *data->socket);
+        return node_socket_get_tooltip(C, data->ntree, data->node, data->socket);
       },
       data,
       MEM_freeN);
@@ -1607,27 +1635,26 @@ static char *node_errors_tooltip_fn(bContext *UNUSED(C), void *argN, const char
 
 #define NODE_HEADER_ICON_SIZE (0.8f * U.widget_unit)
 
-static void node_add_error_message_button(
-    const bContext &C, bNode &node, uiBlock &block, const rctf &rect, float &icon_offset)
+static void node_add_error_message_button(TreeDrawContext &tree_draw_ctx,
+                                          bNode &node,
+                                          uiBlock &block,
+                                          const rctf &rect,
+                                          float &icon_offset)
 {
-  SpaceNode *snode = CTX_wm_space_node(&C);
-  const geo_log::NodeLog *node_log = geo_log::ModifierLog::find_node_by_node_editor_context(*snode,
-                                                                                            node);
-  if (node_log == nullptr) {
-    return;
+  Span<geo_log::NodeWarning> warnings;
+  if (tree_draw_ctx.geo_tree_log) {
+    geo_log::GeoNodeLog *node_log = tree_draw_ctx.geo_tree_log->nodes.lookup_ptr(node.name);
+    if (node_log != nullptr) {
+      warnings = node_log->warnings;
+    }
   }
-
-  Span<geo_log::NodeWarning> warnings = node_log->warnings();
-
   if (warnings.is_empty()) {
     return;
   }
 
-  NodeErrorsTooltipData *tooltip_data = (NodeErrorsTooltipData *)MEM_mallocN(
-      sizeof(NodeErrorsTooltipData), __func__);
-  tooltip_data->warnings = warnings;
-
   const geo_log::NodeWarningType display_type = node_error_highest_priority(warnings);
+  NodeErrorsTooltipData *tooltip_data = MEM_new<NodeErrorsTooltipData>(__func__);
+  tooltip_data->warnings = warnings;
 
   icon_offset -= NODE_HEADER_ICON_SIZE;
   UI_block_emboss_set(&block, UI_EMBOSS_NONE);
@@ -1645,90 +1672,70 @@ static void node_add_error_message_button(
                             0,
                             0,
                             nullptr);
-  UI_but_func_tooltip_set(but, node_errors_tooltip_fn, tooltip_data, MEM_freeN);
+  UI_but_func_tooltip_set(but, node_errors_tooltip_fn, tooltip_data, [](void *arg) {
+    MEM_delete(static_cast<NodeErrorsTooltipData *>(arg));
+  });
   UI_block_emboss_set(&block, UI_EMBOSS);
 }
 
-static void get_exec_time_other_nodes(const bNode &node,
-                                      const SpaceNode &snode,
-                                      std::chrono::microseconds &exec_time,
-                                      int &node_count)
+static std::optional<std::chrono::nanoseconds> node_get_execution_time(
+    TreeDrawContext &tree_draw_ctx, const bNodeTree &ntree, const bNode &node)
 {
-  if (node.type == NODE_GROUP) {
-    const geo_log::TreeLog *root_tree_log = geo_log::ModifierLog::find_tree_by_node_editor_context(
-        snode);
-    if (root_tree_log == nullptr) {
-      return;
-    }
-    const geo_log::TreeLog *tree_log = root_tree_log->lookup_child_log(node.name);
-    if (tree_log == nullptr) {
-      return;
-    }
-    tree_log->foreach_node_log([&](const geo_log::NodeLog &node_log) {
-      exec_time += node_log.execution_time();
-      node_count++;
-    });
+  const geo_log::GeoTreeLog *tree_log = tree_draw_ctx.geo_tree_log;
+  if (tree_log == nullptr) {
+    return std::nullopt;
   }
-  else {
-    const geo_log::NodeLog *node_log = geo_log::ModifierLog::find_node_by_node_editor_context(
-        snode, node);
-    if (node_log) {
-      exec_time += node_log->execution_time();
-      node_count++;
-    }
-  }
-}
-
-static std::chrono::microseconds node_get_execution_time(const bNodeTree &ntree,
-                                                         const bNode &node,
-                                                         const SpaceNode &snode,
-                                                         int &node_count)
-{
-  std::chrono::microseconds exec_time = std::chrono::microseconds::zero();
   if (node.type == NODE_GROUP_OUTPUT) {
-    const geo_log::TreeLog *tree_log = geo_log::ModifierLog::find_tree_by_node_editor_context(
-        snode);
-
-    if (tree_log == nullptr) {
-      return exec_time;
-    }
-    tree_log->foreach_node_log([&](const geo_log::NodeLog &node_log) {
-      exec_time += node_log.execution_time();
-      node_count++;
-    });
+    return tree_log->run_time_sum;
   }
-  else if (node.type == NODE_FRAME) {
+  if (node.type == NODE_FRAME) {
     /* Could be cached in the future if this recursive code turns out to be slow. */
+    std::chrono::nanoseconds run_time{0};
+    bool found_node = false;
     LISTBASE_FOREACH (bNode *, tnode, &ntree.nodes) {
       if (tnode->parent != &node) {
         continue;
       }
 
       if (tnode->type == NODE_FRAME) {
-        exec_time += node_get_execution_time(ntree, *tnode, snode, node_count);
+        std::optional<std::chrono::nanoseconds> sub_frame_run_time = node_get_execution_time(
+            tree_draw_ctx, ntree, *tnode);
+        if (sub_frame_run_time.has_value()) {
+          run_time += *sub_frame_run_time;
+          found_node = true;
+        }
       }
       else {
-        get_exec_time_other_nodes(*tnode, snode, exec_time, node_count);
+        if (const geo_log::GeoNodeLog *node_log = tree_log->nodes.lookup_ptr_as(tnode->name)) {
+          found_node = true;
+          run_time += node_log->run_time;
+        }
       }
     }
+    if (found_node) {
+      return run_time;
+    }
+    return std::nullopt;
   }
-  else {
-    get_exec_time_other_nodes(node, snode, exec_time, node_count);
+  if (const geo_log::GeoNodeLog *node_log = tree_log->nodes.lookup_ptr(node.name)) {
+    return node_log->run_time;
   }
-  return exec_time;
+  return std::nullopt;
 }
 
-static std::string node_get_execution_time_label(const SpaceNode &snode, const bNode &node)
+static std::string node_get_execution_time_label(TreeDrawContext &tree_draw_ctx,
+                                                 const SpaceNode &snode,
+                                                 const bNode &node)
 {
-  int node_count = 0;
-  std::chrono::microseconds exec_time = node_get_execution_time(
-      *snode.edittree, node, snode, node_count);
+  const std::optional<std::chrono::nanoseconds> exec_time = node_get_execution_time(
+      tree_draw_ctx, *snode.edittree, node);
 
-  if (node_count == 0) {
+  if (!exec_time.has_value()) {
     return std::string("");
   }
 
-  uint64_t exec_time_us = exec_time.count();
+  const uint64_t exec_time_us =
+      std::chrono::duration_cast<std::chrono::microseconds>(*exec_time).count();
 
   /* Don't show time if execution time is 0 microseconds. */
   if (exec_time_us == 0) {
@@ -1763,7 +1770,7 @@ struct NodeExtraInfoRow {
 };
 
 struct NamedAttributeTooltipArg {
-  Map<std::string, eNamedAttrUsage> usage_by_attribute;
+  Map<std::string, geo_log::NamedAttributeUsage> usage_by_attribute;
 };
 
 static char *named_attribute_tooltip(bContext *UNUSED(C), void *argN, const char *UNUSED(tip))
@@ -1775,7 +1782,7 @@ static char *named_attribute_tooltip(bContext *UNUSED(C), void *argN, const char
 
   struct NameWithUsage {
     StringRefNull name;
-    eNamedAttrUsage usage;
+    geo_log::NamedAttributeUsage usage;
   };
 
   Vector<NameWithUsage> sorted_used_attribute;
@@ -1790,16 +1797,16 @@ static char *named_attribute_tooltip(bContext *UNUSED(C), void *argN, const char
 
   for (const NameWithUsage &attribute : sorted_used_attribute) {
     const StringRefNull name = attribute.name;
-    const eNamedAttrUsage usage = attribute.usage;
+    const geo_log::NamedAttributeUsage usage = attribute.usage;
     ss << "  \u2022 \"" << name << "\": ";
     Vector<std::string> usages;
-    if ((usage & eNamedAttrUsage::Read) != eNamedAttrUsage::None) {
+    if ((usage & geo_log::NamedAttributeUsage::Read) != geo_log::NamedAttributeUsage::None) {
       usages.append(TIP_("read"));
     }
-    if ((usage & eNamedAttrUsage::Write) != eNamedAttrUsage::None) {
+    if ((usage & geo_log::NamedAttributeUsage::Write) != geo_log::NamedAttributeUsage::None) {
       usages.append(TIP_("write"));
     }
-    if ((usage & eNamedAttrUsage::Remove) != eNamedAttrUsage::None) {
+    if ((usage & geo_log::NamedAttributeUsage::Remove) != geo_log::NamedAttributeUsage::None) {
       usages.append(TIP_("remove"));
     }
     for (const int i : usages.index_range()) {
@@ -1817,7 +1824,7 @@ static char *named_attribute_tooltip(bContext *UNUSED(C), void *argN, const char
 }
 
 static NodeExtraInfoRow row_from_used_named_attribute(
-    const Map<std::string, eNamedAttrUsage> &usage_by_attribute_name)
+    const Map<std::string, geo_log::NamedAttributeUsage> &usage_by_attribute_name)
 {
   const int attributes_num = usage_by_attribute_name.size();
 
@@ -1831,32 +1838,11 @@ static NodeExtraInfoRow row_from_used_named_attribute(
   return row;
 }
 
-static std::optional<NodeExtraInfoRow> node_get_accessed_attributes_row(const SpaceNode &snode,
-                                                                        const bNode &node)
+static std::optional<NodeExtraInfoRow> node_get_accessed_attributes_row(
+    TreeDrawContext &tree_draw_ctx, const bNode &node)
 {
-  if (node.type == NODE_GROUP) {
-    const geo_log::TreeLog *root_tree_log = geo_log::ModifierLog::find_tree_by_node_editor_context(
-        snode);
-    if (root_tree_log == nullptr) {
-      return std::nullopt;
-    }
-    const geo_log::TreeLog *tree_log = root_tree_log->lookup_child_log(node.name);
-    if (tree_log == nullptr) {
-      return std::nullopt;
-    }
-
-    Map<std::string, eNamedAttrUsage> usage_by_attribute;
-    tree_log->foreach_node_log([&](const geo_log::NodeLog &node_log) {
-      for (const geo_log::UsedNamedAttribute &used_attribute : node_log.used_named_attributes()) {
-        usage_by_attribute.lookup_or_add_as(used_attribute.name,
-                                            used_attribute.usage) |= used_attribute.usage;
-      }
-    });
-    if (usage_by_attribute.is_empty()) {
-      return std::nullopt;
-    }
-
-    return row_from_used_named_attribute(usage_by_attribute);
+  if (tree_draw_ctx.geo_tree_log == nullptr) {
+    return std::nullopt;
   }
   if (ELEM(node.type,
            GEO_NODE_STORE_NAMED_ATTRIBUTE,
@@ -1865,31 +1851,26 @@ static std::optional<NodeExtraInfoRow> node_get_accessed_attributes_row(const Sp
     /* Only show the overlay when the name is passed in from somewhere else. */
     LISTBASE_FOREACH (bNodeSocket *, socket, &node.inputs) {
       if (STREQ(socket->name, "Name")) {
-        if ((socket->flag & SOCK_IN_USE) == 0) {
+        if (!socket->is_directly_linked()) {
           return std::nullopt;
         }
       }
     }
-    const geo_log::NodeLog *node_log = geo_log::ModifierLog::find_node_by_node_editor_context(
-        snode, node.name);
-    if (node_log == nullptr) {
-      return std::nullopt;
-    }
-    Map<std::string, eNamedAttrUsage> usage_by_attribute;
-    for (const geo_log::UsedNamedAttribute &used_attribute : node_log->used_named_attributes()) {
-      usage_by_attribute.lookup_or_add_as(used_attribute.name,
-                                          used_attribute.usage) |= used_attribute.usage;
-    }
-    if (usage_by_attribute.is_empty()) {
-      return std::nullopt;
-    }
-    return row_from_used_named_attribute(usage_by_attribute);
   }
-
-  return std::nullopt;
+  tree_draw_ctx.geo_tree_log->ensure_used_named_attributes();
+  geo_log::GeoNodeLog *node_log = tree_draw_ctx.geo_tree_log->nodes.lookup_ptr(node.name);
+  if (node_log == nullptr) {
+    return std::nullopt;
+  }
+  if (node_log->used_named_attributes.is_empty()) {
+    return std::nullopt;
+  }
+  return row_from_used_named_attribute(node_log->used_named_attributes);
 }
 
-static Vector<NodeExtraInfoRow> node_get_extra_info(const SpaceNode &snode, const bNode &node)
+static Vector<NodeExtraInfoRow> node_get_extra_info(TreeDrawContext &tree_draw_ctx,
+                                                    const SpaceNode &snode,
+                                                    const bNode &node)
 {
   Vector<NodeExtraInfoRow> rows;
   if (!(snode.overlay.flag & SN_OVERLAY_SHOW_OVERLAYS)) {
@@ -1898,7 +1879,8 @@ static Vector<NodeExtraInfoRow> node_get_extra_info(const SpaceNode &snode, cons
 
   if (snode.overlay.flag & SN_OVERLAY_SHOW_NAMED_ATTRIBUTES &&
       snode.edittree->type == NTREE_GEOMETRY) {
-    if (std::optional<NodeExtraInfoRow> row = node_get_accessed_attributes_row(snode, node)) {
+    if (std::optional<NodeExtraInfoRow> row = node_get_accessed_attributes_row(tree_draw_ctx,
+                                                                               node)) {
       rows.append(std::move(*row));
     }
   }
@@ -1907,7 +1889,7 @@ static Vector<NodeExtraInfoRow> node_get_extra_info(const SpaceNode &snode, cons
       (ELEM(node.typeinfo->nclass, NODE_CLASS_GEOMETRY, NODE_CLASS_GROUP, NODE_CLASS_ATTRIBUTE) ||
        ELEM(node.type, NODE_FRAME, NODE_GROUP_OUTPUT))) {
     NodeExtraInfoRow row;
-    row.text = node_get_execution_time_label(snode, node);
+    row.text = node_get_execution_time_label(tree_draw_ctx, snode, node);
     if (!row.text.empty()) {
       row.tooltip = TIP_(
           "The execution time from the node tree's latest evaluation. For frame and group nodes, "
@@ -1916,14 +1898,17 @@ static Vector<NodeExtraInfoRow> node_get_extra_info(const SpaceNode &snode, cons
       rows.append(std::move(row));
     }
   }
-  const geo_log::NodeLog *node_log = geo_log::ModifierLog::find_node_by_node_editor_context(snode,
-                                                                                            node);
-  if (node_log != nullptr) {
-    for (const std::string &message : node_log->debug_messages()) {
-      NodeExtraInfoRow row;
-      row.text = message;
-      row.icon = ICON_INFO;
-      rows.append(std::move(row));
+
+  if (snode.edittree->type == NTREE_GEOMETRY && tree_draw_ctx.geo_tree_log != nullptr) {
+    tree_draw_ctx.geo_tree_log->ensure_debug_messages();
+    const geo_log::GeoNodeLog *node_log = tree_draw_ctx.geo_tree_log->nodes.lookup_ptr(node.name);
+    if (node_log != nullptr) {
+      for (const StringRef message : node_log->debug_messages) {
+        NodeExtraInfoRow row;
+        row.text = message;
+        row.icon = ICON_INFO;
+        rows.append(std::move(row));
+      }
     }
   }
 
@@ -1988,9 +1973,12 @@ static void node_draw_extra_info_row(const bNode &node,
   }
 }
 
-static void node_draw_extra_info_panel(const SpaceNode &snode, const bNode &node, uiBlock &block)
+static void node_draw_extra_info_panel(TreeDrawContext &tree_draw_ctx,
+                                       const SpaceNode &snode,
+                                       const bNode &node,
+                                       uiBlock &block)
 {
-  Vector<NodeExtraInfoRow> extra_info_rows = node_get_extra_info(snode, node);
+  Vector<NodeExtraInfoRow> extra_info_rows = node_get_extra_info(tree_draw_ctx, snode, node);
 
   if (extra_info_rows.size() == 0) {
     return;
@@ -2046,6 +2034,7 @@ static void node_draw_extra_info_panel(const SpaceNode &snode, const bNode &node
 }
 
 static void node_draw_basis(const bContext &C,
+                            TreeDrawContext &tree_draw_ctx,
                             const View2D &v2d,
                             const SpaceNode &snode,
                             bNodeTree &ntree,
@@ -2070,7 +2059,7 @@ static void node_draw_basis(const bContext &C,
 
   GPU_line_width(1.0f);
 
-  node_draw_extra_info_panel(snode, node, block);
+  node_draw_extra_info_panel(tree_draw_ctx, snode, node, block);
 
   /* Header. */
   {
@@ -2165,7 +2154,7 @@ static void node_draw_basis(const bContext &C,
     UI_block_emboss_set(&block, UI_EMBOSS);
   }
 
-  node_add_error_message_button(C, node, block, rct, iconofs);
+  node_add_error_message_button(tree_draw_ctx, node, block, rct, iconofs);
 
   /* Title. */
   if (node.flag & SELECT) {
@@ -2338,6 +2327,7 @@ static void node_draw_basis(const bContext &C,
 }
 
 static void node_draw_hidden(const bContext &C,
+                             TreeDrawContext &tree_draw_ctx,
                              const View2D &v2d,
                              const SpaceNode &snode,
                              bNodeTree &ntree,
@@ -2353,7 +2343,7 @@ static void node_draw_hidden(const bContext &C,
 
   const int color_id = node_get_colorid(node);
 
-  node_draw_extra_info_panel(snode, node, block);
+  node_draw_extra_info_panel(tree_draw_ctx, snode, node, block);
 
   /* Shadow. */
   node_draw_shadow(snode, node, hiddenrad, 1.0f);
@@ -2668,6 +2658,7 @@ static void reroute_node_prepare_for_draw(bNode &node)
 }
 
 static void node_update_nodetree(const bContext &C,
+                                 TreeDrawContext &tree_draw_ctx,
                                  bNodeTree &ntree,
                                  Span<bNode *> nodes,
                                  Span<uiBlock *> blocks)
@@ -2694,7 +2685,7 @@ static void node_update_nodetree(const bContext &C,
         node_update_hidden(node, block);
       }
       else {
-        node_update_basis(C, ntree, node, block);
+        node_update_basis(C, tree_draw_ctx, ntree, node, block);
       }
     }
   }
@@ -2795,6 +2786,7 @@ static void frame_node_draw_label(const bNodeTree &ntree,
 }
 
 static void frame_node_draw(const bContext &C,
+                            TreeDrawContext &tree_draw_ctx,
                             const ARegion &region,
                             const SpaceNode &snode,
                             bNodeTree &ntree,
@@ -2841,7 +2833,7 @@ static void frame_node_draw(const bContext &C,
   /* label and text */
   frame_node_draw_label(ntree, node, snode);
 
-  node_draw_extra_info_panel(snode, node, block);
+  node_draw_extra_info_panel(tree_draw_ctx, snode, node, block);
 
   UI_block_end(&C, &block);
   UI_block_draw(&C, &block);
@@ -2895,6 +2887,7 @@ static void reroute_node_draw(
 }
 
 static void node_draw(const bContext &C,
+                      TreeDrawContext &tree_draw_ctx,
                       ARegion &region,
                       const SpaceNode &snode,
                       bNodeTree &ntree,
@@ -2903,7 +2896,7 @@ static void node_draw(const bContext &C,
                       bNodeInstanceKey key)
 {
   if (node.type == NODE_FRAME) {
-    frame_node_draw(C, region, snode, ntree, node, block);
+    frame_node_draw(C, tree_draw_ctx, region, snode, ntree, node, block);
   }
   else if (node.type == NODE_REROUTE) {
     reroute_node_draw(C, region, ntree, node, block);
@@ -2911,10 +2904,10 @@ static void node_draw(const bContext &C,
   else {
     const View2D &v2d = region.v2d;
     if (node.flag & NODE_HIDDEN) {
-      node_draw_hidden(C, v2d, snode, ntree, node, block);
+      node_draw_hidden(C, tree_draw_ctx, v2d, snode, ntree, node, block);
     }
     else {
-      node_draw_basis(C, v2d, snode, ntree, node, block, key);
+      node_draw_basis(C, tree_draw_ctx, v2d, snode, ntree, node, block, key);
     }
   }
 }
@@ -2922,6 +2915,7 @@ static void node_draw(const bContext &C,
 #define USE_DRAW_TOT_UPDATE
 
 static void node_draw_nodetree(const bContext &C,
+                               TreeDrawContext &tree_draw_ctx,
                                ARegion &region,
                                SpaceNode &snode,
                                bNodeTree &ntree,
@@ -2946,7 +2940,7 @@ static void node_draw_nodetree(const bContext &C,
     }
 
     bNodeInstanceKey key = BKE_node_instance_key(parent_key, &ntree, nodes[i]);
-    node_draw(C, region, snode, ntree, *nodes[i], *blocks[i], key);
+    node_draw(C, tree_draw_ctx, region, snode, ntree, *nodes[i], *blocks[i], key);
   }
 
   /* Node lines. */
@@ -2976,7 +2970,7 @@ static void node_draw_nodetree(const bContext &C,
     }
 
     bNodeInstanceKey key = BKE_node_instance_key(parent_key, &ntree, nodes[i]);
-    node_draw(C, region, snode, ntree, *nodes[i], *blocks[i], key);
+    node_draw(C, tree_draw_ctx, region, snode, ntree, *nodes[i], *blocks[i], key);
   }
 }
 
@@ -3035,8 +3029,17 @@ static void draw_nodetree(const bContext &C,
 
   Array<uiBlock *> blocks = node_uiblocks_init(C, nodes);
 
-  node_update_nodetree(C, ntree, nodes, blocks);
-  node_draw_nodetree(C, region, *snode, ntree, nodes, blocks, parent_key);
+  TreeDrawContext tree_draw_ctx;
+  if (ntree.type == NTREE_GEOMETRY) {
+    tree_draw_ctx.geo_tree_log = geo_log::GeoModifierLog::get_tree_log_for_node_editor(*snode);
+    if (tree_draw_ctx.geo_tree_log != nullptr) {
+      tree_draw_ctx.geo_tree_log->ensure_node_warnings();
+      tree_draw_ctx.geo_tree_log->ensure_node_run_time();
+    }
+  }
+
+  node_update_nodetree(C, tree_draw_ctx, ntree, nodes, blocks);
+  node_draw_nodetree(C, tree_draw_ctx, region, *snode, ntree, nodes, blocks, parent_key);
 }
 
 /**

source/blender/editors/space_node/node_geometry_attribute_search.cc

@@ -14,6 +14,7 @@
 #include "DNA_space_types.h"
 
 #include "BKE_context.h"
+#include "BKE_node_runtime.hh"
 #include "BKE_node_tree_update.h"
 #include "BKE_object.h"
 
@@ -30,12 +31,11 @@
 #include "UI_interface.hh"
 #include "UI_resources.h"
 
-#include "NOD_geometry_nodes_eval_log.hh"
+#include "NOD_geometry_nodes_log.hh"
 
 #include "node_intern.hh"
 
-namespace geo_log = blender::nodes::geometry_nodes_eval_log;
-using geo_log::GeometryAttributeInfo;
+using blender::nodes::geo_eval_log::GeometryAttributeInfo;
 
 namespace blender::ed::space_node {
 
@@ -50,6 +50,8 @@ BLI_STATIC_ASSERT(std::is_trivially_destructible_v<AttributeSearchData>, "");
 static Vector<const GeometryAttributeInfo *> get_attribute_info_from_context(
     const bContext &C, AttributeSearchData &data)
 {
+  using namespace nodes::geo_eval_log;
+
   SpaceNode *snode = CTX_wm_space_node(&C);
   if (!snode) {
     BLI_assert_unreachable();
@@ -65,41 +67,48 @@ static Vector<const GeometryAttributeInfo *> get_attribute_info_from_context(
     BLI_assert_unreachable();
     return {};
   }
+  GeoTreeLog *tree_log = GeoModifierLog::get_tree_log_for_node_editor(*snode);
+  if (tree_log == nullptr) {
+    return {};
+  }
+  tree_log->ensure_socket_values();
 
   /* For the attribute input node, collect attribute information from all nodes in the group. */
   if (node->type == GEO_NODE_INPUT_NAMED_ATTRIBUTE) {
-    const geo_log::TreeLog *tree_log = geo_log::ModifierLog::find_tree_by_node_editor_context(
-        *snode);
-    if (tree_log == nullptr) {
-      return {};
-    }
-
+    tree_log->ensure_existing_attributes();
     Vector<const GeometryAttributeInfo *> attributes;
-    Set<StringRef> names;
-    tree_log->foreach_node_log([&](const geo_log::NodeLog &node_log) {
-      for (const geo_log::SocketLog &socket_log : node_log.input_logs()) {
-        const geo_log::ValueLog *value_log = socket_log.value();
-        if (const geo_log::GeometryValueLog *geo_value_log =
-                dynamic_cast<const geo_log::GeometryValueLog *>(value_log)) {
-          for (const GeometryAttributeInfo &attribute : geo_value_log->attributes()) {
-            if (bke::allow_procedural_attribute_access(attribute.name)) {
-              if (names.add(attribute.name)) {
-                attributes.append(&attribute);
-              }
-            }
-          }
-        }
+    for (const GeometryAttributeInfo *attribute : tree_log->existing_attributes) {
+      if (bke::allow_procedural_attribute_access(attribute->name)) {
+        attributes.append(attribute);
       }
-    });
+    }
     return attributes;
   }
-
-  const geo_log::NodeLog *node_log = geo_log::ModifierLog::find_node_by_node_editor_context(
-      *snode, data.node_name);
+  GeoNodeLog *node_log = tree_log->nodes.lookup_ptr(node->name);
   if (node_log == nullptr) {
     return {};
   }
-  return node_log->lookup_available_attributes();
+  Set<StringRef> names;
+  Vector<const GeometryAttributeInfo *> attributes;
+  for (const bNodeSocket *input_socket : node->input_sockets()) {
+    if (input_socket->type != SOCK_GEOMETRY) {
+      continue;
+    }
+    const ValueLog *value_log = tree_log->find_socket_value_log(*input_socket);
+    if (value_log == nullptr) {
+      continue;
+    }
+    if (const GeometryInfoLog *geo_log = dynamic_cast<const GeometryInfoLog *>(value_log)) {
+      for (const GeometryAttributeInfo &attribute : geo_log->attributes) {
+        if (bke::allow_procedural_attribute_access(attribute.name)) {
+          if (names.add(attribute.name)) {
+            attributes.append(&attribute);
+          }
+        }
+      }
+    }
+  }
+  return attributes;
 }
 
 static void attribute_search_update_fn(

source/blender/editors/space_spreadsheet/spreadsheet_data_source_geometry.cc

@@ -4,6 +4,7 @@
 #include "BLI_virtual_array.hh"
 
 #include "BKE_attribute.hh"
+#include "BKE_compute_contexts.hh"
 #include "BKE_context.h"
 #include "BKE_curves.hh"
 #include "BKE_editmesh.h"
@@ -26,7 +27,8 @@
 #include "ED_curves_sculpt.h"
 #include "ED_spreadsheet.h"
 
-#include "NOD_geometry_nodes_eval_log.hh"
+#include "NOD_geometry_nodes_lazy_function.hh"
+#include "NOD_geometry_nodes_log.hh"
 
 #include "BLT_translation.h"
 
@@ -40,8 +42,8 @@
 #include "spreadsheet_data_source_geometry.hh"
 #include "spreadsheet_intern.hh"
 
-namespace geo_log = blender::nodes::geometry_nodes_eval_log;
 using blender::fn::GField;
+using blender::nodes::geo_eval_log::ViewerNodeLog;
 
 namespace blender::ed::spreadsheet {
 
@@ -465,19 +467,10 @@ GeometrySet spreadsheet_get_display_geometry_set(const SpaceSpreadsheet *sspread
         }
       }
       else {
-        const geo_log::NodeLog *node_log =
-            geo_log::ModifierLog::find_node_by_spreadsheet_editor_context(*sspreadsheet);
-        if (node_log != nullptr) {
-          for (const geo_log::SocketLog &input_log : node_log->input_logs()) {
-            if (const geo_log::GeometryValueLog *geo_value_log =
-                    dynamic_cast<const geo_log::GeometryValueLog *>(input_log.value())) {
-              const GeometrySet *full_geometry = geo_value_log->full_geometry();
-              if (full_geometry != nullptr) {
-                geometry_set = *full_geometry;
-                break;
-              }
-            }
-          }
+        if (const ViewerNodeLog *viewer_log =
+                nodes::geo_eval_log::GeoModifierLog::find_viewer_node_log_for_spreadsheet(
+                    *sspreadsheet)) {
+          geometry_set = viewer_log->geometry;
         }
       }
     }
@@ -495,27 +488,11 @@ static void find_fields_to_evaluate(const SpaceSpreadsheet *sspreadsheet,
     /* No viewer is currently referenced by the context path. */
     return;
   }
-  const geo_log::NodeLog *node_log = geo_log::ModifierLog::find_node_by_spreadsheet_editor_context(
-      *sspreadsheet);
-  if (node_log == nullptr) {
-    return;
-  }
-  for (const geo_log::SocketLog &socket_log : node_log->input_logs()) {
-    const geo_log::ValueLog *value_log = socket_log.value();
-    if (value_log == nullptr) {
-      continue;
-    }
-    if (const geo_log::GFieldValueLog *field_value_log =
-            dynamic_cast<const geo_log::GFieldValueLog *>(value_log)) {
-      const GField &field = field_value_log->field();
-      if (field) {
-        r_fields.add("Viewer", std::move(field));
-      }
-    }
-    if (const geo_log::GenericValueLog *generic_value_log =
-            dynamic_cast<const geo_log::GenericValueLog *>(value_log)) {
-      GPointer value = generic_value_log->value();
-      r_fields.add("Viewer", fn::make_constant_field(*value.type(), value.get()));
+  if (const ViewerNodeLog *viewer_log =
+          nodes::geo_eval_log::GeoModifierLog::find_viewer_node_log_for_spreadsheet(
+              *sspreadsheet)) {
+    if (viewer_log->field) {
+      r_fields.add("Viewer", viewer_log->field);
     }
   }
 }

source/blender/functions/CMakeLists.txt

@@ -13,6 +13,10 @@ set(INC_SYS
 set(SRC
   intern/cpp_types.cc
   intern/field.cc
+  intern/lazy_function.cc
+  intern/lazy_function_execute.cc
+  intern/lazy_function_graph.cc
+  intern/lazy_function_graph_executor.cc
   intern/multi_function.cc
   intern/multi_function_builder.cc
   intern/multi_function_params.cc
@@ -23,6 +27,10 @@ set(SRC
 
   FN_field.hh
   FN_field_cpp_type.hh
+  FN_lazy_function.hh
+  FN_lazy_function_execute.hh
+  FN_lazy_function_graph.hh
+  FN_lazy_function_graph_executor.hh
   FN_multi_function.hh
   FN_multi_function_builder.hh
   FN_multi_function_context.hh
@@ -61,6 +69,7 @@ blender_add_lib(bf_functions "${SRC}" "${INC}" "${INC_SYS}" "${LIB}")
 if(WITH_GTESTS)
   set(TEST_SRC
     tests/FN_field_test.cc
+    tests/FN_lazy_function_test.cc
     tests/FN_multi_function_procedure_test.cc
     tests/FN_multi_function_test.cc
 

source/blender/functions/FN_field.hh

@@ -565,6 +565,17 @@ template<typename T> struct ValueOrField {
     }
     return this->value;
   }
+
+  friend std::ostream &operator<<(std::ostream &stream, const ValueOrField<T> &value_or_field)
+  {
+    if (value_or_field.field) {
+      stream << "ValueOrField<T>";
+    }
+    else {
+      stream << value_or_field.value;
+    }
+    return stream;
+  }
 };
 
 /** \} */

source/blender/functions/FN_field_cpp_type.hh

@@ -59,7 +59,7 @@ class ValueOrFieldCPPType : public CPPType {
  public:
   template<typename T>
   ValueOrFieldCPPType(FieldCPPTypeParam<ValueOrField<T>> /* unused */, StringRef debug_name)
-      : CPPType(CPPTypeParam<ValueOrField<T>, CPPTypeFlags::None>(), debug_name),
+      : CPPType(CPPTypeParam<ValueOrField<T>, CPPTypeFlags::Printable>(), debug_name),
         base_type_(CPPType::get<T>())
   {
     construct_from_value_ = [](void *dst, const void *value_or_field) {

source/blender/functions/FN_lazy_function.hh

@@ -0,0 +1,384 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+
+#pragma once
+
+/** \file
+ * \ingroup fn
+ *
+ * A `LazyFunction` encapsulates a computation which has inputs, outputs and potentially side
+ * effects. Most importantly, a `LazyFunction` supports lazyness in its inputs and outputs:
+ * - Only outputs that are actually used have to be computed.
+ * - Inputs can be requested lazily based on which outputs are used or what side effects the
+ *   function has.
+ *
+ * A lazy-function that uses lazyness may be executed more than once. The most common example is
+ * the geometry nodes switch node. Depending on a condition input, it decides which one of the
+ * other inputs is actually used. From the perspective of the switch node, its execution works as
+ * follows:
+ * 1. The switch node is first executed. It sees that the output is used. Now it requests the
+ *    condition input from the caller and exits.
+ * 2. Once the caller is able to provide the condition input the switch node is executed again.
+ *    This time it retrieves the condition and requests one of the other inputs. Then the node
+ *    exits again, giving back control to the caller.
+ * 3. When the caller computed the second requested input the switch node executes a last time.
+ *    This time it retrieves the new input and forwards it to the output.
+ *
+ * In some sense, a lazy-function can be thought of like a state machine. Every time it is
+ * executed, it advances its state until all required outputs are ready.
+ *
+ * The lazy-function interface is designed to support composition of many such functions into a new
+ * lazy-functions, all while keeping the lazyness working. For example, in geometry nodes a switch
+ * node in a node group should still be able to decide whether a node in the parent group will be
+ * executed or not. This is essential to avoid doing unnecessary work.
+ *
+ * The lazy-function system consists of multiple core components:
+ * - The interface of a lazy-function itself including its calling convention.
+ * - A graph data structure that allows composing many lazy-functions by connecting their inputs
+ *   and outputs.
+ * - An executor that allows multi-threaded execution or such a graph.
+ */
+
+#include "BLI_cpp_type.hh"
+#include "BLI_generic_pointer.hh"
+#include "BLI_linear_allocator.hh"
+#include "BLI_vector.hh"
+
+namespace blender::fn::lazy_function {
+
+enum class ValueUsage {
+  /**
+   * The value is definitely used and therefore has to be computed.
+   */
+  Used,
+  /**
+   * It's unknown whether this value will be used or not. Computing it is ok but the result may be
+   * discarded.
+   */
+  Maybe,
+  /**
+   * The value will definitely not be used. It can still be computed but the result will be
+   * discarded in all cases.
+   */
+  Unused,
+};
+
+class LazyFunction;
+
+/**
+ * This allows passing arbitrary data into a lazy-function during execution. For that, #UserData
+ * has to be subclassed. This mainly exists because it's more type safe than passing a `void *`
+ * with no type information attached.
+ *
+ * Some lazy-functions may expect to find a certain type of user data when executed.
+ */
+class UserData {
+ public:
+  virtual ~UserData() = default;
+};
+
+/**
+ * Passed to the lazy-function when it is executed.
+ */
+struct Context {
+  /**
+   * If the lazy-function has some state (which only makes sense when it is executed more than once
+   * to finish its job), the state is stored here. This points to memory returned from
+   * #LazyFunction::init_storage.
+   */
+  void *storage;
+  /**
+   * Custom user data that can be used in the function.
+   */
+  UserData *user_data;
+};
+
+/**
+ * Defines the calling convention for a lazy-function. During execution, a lazy-function retrieves
+ * its inputs and sets the outputs through #Params.
+ */
+class Params {
+ public:
+  /**
+   * The lazy-function this #Params has been prepared for.
+   */
+  const LazyFunction &fn_;
+
+ public:
+  Params(const LazyFunction &fn);
+
+  /**
+   * Get a pointer to an input value if the value is available already. Otherwise null is returned.
+   *
+   * The #LazyFunction must leave returned object in an initialized state, but can move from it.
+   */
+  void *try_get_input_data_ptr(int index) const;
+
+  /**
+   * Same as #try_get_input_data_ptr, but if the data is not yet available, request it. This makes
+   * sure that the data will be available in a future execution of the #LazyFunction.
+   */
+  void *try_get_input_data_ptr_or_request(int index);
+
+  /**
+   * Get a pointer to where the output value should be stored.
+   * The value at the pointer is in an uninitialized state at first.
+   * The #LazyFunction is responsible for initializing the value.
+   * After the output has been initialized to its final value, #output_set has to be called.
+   */
+  void *get_output_data_ptr(int index);
+
+  /**
+   * Call this after the output value is initialized. After this is called, the value must not be
+   * touched anymore. It may be moved or destructed immediatly.
+   */
+  void output_set(int index);
+
+  /**
+   * Allows the #LazyFunction to check whether an output was computed already without keeping
+   * track of it itself.
+   */
+  bool output_was_set(int index) const;
+
+  /**
+   * Can be used to detect which outputs have to be computed.
+   */
+  ValueUsage get_output_usage(int index) const;
+
+  /**
+   * Tell the caller of the #LazyFunction that a specific input will definitely not be used.
+   * Only an input that was not #ValueUsage::Used can become unused.
+   */
+  void set_input_unused(int index);
+
+  /**
+   * Typed utility methods that wrap the methods above.
+   */
+  template<typename T> T extract_input(int index);
+  template<typename T> const T &get_input(int index);
+  template<typename T> T *try_get_input_data_ptr_or_request(int index);
+  template<typename T> void set_output(int index, T &&value);
+
+  /**
+   * Utility to initialize all outputs that haven't been set yet.
+   */
+  void set_default_remaining_outputs();
+
+ private:
+  /**
+   * Methods that need to be implemented by subclasses. Those are separate from the non-virtual
+   * methods above to make it easy to insert additional debugging logic on top of the
+   * implementations.
+   */
+  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;
+};
+
+/**
+ * Describes an input of a #LazyFunction.
+ */
+struct Input {
+  /**
+   * Name used for debugging purposes. The string has to be static or has to be owned by something
+   * else.
+   */
+  const char *debug_name;
+  /**
+   * Data type of this input.
+   */
+  const CPPType *type;
+  /**
+   * Can be used to indicate a caller or this function if this input is used statically before
+   * executing it the first time. This is technically not needed but can improve efficiency because
+   * a round-trip through the `execute` method can be avoided.
+   *
+   * When this is #ValueUsage::Used, the caller has to ensure that the input is definitely
+   * available when the #execute method is first called. The #execute method does not have to check
+   * whether the value is actually available.
+   */
+  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 {
+  /**
+   * Name used for debugging purposes. The string has to be static or has to be owned by something
+   * else.
+   */
+  const char *debug_name;
+  /**
+   * Data type of this output.
+   */
+  const CPPType *type = nullptr;
+
+  Output(const char *debug_name, const CPPType &type) : debug_name(debug_name), type(&type)
+  {
+  }
+};
+
+/**
+ * A function that can compute outputs and request inputs lazily. For more details see the comment
+ * at the top of the file.
+ */
+class LazyFunction {
+ protected:
+  const char *debug_name_ = "<unknown>";
+  Vector<Input> inputs_;
+  Vector<Output> outputs_;
+
+ public:
+  virtual ~LazyFunction() = default;
+
+  /**
+   * Get a name of the function or an input or output. This is mainly used for debugging.
+   * These are virtual functions because the names are often not used outside of debugging
+   * workflows. This way the names are only generated when they are actually needed.
+   */
+  virtual std::string name() const;
+  virtual std::string input_name(int index) const;
+  virtual std::string output_name(int index) const;
+
+  /**
+   * Allocates storage for this function. The storage will be passed to every call to #execute.
+   * If the function does not keep track of any state, this does not have to be implemented.
+   */
+  virtual void *init_storage(LinearAllocator<> &allocator) const;
+
+  /**
+   * Destruct the storage created in #init_storage.
+   */
+  virtual void destruct_storage(void *storage) const;
+
+  /**
+   * Inputs of the function.
+   */
+  Span<Input> inputs() const;
+  /**
+   * Outputs of the function.
+   */
+  Span<Output> outputs() const;
+
+  /**
+   * During execution the function retrieves inputs and sets outputs in #params. For some
+   * functions, this method is called more than once. After execution, the function either has
+   * computed all required outputs or is waiting for more inputs.
+   */
+  void execute(Params &params, const Context &context) const;
+
+  /**
+   * Utility to check that the guarantee by #Input::usage is followed.
+   */
+  bool always_used_inputs_available(const Params &params) const;
+
+ private:
+  /**
+   * Needs to be implemented by subclasses. This is separate from #execute so that additional
+   * debugging logic can be implemented in #execute.
+   */
+  virtual void execute_impl(Params &params, const Context &context) const = 0;
+};
+
+/* -------------------------------------------------------------------- */
+/** \name #LazyFunction Inline Methods
+ * \{ */
+
+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);
+}
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name #Params Inline Methods
+ * \{ */
+
+inline Params::Params(const LazyFunction &fn) : fn_(fn)
+{
+}
+
+inline void *Params::try_get_input_data_ptr(const int index) const
+{
+  return this->try_get_input_data_ptr_impl(index);
+}
+
+inline void *Params::try_get_input_data_ptr_or_request(const int index)
+{
+  return this->try_get_input_data_ptr_or_request_impl(index);
+}
+
+inline void *Params::get_output_data_ptr(const int index)
+{
+  return this->get_output_data_ptr_impl(index);
+}
+
+inline void Params::output_set(const int index)
+{
+  this->output_set_impl(index);
+}
+
+inline bool Params::output_was_set(const int index) const
+{
+  return this->output_was_set_impl(index);
+}
+
+inline ValueUsage Params::get_output_usage(const int index) const
+{
+  return this->get_output_usage_impl(index);
+}
+
+inline void Params::set_input_unused(const int index)
+{
+  this->set_input_unused_impl(index);
+}
+
+template<typename T> inline T Params::extract_input(const int index)
+{
+  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 const T &Params::get_input(const int index)
+{
+  const void *data = this->try_get_input_data_ptr(index);
+  BLI_assert(data != nullptr);
+  return *static_cast<const T *>(data);
+}
+
+template<typename T> inline T *Params::try_get_input_data_ptr_or_request(const int index)
+{
+  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>;
+  void *data = this->get_output_data_ptr(index);
+  new (data) DecayT(std::forward<T>(value));
+  this->output_set(index);
+}
+
+/** \} */
+
+}  // namespace blender::fn::lazy_function

source/blender/functions/FN_lazy_function_execute.hh

@@ -0,0 +1,122 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+
+#pragma once
+
+/** \file
+ * \ingroup fn
+ *
+ * This file contains common utilities for actually executing a lazy-function.
+ */
+
+#include "BLI_parameter_pack_utils.hh"
+
+#include "FN_lazy_function.hh"
+
+namespace blender::fn::lazy_function {
+
+/**
+ * Most basic implementation of #Params. It does not actually implement any logic for how to
+ * retrieve inputs or set outputs. Instead, code using #BasicParams has to implement that.
+ */
+class BasicParams : public Params {
+ private:
+  const Span<GMutablePointer> inputs_;
+  const Span<GMutablePointer> outputs_;
+  MutableSpan<std::optional<ValueUsage>> input_usages_;
+  Span<ValueUsage> output_usages_;
+  MutableSpan<bool> set_outputs_;
+
+ public:
+  BasicParams(const LazyFunction &fn,
+              const Span<GMutablePointer> inputs,
+              const Span<GMutablePointer> outputs,
+              MutableSpan<std::optional<ValueUsage>> input_usages,
+              Span<ValueUsage> output_usages,
+              MutableSpan<bool> set_outputs);
+
+  void *try_get_input_data_ptr_impl(const int index) const override;
+  void *try_get_input_data_ptr_or_request_impl(const int index) override;
+  void *get_output_data_ptr_impl(const int index) override;
+  void output_set_impl(const int index) override;
+  bool output_was_set_impl(const int index) const override;
+  ValueUsage get_output_usage_impl(const int index) const override;
+  void set_input_unused_impl(const int index) override;
+};
+
+namespace detail {
+
+/**
+ * Utility to implement #execute_lazy_function_eagerly.
+ */
+template<typename... Inputs, typename... Outputs, size_t... InIndices, size_t... OutIndices>
+inline void execute_lazy_function_eagerly_impl(
+    const LazyFunction &fn,
+    UserData *user_data,
+    std::tuple<Inputs...> &inputs,
+    std::tuple<Outputs *...> &outputs,
+    std::index_sequence<InIndices...> /* in_indices */,
+    std::index_sequence<OutIndices...> /* out_indices */)
+{
+  constexpr size_t InputsNum = sizeof...(Inputs);
+  constexpr size_t OutputsNum = sizeof...(Outputs);
+  std::array<GMutablePointer, InputsNum> input_pointers;
+  std::array<GMutablePointer, OutputsNum> output_pointers;
+  std::array<std::optional<ValueUsage>, InputsNum> input_usages;
+  std::array<ValueUsage, OutputsNum> output_usages;
+  std::array<bool, OutputsNum> set_outputs;
+  (
+      [&]() {
+        constexpr size_t I = InIndices;
+        using T = Inputs;
+        const CPPType &type = CPPType::get<T>();
+        input_pointers[I] = {type, &std::get<I>(inputs)};
+      }(),
+      ...);
+  (
+      [&]() {
+        constexpr size_t I = OutIndices;
+        using T = Outputs;
+        const CPPType &type = CPPType::get<T>();
+        output_pointers[I] = {type, std::get<I>(outputs)};
+      }(),
+      ...);
+  output_usages.fill(ValueUsage::Used);
+  set_outputs.fill(false);
+  LinearAllocator<> allocator;
+  Context context;
+  context.user_data = user_data;
+  context.storage = fn.init_storage(allocator);
+  BasicParams params{
+      fn, input_pointers, output_pointers, input_usages, output_usages, set_outputs};
+  fn.execute(params, context);
+  fn.destruct_storage(context.storage);
+}
+
+}  // namespace detail
+
+/**
+ * In some cases (mainly for tests), the set of inputs and outputs for a lazy-function is known at
+ * compile time and one just wants to compute the outputs based on the inputs, without any
+ * lazyness.
+ *
+ * This function does exactly that. It takes all inputs in a tuple and writes the outputs to points
+ * provided in a second tuple. Since all inputs have to be provided, the lazy-function has to
+ * compute all outputs.
+ */
+template<typename... Inputs, typename... Outputs>
+inline void execute_lazy_function_eagerly(const LazyFunction &fn,
+                                          UserData *user_data,
+                                          std::tuple<Inputs...> inputs,
+                                          std::tuple<Outputs *...> outputs)
+{
+  BLI_assert(fn.inputs().size() == sizeof...(Inputs));
+  BLI_assert(fn.outputs().size() == sizeof...(Outputs));
+  detail::execute_lazy_function_eagerly_impl(fn,
+                                             user_data,
+                                             inputs,
+                                             outputs,
+                                             std::make_index_sequence<sizeof...(Inputs)>(),
+                                             std::make_index_sequence<sizeof...(Outputs)>());
+}
+
+}  // namespace blender::fn::lazy_function

source/blender/functions/FN_lazy_function_graph.hh

@@ -0,0 +1,421 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+
+#pragma once
+
+/** \file
+ * \ingroup fn
+ *
+ * This file contains a graph data structure that allows composing multiple lazy-functions into a
+ * combined lazy-function.
+ *
+ * There are two types of nodes in the graph:
+ * - #FunctionNode: Corresponds to a #LazyFunction. The inputs and outputs of the function become
+ *   input and output sockets of the node.
+ * - #DummyNode: Is used to indicate inputs and outputs of the entire graph. It can have an
+ *   arbitrary number of sockets.
+ */
+
+#include "BLI_linear_allocator.hh"
+
+#include "FN_lazy_function.hh"
+
+namespace blender::fn::lazy_function {
+
+class Socket;
+class InputSocket;
+class OutputSocket;
+class Node;
+class Graph;
+
+/**
+ * A #Socket is the interface of a #Node. Every #Socket is either an #InputSocket or #OutputSocket.
+ * Links can be created from output sockets to input sockets.
+ */
+class Socket : NonCopyable, NonMovable {
+ protected:
+  /**
+   * The node the socket belongs to.
+   */
+  Node *node_;
+  /**
+   * Data type of the socket. Only sockets with the same type can be linked.
+   */
+  const CPPType *type_;
+  /**
+   * Indicates whether this is an #InputSocket or #OutputSocket.
+   */
+  bool is_input_;
+  /**
+   * Index of the socket. E.g. 0 for the first input and the first output socket.
+   */
+  int index_in_node_;
+
+  friend Graph;
+
+ public:
+  bool is_input() const;
+  bool is_output() const;
+
+  int index() const;
+
+  InputSocket &as_input();
+  OutputSocket &as_output();
+  const InputSocket &as_input() const;
+  const OutputSocket &as_output() const;
+
+  const Node &node() const;
+  Node &node();
+
+  const CPPType &type() const;
+
+  std::string name() const;
+};
+
+class InputSocket : public Socket {
+ private:
+  /**
+   * An input can have at most one link connected to it. The linked socket is the "origin" because
+   * it's where the data is coming from. The type of the origin must be the same as the type of
+   * this socket.
+   */
+  OutputSocket *origin_;
+  /**
+   * Can be null or a non-owning pointer to a value of the type of the socket. This value will be
+   * used when the input is used but not linked.
+   *
+   * This is technically not needed, because one could just create a separate node that just
+   * outputs the value, but that would have more overhead. Especially because it's commonly the
+   * case that most inputs are unlinked.
+   */
+  const void *default_value_ = nullptr;
+
+  friend Graph;
+
+ public:
+  OutputSocket *origin();
+  const OutputSocket *origin() const;
+
+  const void *default_value() const;
+  void set_default_value(const void *value);
+};
+
+class OutputSocket : public Socket {
+ private:
+  /**
+   * An output can be linked to an arbitrary number of inputs of the same type.
+   */
+  Vector<InputSocket *> targets_;
+
+  friend Graph;
+
+ public:
+  Span<InputSocket *> targets();
+  Span<const InputSocket *> targets() const;
+};
+
+/**
+ * A #Node has input and output sockets. Every node is either a #FunctionNode or a #DummyNode.
+ */
+class Node : NonCopyable, NonMovable {
+ protected:
+  /**
+   * The function this node corresponds to. If this is null, the node is a #DummyNode.
+   * The function is not owned by this #Node nor by the #Graph.
+   */
+  const LazyFunction *fn_ = nullptr;
+  /**
+   * Input sockets of the node.
+   */
+  Span<InputSocket *> inputs_;
+  /**
+   * Output sockets of the node.
+   */
+  Span<OutputSocket *> outputs_;
+  /**
+   * An index that is set when calling #Graph::update_node_indices. This can be used to create
+   * efficient mappings from nodes to other data using just an array instead of a hash map.
+   *
+   * This is technically not necessary but has better performance than always using hash maps.
+   */
+  int index_in_graph_ = -1;
+
+  friend Graph;
+
+ public:
+  bool is_dummy() const;
+  bool is_function() const;
+  int index_in_graph() const;
+
+  Span<const InputSocket *> inputs() const;
+  Span<const OutputSocket *> outputs() const;
+  Span<InputSocket *> inputs();
+  Span<OutputSocket *> outputs();
+
+  const InputSocket &input(int index) const;
+  const OutputSocket &output(int index) const;
+  InputSocket &input(int index);
+  OutputSocket &output(int index);
+
+  std::string name() const;
+};
+
+/**
+ * A #Node that corresponds to a specific #LazyFunction.
+ */
+class FunctionNode : public Node {
+ public:
+  const LazyFunction &function() const;
+};
+
+/**
+ * A #Node that does *not* correspond to a #LazyFunction. Instead it can be used to indicate inputs
+ * and outputs of the entire graph. It can have an arbitrary number of inputs and outputs.
+ */
+class DummyNode : public Node {
+ private:
+  std::string name_;
+
+  friend Node;
+};
+
+/**
+ * A container for an arbitrary number of nodes and links between their sockets.
+ */
+class Graph : NonCopyable, NonMovable {
+ private:
+  /**
+   * Used to allocate nodes and sockets in the graph.
+   */
+  LinearAllocator<> allocator_;
+  /**
+   * Contains all nodes in the graph so that it is efficient to iterate over them.
+   */
+  Vector<Node *> nodes_;
+
+ public:
+  ~Graph();
+
+  /**
+   * Get all nodes in the graph. The index in the span corresponds to #Node::index_in_graph.
+   */
+  Span<const Node *> nodes() const;
+
+  /**
+   * Add a new function node with sockets that match the passed in #LazyFunction.
+   */
+  FunctionNode &add_function(const LazyFunction &fn);
+
+  /**
+   * Add a new dummy node with the given socket types.
+   */
+  DummyNode &add_dummy(Span<const CPPType *> input_types, Span<const CPPType *> output_types);
+
+  /**
+   * Add a link between the two given sockets.
+   * This has undefined behavior when the input is linked to something else already.
+   */
+  void add_link(OutputSocket &from, InputSocket &to);
+
+  /**
+   * Make sure that #Node::index_in_graph is up to date.
+   */
+  void update_node_indices();
+
+  /**
+   * Can be used to assert that #update_node_indices has been called.
+   */
+  bool node_indices_are_valid() const;
+
+  /**
+   * Utility to generate a dot graph string for the graph. This can be used for debugging.
+   */
+  std::string to_dot() const;
+};
+
+/* -------------------------------------------------------------------- */
+/** \name #Socket Inline Methods
+ * \{ */
+
+inline bool Socket::is_input() const
+{
+  return is_input_;
+}
+
+inline bool Socket::is_output() const
+{
+  return !is_input_;
+}
+
+inline int Socket::index() const
+{
+  return index_in_node_;
+}
+
+inline InputSocket &Socket::as_input()
+{
+  BLI_assert(this->is_input());
+  return *static_cast<InputSocket *>(this);
+}
+
+inline OutputSocket &Socket::as_output()
+{
+  BLI_assert(this->is_output());
+  return *static_cast<OutputSocket *>(this);
+}
+
+inline const InputSocket &Socket::as_input() const
+{
+  BLI_assert(this->is_input());
+  return *static_cast<const InputSocket *>(this);
+}
+
+inline const OutputSocket &Socket::as_output() const
+{
+  BLI_assert(this->is_output());
+  return *static_cast<const OutputSocket *>(this);
+}
+
+inline const Node &Socket::node() const
+{
+  return *node_;
+}
+
+inline Node &Socket::node()
+{
+  return *node_;
+}
+
+inline const CPPType &Socket::type() const
+{
+  return *type_;
+}
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name #InputSocket Inline Methods
+ * \{ */
+
+inline const OutputSocket *InputSocket::origin() const
+{
+  return origin_;
+}
+
+inline OutputSocket *InputSocket::origin()
+{
+  return origin_;
+}
+
+inline const void *InputSocket::default_value() const
+{
+  return default_value_;
+}
+
+inline void InputSocket::set_default_value(const void *value)
+{
+  default_value_ = value;
+}
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name #OutputSocket Inline Methods
+ * \{ */
+
+inline Span<const InputSocket *> OutputSocket::targets() const
+{
+  return targets_;
+}
+
+inline Span<InputSocket *> OutputSocket::targets()
+{
+  return targets_;
+}
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name #Node Inline Methods
+ * \{ */
+
+inline bool Node::is_dummy() const
+{
+  return fn_ == nullptr;
+}
+
+inline bool Node::is_function() const
+{
+  return fn_ != nullptr;
+}
+
+inline int Node::index_in_graph() const
+{
+  return index_in_graph_;
+}
+
+inline Span<const InputSocket *> Node::inputs() const
+{
+  return inputs_;
+}
+
+inline Span<const OutputSocket *> Node::outputs() const
+{
+  return outputs_;
+}
+
+inline Span<InputSocket *> Node::inputs()
+{
+  return inputs_;
+}
+
+inline Span<OutputSocket *> Node::outputs()
+{
+  return outputs_;
+}
+
+inline const InputSocket &Node::input(const int index) const
+{
+  return *inputs_[index];
+}
+
+inline const OutputSocket &Node::output(const int index) const
+{
+  return *outputs_[index];
+}
+
+inline InputSocket &Node::input(const int index)
+{
+  return *inputs_[index];
+}
+
+inline OutputSocket &Node::output(const int index)
+{
+  return *outputs_[index];
+}
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name #FunctionNode Inline Methods
+ * \{ */
+
+inline const LazyFunction &FunctionNode::function() const
+{
+  BLI_assert(fn_ != nullptr);
+  return *fn_;
+}
+
+/** \} */
+
+/* -------------------------------------------------------------------- */
+/** \name #Graph Inline Methods
+ * \{ */
+
+inline Span<const Node *> Graph::nodes() const
+{
+  return nodes_;
+}
+
+/** \} */
+
+}  // namespace blender::fn::lazy_function

source/blender/functions/FN_lazy_function_graph_executor.hh

@@ -0,0 +1,98 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+
+#pragma once
+
+/** \file
+ * \ingroup fn
+ *
+ * This file provides means to create a #LazyFunction from #Graph (which could then e.g. be used in
+ * another #Graph again).
+ */
+
+#include "BLI_vector.hh"
+#include "BLI_vector_set.hh"
+
+#include "FN_lazy_function_graph.hh"
+
+namespace blender::fn::lazy_function {
+
+/**
+ * Can be implemented to log values produced during graph evaluation.
+ */
+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;
+};
+
+/**
+ * Has to be implemented when some of the nodes in the graph may have side effects. The
+ * #GraphExecutor has to know about that to make sure that these nodes will be executed even though
+ * their outputs are not needed.
+ */
+class GraphExecutorSideEffectProvider {
+ public:
+  virtual ~GraphExecutorSideEffectProvider() = default;
+  virtual Vector<const FunctionNode *> get_nodes_with_side_effects(const Context &context) const;
+};
+
+class GraphExecutor : public LazyFunction {
+ public:
+  using Logger = GraphExecutorLogger;
+  using SideEffectProvider = GraphExecutorSideEffectProvider;
+
+ private:
+  /**
+   * The graph that is evaluated.
+   */
+  const Graph &graph_;
+  /**
+   * Input and output sockets of the entire graph.
+   */
+  VectorSet<const OutputSocket *> graph_inputs_;
+  VectorSet<const InputSocket *> graph_outputs_;
+  /**
+   * Optional logger for events that happen during execution.
+   */
+  const Logger *logger_;
+  /**
+   * Optional side effect provider. It knows which nodes have side effects based on the context
+   * during evaluation.
+   */
+  const SideEffectProvider *side_effect_provider_;
+
+  friend class Executor;
+
+ public:
+  GraphExecutor(const Graph &graph,
+                Span<const OutputSocket *> graph_inputs,
+                Span<const InputSocket *> graph_outputs,
+                const Logger *logger,
+                const SideEffectProvider *side_effect_provider);
+
+  void *init_storage(LinearAllocator<> &allocator) const override;
+  void destruct_storage(void *storage) const override;
+
+ private:
+  void execute_impl(Params &params, const Context &context) const override;
+};
+
+}  // namespace blender::fn::lazy_function

source/blender/functions/FN_multi_function.hh

@@ -157,6 +157,7 @@ namespace multi_function_types {
 using fn::MFContext;
 using fn::MFContextBuilder;
 using fn::MFDataType;
+using fn::MFParamCategory;
 using fn::MFParams;
 using fn::MFParamsBuilder;
 using fn::MFParamType;

source/blender/functions/intern/cpp_types.cc

@@ -16,3 +16,6 @@ MAKE_FIELD_CPP_TYPE(BoolField, bool);
 MAKE_FIELD_CPP_TYPE(Int8Field, int8_t);
 MAKE_FIELD_CPP_TYPE(Int32Field, int32_t);
 MAKE_FIELD_CPP_TYPE(StringField, std::string);
+BLI_CPP_TYPE_MAKE(StringValueOrFieldVector,
+                  blender::Vector<blender::fn::ValueOrField<std::string>>,
+                  CPPTypeFlags::None);

source/blender/functions/intern/lazy_function.cc

@@ -0,0 +1,66 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+
+/** \file
+ * \ingroup fn
+ */
+
+#include "BLI_array.hh"
+
+#include "FN_lazy_function.hh"
+
+namespace blender::fn::lazy_function {
+
+std::string LazyFunction::name() const
+{
+  return debug_name_;
+}
+
+std::string LazyFunction::input_name(int index) const
+{
+  return inputs_[index].debug_name;
+}
+
+std::string LazyFunction::output_name(int index) const
+{
+  return outputs_[index].debug_name;
+}
+
+void *LazyFunction::init_storage(LinearAllocator<> &UNUSED(allocator)) const
+{
+  return nullptr;
+}
+
+void LazyFunction::destruct_storage(void *storage) const
+{
+  BLI_assert(storage == nullptr);
+  UNUSED_VARS_NDEBUG(storage);
+}
+
+bool LazyFunction::always_used_inputs_available(const Params &params) const
+{
+  for (const int i : inputs_.index_range()) {
+    const Input &fn_input = inputs_[i];
+    if (fn_input.usage == ValueUsage::Used) {
+      if (params.try_get_input_data_ptr(i) == nullptr) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+void Params::set_default_remaining_outputs()
+{
+  for (const int i : fn_.outputs().index_range()) {
+    if (this->output_was_set(i)) {
+      continue;
+    }
+    const Output &fn_output = fn_.outputs()[i];
+    const CPPType &type = *fn_output.type;
+    void *data_ptr = this->get_output_data_ptr(i);
+    type.value_initialize(data_ptr);
+    this->output_set(i);
+  }
+}
+
+}  // namespace blender::fn::lazy_function

source/blender/functions/intern/lazy_function_execute.cc

@@ -0,0 +1,65 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+
+/** \file
+ * \ingroup fn
+ */
+
+#include "FN_lazy_function_execute.hh"
+
+namespace blender::fn::lazy_function {
+
+BasicParams::BasicParams(const LazyFunction &fn,
+                         const Span<GMutablePointer> inputs,
+                         const Span<GMutablePointer> outputs,
+                         MutableSpan<std::optional<ValueUsage>> input_usages,
+                         Span<ValueUsage> output_usages,
+                         MutableSpan<bool> set_outputs)
+    : Params(fn),
+      inputs_(inputs),
+      outputs_(outputs),
+      input_usages_(input_usages),
+      output_usages_(output_usages),
+      set_outputs_(set_outputs)
+{
+}
+
+void *BasicParams::try_get_input_data_ptr_impl(const int index) const
+{
+  return inputs_[index].get();
+}
+
+void *BasicParams::try_get_input_data_ptr_or_request_impl(const int index)
+{
+  void *value = inputs_[index].get();
+  if (value == nullptr) {
+    input_usages_[index] = ValueUsage::Used;
+  }
+  return value;
+}
+
+void *BasicParams::get_output_data_ptr_impl(const int index)
+{
+  return outputs_[index].get();
+}
+
+void BasicParams::output_set_impl(const int index)
+{
+  set_outputs_[index] = true;
+}
+
+bool BasicParams::output_was_set_impl(const int index) const
+{
+  return set_outputs_[index];
+}
+
+ValueUsage BasicParams::get_output_usage_impl(const int index) const
+{
+  return output_usages_[index];
+}
+
+void BasicParams::set_input_unused_impl(const int index)
+{
+  input_usages_[index] = ValueUsage::Unused;
+}
+
+}  // namespace blender::fn::lazy_function

source/blender/functions/intern/lazy_function_graph.cc

@@ -0,0 +1,181 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+
+#include "BLI_dot_export.hh"
+
+#include "FN_lazy_function_graph.hh"
+
+namespace blender::fn::lazy_function {
+
+Graph::~Graph()
+{
+  for (Node *node : nodes_) {
+    for (InputSocket *socket : node->inputs_) {
+      std::destroy_at(socket);
+    }
+    for (OutputSocket *socket : node->outputs_) {
+      std::destroy_at(socket);
+    }
+    std::destroy_at(node);
+  }
+}
+
+FunctionNode &Graph::add_function(const LazyFunction &fn)
+{
+  const Span<Input> inputs = fn.inputs();
+  const Span<Output> outputs = fn.outputs();
+
+  FunctionNode &node = *allocator_.construct<FunctionNode>().release();
+  node.fn_ = &fn;
+  node.inputs_ = allocator_.construct_elements_and_pointer_array<InputSocket>(inputs.size());
+  node.outputs_ = allocator_.construct_elements_and_pointer_array<OutputSocket>(outputs.size());
+
+  for (const int i : inputs.index_range()) {
+    InputSocket &socket = *node.inputs_[i];
+    socket.index_in_node_ = i;
+    socket.is_input_ = true;
+    socket.node_ = &node;
+    socket.type_ = inputs[i].type;
+  }
+  for (const int i : outputs.index_range()) {
+    OutputSocket &socket = *node.outputs_[i];
+    socket.index_in_node_ = i;
+    socket.is_input_ = false;
+    socket.node_ = &node;
+    socket.type_ = outputs[i].type;
+  }
+
+  nodes_.append(&node);
+  return node;
+}
+
+DummyNode &Graph::add_dummy(Span<const CPPType *> input_types, Span<const CPPType *> output_types)
+{
+  DummyNode &node = *allocator_.construct<DummyNode>().release();
+  node.fn_ = nullptr;
+  node.inputs_ = allocator_.construct_elements_and_pointer_array<InputSocket>(input_types.size());
+  node.outputs_ = allocator_.construct_elements_and_pointer_array<OutputSocket>(
+      output_types.size());
+
+  for (const int i : input_types.index_range()) {
+    InputSocket &socket = *node.inputs_[i];
+    socket.index_in_node_ = i;
+    socket.is_input_ = true;
+    socket.node_ = &node;
+    socket.type_ = input_types[i];
+  }
+  for (const int i : output_types.index_range()) {
+    OutputSocket &socket = *node.outputs_[i];
+    socket.index_in_node_ = i;
+    socket.is_input_ = false;
+    socket.node_ = &node;
+    socket.type_ = output_types[i];
+  }
+
+  nodes_.append(&node);
+  return node;
+}
+
+void Graph::add_link(OutputSocket &from, InputSocket &to)
+{
+  BLI_assert(to.origin_ == nullptr);
+  BLI_assert(from.type_ == to.type_);
+  to.origin_ = &from;
+  from.targets_.append(&to);
+}
+
+void Graph::update_node_indices()
+{
+  for (const int i : nodes_.index_range()) {
+    nodes_[i]->index_in_graph_ = i;
+  }
+}
+
+bool Graph::node_indices_are_valid() const
+{
+  for (const int i : nodes_.index_range()) {
+    if (nodes_[i]->index_in_graph_ != i) {
+      return false;
+    }
+  }
+  return true;
+}
+
+std::string Socket::name() const
+{
+  if (node_->is_function()) {
+    const FunctionNode &fn_node = static_cast<const FunctionNode &>(*node_);
+    const LazyFunction &fn = fn_node.function();
+    if (is_input_) {
+      return fn.input_name(index_in_node_);
+    }
+    return fn.output_name(index_in_node_);
+  }
+  return "Unnamed";
+}
+
+std::string Node::name() const
+{
+  if (fn_ == nullptr) {
+    return static_cast<const DummyNode *>(this)->name_;
+  }
+  return fn_->name();
+}
+
+std::string Graph::to_dot() const
+{
+  dot::DirectedGraph digraph;
+  digraph.set_rankdir(dot::Attr_rankdir::LeftToRight);
+
+  Map<const Node *, dot::NodeWithSocketsRef> dot_nodes;
+
+  for (const Node *node : nodes_) {
+    dot::Node &dot_node = digraph.new_node("");
+    if (node->is_dummy()) {
+      dot_node.set_background_color("lightblue");
+    }
+    else {
+      dot_node.set_background_color("white");
+    }
+
+    Vector<std::string> input_names;
+    Vector<std::string> output_names;
+    for (const InputSocket *socket : node->inputs()) {
+      input_names.append(socket->name());
+    }
+    for (const OutputSocket *socket : node->outputs()) {
+      output_names.append(socket->name());
+    }
+
+    dot_nodes.add_new(node,
+                      dot::NodeWithSocketsRef(dot_node, node->name(), input_names, output_names));
+  }
+
+  for (const Node *node : nodes_) {
+    for (const InputSocket *socket : node->inputs()) {
+      const dot::NodeWithSocketsRef &to_dot_node = dot_nodes.lookup(&socket->node());
+      const dot::NodePort to_dot_port = to_dot_node.input(socket->index());
+
+      if (const OutputSocket *origin = socket->origin()) {
+        dot::NodeWithSocketsRef &from_dot_node = dot_nodes.lookup(&origin->node());
+        digraph.new_edge(from_dot_node.output(origin->index()), to_dot_port);
+      }
+      else if (const void *default_value = socket->default_value()) {
+        const CPPType &type = socket->type();
+        std::string value_string;
+        if (type.is_printable()) {
+          value_string = type.to_string(default_value);
+        }
+        else {
+          value_string = "<" + type.name() + ">";
+        }
+        dot::Node &default_value_dot_node = digraph.new_node(value_string);
+        default_value_dot_node.set_shape(dot::Attr_shape::Ellipse);
+        digraph.new_edge(default_value_dot_node, to_dot_port);
+      }
+    }
+  }
+
+  return digraph.to_dot_string();
+}
+
+}  // namespace blender::fn::lazy_function

source/blender/functions/tests/FN_lazy_function_test.cc

@@ -0,0 +1,115 @@
+/* SPDX-License-Identifier: Apache-2.0 */
+
+#include "testing/testing.h"
+
+#include "FN_lazy_function_execute.hh"
+#include "FN_lazy_function_graph.hh"
+#include "FN_lazy_function_graph_executor.hh"
+
+#include "BLI_task.h"
+#include "BLI_timeit.hh"
+
+namespace blender::fn::lazy_function::tests {
+
+class AddLazyFunction : public LazyFunction {
+ public:
+  AddLazyFunction()
+  {
+    debug_name_ = "Add";
+    inputs_.append({"A", CPPType::get<int>()});
+    inputs_.append({"B", CPPType::get<int>()});
+    outputs_.append({"Result", CPPType::get<int>()});
+  }
+
+  void execute_impl(Params &params, const Context &UNUSED(context)) const override
+  {
+    const int a = params.get_input<int>(0);
+    const int b = params.get_input<int>(1);
+    params.set_output(0, a + b);
+  }
+};
+
+class StoreValueFunction : public LazyFunction {
+ private:
+  int *dst1_;
+  int *dst2_;
+
+ public:
+  StoreValueFunction(int *dst1, int *dst2) : dst1_(dst1), dst2_(dst2)
+  {
+    debug_name_ = "Store Value";
+    inputs_.append({"A", CPPType::get<int>()});
+    inputs_.append({"B", CPPType::get<int>(), ValueUsage::Maybe});
+  }
+
+  void execute_impl(Params &params, const Context &UNUSED(context)) const override
+  {
+    *dst1_ = params.get_input<int>(0);
+    if (int *value = params.try_get_input_data_ptr_or_request<int>(1)) {
+      *dst2_ = *value;
+    }
+  }
+};
+
+class SimpleSideEffectProvider : public GraphExecutor::SideEffectProvider {
+ private:
+  Vector<const FunctionNode *> side_effect_nodes_;
+
+ public:
+  SimpleSideEffectProvider(Span<const FunctionNode *> side_effect_nodes)
+      : side_effect_nodes_(side_effect_nodes)
+  {
+  }
+
+  Vector<const FunctionNode *> get_nodes_with_side_effects(
+      const Context &UNUSED(context)) const override
+  {
+    return side_effect_nodes_;
+  }
+};
+
+TEST(lazy_function, SimpleAdd)
+{
+  const AddLazyFunction add_fn;
+  int result = 0;
+  execute_lazy_function_eagerly(add_fn, nullptr, std::make_tuple(30, 5), std::make_tuple(&result));
+  EXPECT_EQ(result, 35);
+}
+
+TEST(lazy_function, SideEffects)
+{
+  BLI_task_scheduler_init();
+  int dst1 = 0;
+  int dst2 = 0;
+
+  const AddLazyFunction add_fn;
+  const StoreValueFunction store_fn{&dst1, &dst2};
+
+  Graph graph;
+  FunctionNode &add_node_1 = graph.add_function(add_fn);
+  FunctionNode &add_node_2 = graph.add_function(add_fn);
+  FunctionNode &store_node = graph.add_function(store_fn);
+  DummyNode &input_node = graph.add_dummy({}, {&CPPType::get<int>()});
+
+  graph.add_link(input_node.output(0), add_node_1.input(0));
+  graph.add_link(input_node.output(0), add_node_2.input(0));
+  graph.add_link(add_node_1.output(0), store_node.input(0));
+  graph.add_link(add_node_2.output(0), store_node.input(1));
+
+  const int value_10 = 10;
+  const int value_100 = 100;
+  add_node_1.input(1).set_default_value(&value_10);
+  add_node_2.input(1).set_default_value(&value_100);
+
+  graph.update_node_indices();
+
+  SimpleSideEffectProvider side_effect_provider{{&store_node}};
+
+  GraphExecutor executor_fn{graph, {&input_node.output(0)}, {}, nullptr, &side_effect_provider};
+  execute_lazy_function_eagerly(executor_fn, nullptr, std::make_tuple(5), std::make_tuple());
+
+  EXPECT_EQ(dst1, 15);
+  EXPECT_EQ(dst2, 105);
+}
+
+}  // namespace blender::fn::lazy_function::tests

source/blender/makesdna/DNA_node_types.h

@@ -637,6 +637,9 @@ typedef struct bNodeTree {
   /** A span containing all nodes in the node tree. */
   blender::Span<bNode *> all_nodes();
   blender::Span<const bNode *> all_nodes() const;
+  /** A span containing all group nodes in the node tree. */
+  blender::Span<bNode *> group_nodes();
+  blender::Span<const bNode *> group_nodes() const;
   /** A span containing all input sockets in the node tree. */
   blender::Span<bNodeSocket *> all_input_sockets();
   blender::Span<const bNodeSocket *> all_input_sockets() const;

source/blender/modifiers/CMakeLists.txt

@@ -65,7 +65,6 @@ set(SRC
   intern/MOD_mirror.c
   intern/MOD_multires.c
   intern/MOD_nodes.cc
-  intern/MOD_nodes_evaluator.cc
   intern/MOD_none.c
   intern/MOD_normal_edit.c
   intern/MOD_ocean.c
@@ -105,7 +104,6 @@ set(SRC
   MOD_modifiertypes.h
   MOD_nodes.h
   intern/MOD_meshcache_util.h
-  intern/MOD_nodes_evaluator.hh
   intern/MOD_solidify_util.h
   intern/MOD_ui_common.h
   intern/MOD_util.h

source/blender/modifiers/intern/MOD_nodes.cc

@@ -36,6 +36,7 @@
 #include "DNA_windowmanager_types.h"
 
 #include "BKE_attribute_math.hh"
+#include "BKE_compute_contexts.hh"
 #include "BKE_customdata.h"
 #include "BKE_geometry_fields.hh"
 #include "BKE_geometry_set_instances.hh"
@@ -73,7 +74,6 @@
 
 #include "MOD_modifiertypes.h"
 #include "MOD_nodes.h"
-#include "MOD_nodes_evaluator.hh"
 #include "MOD_ui_common.h"
 
 #include "ED_object.h"
@@ -81,15 +81,18 @@
 #include "ED_spreadsheet.h"
 #include "ED_undo.h"
 
-#include "NOD_derived_node_tree.hh"
 #include "NOD_geometry.h"
-#include "NOD_geometry_nodes_eval_log.hh"
+#include "NOD_geometry_nodes_lazy_function.hh"
 #include "NOD_node_declaration.hh"
 
 #include "FN_field.hh"
 #include "FN_field_cpp_type.hh"
+#include "FN_lazy_function_execute.hh"
+#include "FN_lazy_function_graph_executor.hh"
 #include "FN_multi_function.hh"
 
+namespace lf = blender::fn::lazy_function;
+
 using blender::Array;
 using blender::ColorGeometry4f;
 using blender::CPPType;
@@ -106,6 +109,7 @@ using blender::MultiValueMap;
 using blender::MutableSpan;
 using blender::Set;
 using blender::Span;
+using blender::Stack;
 using blender::StringRef;
 using blender::StringRefNull;
 using blender::Vector;
@@ -117,11 +121,17 @@ using blender::fn::ValueOrFieldCPPType;
 using blender::nodes::FieldInferencingInterface;
 using blender::nodes::GeoNodeExecParams;
 using blender::nodes::InputSocketFieldType;
+using blender::nodes::geo_eval_log::GeoModifierLog;
 using blender::threading::EnumerableThreadSpecific;
 using namespace blender::fn::multi_function_types;
-using namespace blender::nodes::derived_node_tree_types;
-using geo_log::eNamedAttrUsage;
-using geo_log::GeometryAttributeInfo;
+using blender::nodes::geo_eval_log::GeometryAttributeInfo;
+using blender::nodes::geo_eval_log::GeometryInfoLog;
+using blender::nodes::geo_eval_log::GeoNodeLog;
+using blender::nodes::geo_eval_log::GeoTreeLog;
+using blender::nodes::geo_eval_log::NamedAttributeUsage;
+using blender::nodes::geo_eval_log::NodeWarning;
+using blender::nodes::geo_eval_log::NodeWarningType;
+using blender::nodes::geo_eval_log::ValueLog;
 
 static void initData(ModifierData *md)
 {
@@ -756,36 +766,37 @@ void MOD_nodes_update_interface(Object *object, NodesModifierData *nmd)
 }
 
 static void initialize_group_input(NodesModifierData &nmd,
-                                   const bNodeSocket &socket,
+                                   const bNodeSocket &interface_socket,
+                                   const int input_index,
                                    void *r_value)
 {
-  const bNodeSocketType &socket_type = *socket.typeinfo;
-  const bNodeSocket &bsocket = socket;
-  const eNodeSocketDatatype socket_data_type = static_cast<eNodeSocketDatatype>(bsocket.type);
+  const bNodeSocketType &socket_type = *interface_socket.typeinfo;
+  const eNodeSocketDatatype socket_data_type = static_cast<eNodeSocketDatatype>(
+      interface_socket.type);
   if (nmd.settings.properties == nullptr) {
-    socket_type.get_geometry_nodes_cpp_value(bsocket, r_value);
+    socket_type.get_geometry_nodes_cpp_value(interface_socket, r_value);
     return;
   }
   const IDProperty *property = IDP_GetPropertyFromGroup(nmd.settings.properties,
-                                                        socket.identifier);
+                                                        interface_socket.identifier);
   if (property == nullptr) {
-    socket_type.get_geometry_nodes_cpp_value(bsocket, r_value);
+    socket_type.get_geometry_nodes_cpp_value(interface_socket, r_value);
     return;
   }
-  if (!id_property_type_matches_socket(bsocket, *property)) {
-    socket_type.get_geometry_nodes_cpp_value(bsocket, r_value);
+  if (!id_property_type_matches_socket(interface_socket, *property)) {
+    socket_type.get_geometry_nodes_cpp_value(interface_socket, r_value);
     return;
   }
 
-  if (!input_has_attribute_toggle(*nmd.node_group, socket.runtime->index_in_node)) {
+  if (!input_has_attribute_toggle(*nmd.node_group, input_index)) {
     init_socket_cpp_value_from_property(*property, socket_data_type, r_value);
     return;
   }
 
   const IDProperty *property_use_attribute = IDP_GetPropertyFromGroup(
-      nmd.settings.properties, (socket.identifier + use_attribute_suffix).c_str());
+      nmd.settings.properties, (interface_socket.identifier + use_attribute_suffix).c_str());
   const IDProperty *property_attribute_name = IDP_GetPropertyFromGroup(
-      nmd.settings.properties, (socket.identifier + attribute_name_suffix).c_str());
+      nmd.settings.properties, (interface_socket.identifier + attribute_name_suffix).c_str());
   if (property_use_attribute == nullptr || property_attribute_name == nullptr) {
     init_socket_cpp_value_from_property(*property, socket_data_type, r_value);
     return;
@@ -831,13 +842,25 @@ static Vector<SpaceSpreadsheet *> find_spreadsheet_editors(Main *bmain)
   return spreadsheets;
 }
 
-static void find_sockets_to_preview_for_spreadsheet(SpaceSpreadsheet *sspreadsheet,
-                                                    NodesModifierData *nmd,
-                                                    const ModifierEvalContext *ctx,
-                                                    const DerivedNodeTree &tree,
-                                                    Set<DSocket> &r_sockets_to_preview)
+static const lf::FunctionNode &find_viewer_lf_node(const bNode &viewer_bnode)
 {
-  Vector<SpreadsheetContext *> context_path = sspreadsheet->context_path;
+  return *blender::nodes::ensure_geometry_nodes_lazy_function_graph(viewer_bnode.owner_tree())
+              ->mapping.viewer_node_map.lookup(&viewer_bnode);
+}
+static const lf::FunctionNode &find_group_lf_node(const bNode &group_bnode)
+{
+  return *blender::nodes::ensure_geometry_nodes_lazy_function_graph(group_bnode.owner_tree())
+              ->mapping.group_node_map.lookup(&group_bnode);
+}
+
+static void find_side_effect_nodes_for_spreadsheet(
+    const SpaceSpreadsheet &sspreadsheet,
+    const NodesModifierData &nmd,
+    const ModifierEvalContext &ctx,
+    const bNodeTree &root_tree,
+    MultiValueMap<blender::ComputeContextHash, const lf::FunctionNode *> &r_side_effect_nodes)
+{
+  Vector<SpreadsheetContext *> context_path = sspreadsheet.context_path;
   if (context_path.size() < 3) {
     return;
   }
@@ -848,11 +871,11 @@ static void find_sockets_to_preview_for_spreadsheet(SpaceSpreadsheet *sspreadshe
     return;
   }
   SpreadsheetContextObject *object_context = (SpreadsheetContextObject *)context_path[0];
-  if (object_context->object != DEG_get_original_object(ctx->object)) {
+  if (object_context->object != DEG_get_original_object(ctx.object)) {
     return;
   }
   SpreadsheetContextModifier *modifier_context = (SpreadsheetContextModifier *)context_path[1];
-  if (StringRef(modifier_context->modifier_name) != nmd->modifier.name) {
+  if (StringRef(modifier_context->modifier_name) != nmd.modifier.name) {
     return;
   }
   for (SpreadsheetContext *context : context_path.as_span().drop_front(2)) {
@@ -861,61 +884,77 @@ static void find_sockets_to_preview_for_spreadsheet(SpaceSpreadsheet *sspreadshe
     }
   }
 
-  Span<SpreadsheetContextNode *> nested_group_contexts =
-      context_path.as_span().drop_front(2).drop_back(1).cast<SpreadsheetContextNode *>();
-  SpreadsheetContextNode *last_context = (SpreadsheetContextNode *)context_path.last();
+  blender::ComputeContextBuilder compute_context_builder;
+  compute_context_builder.push<blender::bke::ModifierComputeContext>(nmd.modifier.name);
 
-  const DTreeContext *context = &tree.root_context();
+  const Span<SpreadsheetContextNode *> nested_group_contexts =
+      context_path.as_span().drop_front(2).drop_back(1).cast<SpreadsheetContextNode *>();
+  const SpreadsheetContextNode *last_context = (SpreadsheetContextNode *)context_path.last();
+
+  Stack<const bNode *> group_node_stack;
+  const bNodeTree *group = &root_tree;
   for (SpreadsheetContextNode *node_context : nested_group_contexts) {
-    const bNodeTree &btree = context->btree();
     const bNode *found_node = nullptr;
-    for (const bNode *bnode : btree.all_nodes()) {
-      if (STREQ(bnode->name, node_context->node_name)) {
-        found_node = bnode;
+    for (const bNode *node : group->group_nodes()) {
+      if (STREQ(node->name, node_context->node_name)) {
+        found_node = node;
         break;
       }
     }
     if (found_node == nullptr) {
       return;
     }
-    context = context->child_context(*found_node);
-    if (context == nullptr) {
+    if (found_node->id == nullptr) {
       return;
     }
+    group_node_stack.push(found_node);
+    group = reinterpret_cast<const bNodeTree *>(found_node->id);
+    compute_context_builder.push<blender::bke::NodeGroupComputeContext>(node_context->node_name);
   }
 
-  const bNodeTree &btree = context->btree();
-  for (const bNode *bnode : btree.nodes_by_type("GeometryNodeViewer")) {
-    if (STREQ(bnode->name, last_context->node_name)) {
-      const DNode viewer_node{context, bnode};
-      for (const bNodeSocket *input_socket : bnode->input_sockets()) {
-        if (input_socket->is_available() && input_socket->is_logically_linked()) {
-          r_sockets_to_preview.add(DSocket{context, input_socket});
-        }
-      }
+  const bNode *found_viewer_node = nullptr;
+  for (const bNode *viewer_node : group->nodes_by_type("GeometryNodeViewer")) {
+    if (STREQ(viewer_node->name, last_context->node_name)) {
+      found_viewer_node = viewer_node;
+      break;
     }
   }
+  if (found_viewer_node == nullptr) {
+    return;
+  }
+
+  /* Not only mark the viewer node as having side effects, but also all group nodes it is contained
+   * in. */
+  r_side_effect_nodes.add(compute_context_builder.hash(),
+                          &find_viewer_lf_node(*found_viewer_node));
+  compute_context_builder.pop();
+  while (!compute_context_builder.is_empty()) {
+    r_side_effect_nodes.add(compute_context_builder.hash(),
+                            &find_group_lf_node(*group_node_stack.pop()));
+    compute_context_builder.pop();
+  }
 }
 
-static void find_sockets_to_preview(NodesModifierData *nmd,
-                                    const ModifierEvalContext *ctx,
-                                    const DerivedNodeTree &tree,
-                                    Set<DSocket> &r_sockets_to_preview)
+static void find_side_effect_nodes(
+    const NodesModifierData &nmd,
+    const ModifierEvalContext &ctx,
+    const bNodeTree &tree,
+    MultiValueMap<blender::ComputeContextHash, const lf::FunctionNode *> &r_side_effect_nodes)
 {
-  Main *bmain = DEG_get_bmain(ctx->depsgraph);
+  Main *bmain = DEG_get_bmain(ctx.depsgraph);
 
   /* Based on every visible spreadsheet context path, get a list of sockets that need to have their
    * intermediate geometries cached for display. */
   Vector<SpaceSpreadsheet *> spreadsheets = find_spreadsheet_editors(bmain);
   for (SpaceSpreadsheet *sspreadsheet : spreadsheets) {
-    find_sockets_to_preview_for_spreadsheet(sspreadsheet, nmd, ctx, tree, r_sockets_to_preview);
+    find_side_effect_nodes_for_spreadsheet(*sspreadsheet, nmd, ctx, tree, r_side_effect_nodes);
   }
 }
 
 static void clear_runtime_data(NodesModifierData *nmd)
 {
   if (nmd->runtime_eval_log != nullptr) {
-    delete (geo_log::ModifierLog *)nmd->runtime_eval_log;
+    delete static_cast<GeoModifierLog *>(nmd->runtime_eval_log);
     nmd->runtime_eval_log = nullptr;
   }
 }
@@ -1079,92 +1118,104 @@ static void store_output_attributes(GeometrySet &geometry,
 /**
  * Evaluate a node group to compute the output geometry.
  */
-static GeometrySet compute_geometry(const DerivedNodeTree &tree,
-                                    Span<const bNode *> group_input_nodes,
-                                    const bNode &output_node,
-                                    GeometrySet input_geometry_set,
-                                    NodesModifierData *nmd,
-                                    const ModifierEvalContext *ctx)
+static GeometrySet compute_geometry(
+    const bNodeTree &btree,
+    const blender::nodes::GeometryNodesLazyFunctionGraphInfo &lf_graph_info,
+    const bNode &output_node,
+    GeometrySet input_geometry_set,
+    NodesModifierData *nmd,
+    const ModifierEvalContext *ctx)
 {
-  blender::ResourceScope scope;
-  blender::LinearAllocator<> &allocator = scope.linear_allocator();
-  blender::nodes::NodeMultiFunctions mf_by_node{tree};
+  const blender::nodes::GeometryNodeLazyFunctionGraphMapping &mapping = lf_graph_info.mapping;
 
-  Map<DOutputSocket, GMutablePointer> group_inputs;
+  Span<const lf::OutputSocket *> graph_inputs = mapping.group_input_sockets;
+  Vector<const lf::InputSocket *> graph_outputs;
+  for (const bNodeSocket *bsocket : output_node.input_sockets().drop_back(1)) {
+    const lf::InputSocket &socket = mapping.dummy_socket_map.lookup(bsocket)->as_input();
+    graph_outputs.append(&socket);
+  }
 
-  const DTreeContext *root_context = &tree.root_context();
-  for (const bNode *group_input_node : group_input_nodes) {
-    Span<const bNodeSocket *> group_input_sockets = group_input_node->output_sockets().drop_back(
-        1);
-    if (group_input_sockets.is_empty()) {
+  Array<GMutablePointer> param_inputs(graph_inputs.size());
+  Array<GMutablePointer> param_outputs(graph_outputs.size());
+  Array<std::optional<lf::ValueUsage>> param_input_usages(graph_inputs.size());
+  Array<lf::ValueUsage> param_output_usages(graph_outputs.size(), lf::ValueUsage::Used);
+  Array<bool> param_set_outputs(graph_outputs.size(), false);
+
+  blender::nodes::GeometryNodesLazyFunctionLogger lf_logger(lf_graph_info);
+  blender::nodes::GeometryNodesLazyFunctionSideEffectProvider lf_side_effect_provider(
+      lf_graph_info);
+
+  lf::GraphExecutor graph_executor{
+      lf_graph_info.graph, graph_inputs, graph_outputs, &lf_logger, &lf_side_effect_provider};
+
+  blender::nodes::GeoNodesModifierData geo_nodes_modifier_data;
+  geo_nodes_modifier_data.depsgraph = ctx->depsgraph;
+  geo_nodes_modifier_data.self_object = ctx->object;
+  auto eval_log = std::make_unique<GeoModifierLog>();
+  if (logging_enabled(ctx)) {
+    geo_nodes_modifier_data.eval_log = eval_log.get();
+  }
+  MultiValueMap<blender::ComputeContextHash, const lf::FunctionNode *> r_side_effect_nodes;
+  find_side_effect_nodes(*nmd, *ctx, btree, r_side_effect_nodes);
+  geo_nodes_modifier_data.side_effect_nodes = &r_side_effect_nodes;
+  blender::nodes::GeoNodesLFUserData user_data;
+  user_data.modifier_data = &geo_nodes_modifier_data;
+  blender::bke::ModifierComputeContext modifier_compute_context{nullptr, nmd->modifier.name};
+  user_data.compute_context = &modifier_compute_context;
+
+  blender::LinearAllocator<> allocator;
+  Vector<GMutablePointer> inputs_to_destruct;
+
+  int input_index;
+  LISTBASE_FOREACH_INDEX (bNodeSocket *, interface_socket, &btree.inputs, input_index) {
+    if (interface_socket->type == SOCK_GEOMETRY && input_index == 0) {
+      param_inputs[input_index] = &input_geometry_set;
       continue;
     }
 
-    Span<const bNodeSocket *> remaining_input_sockets = group_input_sockets;
-
-    /* If the group expects a geometry as first input, use the geometry that has been passed to
-     * modifier. */
-    const bNodeSocket *first_input_socket = group_input_sockets[0];
-    if (first_input_socket->type == SOCK_GEOMETRY) {
-      GeometrySet *geometry_set_in =
-          allocator.construct<GeometrySet>(input_geometry_set).release();
-      group_inputs.add_new({root_context, first_input_socket}, geometry_set_in);
-      remaining_input_sockets = remaining_input_sockets.drop_front(1);
-    }
-
-    /* Initialize remaining group inputs. */
-    for (const bNodeSocket *socket : remaining_input_sockets) {
-      const CPPType &cpp_type = *socket->typeinfo->geometry_nodes_cpp_type;
-      void *value_in = allocator.allocate(cpp_type.size(), cpp_type.alignment());
-      initialize_group_input(*nmd, *socket, value_in);
-      group_inputs.add_new({root_context, socket}, {cpp_type, value_in});
-    }
+    const CPPType *type = interface_socket->typeinfo->geometry_nodes_cpp_type;
+    BLI_assert(type != nullptr);
+    void *value = allocator.allocate(type->size(), type->alignment());
+    initialize_group_input(*nmd, *interface_socket, input_index, value);
+    param_inputs[input_index] = {type, value};
+    inputs_to_destruct.append({type, value});
   }
 
-  Vector<DInputSocket> group_outputs;
-  for (const bNodeSocket *socket_ref : output_node.input_sockets().drop_back(1)) {
-    group_outputs.append({root_context, socket_ref});
+  for (const int i : graph_outputs.index_range()) {
+    const lf::InputSocket &socket = *graph_outputs[i];
+    const CPPType &type = socket.type();
+    void *buffer = allocator.allocate(type.size(), type.alignment());
+    param_outputs[i] = {type, buffer};
   }
 
-  std::optional<geo_log::GeoLogger> geo_logger;
+  lf::Context lf_context;
+  lf_context.storage = graph_executor.init_storage(allocator);
+  lf_context.user_data = &user_data;
+  lf::BasicParams lf_params{graph_executor,
+                            param_inputs,
+                            param_outputs,
+                            param_input_usages,
+                            param_output_usages,
+                            param_set_outputs};
+  graph_executor.execute(lf_params, lf_context);
+  graph_executor.destruct_storage(lf_context.storage);
 
-  blender::modifiers::geometry_nodes::GeometryNodesEvaluationParams eval_params;
+  for (GMutablePointer &ptr : inputs_to_destruct) {
+    ptr.destruct();
+  }
+
+  GeometrySet output_geometry_set = std::move(*static_cast<GeometrySet *>(param_outputs[0].get()));
+  store_output_attributes(output_geometry_set, *nmd, output_node, param_outputs);
+
+  for (GMutablePointer &ptr : param_outputs) {
+    ptr.destruct();
+  }
 
   if (logging_enabled(ctx)) {
-    Set<DSocket> preview_sockets;
-    find_sockets_to_preview(nmd, ctx, tree, preview_sockets);
-    eval_params.force_compute_sockets.extend(preview_sockets.begin(), preview_sockets.end());
-    geo_logger.emplace(std::move(preview_sockets));
-
-    geo_logger->log_input_geometry(input_geometry_set);
-  }
-
-  /* Don't keep a reference to the input geometry components to avoid copies during evaluation. */
-  input_geometry_set.clear();
-
-  eval_params.input_values = group_inputs;
-  eval_params.output_sockets = group_outputs;
-  eval_params.mf_by_node = &mf_by_node;
-  eval_params.modifier_ = nmd;
-  eval_params.depsgraph = ctx->depsgraph;
-  eval_params.self_object = ctx->object;
-  eval_params.geo_logger = geo_logger.has_value() ? &*geo_logger : nullptr;
-  blender::modifiers::geometry_nodes::evaluate_geometry_nodes(eval_params);
-
-  GeometrySet output_geometry_set = std::move(*eval_params.r_output_values[0].get<GeometrySet>());
-
-  if (geo_logger.has_value()) {
-    geo_logger->log_output_geometry(output_geometry_set);
-    NodesModifierData *nmd_orig = (NodesModifierData *)BKE_modifier_get_original(ctx->object,
-                                                                                 &nmd->modifier);
-    clear_runtime_data(nmd_orig);
-    nmd_orig->runtime_eval_log = new geo_log::ModifierLog(*geo_logger);
-  }
-
-  store_output_attributes(output_geometry_set, *nmd, output_node, eval_params.r_output_values);
-
-  for (GMutablePointer value : eval_params.r_output_values) {
-    value.destruct();
+    NodesModifierData *nmd_orig = reinterpret_cast<NodesModifierData *>(
+        BKE_modifier_get_original(ctx->object, &nmd->modifier));
+    delete static_cast<GeoModifierLog *>(nmd_orig->runtime_eval_log);
+    nmd_orig->runtime_eval_log = eval_log.release();
   }
 
   return output_geometry_set;
@@ -1225,27 +1276,18 @@ static void modifyGeometry(ModifierData *md,
     return;
   }
 
+  const bNodeTree &tree = *nmd->node_group;
+  tree.ensure_topology_cache();
   check_property_socket_sync(ctx->object, md);
 
-  const bNodeTree &root_tree_ref = *nmd->node_group;
-  DerivedNodeTree tree{root_tree_ref};
-
-  if (tree.has_link_cycles()) {
-    BKE_modifier_set_error(ctx->object, md, "Node group has cycles");
+  const bNode *output_node = tree.group_output_node();
+  if (output_node == nullptr) {
+    BKE_modifier_set_error(ctx->object, md, "Node group must have a group output node");
     geometry_set.clear();
     return;
   }
 
-  Span<const bNode *> input_nodes = root_tree_ref.nodes_by_type("NodeGroupInput");
-  Span<const bNode *> output_nodes = root_tree_ref.nodes_by_type("NodeGroupOutput");
-  if (output_nodes.size() != 1) {
-    BKE_modifier_set_error(ctx->object, md, "Node group must have a single output node");
-    geometry_set.clear();
-    return;
-  }
-
-  const bNode &output_node = *output_nodes[0];
-  Span<const bNodeSocket *> group_outputs = output_node.input_sockets().drop_back(1);
+  Span<const bNodeSocket *> group_outputs = output_node->input_sockets().drop_back(1);
   if (group_outputs.is_empty()) {
     BKE_modifier_set_error(ctx->object, md, "Node group must have an output socket");
     geometry_set.clear();
@@ -1259,6 +1301,14 @@ static void modifyGeometry(ModifierData *md,
     return;
   }
 
+  const blender::nodes::GeometryNodesLazyFunctionGraphInfo *lf_graph_info =
+      blender::nodes::ensure_geometry_nodes_lazy_function_graph(tree);
+  if (lf_graph_info == nullptr) {
+    BKE_modifier_set_error(ctx->object, md, "Cannot evaluate node group");
+    geometry_set.clear();
+    return;
+  }
+
   bool use_orig_index_verts = false;
   bool use_orig_index_edges = false;
   bool use_orig_index_polys = false;
@@ -1270,7 +1320,7 @@ static void modifyGeometry(ModifierData *md,
   }
 
   geometry_set = compute_geometry(
-      tree, input_nodes, output_node, std::move(geometry_set), nmd, ctx);
+      tree, *lf_graph_info, *output_node, std::move(geometry_set), nmd, ctx);
 
   if (geometry_set.has_mesh()) {
     /* Add #CD_ORIGINDEX layers if they don't exist already. This is required because the
@@ -1342,6 +1392,16 @@ static NodesModifierData *get_modifier_data(Main &bmain,
   return reinterpret_cast<NodesModifierData *>(md);
 }
 
+static GeoTreeLog *get_root_tree_log(const NodesModifierData &nmd)
+{
+  if (nmd.runtime_eval_log == nullptr) {
+    return nullptr;
+  }
+  GeoModifierLog &modifier_log = *static_cast<GeoModifierLog *>(nmd.runtime_eval_log);
+  blender::bke::ModifierComputeContext compute_context{nullptr, nmd.modifier.name};
+  return &modifier_log.get_tree_log(compute_context.hash());
+}
+
 static void attribute_search_update_fn(
     const bContext *C, void *arg, const char *str, uiSearchItems *items, const bool is_first)
 {
@@ -1350,27 +1410,52 @@ static void attribute_search_update_fn(
   if (nmd == nullptr) {
     return;
   }
-  const geo_log::ModifierLog *modifier_log = static_cast<const geo_log::ModifierLog *>(
-      nmd->runtime_eval_log);
-  if (modifier_log == nullptr) {
+  if (nmd->node_group == nullptr) {
     return;
   }
-  const geo_log::GeometryValueLog *geometry_log = data.is_output ?
-                                                      modifier_log->output_geometry_log() :
-                                                      modifier_log->input_geometry_log();
-  if (geometry_log == nullptr) {
+  GeoTreeLog *tree_log = get_root_tree_log(*nmd);
+  if (tree_log == nullptr) {
     return;
   }
+  tree_log->ensure_existing_attributes();
+  nmd->node_group->ensure_topology_cache();
 
-  Span<GeometryAttributeInfo> infos = geometry_log->attributes();
-
-  /* The shared attribute search code expects a span of pointers, so convert to that. */
-  Array<const GeometryAttributeInfo *> info_ptrs(infos.size());
-  for (const int i : infos.index_range()) {
-    info_ptrs[i] = &infos[i];
+  Vector<const bNodeSocket *> sockets_to_check;
+  if (data.is_output) {
+    for (const bNode *node : nmd->node_group->nodes_by_type("NodeGroupOutput")) {
+      for (const bNodeSocket *socket : node->input_sockets()) {
+        if (socket->type == SOCK_GEOMETRY) {
+          sockets_to_check.append(socket);
+        }
+      }
+    }
+  }
+  else {
+    for (const bNode *node : nmd->node_group->nodes_by_type("NodeGroupInput")) {
+      for (const bNodeSocket *socket : node->output_sockets()) {
+        if (socket->type == SOCK_GEOMETRY) {
+          sockets_to_check.append(socket);
+        }
+      }
+    }
+  }
+  Set<StringRef> names;
+  Vector<const GeometryAttributeInfo *> attributes;
+  for (const bNodeSocket *socket : sockets_to_check) {
+    const ValueLog *value_log = tree_log->find_socket_value_log(*socket);
+    if (value_log == nullptr) {
+      continue;
+    }
+    if (const GeometryInfoLog *geo_log = dynamic_cast<const GeometryInfoLog *>(value_log)) {
+      for (const GeometryAttributeInfo &attribute : geo_log->attributes) {
+        if (names.add(attribute.name)) {
+          attributes.append(&attribute);
+        }
+      }
+    }
   }
   blender::ui::attribute_search_add_items(
-      str, data.is_output, info_ptrs.as_span(), items, is_first);
+      str, data.is_output, attributes.as_span(), items, is_first);
 }
 
 static void attribute_search_exec_fn(bContext *C, void *data_v, void *item_v)
@@ -1401,8 +1486,7 @@ static void add_attribute_search_button(const bContext &C,
                                         const bNodeSocket &socket,
                                         const bool is_output)
 {
-  const geo_log::ModifierLog *log = static_cast<geo_log::ModifierLog *>(nmd.runtime_eval_log);
-  if (log == nullptr) {
+  if (nmd.runtime_eval_log == nullptr) {
     uiItemR(layout, md_ptr, rna_path_attribute_name.c_str(), 0, "", ICON_NONE);
     return;
   }
@@ -1627,15 +1711,14 @@ static void panel_draw(const bContext *C, Panel *panel)
   }
 
   /* Draw node warnings. */
-  if (nmd->runtime_eval_log != nullptr) {
-    const geo_log::ModifierLog &log = *static_cast<geo_log::ModifierLog *>(nmd->runtime_eval_log);
-    log.foreach_node_log([&](const geo_log::NodeLog &node_log) {
-      for (const geo_log::NodeWarning &warning : node_log.warnings()) {
-        if (warning.type != geo_log::NodeWarningType::Info) {
-          uiItemL(layout, warning.message.c_str(), ICON_ERROR);
-        }
+  GeoTreeLog *tree_log = get_root_tree_log(*nmd);
+  if (tree_log != nullptr) {
+    tree_log->ensure_node_warnings();
+    for (const NodeWarning &warning : tree_log->all_warnings) {
+      if (warning.type != NodeWarningType::Info) {
+        uiItemL(layout, warning.message.c_str(), ICON_ERROR);
       }
-    });
+    }
   }
 
   modifier_panel_end(layout, ptr);
@@ -1672,17 +1755,14 @@ static void internal_dependencies_panel_draw(const bContext *UNUSED(C), Panel *p
   PointerRNA *ptr = modifier_panel_get_property_pointers(panel, nullptr);
   NodesModifierData *nmd = static_cast<NodesModifierData *>(ptr->data);
 
-  if (nmd->runtime_eval_log == nullptr) {
+  GeoTreeLog *tree_log = get_root_tree_log(*nmd);
+  if (tree_log == nullptr) {
     return;
   }
-  const geo_log::ModifierLog &log = *static_cast<geo_log::ModifierLog *>(nmd->runtime_eval_log);
-  Map<std::string, eNamedAttrUsage> usage_by_attribute;
-  log.foreach_node_log([&](const geo_log::NodeLog &node_log) {
-    for (const geo_log::UsedNamedAttribute &used_attribute : node_log.used_named_attributes()) {
-      usage_by_attribute.lookup_or_add_as(used_attribute.name,
-                                          used_attribute.usage) |= used_attribute.usage;
-    }
-  });
+
+  tree_log->ensure_used_named_attributes();
+  const Map<std::string, NamedAttributeUsage> &usage_by_attribute =
+      tree_log->used_named_attributes;
 
   if (usage_by_attribute.is_empty()) {
     uiItemL(layout, IFACE_("No named attributes used"), ICON_INFO);
@@ -1691,7 +1771,7 @@ static void internal_dependencies_panel_draw(const bContext *UNUSED(C), Panel *p
 
   struct NameWithUsage {
     StringRefNull name;
-    eNamedAttrUsage usage;
+    NamedAttributeUsage usage;
   };
 
   Vector<NameWithUsage> sorted_used_attribute;
@@ -1706,20 +1786,20 @@ static void internal_dependencies_panel_draw(const bContext *UNUSED(C), Panel *p
 
   for (const NameWithUsage &attribute : sorted_used_attribute) {
     const StringRefNull attribute_name = attribute.name;
-    const eNamedAttrUsage usage = attribute.usage;
+    const NamedAttributeUsage usage = attribute.usage;
 
     /* #uiLayoutRowWithHeading doesn't seem to work in this case. */
     uiLayout *split = uiLayoutSplit(layout, 0.4f, false);
 
     std::stringstream ss;
     Vector<std::string> usages;
-    if ((usage & eNamedAttrUsage::Read) != eNamedAttrUsage::None) {
+    if ((usage & NamedAttributeUsage::Read) != NamedAttributeUsage::None) {
       usages.append(TIP_("Read"));
     }
-    if ((usage & eNamedAttrUsage::Write) != eNamedAttrUsage::None) {
+    if ((usage & NamedAttributeUsage::Write) != NamedAttributeUsage::None) {
       usages.append(TIP_("Write"));
     }
-    if ((usage & eNamedAttrUsage::Remove) != eNamedAttrUsage::None) {
+    if ((usage & NamedAttributeUsage::Remove) != NamedAttributeUsage::None) {
       usages.append(TIP_("Remove"));
     }
     for (const int i : usages.index_range()) {

source/blender/modifiers/intern/MOD_nodes_evaluator.hh

@@ -1,44 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-
-#pragma once
-
-#include "BLI_generic_pointer.hh"
-#include "BLI_map.hh"
-
-#include "NOD_derived_node_tree.hh"
-#include "NOD_geometry_nodes_eval_log.hh"
-#include "NOD_multi_function.hh"
-
-#include "DNA_modifier_types.h"
-
-#include "FN_multi_function.hh"
-
-namespace geo_log = blender::nodes::geometry_nodes_eval_log;
-
-namespace blender::modifiers::geometry_nodes {
-
-using namespace nodes::derived_node_tree_types;
-
-struct GeometryNodesEvaluationParams {
-  blender::LinearAllocator<> allocator;
-
-  Map<DOutputSocket, GMutablePointer> input_values;
-  Vector<DInputSocket> output_sockets;
-  /* These sockets will be computed but are not part of the output. Their value can be retrieved in
-   * `log_socket_value_fn`. These sockets are not part of `output_sockets` because then the
-   * evaluator would have to keep the socket values in memory until the end, which might not be
-   * necessary in all cases. Sometimes `log_socket_value_fn` might just want to look at the value
-   * and then it can be freed. */
-  Vector<DSocket> force_compute_sockets;
-  nodes::NodeMultiFunctions *mf_by_node;
-  const NodesModifierData *modifier_;
-  Depsgraph *depsgraph;
-  Object *self_object;
-  geo_log::GeoLogger *geo_logger;
-
-  Vector<GMutablePointer> r_output_values;
-};
-
-void evaluate_geometry_nodes(GeometryNodesEvaluationParams &params);
-
-}  // namespace blender::modifiers::geometry_nodes

source/blender/nodes/CMakeLists.txt

@@ -40,7 +40,8 @@ set(INC
 
 set(SRC
   intern/derived_node_tree.cc
-  intern/geometry_nodes_eval_log.cc
+  intern/geometry_nodes_lazy_function.cc
+  intern/geometry_nodes_log.cc
   intern/math_functions.cc
   intern/node_common.cc
   intern/node_declaration.cc
@@ -58,7 +59,7 @@ set(SRC
   NOD_function.h
   NOD_geometry.h
   NOD_geometry_exec.hh
-  NOD_geometry_nodes_eval_log.hh
+  NOD_geometry_nodes_lazy_function.hh
   NOD_math_functions.hh
   NOD_multi_function.hh
   NOD_node_declaration.hh

source/blender/nodes/NOD_geometry_exec.hh

@@ -3,6 +3,7 @@
 #pragma once
 
 #include "FN_field.hh"
+#include "FN_lazy_function.hh"
 #include "FN_multi_function_builder.hh"
 
 #include "BKE_geometry_fields.hh"
@@ -11,9 +12,8 @@
 #include "DNA_node_types.h"
 
 #include "NOD_derived_node_tree.hh"
-#include "NOD_geometry_nodes_eval_log.hh"
+#include "NOD_geometry_nodes_lazy_function.hh"
 
-struct Depsgraph;
 struct ModifierData;
 
 namespace blender::nodes {
@@ -40,75 +40,18 @@ using fn::FieldInput;
 using fn::FieldOperation;
 using fn::GField;
 using fn::ValueOrField;
-using geometry_nodes_eval_log::eNamedAttrUsage;
-using geometry_nodes_eval_log::NodeWarningType;
-
-/**
- * This class exists to separate the memory management details of the geometry nodes evaluator
- * from the node execution functions and related utilities.
- */
-class GeoNodeExecParamsProvider {
- public:
-  DNode dnode;
-  const Object *self_object = nullptr;
-  const ModifierData *modifier = nullptr;
-  Depsgraph *depsgraph = nullptr;
-  geometry_nodes_eval_log::GeoLogger *logger = nullptr;
-
-  /**
-   * Returns true when the node is allowed to get/extract the input value. The identifier is
-   * expected to be valid. This may return false if the input value has been consumed already.
-   */
-  virtual bool can_get_input(StringRef identifier) const = 0;
-
-  /**
-   * Returns true when the node is allowed to set the output value. The identifier is expected to
-   * be valid. This may return false if the output value has been set already.
-   */
-  virtual bool can_set_output(StringRef identifier) const = 0;
-
-  /**
-   * Take ownership of an input value. The caller is responsible for destructing the value. It does
-   * not have to be freed, because the memory is managed by the geometry nodes evaluator.
-   */
-  virtual GMutablePointer extract_input(StringRef identifier) = 0;
-
-  /**
-   * Similar to #extract_input, but has to be used for multi-input sockets.
-   */
-  virtual Vector<GMutablePointer> extract_multi_input(StringRef identifier) = 0;
-
-  /**
-   * Get the input value for the identifier without taking ownership of it.
-   */
-  virtual GPointer get_input(StringRef identifier) const = 0;
-
-  /**
-   * Prepare a memory buffer for an output value of the node. The returned memory has to be
-   * initialized by the caller. The identifier and type are expected to be correct.
-   */
-  virtual GMutablePointer alloc_output_value(const CPPType &type) = 0;
-
-  /**
-   * The value has been allocated with #alloc_output_value.
-   */
-  virtual void set_output(StringRef identifier, GMutablePointer value) = 0;
-
-  /* A description for these methods is provided in GeoNodeExecParams. */
-  virtual void set_input_unused(StringRef identifier) = 0;
-  virtual bool output_is_required(StringRef identifier) const = 0;
-  virtual bool lazy_require_input(StringRef identifier) = 0;
-  virtual bool lazy_output_is_required(StringRef identifier) const = 0;
-
-  virtual void set_default_remaining_outputs() = 0;
-};
+using geo_eval_log::NamedAttributeUsage;
+using geo_eval_log::NodeWarningType;
 
 class GeoNodeExecParams {
  private:
-  GeoNodeExecParamsProvider *provider_;
+  const bNode &node_;
+  lf::Params &params_;
+  const lf::Context &lf_context_;
 
  public:
-  GeoNodeExecParams(GeoNodeExecParamsProvider &provider) : provider_(&provider)
+  GeoNodeExecParams(const bNode &node, lf::Params &params, const lf::Context &lf_context)
+      : node_(node), params_(params), lf_context_(lf_context)
   {
   }
 
@@ -116,20 +59,6 @@ class GeoNodeExecParams {
   static inline constexpr bool is_field_base_type_v =
       is_same_any_v<T, float, int, bool, ColorGeometry4f, float3, std::string>;
 
-  /**
-   * Get the input value for the input socket with the given identifier.
-   *
-   * The node calling becomes responsible for destructing the value before it is done
-   * executing. This method can only be called once for each identifier.
-   */
-  GMutablePointer extract_input(StringRef identifier)
-  {
-#ifdef DEBUG
-    this->check_input_access(identifier);
-#endif
-    return provider_->extract_input(identifier);
-  }
-
   /**
    * Get the input value for the input socket with the given identifier.
    *
@@ -151,8 +80,8 @@ class GeoNodeExecParams {
 #ifdef DEBUG
       this->check_input_access(identifier, &CPPType::get<T>());
 #endif
-      GMutablePointer gvalue = this->extract_input(identifier);
-      T value = gvalue.relocate_out<T>();
+      const int index = this->get_input_index(identifier);
+      T value = params_.extract_input<T>(index);
       if constexpr (std::is_same_v<T, GeometrySet>) {
         this->check_input_geometry_set(identifier, value);
       }
@@ -163,27 +92,6 @@ class GeoNodeExecParams {
   void check_input_geometry_set(StringRef identifier, const GeometrySet &geometry_set) const;
   void check_output_geometry_set(const GeometrySet &geometry_set) const;
 
-  /**
-   * Get input as vector for multi input socket with the given identifier.
-   *
-   * This method can only be called once for each identifier.
-   */
-  template<typename T> Vector<T> extract_multi_input(StringRef identifier)
-  {
-    Vector<GMutablePointer> gvalues = provider_->extract_multi_input(identifier);
-    Vector<T> values;
-    for (GMutablePointer gvalue : gvalues) {
-      if constexpr (is_field_base_type_v<T>) {
-        const ValueOrField<T> value_or_field = gvalue.relocate_out<ValueOrField<T>>();
-        values.append(value_or_field.as_value());
-      }
-      else {
-        values.append(gvalue.relocate_out<T>());
-      }
-    }
-    return values;
-  }
-
   /**
    * Get the input value for the input socket with the given identifier.
    */
@@ -202,9 +110,8 @@ class GeoNodeExecParams {
 #ifdef DEBUG
       this->check_input_access(identifier, &CPPType::get<T>());
 #endif
-      GPointer gvalue = provider_->get_input(identifier);
-      BLI_assert(gvalue.is_type<T>());
-      const T &value = *(const T *)gvalue.get();
+      const int index = this->get_input_index(identifier);
+      const T &value = params_.get_input<T>(index);
       if constexpr (std::is_same_v<T, GeometrySet>) {
         this->check_input_geometry_set(identifier, value);
       }
@@ -226,25 +133,37 @@ class GeoNodeExecParams {
       this->set_output(identifier, ValueOrField<BaseType>(std::forward<T>(value)));
     }
     else {
-      const CPPType &type = CPPType::get<StoredT>();
 #ifdef DEBUG
+      const CPPType &type = CPPType::get<StoredT>();
       this->check_output_access(identifier, type);
 #endif
       if constexpr (std::is_same_v<StoredT, GeometrySet>) {
         this->check_output_geometry_set(value);
       }
-      GMutablePointer gvalue = provider_->alloc_output_value(type);
-      new (gvalue.get()) StoredT(std::forward<T>(value));
-      provider_->set_output(identifier, gvalue);
+      const int index = this->get_output_index(identifier);
+      params_.set_output(index, std::forward<T>(value));
     }
   }
 
+  geo_eval_log::GeoTreeLogger *get_local_tree_logger() const
+  {
+    GeoNodesLFUserData *user_data = this->user_data();
+    BLI_assert(user_data != nullptr);
+    const ComputeContext *compute_context = user_data->compute_context;
+    BLI_assert(compute_context != nullptr);
+    if (user_data->modifier_data->eval_log == nullptr) {
+      return nullptr;
+    }
+    return &user_data->modifier_data->eval_log->get_local_tree_logger(*compute_context);
+  }
+
   /**
    * Tell the evaluator that a specific input won't be used anymore.
    */
   void set_input_unused(StringRef identifier)
   {
-    provider_->set_input_unused(identifier);
+    const int index = this->get_input_index(identifier);
+    params_.set_input_unused(index);
   }
 
   /**
@@ -254,7 +173,8 @@ class GeoNodeExecParams {
    */
   bool output_is_required(StringRef identifier) const
   {
-    return provider_->output_is_required(identifier);
+    const int index = this->get_output_index(identifier);
+    return params_.get_output_usage(index) != lf::ValueUsage::Unused;
   }
 
   /**
@@ -265,7 +185,8 @@ class GeoNodeExecParams {
    */
   bool lazy_require_input(StringRef identifier)
   {
-    return provider_->lazy_require_input(identifier);
+    const int index = this->get_input_index(identifier);
+    return params_.try_get_input_data_ptr_or_request(index) == nullptr;
   }
 
   /**
@@ -275,7 +196,8 @@ class GeoNodeExecParams {
    */
   bool lazy_output_is_required(StringRef identifier)
   {
-    return provider_->lazy_output_is_required(identifier);
+    const int index = this->get_output_index(identifier);
+    return params_.get_output_usage(index) == lf::ValueUsage::Used;
   }
 
   /**
@@ -283,17 +205,32 @@ class GeoNodeExecParams {
    */
   const bNode &node() const
   {
-    return *provider_->dnode;
+    return node_;
   }
 
   const Object *self_object() const
   {
-    return provider_->self_object;
+    if (const auto *data = this->user_data()) {
+      if (data->modifier_data) {
+        return data->modifier_data->self_object;
+      }
+    }
+    return nullptr;
   }
 
   Depsgraph *depsgraph() const
   {
-    return provider_->depsgraph;
+    if (const auto *data = this->user_data()) {
+      if (data->modifier_data) {
+        return data->modifier_data->depsgraph;
+      }
+    }
+    return nullptr;
+  }
+
+  GeoNodesLFUserData *user_data() const
+  {
+    return dynamic_cast<GeoNodesLFUserData *>(lf_context_.user_data);
   }
 
   /**
@@ -306,7 +243,7 @@ class GeoNodeExecParams {
 
   void set_default_remaining_outputs();
 
-  void used_named_attribute(std::string attribute_name, eNamedAttrUsage usage);
+  void used_named_attribute(std::string attribute_name, NamedAttributeUsage usage);
 
  private:
   /* Utilities for detecting common errors at when using this class. */
@@ -315,6 +252,38 @@ class GeoNodeExecParams {
 
   /* Find the active socket with the input name (not the identifier). */
   const bNodeSocket *find_available_socket(const StringRef name) const;
+
+  int get_input_index(const StringRef identifier) const
+  {
+    int counter = 0;
+    for (const bNodeSocket *socket : node_.input_sockets()) {
+      if (!socket->is_available()) {
+        continue;
+      }
+      if (socket->identifier == identifier) {
+        return counter;
+      }
+      counter++;
+    }
+    BLI_assert_unreachable();
+    return -1;
+  }
+
+  int get_output_index(const StringRef identifier) const
+  {
+    int counter = 0;
+    for (const bNodeSocket *socket : node_.output_sockets()) {
+      if (!socket->is_available()) {
+        continue;
+      }
+      if (socket->identifier == identifier) {
+        return counter;
+      }
+      counter++;
+    }
+    BLI_assert_unreachable();
+    return -1;
+  }
 };
 
 }  // namespace blender::nodes

source/blender/nodes/NOD_geometry_nodes_eval_log.hh

@@ -1,411 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-
-#pragma once
-
-/**
- * Many geometry nodes related UI features need access to data produced during evaluation. Not only
- * is the final output required but also the intermediate results. Those features include
- * attribute search, node warnings, socket inspection and the viewer node.
- *
- * This file provides the framework for logging data during evaluation and accessing the data after
- * evaluation.
- *
- * During logging every thread gets its own local logger to avoid too much locking (logging
- * generally happens for every socket). After geometry nodes evaluation is done, the thread-local
- * logging information is combined and post-processed to make it easier for the UI to lookup.
- * necessary information.
- */
-
-#include "BLI_enumerable_thread_specific.hh"
-#include "BLI_function_ref.hh"
-#include "BLI_generic_pointer.hh"
-#include "BLI_linear_allocator.hh"
-#include "BLI_map.hh"
-
-#include "BKE_geometry_set.hh"
-
-#include "NOD_derived_node_tree.hh"
-
-#include "FN_field.hh"
-
-#include <chrono>
-
-struct SpaceNode;
-struct SpaceSpreadsheet;
-
-namespace blender::nodes::geometry_nodes_eval_log {
-
-/** Contains information about a value that has been computed during geometry nodes evaluation. */
-class ValueLog {
- public:
-  virtual ~ValueLog() = default;
-};
-
-/** Contains an owned copy of a value of a generic type. */
-class GenericValueLog : public ValueLog {
- private:
-  GMutablePointer data_;
-
- public:
-  GenericValueLog(GMutablePointer data) : data_(data)
-  {
-  }
-
-  ~GenericValueLog()
-  {
-    data_.destruct();
-  }
-
-  GPointer value() const
-  {
-    return data_;
-  }
-};
-
-class GFieldValueLog : public ValueLog {
- private:
-  fn::GField field_;
-  const CPPType &type_;
-  Vector<std::string> input_tooltips_;
-
- public:
-  GFieldValueLog(fn::GField field, bool log_full_field);
-
-  const fn::GField &field() const
-  {
-    return field_;
-  }
-
-  Span<std::string> input_tooltips() const
-  {
-    return input_tooltips_;
-  }
-
-  const CPPType &type() const
-  {
-    return type_;
-  }
-};
-
-struct GeometryAttributeInfo {
-  std::string name;
-  /** Can be empty when #name does not actually exist on a geometry yet. */
-  std::optional<eAttrDomain> domain;
-  std::optional<eCustomDataType> data_type;
-};
-
-/** Contains information about a geometry set. In most cases this does not store the entire
- * geometry set as this would require too much memory. */
-class GeometryValueLog : public ValueLog {
- private:
-  Vector<GeometryAttributeInfo> attributes_;
-  Vector<GeometryComponentType> component_types_;
-  std::unique_ptr<GeometrySet> full_geometry_;
-
- public:
-  struct MeshInfo {
-    int verts_num, edges_num, faces_num;
-  };
-  struct CurveInfo {
-    int splines_num;
-  };
-  struct PointCloudInfo {
-    int points_num;
-  };
-  struct InstancesInfo {
-    int instances_num;
-  };
-  struct EditDataInfo {
-    bool has_deformed_positions;
-    bool has_deform_matrices;
-  };
-
-  std::optional<MeshInfo> mesh_info;
-  std::optional<CurveInfo> curve_info;
-  std::optional<PointCloudInfo> pointcloud_info;
-  std::optional<InstancesInfo> instances_info;
-  std::optional<EditDataInfo> edit_data_info;
-
-  GeometryValueLog(const GeometrySet &geometry_set, bool log_full_geometry = false);
-
-  Span<GeometryAttributeInfo> attributes() const
-  {
-    return attributes_;
-  }
-
-  Span<GeometryComponentType> component_types() const
-  {
-    return component_types_;
-  }
-
-  const GeometrySet *full_geometry() const
-  {
-    return full_geometry_.get();
-  }
-};
-
-enum class NodeWarningType {
-  Error,
-  Warning,
-  Info,
-};
-
-struct NodeWarning {
-  NodeWarningType type;
-  std::string message;
-};
-
-struct NodeWithWarning {
-  DNode node;
-  NodeWarning warning;
-};
-
-struct NodeWithExecutionTime {
-  DNode node;
-  std::chrono::microseconds exec_time;
-};
-
-struct NodeWithDebugMessage {
-  DNode node;
-  std::string message;
-};
-
-/** The same value can be referenced by multiple sockets when they are linked. */
-struct ValueOfSockets {
-  Span<DSocket> sockets;
-  destruct_ptr<ValueLog> value;
-};
-
-enum class eNamedAttrUsage {
-  None = 0,
-  Read = 1 << 0,
-  Write = 1 << 1,
-  Remove = 1 << 2,
-};
-ENUM_OPERATORS(eNamedAttrUsage, eNamedAttrUsage::Remove);
-
-struct UsedNamedAttribute {
-  std::string name;
-  eNamedAttrUsage usage;
-};
-
-struct NodeWithUsedNamedAttribute {
-  DNode node;
-  UsedNamedAttribute attribute;
-};
-
-class GeoLogger;
-class ModifierLog;
-
-/** Every thread has its own local logger to avoid having to communicate between threads during
- * evaluation. After evaluation the individual logs are combined. */
-class LocalGeoLogger {
- private:
-  /* Back pointer to the owner of this local logger. */
-  GeoLogger *main_logger_;
-  /* Allocator for the many small allocations during logging. This is in a `unique_ptr` so that
-   * ownership can be transferred later on. */
-  std::unique_ptr<LinearAllocator<>> allocator_;
-  Vector<ValueOfSockets> values_;
-  Vector<NodeWithWarning> node_warnings_;
-  Vector<NodeWithExecutionTime> node_exec_times_;
-  Vector<NodeWithDebugMessage> node_debug_messages_;
-  Vector<NodeWithUsedNamedAttribute> used_named_attributes_;
-
-  friend ModifierLog;
-
- public:
-  LocalGeoLogger(GeoLogger &main_logger) : main_logger_(&main_logger)
-  {
-    this->allocator_ = std::make_unique<LinearAllocator<>>();
-  }
-
-  void log_value_for_sockets(Span<DSocket> sockets, GPointer value);
-  void log_multi_value_socket(DSocket socket, Span<GPointer> values);
-  void log_node_warning(DNode node, NodeWarningType type, std::string message);
-  void log_execution_time(DNode node, std::chrono::microseconds exec_time);
-  void log_used_named_attribute(DNode node, std::string attribute_name, eNamedAttrUsage usage);
-  /**
-   * Log a message that will be displayed in the node editor next to the node.
-   * This should only be used for debugging purposes and not to display information to users.
-   */
-  void log_debug_message(DNode node, std::string message);
-};
-
-/** The root logger class. */
-class GeoLogger {
- private:
-  /**
-   * Log the entire value for these sockets, because they may be inspected afterwards.
-   * We don't log everything, because that would take up too much memory and cause significant
-   * slowdowns.
-   */
-  Set<DSocket> log_full_sockets_;
-  threading::EnumerableThreadSpecific<LocalGeoLogger> threadlocals_;
-
-  /* These are only optional since they don't have a default constructor. */
-  std::unique_ptr<GeometryValueLog> input_geometry_log_;
-  std::unique_ptr<GeometryValueLog> output_geometry_log_;
-
-  friend LocalGeoLogger;
-  friend ModifierLog;
-
- public:
-  GeoLogger(Set<DSocket> log_full_sockets)
-      : log_full_sockets_(std::move(log_full_sockets)),
-        threadlocals_([this]() { return LocalGeoLogger(*this); })
-  {
-  }
-
-  void log_input_geometry(const GeometrySet &geometry)
-  {
-    input_geometry_log_ = std::make_unique<GeometryValueLog>(geometry);
-  }
-
-  void log_output_geometry(const GeometrySet &geometry)
-  {
-    output_geometry_log_ = std::make_unique<GeometryValueLog>(geometry);
-  }
-
-  LocalGeoLogger &local()
-  {
-    return threadlocals_.local();
-  }
-
-  auto begin()
-  {
-    return threadlocals_.begin();
-  }
-
-  auto end()
-  {
-    return threadlocals_.end();
-  }
-};
-
-/** Contains information that has been logged for one specific socket. */
-class SocketLog {
- private:
-  ValueLog *value_ = nullptr;
-
-  friend ModifierLog;
-
- public:
-  const ValueLog *value() const
-  {
-    return value_;
-  }
-};
-
-/** Contains information that has been logged for one specific node. */
-class NodeLog {
- private:
-  Vector<SocketLog> input_logs_;
-  Vector<SocketLog> output_logs_;
-  Vector<NodeWarning, 0> warnings_;
-  Vector<std::string, 0> debug_messages_;
-  Vector<UsedNamedAttribute, 0> used_named_attributes_;
-  std::chrono::microseconds exec_time_;
-
-  friend ModifierLog;
-
- public:
-  const SocketLog *lookup_socket_log(eNodeSocketInOut in_out, int index) const;
-  const SocketLog *lookup_socket_log(const bNode &node, const bNodeSocket &socket) const;
-  void execution_time(std::chrono::microseconds exec_time);
-
-  Span<SocketLog> input_logs() const
-  {
-    return input_logs_;
-  }
-
-  Span<SocketLog> output_logs() const
-  {
-    return output_logs_;
-  }
-
-  Span<NodeWarning> warnings() const
-  {
-    return warnings_;
-  }
-
-  Span<std::string> debug_messages() const
-  {
-    return debug_messages_;
-  }
-
-  Span<UsedNamedAttribute> used_named_attributes() const
-  {
-    return used_named_attributes_;
-  }
-
-  std::chrono::microseconds execution_time() const
-  {
-    return exec_time_;
-  }
-
-  Vector<const GeometryAttributeInfo *> lookup_available_attributes() const;
-};
-
-/** Contains information that has been logged for one specific tree. */
-class TreeLog {
- private:
-  Map<std::string, destruct_ptr<NodeLog>> node_logs_;
-  Map<std::string, destruct_ptr<TreeLog>> child_logs_;
-
-  friend ModifierLog;
-
- public:
-  const NodeLog *lookup_node_log(StringRef node_name) const;
-  const NodeLog *lookup_node_log(const bNode &node) const;
-  const TreeLog *lookup_child_log(StringRef node_name) const;
-  void foreach_node_log(FunctionRef<void(const NodeLog &)> fn) const;
-};
-
-/** Contains information about an entire geometry nodes evaluation. */
-class ModifierLog {
- private:
-  LinearAllocator<> allocator_;
-  /* Allocators of the individual loggers. */
-  Vector<std::unique_ptr<LinearAllocator<>>> logger_allocators_;
-  destruct_ptr<TreeLog> root_tree_logs_;
-  Vector<destruct_ptr<ValueLog>> logged_values_;
-
-  std::unique_ptr<GeometryValueLog> input_geometry_log_;
-  std::unique_ptr<GeometryValueLog> output_geometry_log_;
-
- public:
-  ModifierLog(GeoLogger &logger);
-
-  const TreeLog &root_tree() const
-  {
-    return *root_tree_logs_;
-  }
-
-  /* Utilities to find logged information for a specific context. */
-  static const ModifierLog *find_root_by_node_editor_context(const SpaceNode &snode);
-  static const TreeLog *find_tree_by_node_editor_context(const SpaceNode &snode);
-  static const NodeLog *find_node_by_node_editor_context(const SpaceNode &snode,
-                                                         const bNode &node);
-  static const NodeLog *find_node_by_node_editor_context(const SpaceNode &snode,
-                                                         const StringRef node_name);
-  static const SocketLog *find_socket_by_node_editor_context(const SpaceNode &snode,
-                                                             const bNode &node,
-                                                             const bNodeSocket &socket);
-  static const NodeLog *find_node_by_spreadsheet_editor_context(
-      const SpaceSpreadsheet &sspreadsheet);
-  void foreach_node_log(FunctionRef<void(const NodeLog &)> fn) const;
-
-  const GeometryValueLog *input_geometry_log() const;
-  const GeometryValueLog *output_geometry_log() const;
-
- private:
-  using LogByTreeContext = Map<const DTreeContext *, TreeLog *>;
-
-  TreeLog &lookup_or_add_tree_log(LogByTreeContext &log_by_tree_context,
-                                  const DTreeContext &tree_context);
-  NodeLog &lookup_or_add_node_log(LogByTreeContext &log_by_tree_context, DNode node);
-  SocketLog &lookup_or_add_socket_log(LogByTreeContext &log_by_tree_context, DSocket socket);
-};
-
-}  // namespace blender::nodes::geometry_nodes_eval_log

source/blender/nodes/NOD_geometry_nodes_lazy_function.hh

@@ -0,0 +1,178 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+
+#pragma once
+
+/**
+ * For evaluation, geometry node groups are converted to a lazy-function graph. The generated graph
+ * is cached per node group, so it only has to be generated once after a change.
+ *
+ * Node groups are *not* inlined into the lazy-function graph. This could be added in the future as
+ * it might improve performance in some cases, but generally does not seem necessary. Inlining node
+ * groups also has disadvantages like making per-node-group caches less useful, resulting in more
+ * overhead.
+ *
+ * Instead, group nodes are just like all other nodes in the lazy-function graph. What makes them
+ * special is that they reference the lazy-function graph of the group they reference.
+ *
+ * During lazy-function graph generation, a mapping between the #bNodeTree and
+ * #lazy_function::Graph is build that can be used when evaluating the graph (e.g. for logging).
+ */
+
+#include "FN_lazy_function_graph.hh"
+#include "FN_lazy_function_graph_executor.hh"
+
+#include "NOD_geometry_nodes_log.hh"
+#include "NOD_multi_function.hh"
+
+#include "BLI_compute_context.hh"
+
+struct Object;
+struct Depsgraph;
+
+namespace blender::nodes {
+
+namespace lf = fn::lazy_function;
+using lf::LazyFunction;
+
+/**
+ * Data that is passed into geometry nodes evaluation from the modifier.
+ */
+struct GeoNodesModifierData {
+  /** Object that is currently evaluated. */
+  const Object *self_object = nullptr;
+  /** Depsgraph that is evaluating the modifier. */
+  Depsgraph *depsgraph = nullptr;
+  /** Optional logger. */
+  geo_eval_log::GeoModifierLog *eval_log = nullptr;
+  /**
+   * Some nodes should be executed even when their output is not used (e.g. active viewer nodes and
+   * the node groups they are contained in).
+   */
+  const MultiValueMap<ComputeContextHash, const lf::FunctionNode *> *side_effect_nodes;
+};
+
+/**
+ * Custom user data that is passed to every geometry nodes related lazy-function evaluation.
+ */
+struct GeoNodesLFUserData : public lf::UserData {
+  /**
+   * Data from the modifier that is being evaluated.
+   */
+  GeoNodesModifierData *modifier_data = nullptr;
+  /**
+   * Current compute context. This is different depending in the (nested) node group that is being
+   * evaluated.
+   */
+  const ComputeContext *compute_context = nullptr;
+};
+
+/**
+ * Contains the mapping between the #bNodeTree and the corresponding lazy-function graph.
+ * This is *not* a one-to-one mapping.
+ */
+struct GeometryNodeLazyFunctionGraphMapping {
+  /**
+   * Contains mapping of sockets for special nodes like group input and group output.
+   */
+  Map<const bNodeSocket *, lf::Socket *> dummy_socket_map;
+  /**
+   * The inputs sockets in the graph. Multiple group input nodes are combined into one in the
+   * lazy-function graph.
+   */
+  Vector<lf::OutputSocket *> group_input_sockets;
+  /**
+   * A mapping used for logging intermediate values.
+   */
+  MultiValueMap<const lf::Socket *, const bNodeSocket *> bsockets_by_lf_socket_map;
+  /**
+   * Mappings for some special node types. Generally, this mapping does not exist for all node
+   * types, so better have more specialized mappings for now.
+   */
+  Map<const bNode *, const lf::FunctionNode *> group_node_map;
+  Map<const bNode *, const lf::FunctionNode *> viewer_node_map;
+};
+
+/**
+ * Data that is cached for every #bNodeTree.
+ */
+struct GeometryNodesLazyFunctionGraphInfo {
+  /**
+   * Allocator used for many things contained in this struct.
+   */
+  LinearAllocator<> allocator;
+  /**
+   * Many nodes are implemented as multi-functions. So this contains a mapping from nodes to their
+   * corresponding multi-functions.
+   */
+  std::unique_ptr<NodeMultiFunctions> node_multi_functions;
+  /**
+   * Many lazy-functions are build for the lazy-function graph. Since the graph does not own them,
+   * we have to keep track of them separately.
+   */
+  Vector<std::unique_ptr<LazyFunction>> functions;
+  /**
+   * Many sockets have default values. Since those are not owned by the lazy-function graph, we
+   * have to keep track of them separately. This only owns the values, the memory is owned by the
+   * allocator above.
+   */
+  Vector<GMutablePointer> values_to_destruct;
+  /**
+   * The actual lazy-function graph.
+   */
+  lf::Graph graph;
+  /**
+   * Mappings between the lazy-function graph and the #bNodeTree.
+   */
+  GeometryNodeLazyFunctionGraphMapping mapping;
+
+  GeometryNodesLazyFunctionGraphInfo();
+  ~GeometryNodesLazyFunctionGraphInfo();
+};
+
+/**
+ * Logs intermediate values from the lazy-function graph evaluation into #GeoModifierLog based on
+ * the mapping between the lazy-function graph and the corresponding #bNodeTree.
+ */
+class GeometryNodesLazyFunctionLogger : public fn::lazy_function::GraphExecutor::Logger {
+ private:
+  const GeometryNodesLazyFunctionGraphInfo &lf_graph_info_;
+
+ public:
+  GeometryNodesLazyFunctionLogger(const GeometryNodesLazyFunctionGraphInfo &lf_graph_info);
+  void log_socket_value(const fn::lazy_function::Socket &lf_socket,
+                        GPointer value,
+                        const fn::lazy_function::Context &context) const override;
+  void dump_when_outputs_are_missing(const lf::FunctionNode &node,
+                                     Span<const lf::OutputSocket *> missing_sockets,
+                                     const lf::Context &context) const override;
+  void dump_when_input_is_set_twice(const lf::InputSocket &target_socket,
+                                    const lf::OutputSocket &from_socket,
+                                    const lf::Context &context) const override;
+};
+
+/**
+ * Tells the lazy-function graph evaluator which nodes have side effects based on the current
+ * context. For example, the same viewer node can have side effects in one context, but not in
+ * another (depending on e.g. which tree path is currently viewed in the node editor).
+ */
+class GeometryNodesLazyFunctionSideEffectProvider
+    : public fn::lazy_function::GraphExecutor::SideEffectProvider {
+ private:
+  const GeometryNodesLazyFunctionGraphInfo &lf_graph_info_;
+
+ public:
+  GeometryNodesLazyFunctionSideEffectProvider(
+      const GeometryNodesLazyFunctionGraphInfo &lf_graph_info);
+  Vector<const lf::FunctionNode *> get_nodes_with_side_effects(
+      const lf::Context &context) const override;
+};
+
+/**
+ * Main function that converts a #bNodeTree into a lazy-function graph. If the graph has been
+ * generated already, nothing is done. Under some circumstances a valid graph cannot be created. In
+ * those cases null is returned.
+ */
+const GeometryNodesLazyFunctionGraphInfo *ensure_geometry_nodes_lazy_function_graph(
+    const bNodeTree &btree);
+
+}  // namespace blender::nodes

source/blender/nodes/NOD_geometry_nodes_log.hh

@@ -0,0 +1,340 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+
+#pragma once
+
+/**
+ * Many geometry nodes related UI features need access to data produced during evaluation. Not only
+ * is the final output required but also the intermediate results. Those features include attribute
+ * search, node warnings, socket inspection and the viewer node.
+ *
+ * This file provides the system for logging data during evaluation and accessing the data after
+ * evaluation. Geometry nodes is executed by a modifier, therefore the "root" of logging is
+ * #GeoModifierLog which will contain all data generated in a modifier.
+ *
+ * The system makes a distinction between "loggers" and the "log":
+ * - Logger (#GeoTreeLogger): Is used during geometry nodes evaluation. Each thread logs data
+ *   independently to avoid communication between threads. Logging should generally be fast.
+ *   Generally, the logged data is just dumped into simple containers. Any processing of the data
+ *   happens later if necessary. This is important for performance, because in practice, most of
+ *   the logged data is never used again. So any processing of the data is likely to be a waste of
+ *   resources.
+ * - Log (#GeoTreeLog, #GeoNodeLog): Those are used when accessing logged data in UI code. They
+ *   contain and cache preprocessed data produced during logging. The log combines data from all
+ *   threadlocal loggers to provide simple access. Importantly, the (preprocessed) log is only
+ *   created when it is actually used by UI code.
+ */
+
+#include <chrono>
+
+#include "BLI_compute_context.hh"
+#include "BLI_enumerable_thread_specific.hh"
+#include "BLI_generic_pointer.hh"
+#include "BLI_multi_value_map.hh"
+
+#include "BKE_attribute.h"
+#include "BKE_geometry_set.hh"
+
+#include "FN_field.hh"
+
+#include "DNA_node_types.h"
+
+struct SpaceNode;
+struct SpaceSpreadsheet;
+struct NodesModifierData;
+
+namespace blender::nodes::geo_eval_log {
+
+using fn::GField;
+
+enum class NodeWarningType {
+  Error,
+  Warning,
+  Info,
+};
+
+struct NodeWarning {
+  NodeWarningType type;
+  std::string message;
+};
+
+enum class NamedAttributeUsage {
+  None = 0,
+  Read = 1 << 0,
+  Write = 1 << 1,
+  Remove = 1 << 2,
+};
+ENUM_OPERATORS(NamedAttributeUsage, NamedAttributeUsage::Remove);
+
+/**
+ * Values of different types are logged differently. This is necesary because some types are so
+ * simple that we can log them entirely (e.g. `int`), while we don't want to log all intermediate
+ * geometries in their entirety.
+ *
+ * #ValueLog is a base class for the different ways we log values.
+ */
+class ValueLog {
+ public:
+  virtual ~ValueLog() = default;
+};
+
+/**
+ * Simplest logger. It just stores a copy of the entire value. This is used for most simple types
+ * like `int`.
+ */
+class GenericValueLog : public ValueLog {
+ public:
+  /**
+   * This is owning the value, but not the memory.
+   */
+  GMutablePointer value;
+
+  GenericValueLog(const GMutablePointer value) : value(value)
+  {
+  }
+
+  ~GenericValueLog();
+};
+
+/**
+ * Fields are not logged entirely, because they might contain arbitrarily large data (e.g.
+ * geometries that are sampled). Instead, only the data needed for ui features is logged.
+ */
+class FieldInfoLog : public ValueLog {
+ public:
+  const CPPType &type;
+  Vector<std::string> input_tooltips;
+
+  FieldInfoLog(const GField &field);
+};
+
+struct GeometryAttributeInfo {
+  std::string name;
+  /** Can be empty when #name does not actually exist on a geometry yet. */
+  std::optional<eAttrDomain> domain;
+  std::optional<eCustomDataType> data_type;
+};
+
+/**
+ * Geometries are not logged entirely, because that would result in a lot of time and memory
+ * overhead. Instead, only the data needed for ui features is logged.
+ */
+class GeometryInfoLog : public ValueLog {
+ public:
+  Vector<GeometryAttributeInfo> attributes;
+  Vector<GeometryComponentType> component_types;
+
+  struct MeshInfo {
+    int verts_num, edges_num, faces_num;
+  };
+  struct CurveInfo {
+    int splines_num;
+  };
+  struct PointCloudInfo {
+    int points_num;
+  };
+  struct InstancesInfo {
+    int instances_num;
+  };
+  struct EditDataInfo {
+    bool has_deformed_positions;
+    bool has_deform_matrices;
+  };
+
+  std::optional<MeshInfo> mesh_info;
+  std::optional<CurveInfo> curve_info;
+  std::optional<PointCloudInfo> pointcloud_info;
+  std::optional<InstancesInfo> instances_info;
+  std::optional<EditDataInfo> edit_data_info;
+
+  GeometryInfoLog(const GeometrySet &geometry_set);
+};
+
+/**
+ * Data logged by a viewer node when it is executed. In this case, we do want to log the entire
+ * geometry.
+ */
+class ViewerNodeLog {
+ public:
+  GeometrySet geometry;
+  GField field;
+};
+
+using Clock = std::chrono::steady_clock;
+using TimePoint = Clock::time_point;
+
+/**
+ * Logs all data for a specific geometry node tree in a specific context. When the same node group
+ * is used in multiple times each instantiation will have a separate logger.
+ */
+class GeoTreeLogger {
+ public:
+  std::optional<ComputeContextHash> parent_hash;
+  std::optional<std::string> group_node_name;
+  Vector<ComputeContextHash> children_hashes;
+
+  LinearAllocator<> *allocator = nullptr;
+
+  struct WarningWithNode {
+    std::string node_name;
+    NodeWarning warning;
+  };
+  struct SocketValueLog {
+    std::string node_name;
+    std::string socket_identifier;
+    destruct_ptr<ValueLog> value;
+  };
+  struct NodeExecutionTime {
+    std::string node_name;
+    TimePoint start;
+    TimePoint end;
+  };
+  struct ViewerNodeLogWithNode {
+    std::string node_name;
+    destruct_ptr<ViewerNodeLog> viewer_log;
+  };
+  struct AttributeUsageWithNode {
+    std::string node_name;
+    std::string attribute_name;
+    NamedAttributeUsage usage;
+  };
+  struct DebugMessage {
+    std::string node_name;
+    std::string message;
+  };
+
+  Vector<WarningWithNode> node_warnings;
+  Vector<SocketValueLog> input_socket_values;
+  Vector<SocketValueLog> output_socket_values;
+  Vector<NodeExecutionTime> node_execution_times;
+  Vector<ViewerNodeLogWithNode, 0> viewer_node_logs;
+  Vector<AttributeUsageWithNode, 0> used_named_attributes;
+  Vector<DebugMessage, 0> debug_messages;
+
+  GeoTreeLogger();
+  ~GeoTreeLogger();
+
+  void log_value(const bNode &node, const bNodeSocket &socket, GPointer value);
+  void log_viewer_node(const bNode &viewer_node, const GeometrySet &geometry, const GField &field);
+};
+
+/**
+ * Contains data that has been logged for a specific node in a context. So when the node is in a
+ * node group that is used multiple times, there will be a different #GeoNodeLog for every
+ * instance.
+ *
+ * By default, not all of the info below is valid. A #GeoTreeLog::ensure_* method has to be called
+ * first.
+ */
+class GeoNodeLog {
+ public:
+  /** Warnings generated for that node. */
+  Vector<NodeWarning> warnings;
+  /**
+   * Time spend in that node. For node groups this is the sum of the run times of the nodes
+   * inside.
+   */
+  std::chrono::nanoseconds run_time{0};
+  /** Maps from socket identifiers to their values. */
+  Map<std::string, ValueLog *> input_values_;
+  Map<std::string, ValueLog *> output_values_;
+  /** Maps from attribute name to their usage flags. */
+  Map<std::string, NamedAttributeUsage> used_named_attributes;
+  /** Messages that are used for debugging purposes during development. */
+  Vector<std::string> debug_messages;
+
+  GeoNodeLog();
+  ~GeoNodeLog();
+};
+
+class GeoModifierLog;
+
+/**
+ * Contains data that has been logged for a specific node group in a context. If the same node
+ * group is used multiple times, there will be a different #GeoTreeLog for every instance.
+ *
+ * This contains lazily evaluated data. Call the corresponding `ensure_*` methods before accessing
+ * data.
+ */
+class GeoTreeLog {
+ private:
+  GeoModifierLog *modifier_log_;
+  Vector<GeoTreeLogger *> tree_loggers_;
+  VectorSet<ComputeContextHash> children_hashes_;
+  bool reduced_node_warnings_ = false;
+  bool reduced_node_run_times_ = false;
+  bool reduced_socket_values_ = false;
+  bool reduced_viewer_node_logs_ = false;
+  bool reduced_existing_attributes_ = false;
+  bool reduced_used_named_attributes_ = false;
+  bool reduced_debug_messages_ = false;
+
+ public:
+  Map<std::string, GeoNodeLog> nodes;
+  Map<std::string, ViewerNodeLog *, 0> viewer_node_logs;
+  Vector<NodeWarning> all_warnings;
+  std::chrono::nanoseconds run_time_sum{0};
+  Vector<const GeometryAttributeInfo *> existing_attributes;
+  Map<std::string, NamedAttributeUsage> used_named_attributes;
+
+  GeoTreeLog(GeoModifierLog *modifier_log, Vector<GeoTreeLogger *> tree_loggers);
+  ~GeoTreeLog();
+
+  void ensure_node_warnings();
+  void ensure_node_run_time();
+  void ensure_socket_values();
+  void ensure_viewer_node_logs();
+  void ensure_existing_attributes();
+  void ensure_used_named_attributes();
+  void ensure_debug_messages();
+
+  ValueLog *find_socket_value_log(const bNodeSocket &query_socket);
+};
+
+/**
+ * There is one #GeoModifierLog for every modifier that evaluates geometry nodes. It contains all
+ * the loggers that are used during evaluation as well as the preprocessed logs that are used by UI
+ * code.
+ */
+class GeoModifierLog {
+ private:
+  /** Data that is stored for each thread. */
+  struct LocalData {
+    /** Each thread has its own allocator. */
+    LinearAllocator<> allocator;
+    /**
+     * Store a separate #GeoTreeLogger for each instance of the corresponding node group (e.g.
+     * when the same node group is used multiple times).
+     */
+    Map<ComputeContextHash, destruct_ptr<GeoTreeLogger>> tree_logger_by_context;
+  };
+
+  /** Container for all threadlocal data. */
+  threading::EnumerableThreadSpecific<LocalData> data_per_thread_;
+  /**
+   * A #GeoTreeLog for every compute context. Those are created lazily when requested by UI code.
+   */
+  Map<ComputeContextHash, std::unique_ptr<GeoTreeLog>> tree_logs_;
+
+ public:
+  GeoModifierLog();
+  ~GeoModifierLog();
+
+  /**
+   * Get a threadlocal logger for the current node tree.
+   */
+  GeoTreeLogger &get_local_tree_logger(const ComputeContext &compute_context);
+
+  /**
+   * Get a log a specific node tree instance.
+   */
+  GeoTreeLog &get_tree_log(const ComputeContextHash &compute_context_hash);
+
+  /**
+   * Utility accessor to logged data.
+   */
+  static GeoTreeLog *get_tree_log_for_node_editor(const SpaceNode &snode);
+  static const ViewerNodeLog *find_viewer_node_log_for_spreadsheet(
+      const SpaceSpreadsheet &sspreadsheet);
+};
+
+}  // namespace blender::nodes::geo_eval_log

source/blender/nodes/NOD_multi_function.hh

@@ -6,8 +6,6 @@
 
 #include "DNA_node_types.h"
 
-#include "NOD_derived_node_tree.hh"
-
 namespace blender::nodes {
 
 using namespace fn::multi_function_types;
@@ -60,9 +58,9 @@ class NodeMultiFunctions {
   Map<const bNode *, Item> map_;
 
  public:
-  NodeMultiFunctions(const DerivedNodeTree &tree);
+  NodeMultiFunctions(const bNodeTree &tree);
 
-  const Item &try_get(const DNode &node) const;
+  const Item &try_get(const bNode &node) const;
 };
 
 /* -------------------------------------------------------------------- */
@@ -107,10 +105,10 @@ inline void NodeMultiFunctionBuilder::construct_and_set_matching_fn(Args &&...ar
 /** \name #NodeMultiFunctions Inline Methods
  * \{ */
 
-inline const NodeMultiFunctions::Item &NodeMultiFunctions::try_get(const DNode &node) const
+inline const NodeMultiFunctions::Item &NodeMultiFunctions::try_get(const bNode &node) const
 {
   static Item empty_item;
-  const Item *item = map_.lookup_ptr(node.bnode());
+  const Item *item = map_.lookup_ptr(&node);
   if (item == nullptr) {
     return empty_item;
   }

source/blender/nodes/geometry/node_geometry_exec.cc

@@ -4,3 +4,4 @@
 #include "NOD_geometry_exec.hh"
 
 BLI_CPP_TYPE_MAKE(GeometrySet, GeometrySet, CPPTypeFlags::Printable);
+BLI_CPP_TYPE_MAKE(GeometrySetVector, blender::Vector<GeometrySet>, CPPTypeFlags::None);

source/blender/nodes/geometry/nodes/node_geo_boolean.cc

@@ -93,7 +93,7 @@ static void node_geo_exec(GeoNodeExecParams params)
   /* The instance transform matrices are owned by the instance group, so we have to
    * keep all of them around for use during the boolean operation. */
   Vector<bke::GeometryInstanceGroup> set_groups;
-  Vector<GeometrySet> geometry_sets = params.extract_multi_input<GeometrySet>("Mesh 2");
+  Vector<GeometrySet> geometry_sets = params.extract_input<Vector<GeometrySet>>("Mesh 2");
   for (const GeometrySet &geometry_set : geometry_sets) {
     bke::geometry_set_gather_instances(geometry_set, set_groups);
   }

source/blender/nodes/geometry/nodes/node_geo_geometry_to_instance.cc

@@ -12,7 +12,7 @@ static void node_declare(NodeDeclarationBuilder &b)
 
 static void node_geo_exec(GeoNodeExecParams params)
 {
-  Vector<GeometrySet> geometries = params.extract_multi_input<GeometrySet>("Geometry");
+  Vector<GeometrySet> geometries = params.extract_input<Vector<GeometrySet>>("Geometry");
   GeometrySet instances_geometry;
   InstancesComponent &instances_component =
       instances_geometry.get_component_for_write<InstancesComponent>();

source/blender/nodes/geometry/nodes/node_geo_input_named_attribute.cc

@@ -88,7 +88,7 @@ static void node_geo_exec(GeoNodeExecParams params)
     return;
   }
 
-  params.used_named_attribute(name, eNamedAttrUsage::Read);
+  params.used_named_attribute(name, NamedAttributeUsage::Read);
 
   switch (data_type) {
     case CD_PROP_FLOAT:

source/blender/nodes/geometry/nodes/node_geo_join_geometry.cc

@@ -177,7 +177,7 @@ static void join_component_type(Span<GeometrySet> src_geometry_sets, GeometrySet
 
 static void node_geo_exec(GeoNodeExecParams params)
 {
-  Vector<GeometrySet> geometry_sets = params.extract_multi_input<GeometrySet>("Geometry");
+  Vector<GeometrySet> geometry_sets = params.extract_input<Vector<GeometrySet>>("Geometry");
 
   GeometrySet geometry_set_result;
   join_component_type<MeshComponent>(geometry_sets, geometry_set_result);

source/blender/nodes/geometry/nodes/node_geo_remove_attribute.cc

@@ -55,7 +55,7 @@ static void node_geo_exec(GeoNodeExecParams params)
   });
 
   if (attribute_exists && !cannot_delete) {
-    params.used_named_attribute(name, eNamedAttrUsage::Remove);
+    params.used_named_attribute(name, NamedAttributeUsage::Remove);
   }
 
   if (!attribute_exists) {

source/blender/nodes/geometry/nodes/node_geo_store_named_attribute.cc

@@ -149,7 +149,7 @@ static void node_geo_exec(GeoNodeExecParams params)
     return;
   }
 
-  params.used_named_attribute(name, eNamedAttrUsage::Write);
+  params.used_named_attribute(name, NamedAttributeUsage::Write);
 
   const NodeGeometryStoreNamedAttribute &storage = node_storage(params.node());
   const eCustomDataType data_type = static_cast<eCustomDataType>(storage.data_type);

source/blender/nodes/geometry/nodes/node_geo_string_join.cc

@@ -13,12 +13,13 @@ static void node_declare(NodeDeclarationBuilder &b)
 
 static void node_geo_exec(GeoNodeExecParams params)
 {
-  Vector<std::string> strings = params.extract_multi_input<std::string>("Strings");
+  Vector<fn::ValueOrField<std::string>> strings =
+      params.extract_input<Vector<fn::ValueOrField<std::string>>>("Strings");
   const std::string delim = params.extract_input<std::string>("Delimiter");
 
   std::string output;
   for (const int i : strings.index_range()) {
-    output += strings[i];
+    output += strings[i].as_value();
     if (i < (strings.size() - 1)) {
       output += delim;
     }

source/blender/nodes/intern/geometry_nodes_eval_log.cc

@@ -1,520 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-or-later */
-
-#include "NOD_geometry_nodes_eval_log.hh"
-
-#include "BKE_curves.hh"
-#include "BKE_geometry_set_instances.hh"
-
-#include "DNA_modifier_types.h"
-#include "DNA_space_types.h"
-
-#include "FN_field_cpp_type.hh"
-
-#include "BLT_translation.h"
-
-#include <chrono>
-
-namespace blender::nodes::geometry_nodes_eval_log {
-
-using fn::FieldCPPType;
-using fn::FieldInput;
-using fn::GField;
-using fn::ValueOrFieldCPPType;
-
-ModifierLog::ModifierLog(GeoLogger &logger)
-    : input_geometry_log_(std::move(logger.input_geometry_log_)),
-      output_geometry_log_(std::move(logger.output_geometry_log_))
-{
-  root_tree_logs_ = allocator_.construct<TreeLog>();
-
-  LogByTreeContext log_by_tree_context;
-
-  /* Combine all the local loggers that have been used by separate threads. */
-  for (LocalGeoLogger &local_logger : logger) {
-    /* Take ownership of the allocator. */
-    logger_allocators_.append(std::move(local_logger.allocator_));
-
-    for (ValueOfSockets &value_of_sockets : local_logger.values_) {
-      ValueLog *value_log = value_of_sockets.value.get();
-
-      /* Take centralized ownership of the logged value. It might be referenced by multiple
-       * sockets. */
-      logged_values_.append(std::move(value_of_sockets.value));
-
-      for (const DSocket &socket : value_of_sockets.sockets) {
-        SocketLog &socket_log = this->lookup_or_add_socket_log(log_by_tree_context, socket);
-        socket_log.value_ = value_log;
-      }
-    }
-
-    for (NodeWithWarning &node_with_warning : local_logger.node_warnings_) {
-      NodeLog &node_log = this->lookup_or_add_node_log(log_by_tree_context,
-                                                       node_with_warning.node);
-      node_log.warnings_.append(node_with_warning.warning);
-    }
-
-    for (NodeWithExecutionTime &node_with_exec_time : local_logger.node_exec_times_) {
-      NodeLog &node_log = this->lookup_or_add_node_log(log_by_tree_context,
-                                                       node_with_exec_time.node);
-      node_log.exec_time_ = node_with_exec_time.exec_time;
-    }
-
-    for (NodeWithDebugMessage &debug_message : local_logger.node_debug_messages_) {
-      NodeLog &node_log = this->lookup_or_add_node_log(log_by_tree_context, debug_message.node);
-      node_log.debug_messages_.append(debug_message.message);
-    }
-
-    for (NodeWithUsedNamedAttribute &node_with_attribute_name :
-         local_logger.used_named_attributes_) {
-      NodeLog &node_log = this->lookup_or_add_node_log(log_by_tree_context,
-                                                       node_with_attribute_name.node);
-      node_log.used_named_attributes_.append(std::move(node_with_attribute_name.attribute));
-    }
-  }
-}
-
-TreeLog &ModifierLog::lookup_or_add_tree_log(LogByTreeContext &log_by_tree_context,
-                                             const DTreeContext &tree_context)
-{
-  TreeLog *tree_log = log_by_tree_context.lookup_default(&tree_context, nullptr);
-  if (tree_log != nullptr) {
-    return *tree_log;
-  }
-
-  const DTreeContext *parent_context = tree_context.parent_context();
-  if (parent_context == nullptr) {
-    return *root_tree_logs_.get();
-  }
-  TreeLog &parent_log = this->lookup_or_add_tree_log(log_by_tree_context, *parent_context);
-  destruct_ptr<TreeLog> owned_tree_log = allocator_.construct<TreeLog>();
-  tree_log = owned_tree_log.get();
-  log_by_tree_context.add_new(&tree_context, tree_log);
-  parent_log.child_logs_.add_new(tree_context.parent_node()->name, std::move(owned_tree_log));
-  return *tree_log;
-}
-
-NodeLog &ModifierLog::lookup_or_add_node_log(LogByTreeContext &log_by_tree_context, DNode node)
-{
-  TreeLog &tree_log = this->lookup_or_add_tree_log(log_by_tree_context, *node.context());
-  NodeLog &node_log = *tree_log.node_logs_.lookup_or_add_cb(node->name, [&]() {
-    destruct_ptr<NodeLog> node_log = allocator_.construct<NodeLog>();
-    node_log->input_logs_.resize(node->input_sockets().size());
-    node_log->output_logs_.resize(node->output_sockets().size());
-    return node_log;
-  });
-  return node_log;
-}
-
-SocketLog &ModifierLog::lookup_or_add_socket_log(LogByTreeContext &log_by_tree_context,
-                                                 DSocket socket)
-{
-  NodeLog &node_log = this->lookup_or_add_node_log(log_by_tree_context, socket.node());
-  MutableSpan<SocketLog> socket_logs = socket->is_input() ? node_log.input_logs_ :
-                                                            node_log.output_logs_;
-  SocketLog &socket_log = socket_logs[socket->index()];
-  return socket_log;
-}
-
-void ModifierLog::foreach_node_log(FunctionRef<void(const NodeLog &)> fn) const
-{
-  if (root_tree_logs_) {
-    root_tree_logs_->foreach_node_log(fn);
-  }
-}
-
-const GeometryValueLog *ModifierLog::input_geometry_log() const
-{
-  return input_geometry_log_.get();
-}
-const GeometryValueLog *ModifierLog::output_geometry_log() const
-{
-  return output_geometry_log_.get();
-}
-
-const NodeLog *TreeLog::lookup_node_log(StringRef node_name) const
-{
-  const destruct_ptr<NodeLog> *node_log = node_logs_.lookup_ptr_as(node_name);
-  if (node_log == nullptr) {
-    return nullptr;
-  }
-  return node_log->get();
-}
-
-const NodeLog *TreeLog::lookup_node_log(const bNode &node) const
-{
-  return this->lookup_node_log(node.name);
-}
-
-const TreeLog *TreeLog::lookup_child_log(StringRef node_name) const
-{
-  const destruct_ptr<TreeLog> *tree_log = child_logs_.lookup_ptr_as(node_name);
-  if (tree_log == nullptr) {
-    return nullptr;
-  }
-  return tree_log->get();
-}
-
-void TreeLog::foreach_node_log(FunctionRef<void(const NodeLog &)> fn) const
-{
-  for (auto node_log : node_logs_.items()) {
-    fn(*node_log.value);
-  }
-
-  for (auto child : child_logs_.items()) {
-    child.value->foreach_node_log(fn);
-  }
-}
-
-const SocketLog *NodeLog::lookup_socket_log(eNodeSocketInOut in_out, int index) const
-{
-  BLI_assert(index >= 0);
-  Span<SocketLog> socket_logs = (in_out == SOCK_IN) ? input_logs_ : output_logs_;
-  if (index >= socket_logs.size()) {
-    return nullptr;
-  }
-  return &socket_logs[index];
-}
-
-const SocketLog *NodeLog::lookup_socket_log(const bNode &node, const bNodeSocket &socket) const
-{
-  ListBase sockets = socket.in_out == SOCK_IN ? node.inputs : node.outputs;
-  int index = BLI_findindex(&sockets, &socket);
-  return this->lookup_socket_log((eNodeSocketInOut)socket.in_out, index);
-}
-
-GFieldValueLog::GFieldValueLog(fn::GField field, bool log_full_field) : type_(field.cpp_type())
-{
-  const std::shared_ptr<const fn::FieldInputs> &field_input_nodes = field.node().field_inputs();
-
-  /* Put the deduplicated field inputs into a vector so that they can be sorted below. */
-  Vector<std::reference_wrapper<const FieldInput>> field_inputs;
-  if (field_input_nodes) {
-    field_inputs.extend(field_input_nodes->deduplicated_nodes.begin(),
-                        field_input_nodes->deduplicated_nodes.end());
-  }
-
-  std::sort(
-      field_inputs.begin(), field_inputs.end(), [](const FieldInput &a, const FieldInput &b) {
-        const int index_a = (int)a.category();
-        const int index_b = (int)b.category();
-        if (index_a == index_b) {
-          return a.socket_inspection_name().size() < b.socket_inspection_name().size();
-        }
-        return index_a < index_b;
-      });
-
-  for (const FieldInput &field_input : field_inputs) {
-    input_tooltips_.append(field_input.socket_inspection_name());
-  }
-
-  if (log_full_field) {
-    field_ = std::move(field);
-  }
-}
-
-GeometryValueLog::GeometryValueLog(const GeometrySet &geometry_set, bool log_full_geometry)
-{
-  static std::array all_component_types = {GEO_COMPONENT_TYPE_CURVE,
-                                           GEO_COMPONENT_TYPE_INSTANCES,
-                                           GEO_COMPONENT_TYPE_MESH,
-                                           GEO_COMPONENT_TYPE_POINT_CLOUD,
-                                           GEO_COMPONENT_TYPE_VOLUME};
-
-  /* Keep track handled attribute names to make sure that we do not return the same name twice.
-   * Currently #GeometrySet::attribute_foreach does not do that. Note that this will merge
-   * attributes with the same name but different domains or data types on separate components. */
-  Set<StringRef> names;
-
-  geometry_set.attribute_foreach(
-      all_component_types,
-      true,
-      [&](const bke::AttributeIDRef &attribute_id,
-          const bke::AttributeMetaData &meta_data,
-          const GeometryComponent &UNUSED(component)) {
-        if (attribute_id.is_named() && names.add(attribute_id.name())) {
-          this->attributes_.append({attribute_id.name(), meta_data.domain, meta_data.data_type});
-        }
-      });
-
-  for (const GeometryComponent *component : geometry_set.get_components_for_read()) {
-    component_types_.append(component->type());
-    switch (component->type()) {
-      case GEO_COMPONENT_TYPE_MESH: {
-        const MeshComponent &mesh_component = *(const MeshComponent *)component;
-        MeshInfo &info = this->mesh_info.emplace();
-        info.verts_num = mesh_component.attribute_domain_size(ATTR_DOMAIN_POINT);
-        info.edges_num = mesh_component.attribute_domain_size(ATTR_DOMAIN_EDGE);
-        info.faces_num = mesh_component.attribute_domain_size(ATTR_DOMAIN_FACE);
-        break;
-      }
-      case GEO_COMPONENT_TYPE_CURVE: {
-        const CurveComponent &curve_component = *(const CurveComponent *)component;
-        CurveInfo &info = this->curve_info.emplace();
-        info.splines_num = curve_component.attribute_domain_size(ATTR_DOMAIN_CURVE);
-        break;
-      }
-      case GEO_COMPONENT_TYPE_POINT_CLOUD: {
-        const PointCloudComponent &pointcloud_component = *(const PointCloudComponent *)component;
-        PointCloudInfo &info = this->pointcloud_info.emplace();
-        info.points_num = pointcloud_component.attribute_domain_size(ATTR_DOMAIN_POINT);
-        break;
-      }
-      case GEO_COMPONENT_TYPE_INSTANCES: {
-        const InstancesComponent &instances_component = *(const InstancesComponent *)component;
-        InstancesInfo &info = this->instances_info.emplace();
-        info.instances_num = instances_component.instances_num();
-        break;
-      }
-      case GEO_COMPONENT_TYPE_EDIT: {
-        const GeometryComponentEditData &edit_component = *(
-            const GeometryComponentEditData *)component;
-        if (const bke::CurvesEditHints *curve_edit_hints =
-                edit_component.curves_edit_hints_.get()) {
-          EditDataInfo &info = this->edit_data_info.emplace();
-          info.has_deform_matrices = curve_edit_hints->deform_mats.has_value();
-          info.has_deformed_positions = curve_edit_hints->positions.has_value();
-        }
-        break;
-      }
-      case GEO_COMPONENT_TYPE_VOLUME: {
-        break;
-      }
-    }
-  }
-  if (log_full_geometry) {
-    full_geometry_ = std::make_unique<GeometrySet>(geometry_set);
-    full_geometry_->ensure_owns_direct_data();
-  }
-}
-
-Vector<const GeometryAttributeInfo *> NodeLog::lookup_available_attributes() const
-{
-  Vector<const GeometryAttributeInfo *> attributes;
-  Set<StringRef> names;
-  for (const SocketLog &socket_log : input_logs_) {
-    const ValueLog *value_log = socket_log.value();
-    if (const GeometryValueLog *geo_value_log = dynamic_cast<const GeometryValueLog *>(
-            value_log)) {
-      for (const GeometryAttributeInfo &attribute : geo_value_log->attributes()) {
-        if (names.add(attribute.name)) {
-          attributes.append(&attribute);
-        }
-      }
-    }
-  }
-  return attributes;
-}
-
-const ModifierLog *ModifierLog::find_root_by_node_editor_context(const SpaceNode &snode)
-{
-  if (snode.id == nullptr) {
-    return nullptr;
-  }
-  if (GS(snode.id->name) != ID_OB) {
-    return nullptr;
-  }
-  Object *object = (Object *)snode.id;
-  LISTBASE_FOREACH (ModifierData *, md, &object->modifiers) {
-    if (md->type == eModifierType_Nodes) {
-      NodesModifierData *nmd = (NodesModifierData *)md;
-      if (nmd->node_group == snode.nodetree) {
-        return (ModifierLog *)nmd->runtime_eval_log;
-      }
-    }
-  }
-  return nullptr;
-}
-
-const TreeLog *ModifierLog::find_tree_by_node_editor_context(const SpaceNode &snode)
-{
-  const ModifierLog *eval_log = ModifierLog::find_root_by_node_editor_context(snode);
-  if (eval_log == nullptr) {
-    return nullptr;
-  }
-  Vector<bNodeTreePath *> tree_path_vec = snode.treepath;
-  if (tree_path_vec.is_empty()) {
-    return nullptr;
-  }
-  TreeLog *current = eval_log->root_tree_logs_.get();
-  for (bNodeTreePath *path : tree_path_vec.as_span().drop_front(1)) {
-    destruct_ptr<TreeLog> *tree_log = current->child_logs_.lookup_ptr_as(path->node_name);
-    if (tree_log == nullptr) {
-      return nullptr;
-    }
-    current = tree_log->get();
-  }
-  return current;
-}
-
-const NodeLog *ModifierLog::find_node_by_node_editor_context(const SpaceNode &snode,
-                                                             const bNode &node)
-{
-  const TreeLog *tree_log = ModifierLog::find_tree_by_node_editor_context(snode);
-  if (tree_log == nullptr) {
-    return nullptr;
-  }
-  return tree_log->lookup_node_log(node);
-}
-
-const NodeLog *ModifierLog::find_node_by_node_editor_context(const SpaceNode &snode,
-                                                             const StringRef node_name)
-{
-  const TreeLog *tree_log = ModifierLog::find_tree_by_node_editor_context(snode);
-  if (tree_log == nullptr) {
-    return nullptr;
-  }
-  return tree_log->lookup_node_log(node_name);
-}
-
-const SocketLog *ModifierLog::find_socket_by_node_editor_context(const SpaceNode &snode,
-                                                                 const bNode &node,
-                                                                 const bNodeSocket &socket)
-{
-  const NodeLog *node_log = ModifierLog::find_node_by_node_editor_context(snode, node);
-  if (node_log == nullptr) {
-    return nullptr;
-  }
-  return node_log->lookup_socket_log(node, socket);
-}
-
-const NodeLog *ModifierLog::find_node_by_spreadsheet_editor_context(
-    const SpaceSpreadsheet &sspreadsheet)
-{
-  Vector<SpreadsheetContext *> context_path = sspreadsheet.context_path;
-  if (context_path.size() <= 2) {
-    return nullptr;
-  }
-  if (context_path[0]->type != SPREADSHEET_CONTEXT_OBJECT) {
-    return nullptr;
-  }
-  if (context_path[1]->type != SPREADSHEET_CONTEXT_MODIFIER) {
-    return nullptr;
-  }
-  for (SpreadsheetContext *context : context_path.as_span().drop_front(2)) {
-    if (context->type != SPREADSHEET_CONTEXT_NODE) {
-      return nullptr;
-    }
-  }
-  Span<SpreadsheetContextNode *> node_contexts =
-      context_path.as_span().drop_front(2).cast<SpreadsheetContextNode *>();
-
-  Object *object = ((SpreadsheetContextObject *)context_path[0])->object;
-  StringRefNull modifier_name = ((SpreadsheetContextModifier *)context_path[1])->modifier_name;
-  if (object == nullptr) {
-    return nullptr;
-  }
-
-  const ModifierLog *eval_log = nullptr;
-  LISTBASE_FOREACH (ModifierData *, md, &object->modifiers) {
-    if (md->type == eModifierType_Nodes) {
-      if (md->name == modifier_name) {
-        NodesModifierData *nmd = (NodesModifierData *)md;
-        eval_log = (const ModifierLog *)nmd->runtime_eval_log;
-        break;
-      }
-    }
-  }
-  if (eval_log == nullptr) {
-    return nullptr;
-  }
-
-  const TreeLog *tree_log = &eval_log->root_tree();
-  for (SpreadsheetContextNode *context : node_contexts.drop_back(1)) {
-    tree_log = tree_log->lookup_child_log(context->node_name);
-    if (tree_log == nullptr) {
-      return nullptr;
-    }
-  }
-  const NodeLog *node_log = tree_log->lookup_node_log(node_contexts.last()->node_name);
-  return node_log;
-}
-
-void LocalGeoLogger::log_value_for_sockets(Span<DSocket> sockets, GPointer value)
-{
-  const CPPType &type = *value.type();
-  Span<DSocket> copied_sockets = allocator_->construct_array_copy(sockets);
-  if (type.is<GeometrySet>()) {
-    bool log_full_geometry = false;
-    for (const DSocket &socket : sockets) {
-      if (main_logger_->log_full_sockets_.contains(socket)) {
-        log_full_geometry = true;
-        break;
-      }
-    }
-
-    const GeometrySet &geometry_set = *value.get<GeometrySet>();
-    destruct_ptr<GeometryValueLog> value_log = allocator_->construct<GeometryValueLog>(
-        geometry_set, log_full_geometry);
-    values_.append({copied_sockets, std::move(value_log)});
-  }
-  else if (const ValueOrFieldCPPType *value_or_field_type =
-               dynamic_cast<const ValueOrFieldCPPType *>(&type)) {
-    const void *value_or_field = value.get();
-    if (value_or_field_type->is_field(value_or_field)) {
-      GField field = *value_or_field_type->get_field_ptr(value_or_field);
-      bool log_full_field = false;
-      if (!field.node().depends_on_input()) {
-        /* Always log constant fields so that their value can be shown in socket inspection.
-         * In the future we can also evaluate the field here and only store the value. */
-        log_full_field = true;
-      }
-      if (!log_full_field) {
-        for (const DSocket &socket : sockets) {
-          if (main_logger_->log_full_sockets_.contains(socket)) {
-            log_full_field = true;
-            break;
-          }
-        }
-      }
-      destruct_ptr<GFieldValueLog> value_log = allocator_->construct<GFieldValueLog>(
-          std::move(field), log_full_field);
-      values_.append({copied_sockets, std::move(value_log)});
-    }
-    else {
-      const CPPType &base_type = value_or_field_type->base_type();
-      const void *value = value_or_field_type->get_value_ptr(value_or_field);
-      void *buffer = allocator_->allocate(base_type.size(), base_type.alignment());
-      base_type.copy_construct(value, buffer);
-      destruct_ptr<GenericValueLog> value_log = allocator_->construct<GenericValueLog>(
-          GMutablePointer{base_type, buffer});
-      values_.append({copied_sockets, std::move(value_log)});
-    }
-  }
-  else {
-    void *buffer = allocator_->allocate(type.size(), type.alignment());
-    type.copy_construct(value.get(), buffer);
-    destruct_ptr<GenericValueLog> value_log = allocator_->construct<GenericValueLog>(
-        GMutablePointer{type, buffer});
-    values_.append({copied_sockets, std::move(value_log)});
-  }
-}
-
-void LocalGeoLogger::log_multi_value_socket(DSocket socket, Span<GPointer> values)
-{
-  /* Doesn't have to be logged currently. */
-  UNUSED_VARS(socket, values);
-}
-
-void LocalGeoLogger::log_node_warning(DNode node, NodeWarningType type, std::string message)
-{
-  node_warnings_.append({node, {type, std::move(message)}});
-}
-
-void LocalGeoLogger::log_execution_time(DNode node, std::chrono::microseconds exec_time)
-{
-  node_exec_times_.append({node, exec_time});
-}
-
-void LocalGeoLogger::log_used_named_attribute(DNode node,
-                                              std::string attribute_name,
-                                              eNamedAttrUsage usage)
-{
-  used_named_attributes_.append({node, {std::move(attribute_name), usage}});
-}
-
-void LocalGeoLogger::log_debug_message(DNode node, std::string message)
-{
-  node_debug_messages_.append({node, std::move(message)});
-}
-
-}  // namespace blender::nodes::geometry_nodes_eval_log

source/blender/nodes/intern/geometry_nodes_log.cc

@@ -0,0 +1,607 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+
+#include "NOD_geometry_nodes_lazy_function.hh"
+#include "NOD_geometry_nodes_log.hh"
+
+#include "BKE_compute_contexts.hh"
+#include "BKE_curves.hh"
+#include "BKE_node_runtime.hh"
+
+#include "FN_field_cpp_type.hh"
+
+#include "DNA_modifier_types.h"
+#include "DNA_space_types.h"
+
+namespace blender::nodes::geo_eval_log {
+
+using fn::FieldInput;
+using fn::FieldInputs;
+
+GenericValueLog::~GenericValueLog()
+{
+  this->value.destruct();
+}
+
+FieldInfoLog::FieldInfoLog(const GField &field) : type(field.cpp_type())
+{
+  const std::shared_ptr<const fn::FieldInputs> &field_input_nodes = field.node().field_inputs();
+
+  /* Put the deduplicated field inputs into a vector so that they can be sorted below. */
+  Vector<std::reference_wrapper<const FieldInput>> field_inputs;
+  if (field_input_nodes) {
+    field_inputs.extend(field_input_nodes->deduplicated_nodes.begin(),
+                        field_input_nodes->deduplicated_nodes.end());
+  }
+
+  std::sort(
+      field_inputs.begin(), field_inputs.end(), [](const FieldInput &a, const FieldInput &b) {
+        const int index_a = (int)a.category();
+        const int index_b = (int)b.category();
+        if (index_a == index_b) {
+          return a.socket_inspection_name().size() < b.socket_inspection_name().size();
+        }
+        return index_a < index_b;
+      });
+
+  for (const FieldInput &field_input : field_inputs) {
+    this->input_tooltips.append(field_input.socket_inspection_name());
+  }
+}
+
+GeometryInfoLog::GeometryInfoLog(const GeometrySet &geometry_set)
+{
+  static std::array all_component_types = {GEO_COMPONENT_TYPE_CURVE,
+                                           GEO_COMPONENT_TYPE_INSTANCES,
+                                           GEO_COMPONENT_TYPE_MESH,
+                                           GEO_COMPONENT_TYPE_POINT_CLOUD,
+                                           GEO_COMPONENT_TYPE_VOLUME};
+
+  /* Keep track handled attribute names to make sure that we do not return the same name twice.
+   * Currently #GeometrySet::attribute_foreach does not do that. Note that this will merge
+   * attributes with the same name but different domains or data types on separate components. */
+  Set<StringRef> names;
+
+  geometry_set.attribute_foreach(
+      all_component_types,
+      true,
+      [&](const bke::AttributeIDRef &attribute_id,
+          const bke::AttributeMetaData &meta_data,
+          const GeometryComponent &UNUSED(component)) {
+        if (attribute_id.is_named() && names.add(attribute_id.name())) {
+          this->attributes.append({attribute_id.name(), meta_data.domain, meta_data.data_type});
+        }
+      });
+
+  for (const GeometryComponent *component : geometry_set.get_components_for_read()) {
+    this->component_types.append(component->type());
+    switch (component->type()) {
+      case GEO_COMPONENT_TYPE_MESH: {
+        const MeshComponent &mesh_component = *(const MeshComponent *)component;
+        MeshInfo &info = this->mesh_info.emplace();
+        info.verts_num = mesh_component.attribute_domain_size(ATTR_DOMAIN_POINT);
+        info.edges_num = mesh_component.attribute_domain_size(ATTR_DOMAIN_EDGE);
+        info.faces_num = mesh_component.attribute_domain_size(ATTR_DOMAIN_FACE);
+        break;
+      }
+      case GEO_COMPONENT_TYPE_CURVE: {
+        const CurveComponent &curve_component = *(const CurveComponent *)component;
+        CurveInfo &info = this->curve_info.emplace();
+        info.splines_num = curve_component.attribute_domain_size(ATTR_DOMAIN_CURVE);
+        break;
+      }
+      case GEO_COMPONENT_TYPE_POINT_CLOUD: {
+        const PointCloudComponent &pointcloud_component = *(const PointCloudComponent *)component;
+        PointCloudInfo &info = this->pointcloud_info.emplace();
+        info.points_num = pointcloud_component.attribute_domain_size(ATTR_DOMAIN_POINT);
+        break;
+      }
+      case GEO_COMPONENT_TYPE_INSTANCES: {
+        const InstancesComponent &instances_component = *(const InstancesComponent *)component;
+        InstancesInfo &info = this->instances_info.emplace();
+        info.instances_num = instances_component.instances_num();
+        break;
+      }
+      case GEO_COMPONENT_TYPE_EDIT: {
+        const GeometryComponentEditData &edit_component = *(
+            const GeometryComponentEditData *)component;
+        if (const bke::CurvesEditHints *curve_edit_hints =
+                edit_component.curves_edit_hints_.get()) {
+          EditDataInfo &info = this->edit_data_info.emplace();
+          info.has_deform_matrices = curve_edit_hints->deform_mats.has_value();
+          info.has_deformed_positions = curve_edit_hints->positions.has_value();
+        }
+        break;
+      }
+      case GEO_COMPONENT_TYPE_VOLUME: {
+        break;
+      }
+    }
+  }
+}
+
+/* Avoid generating these in every translation unit. */
+GeoModifierLog::GeoModifierLog() = default;
+GeoModifierLog::~GeoModifierLog() = default;
+
+GeoTreeLogger::GeoTreeLogger() = default;
+GeoTreeLogger::~GeoTreeLogger() = default;
+
+GeoNodeLog::GeoNodeLog() = default;
+GeoNodeLog::~GeoNodeLog() = default;
+
+GeoTreeLog::GeoTreeLog(GeoModifierLog *modifier_log, Vector<GeoTreeLogger *> tree_loggers)
+    : modifier_log_(modifier_log), tree_loggers_(std::move(tree_loggers))
+{
+  for (GeoTreeLogger *tree_logger : tree_loggers_) {
+    for (const ComputeContextHash &hash : tree_logger->children_hashes) {
+      children_hashes_.add(hash);
+    }
+  }
+}
+
+GeoTreeLog::~GeoTreeLog() = default;
+
+void GeoTreeLogger::log_value(const bNode &node, const bNodeSocket &socket, const GPointer value)
+{
+  const CPPType &type = *value.type();
+
+  auto store_logged_value = [&](destruct_ptr<ValueLog> value_log) {
+    auto &socket_values = socket.in_out == SOCK_IN ? this->input_socket_values :
+                                                     this->output_socket_values;
+    socket_values.append({node.name, socket.identifier, std::move(value_log)});
+  };
+
+  auto log_generic_value = [&](const CPPType &type, const void *value) {
+    void *buffer = this->allocator->allocate(type.size(), type.alignment());
+    type.copy_construct(value, buffer);
+    store_logged_value(this->allocator->construct<GenericValueLog>(GMutablePointer{type, buffer}));
+  };
+
+  if (type.is<GeometrySet>()) {
+    const GeometrySet &geometry = *value.get<GeometrySet>();
+    store_logged_value(this->allocator->construct<GeometryInfoLog>(geometry));
+  }
+  else if (const auto *value_or_field_type = dynamic_cast<const fn::ValueOrFieldCPPType *>(
+               &type)) {
+    const void *value_or_field = value.get();
+    const CPPType &base_type = value_or_field_type->base_type();
+    if (value_or_field_type->is_field(value_or_field)) {
+      const GField *field = value_or_field_type->get_field_ptr(value_or_field);
+      if (field->node().depends_on_input()) {
+        store_logged_value(this->allocator->construct<FieldInfoLog>(*field));
+      }
+      else {
+        BUFFER_FOR_CPP_TYPE_VALUE(base_type, value);
+        fn::evaluate_constant_field(*field, value);
+        log_generic_value(base_type, value);
+      }
+    }
+    else {
+      const void *value = value_or_field_type->get_value_ptr(value_or_field);
+      log_generic_value(base_type, value);
+    }
+  }
+  else {
+    log_generic_value(type, value.get());
+  }
+}
+
+void GeoTreeLogger::log_viewer_node(const bNode &viewer_node,
+                                    const GeometrySet &geometry,
+                                    const GField &field)
+{
+  destruct_ptr<ViewerNodeLog> log = this->allocator->construct<ViewerNodeLog>();
+  log->geometry = geometry;
+  log->field = field;
+  log->geometry.ensure_owns_direct_data();
+  this->viewer_node_logs.append({viewer_node.name, std::move(log)});
+}
+
+void GeoTreeLog::ensure_node_warnings()
+{
+  if (reduced_node_warnings_) {
+    return;
+  }
+  for (GeoTreeLogger *tree_logger : tree_loggers_) {
+    for (const GeoTreeLogger::WarningWithNode &warnings : tree_logger->node_warnings) {
+      this->nodes.lookup_or_add_default(warnings.node_name).warnings.append(warnings.warning);
+      this->all_warnings.append(warnings.warning);
+    }
+  }
+  for (const ComputeContextHash &child_hash : children_hashes_) {
+    GeoTreeLog &child_log = modifier_log_->get_tree_log(child_hash);
+    child_log.ensure_node_warnings();
+    const std::optional<std::string> &group_node_name =
+        child_log.tree_loggers_[0]->group_node_name;
+    if (group_node_name.has_value()) {
+      this->nodes.lookup_or_add_default(*group_node_name).warnings.extend(child_log.all_warnings);
+    }
+    this->all_warnings.extend(child_log.all_warnings);
+  }
+  reduced_node_warnings_ = true;
+}
+
+void GeoTreeLog::ensure_node_run_time()
+{
+  if (reduced_node_run_times_) {
+    return;
+  }
+  for (GeoTreeLogger *tree_logger : tree_loggers_) {
+    for (const GeoTreeLogger::NodeExecutionTime &timings : tree_logger->node_execution_times) {
+      const std::chrono::nanoseconds duration = timings.end - timings.start;
+      this->nodes.lookup_or_add_default_as(timings.node_name).run_time += duration;
+      this->run_time_sum += duration;
+    }
+  }
+  for (const ComputeContextHash &child_hash : children_hashes_) {
+    GeoTreeLog &child_log = modifier_log_->get_tree_log(child_hash);
+    child_log.ensure_node_run_time();
+    const std::optional<std::string> &group_node_name =
+        child_log.tree_loggers_[0]->group_node_name;
+    if (group_node_name.has_value()) {
+      this->nodes.lookup_or_add_default(*group_node_name).run_time += child_log.run_time_sum;
+    }
+    this->run_time_sum += child_log.run_time_sum;
+  }
+  reduced_node_run_times_ = true;
+}
+
+void GeoTreeLog::ensure_socket_values()
+{
+  if (reduced_socket_values_) {
+    return;
+  }
+  for (GeoTreeLogger *tree_logger : tree_loggers_) {
+    for (const GeoTreeLogger::SocketValueLog &value_log_data : tree_logger->input_socket_values) {
+      this->nodes.lookup_or_add_as(value_log_data.node_name)
+          .input_values_.add(value_log_data.socket_identifier, value_log_data.value.get());
+    }
+    for (const GeoTreeLogger::SocketValueLog &value_log_data : tree_logger->output_socket_values) {
+      this->nodes.lookup_or_add_as(value_log_data.node_name)
+          .output_values_.add(value_log_data.socket_identifier, value_log_data.value.get());
+    }
+  }
+  reduced_socket_values_ = true;
+}
+
+void GeoTreeLog::ensure_viewer_node_logs()
+{
+  if (reduced_viewer_node_logs_) {
+    return;
+  }
+  for (GeoTreeLogger *tree_logger : tree_loggers_) {
+    for (const GeoTreeLogger::ViewerNodeLogWithNode &viewer_log : tree_logger->viewer_node_logs) {
+      this->viewer_node_logs.add(viewer_log.node_name, viewer_log.viewer_log.get());
+    }
+  }
+  reduced_viewer_node_logs_ = true;
+}
+
+void GeoTreeLog::ensure_existing_attributes()
+{
+  if (reduced_existing_attributes_) {
+    return;
+  }
+  this->ensure_socket_values();
+
+  Set<StringRef> names;
+
+  auto handle_value_log = [&](const ValueLog &value_log) {
+    const GeometryInfoLog *geo_log = dynamic_cast<const GeometryInfoLog *>(&value_log);
+    if (geo_log == nullptr) {
+      return;
+    }
+    for (const GeometryAttributeInfo &attribute : geo_log->attributes) {
+      if (names.add(attribute.name)) {
+        this->existing_attributes.append(&attribute);
+      }
+    }
+  };
+
+  for (const GeoNodeLog &node_log : this->nodes.values()) {
+    for (const ValueLog *value_log : node_log.input_values_.values()) {
+      handle_value_log(*value_log);
+    }
+    for (const ValueLog *value_log : node_log.output_values_.values()) {
+      handle_value_log(*value_log);
+    }
+  }
+  reduced_existing_attributes_ = true;
+}
+
+void GeoTreeLog::ensure_used_named_attributes()
+{
+  if (reduced_used_named_attributes_) {
+    return;
+  }
+
+  auto add_attribute = [&](const StringRef node_name,
+                           const StringRef attribute_name,
+                           const NamedAttributeUsage &usage) {
+    this->nodes.lookup_or_add_as(node_name).used_named_attributes.lookup_or_add_as(attribute_name,
+                                                                                   usage) |= usage;
+    this->used_named_attributes.lookup_or_add_as(attribute_name, usage) |= usage;
+  };
+
+  for (GeoTreeLogger *tree_logger : tree_loggers_) {
+    for (const GeoTreeLogger::AttributeUsageWithNode &item : tree_logger->used_named_attributes) {
+      add_attribute(item.node_name, item.attribute_name, item.usage);
+    }
+  }
+  for (const ComputeContextHash &child_hash : children_hashes_) {
+    GeoTreeLog &child_log = modifier_log_->get_tree_log(child_hash);
+    child_log.ensure_used_named_attributes();
+    if (const std::optional<std::string> &group_node_name =
+            child_log.tree_loggers_[0]->group_node_name) {
+      for (const auto &item : child_log.used_named_attributes.items()) {
+        add_attribute(*group_node_name, item.key, item.value);
+      }
+    }
+  }
+  reduced_used_named_attributes_ = true;
+}
+
+void GeoTreeLog::ensure_debug_messages()
+{
+  if (reduced_debug_messages_) {
+    return;
+  }
+  for (GeoTreeLogger *tree_logger : tree_loggers_) {
+    for (const GeoTreeLogger::DebugMessage &debug_message : tree_logger->debug_messages) {
+      this->nodes.lookup_or_add_as(debug_message.node_name)
+          .debug_messages.append(debug_message.message);
+    }
+  }
+  reduced_debug_messages_ = true;
+}
+
+ValueLog *GeoTreeLog::find_socket_value_log(const bNodeSocket &query_socket)
+{
+  /**
+   * Geometry nodes does not log values for every socket. That would produce a lot of redundant
+   * data,because often many linked sockets have the same value. To find the logged value for a
+   * socket one might have to look at linked sockets as well.
+   */
+
+  BLI_assert(reduced_socket_values_);
+  if (query_socket.is_multi_input()) {
+    /* Not supported currently. */
+    return nullptr;
+  }
+
+  Set<const bNodeSocket *> added_sockets;
+  Stack<const bNodeSocket *> sockets_to_check;
+  sockets_to_check.push(&query_socket);
+  added_sockets.add(&query_socket);
+
+  while (!sockets_to_check.is_empty()) {
+    const bNodeSocket &socket = *sockets_to_check.pop();
+    const bNode &node = socket.owner_node();
+    if (GeoNodeLog *node_log = this->nodes.lookup_ptr(node.name)) {
+      ValueLog *value_log = socket.is_input() ?
+                                node_log->input_values_.lookup_default(socket.identifier,
+                                                                       nullptr) :
+                                node_log->output_values_.lookup_default(socket.identifier,
+                                                                        nullptr);
+      if (value_log != nullptr) {
+        return value_log;
+      }
+    }
+
+    if (socket.is_input()) {
+      const Span<const bNodeLink *> links = socket.directly_linked_links();
+      for (const bNodeLink *link : links) {
+        const bNodeSocket &from_socket = *link->fromsock;
+        if (added_sockets.add(&from_socket)) {
+          sockets_to_check.push(&from_socket);
+        }
+      }
+    }
+    else {
+      if (node.is_reroute()) {
+        const bNodeSocket &input_socket = node.input_socket(0);
+        if (added_sockets.add(&input_socket)) {
+          sockets_to_check.push(&input_socket);
+        }
+        const Span<const bNodeLink *> links = input_socket.directly_linked_links();
+        for (const bNodeLink *link : links) {
+          const bNodeSocket &from_socket = *link->fromsock;
+          if (added_sockets.add(&from_socket)) {
+            sockets_to_check.push(&from_socket);
+          }
+        }
+      }
+      else if (node.is_muted()) {
+        if (const bNodeSocket *input_socket = socket.internal_link_input()) {
+          if (added_sockets.add(input_socket)) {
+            sockets_to_check.push(input_socket);
+          }
+          const Span<const bNodeLink *> links = input_socket->directly_linked_links();
+          for (const bNodeLink *link : links) {
+            const bNodeSocket &from_socket = *link->fromsock;
+            if (added_sockets.add(&from_socket)) {
+              sockets_to_check.push(&from_socket);
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return nullptr;
+}
+
+GeoTreeLogger &GeoModifierLog::get_local_tree_logger(const ComputeContext &compute_context)
+{
+  LocalData &local_data = data_per_thread_.local();
+  Map<ComputeContextHash, destruct_ptr<GeoTreeLogger>> &local_tree_loggers =
+      local_data.tree_logger_by_context;
+  destruct_ptr<GeoTreeLogger> &tree_logger_ptr = local_tree_loggers.lookup_or_add_default(
+      compute_context.hash());
+  if (tree_logger_ptr) {
+    return *tree_logger_ptr;
+  }
+  tree_logger_ptr = local_data.allocator.construct<GeoTreeLogger>();
+  GeoTreeLogger &tree_logger = *tree_logger_ptr;
+  tree_logger.allocator = &local_data.allocator;
+  const ComputeContext *parent_compute_context = compute_context.parent();
+  if (parent_compute_context != nullptr) {
+    tree_logger.parent_hash = parent_compute_context->hash();
+    GeoTreeLogger &parent_logger = this->get_local_tree_logger(*parent_compute_context);
+    parent_logger.children_hashes.append(compute_context.hash());
+  }
+  if (const bke::NodeGroupComputeContext *node_group_compute_context =
+          dynamic_cast<const bke::NodeGroupComputeContext *>(&compute_context)) {
+    tree_logger.group_node_name.emplace(node_group_compute_context->node_name());
+  }
+  return tree_logger;
+}
+
+GeoTreeLog &GeoModifierLog::get_tree_log(const ComputeContextHash &compute_context_hash)
+{
+  GeoTreeLog &reduced_tree_log = *tree_logs_.lookup_or_add_cb(compute_context_hash, [&]() {
+    Vector<GeoTreeLogger *> tree_logs;
+    for (LocalData &local_data : data_per_thread_) {
+      destruct_ptr<GeoTreeLogger> *tree_log = local_data.tree_logger_by_context.lookup_ptr(
+          compute_context_hash);
+      if (tree_log != nullptr) {
+        tree_logs.append(tree_log->get());
+      }
+    }
+    return std::make_unique<GeoTreeLog>(this, std::move(tree_logs));
+  });
+  return reduced_tree_log;
+}
+
+struct ObjectAndModifier {
+  const Object *object;
+  const NodesModifierData *nmd;
+};
+
+static std::optional<ObjectAndModifier> get_modifier_for_node_editor(const SpaceNode &snode)
+{
+  if (snode.id == nullptr) {
+    return std::nullopt;
+  }
+  if (GS(snode.id->name) != ID_OB) {
+    return std::nullopt;
+  }
+  const Object *object = reinterpret_cast<Object *>(snode.id);
+  const NodesModifierData *used_modifier = nullptr;
+  if (snode.flag & SNODE_PIN) {
+    LISTBASE_FOREACH (const ModifierData *, md, &object->modifiers) {
+      if (md->type == eModifierType_Nodes) {
+        const NodesModifierData *nmd = reinterpret_cast<const NodesModifierData *>(md);
+        /* Would be good to store the name of the pinned modifier in the node editor. */
+        if (nmd->node_group == snode.nodetree) {
+          used_modifier = nmd;
+          break;
+        }
+      }
+    }
+  }
+  else {
+    LISTBASE_FOREACH (const ModifierData *, md, &object->modifiers) {
+      if (md->type == eModifierType_Nodes) {
+        const NodesModifierData *nmd = reinterpret_cast<const NodesModifierData *>(md);
+        if (nmd->node_group == snode.nodetree) {
+          if (md->flag & eModifierFlag_Active) {
+            used_modifier = nmd;
+            break;
+          }
+        }
+      }
+    }
+  }
+  if (used_modifier == nullptr) {
+    return std::nullopt;
+  }
+  return ObjectAndModifier{object, used_modifier};
+}
+
+GeoTreeLog *GeoModifierLog::get_tree_log_for_node_editor(const SpaceNode &snode)
+{
+  std::optional<ObjectAndModifier> object_and_modifier = get_modifier_for_node_editor(snode);
+  if (!object_and_modifier) {
+    return nullptr;
+  }
+  GeoModifierLog *modifier_log = static_cast<GeoModifierLog *>(
+      object_and_modifier->nmd->runtime_eval_log);
+  if (modifier_log == nullptr) {
+    return nullptr;
+  }
+  Vector<const bNodeTreePath *> tree_path = snode.treepath;
+  if (tree_path.is_empty()) {
+    return nullptr;
+  }
+  ComputeContextBuilder compute_context_builder;
+  compute_context_builder.push<bke::ModifierComputeContext>(
+      object_and_modifier->nmd->modifier.name);
+  for (const bNodeTreePath *path_item : tree_path.as_span().drop_front(1)) {
+    compute_context_builder.push<bke::NodeGroupComputeContext>(path_item->node_name);
+  }
+  return &modifier_log->get_tree_log(compute_context_builder.hash());
+}
+
+const ViewerNodeLog *GeoModifierLog::find_viewer_node_log_for_spreadsheet(
+    const SpaceSpreadsheet &sspreadsheet)
+{
+  Vector<const SpreadsheetContext *> context_path = sspreadsheet.context_path;
+  if (context_path.size() < 3) {
+    return nullptr;
+  }
+  if (context_path[0]->type != SPREADSHEET_CONTEXT_OBJECT) {
+    return nullptr;
+  }
+  if (context_path[1]->type != SPREADSHEET_CONTEXT_MODIFIER) {
+    return nullptr;
+  }
+  const SpreadsheetContextObject *object_context =
+      reinterpret_cast<const SpreadsheetContextObject *>(context_path[0]);
+  const SpreadsheetContextModifier *modifier_context =
+      reinterpret_cast<const SpreadsheetContextModifier *>(context_path[1]);
+  if (object_context->object == nullptr) {
+    return nullptr;
+  }
+  NodesModifierData *nmd = nullptr;
+  LISTBASE_FOREACH (ModifierData *, md, &object_context->object->modifiers) {
+    if (STREQ(md->name, modifier_context->modifier_name)) {
+      if (md->type == eModifierType_Nodes) {
+        nmd = reinterpret_cast<NodesModifierData *>(md);
+      }
+    }
+  }
+  if (nmd == nullptr) {
+    return nullptr;
+  }
+  if (nmd->runtime_eval_log == nullptr) {
+    return nullptr;
+  }
+  nodes::geo_eval_log::GeoModifierLog *modifier_log =
+      static_cast<nodes::geo_eval_log::GeoModifierLog *>(nmd->runtime_eval_log);
+
+  ComputeContextBuilder compute_context_builder;
+  compute_context_builder.push<bke::ModifierComputeContext>(modifier_context->modifier_name);
+  for (const SpreadsheetContext *context : context_path.as_span().drop_front(2).drop_back(1)) {
+    if (context->type != SPREADSHEET_CONTEXT_NODE) {
+      return nullptr;
+    }
+    const SpreadsheetContextNode &node_context = *reinterpret_cast<const SpreadsheetContextNode *>(
+        context);
+    compute_context_builder.push<bke::NodeGroupComputeContext>(node_context.node_name);
+  }
+  const ComputeContextHash context_hash = compute_context_builder.hash();
+  nodes::geo_eval_log::GeoTreeLog &tree_log = modifier_log->get_tree_log(context_hash);
+  tree_log.ensure_viewer_node_logs();
+
+  const SpreadsheetContext *last_context = context_path.last();
+  if (last_context->type != SPREADSHEET_CONTEXT_NODE) {
+    return nullptr;
+  }
+  const SpreadsheetContextNode &last_node_context =
+      *reinterpret_cast<const SpreadsheetContextNode *>(last_context);
+  const ViewerNodeLog *viewer_log = tree_log.viewer_node_logs.lookup(last_node_context.node_name);
+  return viewer_log;
+}
+
+}  // namespace blender::nodes::geo_eval_log

source/blender/nodes/intern/node_geometry_exec.cc

@@ -11,34 +11,27 @@
 
 #include "node_geometry_util.hh"
 
-using blender::nodes::geometry_nodes_eval_log::LocalGeoLogger;
-
 namespace blender::nodes {
 
 void GeoNodeExecParams::error_message_add(const NodeWarningType type, std::string message) const
 {
-  if (provider_->logger == nullptr) {
-    return;
+  if (geo_eval_log::GeoTreeLogger *tree_logger = this->get_local_tree_logger()) {
+    tree_logger->node_warnings.append({node_.name, {type, std::move(message)}});
   }
-  LocalGeoLogger &local_logger = provider_->logger->local();
-  local_logger.log_node_warning(provider_->dnode, type, std::move(message));
 }
 
 void GeoNodeExecParams::used_named_attribute(std::string attribute_name,
-                                             const eNamedAttrUsage usage)
+                                             const NamedAttributeUsage usage)
 {
-  if (provider_->logger == nullptr) {
-    return;
+  if (geo_eval_log::GeoTreeLogger *tree_logger = this->get_local_tree_logger()) {
+    tree_logger->used_named_attributes.append({node_.name, std::move(attribute_name), usage});
   }
-  LocalGeoLogger &local_logger = provider_->logger->local();
-  local_logger.log_used_named_attribute(provider_->dnode, std::move(attribute_name), usage);
 }
 
 void GeoNodeExecParams::check_input_geometry_set(StringRef identifier,
                                                  const GeometrySet &geometry_set) const
 {
-  const SocketDeclaration &decl =
-      *provider_->dnode->input_by_identifier(identifier).runtime->declaration;
+  const SocketDeclaration &decl = *node_.input_by_identifier(identifier).runtime->declaration;
   const decl::Geometry *geo_decl = dynamic_cast<const decl::Geometry *>(&decl);
   if (geo_decl == nullptr) {
     return;
@@ -118,7 +111,7 @@ void GeoNodeExecParams::check_output_geometry_set(const GeometrySet &geometry_se
 
 const bNodeSocket *GeoNodeExecParams::find_available_socket(const StringRef name) const
 {
-  for (const bNodeSocket *socket : provider_->dnode->runtime->inputs) {
+  for (const bNodeSocket *socket : node_.input_sockets()) {
     if (socket->is_available() && socket->name == name) {
       return socket;
     }
@@ -129,19 +122,19 @@ const bNodeSocket *GeoNodeExecParams::find_available_socket(const StringRef name
 
 std::string GeoNodeExecParams::attribute_producer_name() const
 {
-  return provider_->dnode->label_or_name() + TIP_(" node");
+  return node_.label_or_name() + TIP_(" node");
 }
 
 void GeoNodeExecParams::set_default_remaining_outputs()
 {
-  provider_->set_default_remaining_outputs();
+  params_.set_default_remaining_outputs();
 }
 
 void GeoNodeExecParams::check_input_access(StringRef identifier,
                                            const CPPType *requested_type) const
 {
   const bNodeSocket *found_socket = nullptr;
-  for (const bNodeSocket *socket : provider_->dnode->input_sockets()) {
+  for (const bNodeSocket *socket : node_.input_sockets()) {
     if (socket->identifier == identifier) {
       found_socket = socket;
       break;
@@ -151,7 +144,7 @@ void GeoNodeExecParams::check_input_access(StringRef identifier,
   if (found_socket == nullptr) {
     std::cout << "Did not find an input socket with the identifier '" << identifier << "'.\n";
     std::cout << "Possible identifiers are: ";
-    for (const bNodeSocket *socket : provider_->dnode->input_sockets()) {
+    for (const bNodeSocket *socket : node_.input_sockets()) {
       if (socket->is_available()) {
         std::cout << "'" << socket->identifier << "', ";
       }
@@ -164,13 +157,7 @@ void GeoNodeExecParams::check_input_access(StringRef identifier,
               << "' is disabled.\n";
     BLI_assert_unreachable();
   }
-  else if (!provider_->can_get_input(identifier)) {
-    std::cout << "The identifier '" << identifier
-              << "' is valid, but there is no value for it anymore.\n";
-    std::cout << "Most likely it has been extracted before.\n";
-    BLI_assert_unreachable();
-  }
-  else if (requested_type != nullptr) {
+  else if (requested_type != nullptr && (found_socket->flag & SOCK_MULTI_INPUT) == 0) {
     const CPPType &expected_type = *found_socket->typeinfo->geometry_nodes_cpp_type;
     if (*requested_type != expected_type) {
       std::cout << "The requested type '" << requested_type->name() << "' is incorrect. Expected '"
@@ -183,7 +170,7 @@ void GeoNodeExecParams::check_input_access(StringRef identifier,
 void GeoNodeExecParams::check_output_access(StringRef identifier, const CPPType &value_type) const
 {
   const bNodeSocket *found_socket = nullptr;
-  for (const bNodeSocket *socket : provider_->dnode->output_sockets()) {
+  for (const bNodeSocket *socket : node_.output_sockets()) {
     if (socket->identifier == identifier) {
       found_socket = socket;
       break;
@@ -193,8 +180,8 @@ void GeoNodeExecParams::check_output_access(StringRef identifier, const CPPType
   if (found_socket == nullptr) {
     std::cout << "Did not find an output socket with the identifier '" << identifier << "'.\n";
     std::cout << "Possible identifiers are: ";
-    for (const bNodeSocket *socket : provider_->dnode->output_sockets()) {
-      if (!(socket->flag & SOCK_UNAVAIL)) {
+    for (const bNodeSocket *socket : node_.output_sockets()) {
+      if (socket->is_available()) {
         std::cout << "'" << socket->identifier << "', ";
       }
     }
@@ -206,7 +193,7 @@ void GeoNodeExecParams::check_output_access(StringRef identifier, const CPPType
               << "' is disabled.\n";
     BLI_assert_unreachable();
   }
-  else if (!provider_->can_set_output(identifier)) {
+  else if (params_.output_was_set(this->get_output_index(identifier))) {
     std::cout << "The identifier '" << identifier << "' has been set already.\n";
     BLI_assert_unreachable();
   }

source/blender/nodes/intern/node_multi_function.cc

@@ -3,21 +3,21 @@
 #include "NOD_multi_function.hh"
 
 #include "BKE_node.h"
+#include "BKE_node_runtime.hh"
 
 namespace blender::nodes {
 
-NodeMultiFunctions::NodeMultiFunctions(const DerivedNodeTree &tree)
+NodeMultiFunctions::NodeMultiFunctions(const bNodeTree &tree)
 {
-  for (const bNodeTree *btree : tree.used_btrees()) {
-    for (const bNode *bnode : btree->all_nodes()) {
-      if (bnode->typeinfo->build_multi_function == nullptr) {
-        continue;
-      }
-      NodeMultiFunctionBuilder builder{*bnode, *btree};
-      bnode->typeinfo->build_multi_function(builder);
-      if (builder.built_fn_ != nullptr) {
-        map_.add_new(bnode, {builder.built_fn_, std::move(builder.owned_built_fn_)});
-      }
+  tree.ensure_topology_cache();
+  for (const bNode *bnode : tree.all_nodes()) {
+    if (bnode->typeinfo->build_multi_function == nullptr) {
+      continue;
+    }
+    NodeMultiFunctionBuilder builder{*bnode, tree};
+    bnode->typeinfo->build_multi_function(builder);
+    if (builder.built_fn_ != nullptr) {
+      map_.add_new(bnode, {builder.built_fn_, std::move(builder.owned_built_fn_)});
     }
   }
 }