Functions: refactor virtual array data structures

When a function is executed for many elements (e.g. per point) it is often the case
that some parameters are different for every element and other parameters are
the same (there are some more less common cases). To simplify writing such
functions one can use a "virtual array". This is a data structure that has a value
for every index, but might not be stored as an actual array internally. Instead, it
might be just a single value or is computed on the fly. There are various tradeoffs
involved when using this data structure which are mentioned in `BLI_virtual_array.hh`.
It is called "virtual", because it uses inheritance and virtual methods.

Furthermore, there is a new virtual vector array data structure, which is an array
of vectors. Both these types have corresponding generic variants, which can be used
when the data type is not known at compile time. This is typically the case when
building a somewhat generic execution system. The function system used these virtual
data structures before, but now they are more versatile.

I've done this refactor in preparation for the attribute processor and other features of
geometry nodes. I moved the typed virtual arrays to blenlib, so that they can be used
independent of the function system.

One open question for me is whether all the generic data structures (and `CPPType`)
should be moved to blenlib as well. They are well isolated and don't really contain
any business logic. That can be done later if necessary.

4 files changed, 387 insertions, 82 deletions

diff --git a/source/blender/functions/intern/generic_vector_array.cc b/source/blender/functions/intern/generic_vector_array.cc
new file mode 100644
index 00000000000..b3c5517cc43
--- /dev/null
+++ b/source/blender/functions/intern/generic_vector_array.cc
@@ -0,0 +1,104 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "FN_generic_vector_array.hh"
+#include "FN_multi_function_params.hh"
+#include "FN_multi_function_signature.hh"
+
+namespace blender::fn {
+
+GVectorArray::GVectorArray(const CPPType &type, const int64_t array_size)
+    : type_(type), element_size_(type.size()), items_(array_size)
+{
+}
+
+GVectorArray::~GVectorArray()
+{
+  if (type_.is_trivially_destructible()) {
+    return;
+  }
+  for (Item &item : items_) {
+    type_.destruct_n(item.start, item.length);
+  }
+}
+
+void GVectorArray::append(const int64_t index, const void *value)
+{
+  Item &item = items_[index];
+  if (item.length == item.capacity) {
+    this->realloc_to_at_least(item, item.capacity + 1);
+  }
+
+  void *dst = POINTER_OFFSET(item.start, element_size_ * item.length);
+  type_.copy_to_uninitialized(value, dst);
+  item.length++;
+}
+
+void GVectorArray::extend(const int64_t index, const GVArray &values)
+{
+  BLI_assert(values.type() == type_);
+  for (const int i : IndexRange(values.size())) {
+    BUFFER_FOR_CPP_TYPE_VALUE(type_, buffer);
+    values.get(i, buffer);
+    this->append(index, buffer);
+    type_.destruct(buffer);
+  }
+}
+
+void GVectorArray::extend(const int64_t index, const GSpan values)
+{
+  GVArrayForGSpan varray{values};
+  this->extend(index, varray);
+}
+
+void GVectorArray::extend(IndexMask mask, const GVVectorArray &values)
+{
+  for (const int i : mask) {
+    GVArrayForGVVectorArrayIndex array{values, i};
+    this->extend(i, array);
+  }
+}
+
+void GVectorArray::extend(IndexMask mask, const GVectorArray &values)
+{
+  GVVectorArrayForGVectorArray virtual_values{values};
+  this->extend(mask, virtual_values);
+}
+
+GMutableSpan GVectorArray::operator[](const int64_t index)
+{
+  Item &item = items_[index];
+  return GMutableSpan{type_, item.start, item.length};
+}
+
+GSpan GVectorArray::operator[](const int64_t index) const
+{
+  const Item &item = items_[index];
+  return GSpan{type_, item.start, item.length};
+}
+
+void GVectorArray::realloc_to_at_least(Item &item, int64_t min_capacity)
+{
+  const int64_t new_capacity = std::max(min_capacity, item.length * 2);
+
+  void *new_buffer = allocator_.allocate(element_size_ * new_capacity, type_.alignment());
+  type_.relocate_to_initialized_n(item.start, new_buffer, item.length);
+
+  item.start = new_buffer;
+  item.capacity = new_capacity;
+}
+
+}  // namespace blender::fn
diff --git a/source/blender/functions/intern/generic_virtual_array.cc b/source/blender/functions/intern/generic_virtual_array.cc
new file mode 100644
index 00000000000..9380eb257b2
--- /dev/null
+++ b/source/blender/functions/intern/generic_virtual_array.cc
@@ -0,0 +1,107 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "FN_generic_virtual_array.hh"
+
+namespace blender::fn {
+
+void GVArray::materialize_to_uninitialized(const IndexMask mask, void *dst) const
+{
+  for (const int64_t i : mask) {
+    void *elem_dst = POINTER_OFFSET(dst, type_->size() * i);
+    this->get_to_uninitialized(i, elem_dst);
+  }
+}
+
+void GVArray::get_impl(const int64_t index, void *r_value) const
+{
+  type_->destruct(r_value);
+  this->get_to_uninitialized_impl(index, r_value);
+}
+
+bool GVArray::is_span_impl() const
+{
+  return false;
+}
+
+GSpan GVArray::get_span_impl() const
+{
+  BLI_assert(false);
+  return GSpan(*type_);
+}
+
+bool GVArray::is_single_impl() const
+{
+  return false;
+}
+
+void GVArray::get_single_impl(void *UNUSED(r_value)) const
+{
+  BLI_assert(false);
+}
+
+void GVArrayForGSpan::get_impl(const int64_t index, void *r_value) const
+{
+  type_->copy_to_initialized(POINTER_OFFSET(data_, element_size_ * index), r_value);
+}
+
+void GVArrayForGSpan::get_to_uninitialized_impl(const int64_t index, void *r_value) const
+{
+  type_->copy_to_uninitialized(POINTER_OFFSET(data_, element_size_ * index), r_value);
+}
+
+bool GVArrayForGSpan::is_span_impl() const
+{
+  return true;
+}
+
+GSpan GVArrayForGSpan::get_span_impl() const
+{
+  return GSpan(*type_, data_, size_);
+}
+
+void GVArrayForSingleValueRef::get_impl(const int64_t UNUSED(index), void *r_value) const
+{
+  type_->copy_to_initialized(value_, r_value);
+}
+
+void GVArrayForSingleValueRef::get_to_uninitialized_impl(const int64_t UNUSED(index),
+                                                         void *r_value) const
+{
+  type_->copy_to_uninitialized(value_, r_value);
+}
+
+bool GVArrayForSingleValueRef::is_span_impl() const
+{
+  return size_ == 1;
+}
+
+GSpan GVArrayForSingleValueRef::get_span_impl() const
+{
+  return GSpan{*type_, value_, 1};
+}
+
+bool GVArrayForSingleValueRef::is_single_impl() const
+{
+  return true;
+}
+
+void GVArrayForSingleValueRef::get_single_impl(void *r_value) const
+{
+  type_->copy_to_initialized(value_, r_value);
+}
+
+}  // namespace blender::fn
diff --git a/source/blender/functions/intern/generic_virtual_vector_array.cc b/source/blender/functions/intern/generic_virtual_vector_array.cc
new file mode 100644
index 00000000000..f6504cee41e
--- /dev/null
+++ b/source/blender/functions/intern/generic_virtual_vector_array.cc
@@ -0,0 +1,67 @@
+/*
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+
+#include "FN_generic_virtual_vector_array.hh"
+
+namespace blender::fn {
+
+void GVArrayForGVVectorArrayIndex::get_impl(const int64_t index_in_vector, void *r_value) const
+{
+  vector_array_.get_vector_element(index_, index_in_vector, r_value);
+}
+
+void GVArrayForGVVectorArrayIndex::get_to_uninitialized_impl(const int64_t index_in_vector,
+                                                             void *r_value) const
+{
+  type_->construct_default(r_value);
+  vector_array_.get_vector_element(index_, index_in_vector, r_value);
+}
+
+int64_t GVVectorArrayForSingleGVArray::get_vector_size_impl(const int64_t UNUSED(index)) const
+{
+  return array_.size();
+}
+
+void GVVectorArrayForSingleGVArray::get_vector_element_impl(const int64_t UNUSED(index),
+                                                            const int64_t index_in_vector,
+                                                            void *r_value) const
+{
+  array_.get(index_in_vector, r_value);
+}
+
+bool GVVectorArrayForSingleGVArray::is_single_vector_impl() const
+{
+  return true;
+}
+
+int64_t GVVectorArrayForSingleGSpan::get_vector_size_impl(const int64_t UNUSED(index)) const
+{
+  return span_.size();
+}
+
+void GVVectorArrayForSingleGSpan::get_vector_element_impl(const int64_t UNUSED(index),
+                                                          const int64_t index_in_vector,
+                                                          void *r_value) const
+{
+  type_->copy_to_initialized(span_[index_in_vector], r_value);
+}
+
+bool GVVectorArrayForSingleGSpan::is_single_vector_impl() const
+{
+  return true;
+}
+
+}  // namespace blender::fn
diff --git a/source/blender/functions/intern/multi_function_network_evaluation.cc b/source/blender/functions/intern/multi_function_network_evaluation.cc
index 5a37a45908f..98500a350ae 100644
--- a/source/blender/functions/intern/multi_function_network_evaluation.cc
+++ b/source/blender/functions/intern/multi_function_network_evaluation.cc
@@ -37,6 +37,7 @@
 
 #include "FN_multi_function_network_evaluation.hh"
 
+#include "BLI_resource_collector.hh"
 #include "BLI_stack.hh"
 
 namespace blender::fn {
@@ -62,16 +63,20 @@ class MFNetworkEvaluationStorage {
   ~MFNetworkEvaluationStorage();
 
   /* Add the values that have been provided by the caller of the multi-function network. */
