[Bf-blender-cvs] [670537ed8ac] functions: initial tuple call array execution

[Jacques Lucke]

Commit: 670537ed8ac9b93d6789877a2a5bd998abc1df0f
Author: Jacques Lucke
Date:   Wed Jul 31 11:23:13 2019 +0200
Branches: functions
https://developer.blender.org/rB670537ed8ac9b93d6789877a2a5bd998abc1df0f

initial tuple call array execution

===================================================================

M	source/blender/functions/CMakeLists.txt
M	source/blender/functions/FN_functions.hpp
A	source/blender/functions/functions/array_execution.cpp
A	source/blender/functions/functions/array_execution.hpp
M	source/blender/simulations/bparticles/particle_function.cpp

===================================================================

diff --git a/source/blender/functions/CMakeLists.txt b/source/blender/functions/CMakeLists.txt
index 2378765dfc1..4686e1821c6 100644
--- a/source/blender/functions/CMakeLists.txt
+++ b/source/blender/functions/CMakeLists.txt
@@ -128,6 +128,8 @@ set(SRC
   functions/switch.cpp
   functions/auto_vectorization.hpp
   functions/auto_vectorization.cpp
+  functions/array_execution.hpp
+  functions/array_execution.cpp
   functions/ranges.hpp
   functions/ranges.cpp
   functions/comparisons.hpp
diff --git a/source/blender/functions/FN_functions.hpp b/source/blender/functions/FN_functions.hpp
index 35c5cce64e8..d0e55721d89 100644
--- a/source/blender/functions/FN_functions.hpp
+++ b/source/blender/functions/FN_functions.hpp
@@ -12,3 +12,4 @@
 #include "functions/comparisons.hpp"
 #include "functions/constants.hpp"
 #include "functions/color.hpp"
+#include "functions/array_execution.hpp"
diff --git a/source/blender/functions/functions/array_execution.cpp b/source/blender/functions/functions/array_execution.cpp
new file mode 100644
index 00000000000..8495447a3a9
--- /dev/null
+++ b/source/blender/functions/functions/array_execution.cpp
@@ -0,0 +1,50 @@
+#include "FN_tuple_call.hpp"
+
+#include "array_execution.hpp"
+
+namespace FN {
+namespace Functions {
+
+TupleCallArrayExecution::TupleCallArrayExecution(SharedFunction function)
+    : m_function(std::move(function))
+{
+  BLI_assert(m_function->has_body<TupleCallBody>());
+  for (SharedType &type : m_function->input_types()) {
+    m_input_sizes.append(type->extension<CPPTypeInfo>().size());
+  }
+  for (SharedType &type : m_function->output_types()) {
+    m_output_sizes.append(type->extension<CPPTypeInfo>().size());
+  }
+}
+
+void TupleCallArrayExecution::call(ArrayRef<uint> indices,
+                                   ArrayRef<void *> input_buffers,
+                                   ArrayRef<void *> output_buffers,
+                                   ExecutionContext &execution_context)
+{
+  uint input_amount = m_function->input_amount();
+  uint output_amount = m_function->output_amount();
+
+  BLI_assert(input_amount == input_buffers.size());
+  BLI_assert(output_amount == output_buffers.size());
+
+  TupleCallBody &body = m_function->body<TupleCallBody>();
+  FN_TUPLE_CALL_ALLOC_TUPLES(body, fn_in, fn_out);
+
+  for (uint index : indices) {
+    for (uint i = 0; i < input_amount; i++) {
+      void *ptr = POINTER_OFFSET(input_buffers[i], index * m_input_sizes[i]);
+      fn_in.copy_in__dynamic(i, ptr);
+    }
+
+    body.call(fn_in, fn_out, execution_context);
+
+    for (uint i = 0; i < output_amount; i++) {
+      void *ptr = POINTER_OFFSET(output_buffers[i], index * m_output_sizes[i]);
+      fn_out.relocate_out__dynamic(i, ptr);
+    }
+  }
+}
+
+}  // namespace Functions
+}  // namespace FN
diff --git a/source/blender/functions/functions/array_execution.hpp b/source/blender/functions/functions/array_execution.hpp
new file mode 100644
index 00000000000..2d8e310cbee
--- /dev/null
+++ b/source/blender/functions/functions/array_execution.hpp
@@ -0,0 +1,25 @@
+#pragma once
+
+#include "FN_core.hpp"
+#include "FN_tuple_call.hpp"
+
+namespace FN {
+namespace Functions {
+
+class TupleCallArrayExecution {
+ private:
+  SharedFunction m_function;
+  Vector<uint> m_input_sizes;
+  Vector<uint> m_output_sizes;
+
+ public:
+  TupleCallArrayExecution(SharedFunction function);
+
+  void call(ArrayRef<uint> indices,
+            ArrayRef<void *> input_buffers,
+            ArrayRef<void *> output_buffers,
+            ExecutionContext &execution_context);
+};
+
+}  // namespace Functions
+}  // namespace FN
diff --git a/source/blender/simulations/bparticles/particle_function.cpp b/source/blender/simulations/bparticles/particle_function.cpp
index 7fe1767202b..35598fd2b8e 100644
--- a/source/blender/simulations/bparticles/particle_function.cpp
+++ b/source/blender/simulations/bparticles/particle_function.cpp
@@ -1,3 +1,5 @@
+#include "FN_functions.hpp"
+
 #include "particle_function.hpp"
 
 namespace BParticles {
@@ -141,10 +143,9 @@ void ParticleFunction::init_with_deps(ParticleFunctionResult *result,
   }
 
   uint parameter_amount = m_parameter_depends_on_particle.size();
-  TupleCallBody &body = m_fn_with_deps->body<TupleCallBody>();
 
   Vector<void *> input_buffers;
-  Vector<uint> input_strides;
+  Vector<uint> input_sizes;
   Vector<uint> inputs_to_free;
 
   for (uint i = 0; i < m_fn_with_deps->input_amount(); i++) {
@@ -155,14 +156,14 @@ void ParticleFunction::init_with_deps(ParticleFunctionResult *result,
     BLI_assert(array.stride > 0);
 
     input_buffers.append(array.buffer);
-    input_strides.append(array.stride);
+    input_sizes.append(array.stride);
     if (array.is_newly_allocated) {
       inputs_to_free.append(i);
     }
   }
 
   Vector<void *> output_buffers;
-  Vector<uint> output_strides;
+  Vector<uint> output_sizes;
 
   for (uint parameter_index = 0; parameter_index < parameter_amount; parameter_index++) {
     if (!m_parameter_depends_on_particle[parameter_index]) {
@@ -180,31 +181,18 @@ void ParticleFunction::init_with_deps(ParticleFunctionResult *result,
     result->m_only_first[parameter_index] = false;
 
     output_buffers.append(output_buffer);
-    output_strides.append(output_stride);
+    output_sizes.append(output_stride);
   }
 
   ExecutionStack stack;
   ExecutionContext execution_context(stack);
 
-  FN_TUPLE_CALL_ALLOC_TUPLES(body, fn_in, fn_out);
-
-  for (uint pindex : particles.pindices()) {
-    for (uint i = 0; i < input_buffers.size(); i++) {
-      void *ptr = POINTER_OFFSET(input_buffers[i], pindex * input_strides[i]);
-      fn_in.copy_in__dynamic(i, ptr);
-    }
-
-    body.call(fn_in, fn_out, execution_context);
-
-    for (uint i = 0; i < output_buffers.size(); i++) {
-      void *ptr = POINTER_OFFSET(output_buffers[i], pindex * output_strides[i]);
-      fn_out.relocate_out__dynamic(i, ptr);
-    }
-  }
+  FN::Functions::TupleCallArrayExecution array_execution(m_fn_with_deps);
+  array_execution.call(particles.pindices(), input_buffers, output_buffers, execution_context);
 
   for (uint i : inputs_to_free) {
     void *buffer = input_buffers[i];
-    uint stride = input_strides[i];
+    uint stride = input_sizes[i];
     array_allocator.deallocate(buffer, stride);
   }
 }