[Bf-blender-cvs] [76c3bd772e2] functions: move value storage into separate struct

Jacques Lucke noreply at git.blender.org
Sat Apr 27 22:43:34 CEST 2019


Commit: 76c3bd772e220e017a0af4af215b0318f00711a3
Author: Jacques Lucke
Date:   Sat Apr 27 22:03:04 2019 +0200
Branches: functions
https://developer.blender.org/rB76c3bd772e220e017a0af4af215b0318f00711a3

move value storage into separate struct

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

M	source/blender/functions/backends/tuple_call/fgraph_tuple_call.cpp

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

diff --git a/source/blender/functions/backends/tuple_call/fgraph_tuple_call.cpp b/source/blender/functions/backends/tuple_call/fgraph_tuple_call.cpp
index 67c1dc00056..069a945e8d8 100644
--- a/source/blender/functions/backends/tuple_call/fgraph_tuple_call.cpp
+++ b/source/blender/functions/backends/tuple_call/fgraph_tuple_call.cpp
@@ -109,36 +109,79 @@ class ExecuteFGraph : public TupleCallBody {
     }
   }
 
+  struct SocketValueStorage {
+    const ExecuteFGraph &m_parent;
+    void *m_input_values;
+    void *m_output_values;
+    bool *input_inits;
+    bool *output_inits;
+
+    SocketValueStorage(const ExecuteFGraph &parent) : m_parent(parent)
+    {
+    }
+
+    void *input_value_ptr(uint input_socket_id)
+    {
+      return POINTER_OFFSET(m_input_values, m_parent.m_input_info[input_socket_id].offset);
+    }
+
+    void *output_value_ptr(uint output_socket_id)
+    {
+      return POINTER_OFFSET(m_output_values, m_parent.m_output_info[output_socket_id].offset);
+    }
+
+    void *node_input_values_ptr(uint node_id)
+    {
+      return POINTER_OFFSET(m_input_values, m_parent.m_input_starts[node_id]);
+    }
+
+    void *node_output_values_ptr(uint node_id)
+    {
+      return POINTER_OFFSET(m_output_values, m_parent.m_output_starts[node_id]);
+    }
+
+    bool *node_input_inits_ptr(uint node_id)
+    {
+      return (bool *)POINTER_OFFSET(input_inits,
+                                    m_parent.m_graph->first_input_id_of_node(node_id));
+    }
+
+    bool *node_output_inits_ptr(uint node_id)
+    {
+      return (bool *)POINTER_OFFSET(output_inits,
+                                    m_parent.m_graph->first_output_id_of_node(node_id));
+    }
+  };
+
   void call(Tuple &fn_in, Tuple &fn_out, ExecutionContext &ctx) const override
   {
-    char *input_values = BLI_array_alloca(input_values, m_inputs_buffer_size);
-    char *output_values = BLI_array_alloca(output_values, m_outputs_buffer_size);
+    SocketValueStorage storage(*this);
 
-    bool *input_inits = BLI_array_alloca(input_inits, m_inputs_init_buffer_size);
-    bool *output_inits = BLI_array_alloca(output_inits, m_outputs_init_buffer_size);
-    memset(input_inits, 0, m_inputs_init_buffer_size);
-    memset(output_inits, 0, m_outputs_init_buffer_size);
+    storage.m_input_values = alloca(m_inputs_buffer_size);
+    storage.m_output_values = alloca(m_outputs_buffer_size);
+    storage.input_inits = (bool *)alloca(m_inputs_init_buffer_size);
+    storage.output_inits = (bool *)alloca(m_outputs_init_buffer_size);
+    memset(storage.input_inits, 0, m_inputs_init_buffer_size);
+    memset(storage.output_inits, 0, m_outputs_init_buffer_size);
 
     for (uint i = 0; i < m_fgraph.inputs().size(); i++) {
       DFGraphSocket socket = m_fgraph.inputs()[i];
       if (socket.is_input()) {
-        SocketInfo &socket_info = m_input_info[socket.id()];
-        fn_in.relocate_out__dynamic(i, POINTER_OFFSET(input_values, socket_info.offset));
-        input_inits[socket.id()] = true;
+        fn_in.relocate_out__dynamic(i, storage.input_value_ptr(socket.id()));
+        storage.input_inits[socket.id()] = true;
 
-        if (socket_info.is_fn_output) {
+        if (m_input_info[socket.id()].is_fn_output) {
           uint index = m_fgraph.outputs().index(socket);
-          fn_out.copy_in__dynamic(index, POINTER_OFFSET(input_values, socket_info.offset));
+          fn_out.copy_in__dynamic(index, storage.input_value_ptr(socket.id()));
         }
       }
       else {
-        SocketInfo &socket_info = m_output_info[socket.id()];
-        fn_in.relocate_out__dynamic(i, POINTER_OFFSET(output_values, socket_info.offset));
-        output_inits[socket.id()] = true;
+        fn_in.relocate_out__dynamic(i, storage.output_value_ptr(socket.id()));
+        storage.output_inits[socket.id()] = true;
 
-        if (socket_info.is_fn_output) {
+        if (m_output_info[socket.id()].is_fn_output) {
           uint index = m_fgraph.outputs().index(socket);
-          fn_out.copy_in__dynamic(index, POINTER_OFFSET(output_values, socket_info.offset));
+          fn_out.copy_in__dynamic(index, storage.output_value_ptr(socket.id()));
         }
       }
     }
@@ -152,14 +195,13 @@ class ExecuteFGraph : public TupleCallBody {
       DFGraphSocket socket = sockets_to_compute.peek();
 
       if (socket.is_input()) {
-        if (input_inits[socket.id()]) {
+        if (storage.input_inits[socket.id()]) {
           sockets_to_compute.pop();
         }
         else {
           DFGraphSocket origin = m_graph->origin_of_input(socket);
-          if (output_inits[origin.id()]) {
-            this->forward_output(
-                origin.id(), input_values, output_values, input_inits, output_inits, fn_out);
+          if (storage.output_inits[origin.id()]) {
+            this->forward_output(origin.id(), storage, fn_out);
             sockets_to_compute.pop();
           }
           else {
@@ -168,14 +210,14 @@ class ExecuteFGraph : public TupleCallBody {
         }
       }
       else {
-        if (output_inits[socket.id()]) {
+        if (storage.output_inits[socket.id()]) {
           sockets_to_compute.pop();
         }
         else {
           bool all_inputs_computed = true;
           uint node_id = m_graph->node_id_of_output(socket.id());
           for (uint input_id : m_graph->input_ids_of_node(node_id)) {
-            if (!input_inits[input_id]) {
+            if (!storage.input_inits[input_id]) {
               sockets_to_compute.push(DFGraphSocket::FromInput(input_id));
               all_inputs_computed = false;
             }
@@ -186,13 +228,13 @@ class ExecuteFGraph : public TupleCallBody {
             BLI_assert(body);
 
             Tuple body_in(body->meta_in(),
-                          POINTER_OFFSET(input_values, m_input_starts[node_id]),
-                          POINTER_OFFSET(input_inits, m_graph->first_input_id_of_node(node_id)),
+                          storage.node_input_values_ptr(node_id),
+                          storage.node_input_inits_ptr(node_id),
                           true,
                           true);
             Tuple body_out(body->meta_out(),
-                           POINTER_OFFSET(output_values, m_output_starts[node_id]),
-                           POINTER_OFFSET(output_inits, m_graph->first_output_id_of_node(node_id)),
+                           storage.node_output_values_ptr(node_id),
+                           storage.node_output_inits_ptr(node_id),
                            true,
                            false);
 
@@ -200,10 +242,9 @@ class ExecuteFGraph : public TupleCallBody {
             body->call__setup_stack(body_in, body_out, ctx, frame);
 
             for (uint output_id : m_graph->output_ids_of_node(node_id)) {
-              SocketInfo &socket_info = m_output_info[output_id];
-              if (socket_info.is_fn_output) {
+              if (m_output_info[output_id].is_fn_output) {
                 uint index = m_fgraph.outputs().index(DFGraphSocket::FromOutput(output_id));
-                fn_out.copy_in__dynamic(index, POINTER_OFFSET(output_values, socket_info.offset));
+                fn_out.copy_in__dynamic(index, storage.output_value_ptr(output_id));
               }
             }
 
@@ -214,38 +255,33 @@ class ExecuteFGraph : public TupleCallBody {
     }
 
     for (uint input_id = 0; input_id < m_inputs_init_buffer_size; input_id++) {
-      if (input_inits[input_id]) {
+      if (storage.input_inits[input_id]) {
         SocketInfo &socket_info = m_input_info[input_id];
-        socket_info.type->destruct_type(POINTER_OFFSET(input_values, socket_info.offset));
+        socket_info.type->destruct_type(storage.input_value_ptr(input_id));
       }
     }
     for (uint output_id = 0; output_id < m_outputs_init_buffer_size; output_id++) {
-      if (output_inits[output_id]) {
+      if (storage.output_inits[output_id]) {
         SocketInfo &socket_info = m_output_info[output_id];
-        socket_info.type->destruct_type(POINTER_OFFSET(output_values, socket_info.offset));
+        socket_info.type->destruct_type(storage.output_value_ptr(output_id));
       }
     }
   }
 
  private:
-  void forward_output(uint output_id,
-                      char *input_values,
-                      char *output_values,
-                      bool *input_inits,
-                      bool *output_inits,
-                      Tuple &fn_out) const
+  void forward_output(uint output_id, SocketValueStorage &storage, Tuple &fn_out) const
   {
-    BLI_assert(output_inits[output_id]);
+    BLI_assert(storage.output_inits[output_id]);
     auto possible_target_ids = m_graph->targets_of_output(output_id);
 
     SocketInfo &output_info = m_output_info[output_id];
     CPPTypeInfo *type_info = output_info.type;
-    void *value_src = POINTER_OFFSET(output_values, output_info.offset);
+    void *value_src = storage.output_value_ptr(output_id);
 
     uint *target_ids = BLI_array_alloca(target_ids, possible_target_ids.size());
     uint target_amount = 0;
     for (uint possible_target_id : possible_target_ids) {
-      if (!input_inits[possible_target_id]) {
+      if (!storage.input_inits[possible_target_id]) {
         target_ids[target_amount] = possible_target_id;
         target_amount++;
       }
@@ -253,28 +289,28 @@ class ExecuteFGraph : public TupleCallBody {
 
     if (target_amount == 0) {
       type_info->destruct_type(value_src);
-      output_inits[output_id] = false;
+      storage.output_inits[output_id] = false;
     }
     else if (target_amount == 1) {
       uint target_id = target_ids[0];
-      void *value_dst = POINTER_OFFSET(input_values, m_input_info[target_id].offset);
+      void *value_dst = storage.input_value_ptr(target_id);
       type_info->relocate_to_uninitialized(value_src, value_dst);
-      output_inits[output_id] = false;
-      input_inits[target_id] = true;
+      storage.output_inits[output_id] = false;
+      storage.input_inits[target_id] = true;
     }
     else {
       for (uint i = 1; i < target_amount; i++) {
         uint target_id = target_ids[i];
-        void *value_dst = POINTER_OFFSET(input_values, m_input_info[target_id].offset);
+        void *value_dst = storage.input_valu

@@ Diff output truncated at 10240 characters. @@



More information about the Bf-blender-cvs mailing list