-  void add_single_input_from_caller(const MFOutputSocket &socket, GVSpan virtual_span);
-  void add_vector_input_from_caller(const MFOutputSocket &socket, GVArraySpan virtual_array_span);
+  void add_single_input_from_caller(const MFOutputSocket &socket, const GVArray &virtual_array);
+  void add_vector_input_from_caller(const MFOutputSocket &socket,
+                                    const GVVectorArray &virtual_vector_array);
   void add_single_output_from_caller(const MFOutputSocket &socket, GMutableSpan span);
   void add_vector_output_from_caller(const MFOutputSocket &socket, GVectorArray &vector_array);
 
   /* Get input buffers for function node evaluations. */
-  GVSpan get_single_input__full(const MFInputSocket &socket);
-  GVSpan get_single_input__single(const MFInputSocket &socket);
-  GVArraySpan get_vector_input__full(const MFInputSocket &socket);
-  GVArraySpan get_vector_input__single(const MFInputSocket &socket);
+  const GVArray &get_single_input__full(const MFInputSocket &socket, ResourceCollector &resources);
+  const GVArray &get_single_input__single(const MFInputSocket &socket,
+                                          ResourceCollector &resources);
+  const GVVectorArray &get_vector_input__full(const MFInputSocket &socket,
+                                              ResourceCollector &resources);
+  const GVVectorArray &get_vector_input__single(const MFInputSocket &socket,
+                                                ResourceCollector &resources);
 
   /* Get output buffers for function node evaluations. */
   GMutableSpan get_single_output__full(const MFOutputSocket &socket);
