Geometry Nodes: refactor array devirtualization

Goals:
* Better high level control over where devirtualization occurs. There is always
  a trade-off between performance and compile-time/binary-size.
* Simplify using array devirtualization.
* Better performance for cases where devirtualization wasn't used before.

Many geometry nodes accept fields as inputs. Internally, that means that the
execution functions have to accept so called "virtual arrays" as inputs. Those
 can be e.g. actual arrays, just single values, or lazily computed arrays.
Due to these different possible virtual arrays implementations, access to
individual elements is slower than it would be if everything was just a normal
array (access does through a virtual function call). For more complex execution
functions, this overhead does not matter, but for small functions (like a simple
addition) it very much does. The virtual function call also prevents the compiler
from doing some optimizations (e.g. loop unrolling and inserting simd instructions).

The solution is to "devirtualize" the virtual arrays for small functions where the
overhead is measurable. Essentially, the function is generated many times with
different array types as input. Then there is a run-time dispatch that calls the
best implementation. We have been doing devirtualization in e.g. math nodes
for a long time already. This patch just generalizes the concept and makes it
easier to control. It also makes it easier to investigate the different trade-offs
when it comes to devirtualization.

Nodes that we've optimized using devirtualization before didn't get a speedup.
However, a couple of nodes are using devirtualization now, that didn't before.
Those got a 2-4x speedup in common cases.
* Map Range
* Random Value
* Switch
* Combine XYZ

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

1 files changed, 14 insertions, 14 deletions

diff --git a/source/blender/functions/FN_multi_function_params.hh b/source/blender/functions/FN_multi_function_params.hh
index 67f31a61dc4..9d09378ab63 100644
--- a/source/blender/functions/FN_multi_function_params.hh
+++ b/source/blender/functions/FN_multi_function_params.hh
@@ -111,7 +111,7 @@ class MFParamsBuilder {
     this->assert_current_param_name(expected_name);
     const int param_index = this->current_param_index();
     const MFParamType &param_type = signature_->param_types[param_index];
-    BLI_assert(param_type.category() == MFParamType::SingleOutput);
+    BLI_assert(param_type.category() == MFParamCategory::SingleOutput);
     const CPPType &type = param_type.data_type().single_type();
     /* An empty span indicates that this is ignored. */
     const GMutableSpan dummy_span{type};
@@ -144,8 +144,8 @@ class MFParamsBuilder {
   GMutableSpan computed_array(int param_index)
   {
     BLI_assert(ELEM(signature_->param_types[param_index].category(),
-                    MFParamType::SingleOutput,
-                    MFParamType::SingleMutable));
+                    MFParamCategory::SingleOutput,
+                    MFParamCategory::SingleMutable));
     int data_index = signature_->data_index(param_index);
     return mutable_spans_[data_index];
   }
@@ -153,8 +153,8 @@ class MFParamsBuilder {
   GVectorArray &computed_vector_array(int param_index)
   {
     BLI_assert(ELEM(signature_->param_types[param_index].category(),
-                    MFParamType::VectorOutput,
-                    MFParamType::VectorMutable));
+                    MFParamCategory::VectorOutput,
+                    MFParamCategory::VectorMutable));
     int data_index = signature_->data_index(param_index);
     return *vector_arrays_[data_index];
   }
@@ -217,7 +217,7 @@ class MFParams {
   }
   const GVArray &readonly_single_input(int param_index, StringRef name = "")
   {
-    this->assert_correct_param(param_index, name, MFParamType::SingleInput);
+    this->assert_correct_param(param_index, name, MFParamCategory::SingleInput);
     int data_index = builder_->signature_->data_index(param_index);
     return builder_->virtual_arrays_[data_index];
   }
@@ -230,7 +230,7 @@ class MFParams {
    */
   bool single_output_is_required(int param_index, StringRef name = "")
   {
-    this->assert_correct_param(param_index, name, MFParamType::SingleOutput);
+    this->assert_correct_param(param_index, name, MFParamCategory::SingleOutput);
     int data_index = builder_->signature_->data_index(param_index);
     return !builder_->mutable_spans_[data_index].is_empty();
   }
@@ -242,7 +242,7 @@ class MFParams {
   }
   GMutableSpan uninitialized_single_output(int param_index, StringRef name = "")
   {
-    this->assert_correct_param(param_index, name, MFParamType::SingleOutput);
+    this->assert_correct_param(param_index, name, MFParamCategory::SingleOutput);
     int data_index = builder_->signature_->data_index(param_index);
     GMutableSpan span = builder_->mutable_spans_[data_index];
     if (!span.is_empty()) {
@@ -264,7 +264,7 @@ class MFParams {
   }
   GMutableSpan uninitialized_single_output_if_required(int param_index, StringRef name = "")
   {
-    this->assert_correct_param(param_index, name, MFParamType::SingleOutput);
+    this->assert_correct_param(param_index, name, MFParamCategory::SingleOutput);
     int data_index = builder_->signature_->data_index(param_index);
     return builder_->mutable_spans_[data_index];
   }
@@ -277,7 +277,7 @@ class MFParams {
   }
   const GVVectorArray &readonly_vector_input(int param_index, StringRef name = "")
   {
-    this->assert_correct_param(param_index, name, MFParamType::VectorInput);
+    this->assert_correct_param(param_index, name, MFParamCategory::VectorInput);
     int data_index = builder_->signature_->data_index(param_index);
     return *builder_->virtual_vector_arrays_[data_index];
   }
@@ -289,7 +289,7 @@ class MFParams {
   }
   GVectorArray &vector_output(int param_index, StringRef name = "")
   {
-    this->assert_correct_param(param_index, name, MFParamType::VectorOutput);
+    this->assert_correct_param(param_index, name, MFParamCategory::VectorOutput);
     int data_index = builder_->signature_->data_index(param_index);
     return *builder_->vector_arrays_[data_index];
   }
@@ -300,7 +300,7 @@ class MFParams {
   }
   GMutableSpan single_mutable(int param_index, StringRef name = "")
   {
-    this->assert_correct_param(param_index, name, MFParamType::SingleMutable);
+    this->assert_correct_param(param_index, name, MFParamCategory::SingleMutable);
     int data_index = builder_->signature_->data_index(param_index);
     return builder_->mutable_spans_[data_index];
   }
@@ -312,7 +312,7 @@ class MFParams {
   }
   GVectorArray &vector_mutable(int param_index, StringRef name = "")
   {
-    this->assert_correct_param(param_index, name, MFParamType::VectorMutable);
+    this->assert_correct_param(param_index, name, MFParamCategory::VectorMutable);
     int data_index = builder_->signature_->data_index(param_index);
     return *builder_->vector_arrays_[data_index];
   }
@@ -329,7 +329,7 @@ class MFParams {
 #endif
   }
 
-  void assert_correct_param(int param_index, StringRef name, MFParamType::Category category)
+  void assert_correct_param(int param_index, StringRef name, MFParamCategory category)
   {
     UNUSED_VARS_NDEBUG(param_index, name, category);
 #ifdef DEBUG