@@ -80,12 +85,18 @@ class MFNetworkEvaluationStorage {
   GVectorArray &get_vector_output__single(const MFOutputSocket &socket);
 
   /* Get mutable buffers for function node evaluations. */
-  GMutableSpan get_mutable_single__full(const MFInputSocket &input, const MFOutputSocket &output);
+  GMutableSpan get_mutable_single__full(const MFInputSocket &input,
+                                        const MFOutputSocket &output,
+                                        ResourceCollector &resources);
   GMutableSpan get_mutable_single__single(const MFInputSocket &input,
-                                          const MFOutputSocket &output);
-  GVectorArray &get_mutable_vector__full(const MFInputSocket &input, const MFOutputSocket &output);
+                                          const MFOutputSocket &output,
+                                          ResourceCollector &resources);
+  GVectorArray &get_mutable_vector__full(const MFInputSocket &input,
+                                         const MFOutputSocket &output,
+                                         ResourceCollector &resources);
   GVectorArray &get_mutable_vector__single(const MFInputSocket &input,
-                                           const MFOutputSocket &output);
+                                           const MFOutputSocket &output,
+                                           ResourceCollector &resources);
 
   /* Mark a node as being done with evaluation. This might free temporary buffers that are no
    * longer needed. */
@@ -160,12 +171,12 @@ BLI_NOINLINE void MFNetworkEvaluator::copy_inputs_to_storage(MFParams params,
     const MFOutputSocket &socket = *inputs_[input_index];
     switch (socket.data_type().category()) {
       case MFDataType::Single: {
-        GVSpan input_list = params.readonly_single_input(param_index);
+        const GVArray &input_list = params.readonly_single_input(param_index);
         storage.add_single_input_from_caller(socket, input_list);
         break;
       }
       case MFDataType::Vector: {
-        GVArraySpan input_list_list = params.readonly_vector_input(param_index);
+        const GVVectorArray &input_list_list = params.readonly_vector_input(param_index);
         storage.add_vector_input_from_caller(socket, input_list_list);
         break;
       }
@@ -255,6 +266,7 @@ BLI_NOINLINE void MFNetworkEvaluator::evaluate_function(MFContext &global_contex
                                                         const MFFunctionNode &function_node,
                                                         Storage &storage) const
 {
+
   const MultiFunction &function = function_node.function();
   // std::cout << "Function: " << function.name() << "\n";
 
@@ -262,19 +274,20 @@ BLI_NOINLINE void MFNetworkEvaluator::evaluate_function(MFContext &global_contex
     /* The function output would be the same for all elements. Therefore, it is enough to call the
      * function only on a single element. This can avoid many duplicate computations. */
     MFParamsBuilder params{function, 1};
+    ResourceCollector &resources = params.resources();
 
     for (int param_index : function.param_indices()) {
       MFParamType param_type = function.param_type(param_index);
       switch (param_type.category()) {
         case MFParamType::SingleInput: {
           const MFInputSocket &socket = function_node.input_for_param(param_index);
-          GVSpan values = storage.get_single_input__single(socket);
+          const GVArray &values = storage.get_single_input__single(socket, resources);
           params.add_readonly_single_input(values);
           break;
         }
         case MFParamType::VectorInput: {
           const MFInputSocket &socket = function_node.input_for_param(param_index);
-          GVArraySpan values = storage.get_vector_input__single(socket);
+          const GVVectorArray &values = storage.get_vector_input__single(socket, resources);
           params.add_readonly_vector_input(values);
           break;
         }
@@ -293,14 +306,14 @@ BLI_NOINLINE void MFNetworkEvaluator::evaluate_function(MFContext &global_contex
         case MFParamType::SingleMutable: {
           const MFInputSocket &input = function_node.input_for_param(param_index);
           const MFOutputSocket &output = function_node.output_for_param(param_index);
-          GMutableSpan values = storage.get_mutable_single__single(input, output);
+          GMutableSpan values = storage.get_mutable_single__single(input, output, resources);
           params.add_single_mutable(values);
           break;
         }
         case MFParamType::VectorMutable: {
           const MFInputSocket &input = function_node.input_for_param(param_index);
           const MFOutputSocket &output = function_node.output_for_param(param_index);
-          GVectorArray &values = storage.get_mutable_vector__single(input, output);
+          GVectorArray &values = storage.get_mutable_vector__single(input, output, resources);
           params.add_vector_mutable(values);
           break;
         }
@@ -311,19 +324,20 @@ BLI_NOINLINE void MFNetworkEvaluator::evaluate_function(MFContext &global_contex
   }
   else {
     MFParamsBuilder params{function, storage.mask().min_array_size()};
+    ResourceCollector &resources = params.resources();
 
     for (int param_index : function.param_indices()) {
       MFParamType param_type = function.param_type(param_index);
       switch (param_type.category()) {
         case MFParamType::SingleInput: {
           const MFInputSocket &socket = function_node.input_for_param(param_index);
-          GVSpan values = storage.get_single_input__full(socket);
+          const GVArray &values = storage.get_single_input__full(socket, resources);
           params.add_readonly_single_input(values);
           break;
         }
         case MFParamType::VectorInput: {
           const MFInputSocket &socket = function_node.input_for_param(param_index);
-          GVArraySpan values = storage.get_vector_input__full(socket);
+          const GVVectorArray &values = storage.get_vector_input__full(socket, resources);
           params.add_readonly_vector_input(values);
           break;
         }
@@ -342,14 +356,14 @@ BLI_NOINLINE void MFNetworkEvaluator::evaluate_function(MFContext &global_contex
         case MFParamType::SingleMutable: {
           const MFInputSocket &input = function_node.input_for_param(param_index);
           const MFOutputSocket &output = function_node.output_for_param(param_index);
-          GMutableSpan values = storage.get_mutable_single__full(input, output);
+          GMutableSpan values = storage.get_mutable_single__full(input, output, resources);
           params.add_single_mutable(values);
           break;
         }
         case MFParamType::VectorMutable: {
           const MFInputSocket &input = function_node.input_for_param(param_index);
           const MFOutputSocket &output = function_node.output_for_param(param_index);
-          GVectorArray &values = storage.get_mutable_vector__full(input, output);
+          GVectorArray &values = storage.get_mutable_vector__full(input, output, resources);
           params.add_vector_mutable(values);
           break;
         }
@@ -383,18 +397,19 @@ bool MFNetworkEvaluator::can_do_single_value_evaluation(const MFFunctionNode &fu
 BLI_NOINLINE void MFNetworkEvaluator::initialize_remaining_outputs(
     MFParams params, Storage &storage, Span<const MFInputSocket *> remaining_outputs) const
 {
+  ResourceCollector resources;
   for (const MFInputSocket *socket : remaining_outputs) {
     int param_index = inputs_.size() + outputs_.first_index_of(socket);
 
     switch (socket->data_type().category()) {
       case MFDataType::Single: {
-        GVSpan values = storage.get_single_input__full(*socket);
+        const GVArray &values = storage.get_single_input__full(*socket, resources);
         GMutableSpan output_values = params.uninitialized_single_output(param_index);
         values.materialize_to_uninitialized(storage.mask(), output_values.data());
         break;
       }
       case MFDataType::Vector: {
-        GVArraySpan values = storage.get_vector_input__full(*socket);
+        const GVVectorArray &values = storage.get_vector_input__full(*socket, resources);
         GVectorArray &output_values = params.vector_output(param_index);
         output_values.extend(storage.mask(), values);
         break;
@@ -425,20 +440,21 @@ struct Value {
 };
 
 struct InputSingleValue : public Value {
-  /** This span has been provided by the code that called the multi-function network. */
-  GVSpan virtual_span;
+  /** This virtual array has been provided by the code that called the multi-function network. */
+  const GVArray &virtual_array;
 
-  InputSingleValue(GVSpan virtual_span) : Value(ValueType::InputSingle), virtual_span(virtual_span)
+  InputSingleValue(const GVArray &virtual_array)
+      : Value(ValueType::InputSingle), virtual_array(virtual_array)
   {
   }
 };
 
 struct InputVectorValue : public Value {
-  /** This span has been provided by the code that called the multi-function network. */
-  GVArraySpan virtual_array_span;
+  /** This virtual vector has been provided by the code that called the multi-function network. */
+  const GVVectorArray &virtual_vector_array;
 
-  InputVectorValue(GVArraySpan virtual_array_span)
-      : Value(ValueType::InputVector), virtual_array_span(virtual_array_span)
+  InputVectorValue(const GVVectorArray &virtual_vector_array)
+      : Value(ValueType::InputVector), virtual_vector_array(virtual_vector_array)
   {
   }
 };
@@ -564,9 +580,9 @@ bool MFNetworkEvaluationStorage::is_same_value_for_every_index(const MFOutputSoc
     case ValueType::OwnVector:
       return static_cast<OwnVectorValue *>(any_value)->vector_array->size() == 1;
     case ValueType::InputSingle:
-      return static_cast<InputSingleValue *>(any_value)->virtual_span.is_single_element();
+      return static_cast<InputSingleValue *>(any_value)->virtual_array.is_single();
     case ValueType::InputVector:
-      return static_cast<InputVectorValue *>(any_value)->virtual_array_span.is_single_array();
+      return static_cast<InputVectorValue *>(any_value)->virtual_vector_array.is_single_vector();
     case ValueType::OutputSingle:
       return static_cast<OutputSingleValue *>(any_value)->span.size() == 1;
     case ValueType::OutputVector:
@@ -658,22 +674,22 @@ void MFNetworkEvaluationStorage::finish_input_socket(const MFInputSocket &socket
 }
 
 void MFNetworkEvaluationStorage::add_single_input_from_caller(const MFOutputSocket &socket,
-                                                              GVSpan virtual_span)
+                                                              const GVArray &virtual_array)
 {
   BLI_assert(value_per_output_id_[socket.id()] == nullptr);
-  BLI_assert(virtual_span.size() >= min_array_size_);
+  BLI_assert(virtual_array.size() >= min_array_size_);
 
-  auto *value = allocator_.construct<InputSingleValue>(virtual_span).release();
+  auto *value = allocator_.construct<InputSingleValue>(virtual_array).release();
   value_per_output_id_[socket.id()] = value;
 }
 
-void MFNetworkEvaluationStorage::add_vector_input_from_caller(const MFOutputSocket &socket,
-                                                              GVArraySpan virtual_array_span)
+void MFNetworkEvaluationStorage::add_vector_input_from_caller(
+    const MFOutputSocket &socket, const GVVectorArray &virtual_vector_array)
 {
   BLI_assert(value_per_output_id_[socket.id()] == nullptr);
-  BLI_assert(virtual_array_span.size() >= min_array_size_);
+  BLI_assert(virtual_vector_array.size() >= min_array_size_);
 
-  auto *value = allocator_.construct<InputVectorValue>(virtual_array_span).release();
+  auto *value = allocator_.construct<InputVectorValue>(virtual_vector_array).release();
   value_per_output_id_[socket.id()] = value;
 }
 
@@ -776,7 +792,8 @@ GVectorArray &MFNetworkEvaluationStorage::get_vector_output__single(const MFOutp
 }
 
 GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__full(const MFInputSocket &input,
-                                                                  const MFOutputSocket &output)
+                                                                  const MFOutputSocket &output,
+                                                                  ResourceCollector &resources)
 {
   const MFOutputSocket &from = *input.origin();
   const MFOutputSocket &to = output;
@@ -790,8 +807,8 @@ GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__full(const MFInputS
   if (to_any_value != nullptr) {
     BLI_assert(to_any_value->type == ValueType::OutputSingle);
     GMutableSpan span = static_cast<OutputSingleValue *>(to_any_value)->span;
-    GVSpan virtual_span = this->get_single_input__full(input);
-    virtual_span.materialize_to_uninitialized(mask_, span.data());
+    const GVArray &virtual_array = this->get_single_input__full(input, resources);
+    virtual_array.materialize_to_uninitialized(mask_, span.data());
     return span;
   }
 
@@ -805,10 +822,10 @@ GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__full(const MFInputS
     }
   }
 
-  GVSpan virtual_span = this->get_single_input__full(input);
+  const GVArray &virtual_array = this->get_single_input__full(input, resources);
   void *new_buffer = MEM_mallocN_aligned(min_array_size_ * type.size(), type.alignment(), AT);
   GMutableSpan new_array_ref(type, new_buffer, min_array_size_);
-  virtual_span.materialize_to_uninitialized(mask_, new_array_ref.data());
+  virtual_array.materialize_to_uninitialized(mask_, new_array_ref.data());
 
   OwnSingleValue *new_value =
       allocator_.construct<OwnSingleValue>(new_array_ref, to.targets().size(), false).release();
@@ -817,7 +834,8 @@ GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__full(const MFInputS
 }
 
 GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__single(const MFInputSocket &input,
-                                                                    const MFOutputSocket &output)
+                                                                    const MFOutputSocket &output,
+                                                                    ResourceCollector &resources)
 {
   const MFOutputSocket &from = *input.origin();
   const MFOutputSocket &to = output;
@@ -832,8 +850,8 @@ GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__single(const MFInpu
     BLI_assert(to_any_value->type == ValueType::OutputSingle);
     GMutableSpan span = static_cast<OutputSingleValue *>(to_any_value)->span;
     BLI_assert(span.size() == 1);
-    GVSpan virtual_span = this->get_single_input__single(input);
-    type.copy_to_uninitialized(virtual_span.as_single_element(), span[0]);
+    const GVArray &virtual_array = this->get_single_input__single(input, resources);
+    virtual_array.get_single_to_uninitialized(span[0]);
     return span;
   }
 
@@ -848,10 +866,10 @@ GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__single(const MFInpu
     }
   }
 
-  GVSpan virtual_span = this->get_single_input__single(input);
+  const GVArray &virtual_array = this->get_single_input__single(input, resources);
 
   void *new_buffer = allocator_.allocate(type.size(), type.alignment());
-  type.copy_to_uninitialized(virtual_span.as_single_element(), new_buffer);
+  virtual_array.get_single_to_uninitialized(new_buffer);
   GMutableSpan new_array_ref(type, new_buffer, 1);
 
   OwnSingleValue *new_value =
@@ -861,7 +879,8 @@ GMutableSpan MFNetworkEvaluationStorage::get_mutable_single__single(const MFInpu
 }
 
 GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__full(const MFInputSocket &input,
-                                                                   const MFOutputSocket &output)
+                                                                   const MFOutputSocket &output,
+                                                                   ResourceCollector &resources)
 {
   const MFOutputSocket &from = *input.origin();
   const MFOutputSocket &to = output;
@@ -875,8 +894,8 @@ GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__full(const MFInput
   if (to_any_value != nullptr) {
     BLI_assert(to_any_value->type == ValueType::OutputVector);
     GVectorArray &vector_array = *static_cast<OutputVectorValue *>(to_any_value)->vector_array;
-    GVArraySpan virtual_array_span = this->get_vector_input__full(input);
-    vector_array.extend(mask_, virtual_array_span);
+    const GVVectorArray &virtual_vector_array = this->get_vector_input__full(input, resources);
+    vector_array.extend(mask_, virtual_vector_array);
     return vector_array;
   }
 
@@ -890,10 +909,10 @@ GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__full(const MFInput
     }
   }
 
-  GVArraySpan virtual_array_span = this->get_vector_input__full(input);
+  const GVVectorArray &virtual_vector_array = this->get_vector_input__full(input, resources);
 
   GVectorArray *new_vector_array = new GVectorArray(base_type, min_array_size_);
-  new_vector_array->extend(mask_, virtual_array_span);
+  new_vector_array->extend(mask_, virtual_vector_array);
 
   OwnVectorValue *new_value =
       allocator_.construct<OwnVectorValue>(*new_vector_array, to.targets().size()).release();
@@ -903,7 +922,8 @@ GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__full(const MFInput
 }
 
 GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__single(const MFInputSocket &input,
-                                                                     const MFOutputSocket &output)
+                                                                     const MFOutputSocket &output,
+                                                                     ResourceCollector &resources)
 {
   const MFOutputSocket &from = *input.origin();
   const MFOutputSocket &to = output;
@@ -918,8 +938,8 @@ GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__single(const MFInp
     BLI_assert(to_any_value->type == ValueType::OutputVector);
     GVectorArray &vector_array = *static_cast<OutputVectorValue *>(to_any_value)->vector_array;
     BLI_assert(vector_array.size() == 1);
-    GVArraySpan virtual_array_span = this->get_vector_input__single(input);
-    vector_array.extend(0, virtual_array_span[0]);
+    const GVVectorArray &virtual_vector_array = this->get_vector_input__single(input, resources);
+    vector_array.extend({0}, virtual_vector_array);
     return vector_array;
   }
 
@@ -933,10 +953,10 @@ GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__single(const MFInp
     }
   }
 
-  GVArraySpan virtual_array_span = this->get_vector_input__single(input);
+  const GVVectorArray &virtual_vector_array = this->get_vector_input__single(input, resources);
 
   GVectorArray *new_vector_array = new GVectorArray(base_type, 1);
-  new_vector_array->extend(0, virtual_array_span[0]);
+  new_vector_array->extend({0}, virtual_vector_array);
 
   OwnVectorValue *new_value =
       allocator_.construct<OwnVectorValue>(*new_vector_array, to.targets().size()).release();
@@ -944,7 +964,8 @@ GVectorArray &MFNetworkEvaluationStorage::get_mutable_vector__single(const MFInp
   return *new_vector_array;
 }
 
-GVSpan MFNetworkEvaluationStorage::get_single_input__full(const MFInputSocket &socket)
+const GVArray &MFNetworkEvaluationStorage::get_single_input__full(const MFInputSocket &socket,
+                                                                  ResourceCollector &resources)
 {
   const MFOutputSocket &origin = *socket.origin();
   Value *any_value = value_per_output_id_[origin.id()];
@@ -953,26 +974,28 @@ GVSpan MFNetworkEvaluationStorage::get_single_input__full(const MFInputSocket &s
   if (any_value->type == ValueType::OwnSingle) {
     OwnSingleValue *value = static_cast<OwnSingleValue *>(any_value);
     if (value->is_single_allocated) {
-      return GVSpan::FromSingle(value->span.type(), value->span.data(), min_array_size_);
+      return resources.construct<GVArrayForSingleValueRef>(
+          __func__, value->span.type(), min_array_size_, value->span.data());
     }
 
-    return value->span;
+    return resources.construct<GVArrayForGSpan>(__func__, value->span);
   }
   if (any_value->type == ValueType::InputSingle) {
     InputSingleValue *value = static_cast<InputSingleValue *>(any_value);
-    return value->virtual_span;
+    return value->virtual_array;
   }
   if (any_value->type == ValueType::OutputSingle) {
     OutputSingleValue *value = static_cast<OutputSingleValue *>(any_value);
     BLI_assert(value->is_computed);
-    return value->span;
+    return resources.construct<GVArrayForGSpan>(__func__, value->span);
   }
 
   BLI_assert(false);
-  return GVSpan(CPPType::get<float>());
+  return resources.construct<GVArrayForEmpty>(__func__, CPPType::get<float>());
 }
 
-GVSpan MFNetworkEvaluationStorage::get_single_input__single(const MFInputSocket &socket)
+const GVArray &MFNetworkEvaluationStorage::get_single_input__single(const MFInputSocket &socket,
+                                                                    ResourceCollector &resources)
 {
   const MFOutputSocket &origin = *socket.origin();
   Value *any_value = value_per_output_id_[origin.id()];
@@ -981,25 +1004,26 @@ GVSpan MFNetworkEvaluationStorage::get_single_input__single(const MFInputSocket
   if (any_value->type == ValueType::OwnSingle) {
     OwnSingleValue *value = static_cast<OwnSingleValue *>(any_value);
     BLI_assert(value->span.size() == 1);
-    return value->span;
+    return resources.construct<GVArrayForGSpan>(__func__, value->span);
   }
   if (any_value->type == ValueType::InputSingle) {
     InputSingleValue *value = static_cast<InputSingleValue *>(any_value);
-    BLI_assert(value->virtual_span.is_single_element());
-    return value->virtual_span;
+    BLI_assert(value->virtual_array.is_single());
+    return value->virtual_array;
   }
   if (any_value->type == ValueType::OutputSingle) {
     OutputSingleValue *value = static_cast<OutputSingleValue *>(any_value);
     BLI_assert(value->is_computed);
     BLI_assert(value->span.size() == 1);
-    return value->span;
+    return resources.construct<GVArrayForGSpan>(__func__, value->span);
   }
 
   BLI_assert(false);
-  return GVSpan(CPPType::get<float>());
+  return resources.construct<GVArrayForEmpty>(__func__, CPPType::get<float>());
 }
 
-GVArraySpan MFNetworkEvaluationStorage::get_vector_input__full(const MFInputSocket &socket)
+const GVVectorArray &MFNetworkEvaluationStorage::get_vector_input__full(
+    const MFInputSocket &socket, ResourceCollector &resources)
 {
   const MFOutputSocket &origin = *socket.origin();
   Value *any_value = value_per_output_id_[origin.id()];
@@ -1009,25 +1033,27 @@ GVArraySpan MFNetworkEvaluationStorage::get_vector_input__full(const MFInputSock
     OwnVectorValue *value = static_cast<OwnVectorValue *>(any_value);
     if (value->vector_array->size() == 1) {
       GSpan span = (*value->vector_array)[0];
-      return GVArraySpan(span, min_array_size_);
+      return resources.construct<GVVectorArrayForSingleGSpan>(__func__, span, min_array_size_);
     }
 
-    return *value->vector_array;
+    return resources.construct<GVVectorArrayForGVectorArray>(__func__, *value->vector_array);
   }
   if (any_value->type == ValueType::InputVector) {
     InputVectorValue *value = static_cast<InputVectorValue *>(any_value);
-    return value->virtual_array_span;
+    return value->virtual_vector_array;
   }
   if (any_value->type == ValueType::OutputVector) {
     OutputVectorValue *value = static_cast<OutputVectorValue *>(any_value);
-    return *value->vector_array;
+    return resources.construct<GVVectorArrayForGVectorArray>(__func__, *value->vector_array);
   }
 
   BLI_assert(false);
-  return GVArraySpan(CPPType::get<float>());
+  return resources.construct<GVVectorArrayForSingleGSpan>(
+      __func__, GSpan(CPPType::get<float>()), 0);
 }
 
-GVArraySpan MFNetworkEvaluationStorage::get_vector_input__single(const MFInputSocket &socket)
+const GVVectorArray &MFNetworkEvaluationStorage::get_vector_input__single(
+    const MFInputSocket &socket, ResourceCollector &resources)
 {
   const MFOutputSocket &origin = *socket.origin();
   Value *any_value = value_per_output_id_[origin.id()];
@@ -1036,21 +1062,22 @@ GVArraySpan MFNetworkEvaluationStorage::get_vector_input__single(const MFInputSo
   if (any_value->type == ValueType::OwnVector) {
     OwnVectorValue *value = static_cast<OwnVectorValue *>(any_value);
     BLI_assert(value->vector_array->size() == 1);
-    return *value->vector_array;
+    return resources.construct<GVVectorArrayForGVectorArray>(__func__, *value->vector_array);
   }
   if (any_value->type == ValueType::InputVector) {
     InputVectorValue *value = static_cast<InputVectorValue *>(any_value);
-    BLI_assert(value->virtual_array_span.is_single_array());
-    return value->virtual_array_span;
+    BLI_assert(value->virtual_vector_array.is_single_vector());
+    return value->virtual_vector_array;
   }
   if (any_value->type == ValueType::OutputVector) {
     OutputVectorValue *value = static_cast<OutputVectorValue *>(any_value);
     BLI_assert(value->vector_array->size() == 1);
-    return *value->vector_array;
+    return resources.construct<GVVectorArrayForGVectorArray>(__func__, *value->vector_array);
   }
 
   BLI_assert(false);
-  return GVArraySpan(CPPType::get<float>());
+  return resources.construct<GVVectorArrayForSingleGSpan>(
+      __func__, GSpan(CPPType::get<float>()), 0);
 }
 
 /** \} */