[Bf-blender-cvs] [41df03637e7] functions: store data in network builder more compactly

Jacques Lucke noreply at git.blender.org
Sat Jan 18 20:17:30 CET 2020


Commit: 41df03637e716e7a51884e054863825dc0024fd9
Author: Jacques Lucke
Date:   Sat Jan 11 15:34:52 2020 +0100
Branches: functions
https://developer.blender.org/rB41df03637e716e7a51884e054863825dc0024fd9

store data in network builder more compactly

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

M	source/blender/blenlib/BLI_monotonic_allocator.h
M	source/blender/functions/FN_multi_function_network.h
M	source/blender/functions/intern/multi_function_network.cc

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

diff --git a/source/blender/blenlib/BLI_monotonic_allocator.h b/source/blender/blenlib/BLI_monotonic_allocator.h
index 04d3f7218ff..6856f417d1c 100644
--- a/source/blender/blenlib/BLI_monotonic_allocator.h
+++ b/source/blender/blenlib/BLI_monotonic_allocator.h
@@ -103,6 +103,32 @@ class MonotonicAllocator : NonCopyable, NonMovable {
     return destruct_ptr<T>(value);
   }
 
+  template<typename T, typename... Args>
+  ArrayRef<T *> construct_elements_and_pointer_array(uint n, Args &&... args)
+  {
+    void *pointer_buffer = this->allocate(n * sizeof(T *), alignof(T *));
+    void *element_buffer = this->allocate(n * sizeof(T), alignof(T));
+
+    MutableArrayRef<T *> pointers((T **)pointer_buffer, n);
+    T *elements = (T *)element_buffer;
+
+    for (uint i : IndexRange(n)) {
+      pointers[i] = elements + i;
+    }
+    for (uint i : IndexRange(n)) {
+      new (elements + i) T(std::forward<Args>(args)...);
+    }
+
+    return pointers;
+  }
+
+  template<typename T> MutableArrayRef<T> allocate_array_copy(ArrayRef<T> source)
+  {
+    T *buffer = (T *)this->allocate(source.byte_size(), alignof(T));
+    source.copy_to(buffer);
+    return MutableArrayRef<T>(buffer, source.size());
+  }
+
  private:
   void allocate_new_buffer(uint min_allocation_size)
   {
diff --git a/source/blender/functions/FN_multi_function_network.h b/source/blender/functions/FN_multi_function_network.h
index 7955542db69..09442bd8269 100644
--- a/source/blender/functions/FN_multi_function_network.h
+++ b/source/blender/functions/FN_multi_function_network.h
@@ -33,8 +33,8 @@ class MFNetworkBuilder;
 class MFBuilderNode : BLI::NonCopyable, BLI::NonMovable {
  protected:
   MFNetworkBuilder *m_network;
-  Vector<MFBuilderInputSocket *> m_inputs;
-  Vector<MFBuilderOutputSocket *> m_outputs;
+  ArrayRef<MFBuilderInputSocket *> m_inputs;
+  ArrayRef<MFBuilderOutputSocket *> m_outputs;
   bool m_is_dummy;
 
   friend MFNetworkBuilder;
@@ -62,8 +62,8 @@ class MFBuilderNode : BLI::NonCopyable, BLI::NonMovable {
 class MFBuilderFunctionNode : public MFBuilderNode {
  private:
   const MultiFunction *m_function;
-  Vector<uint> m_input_param_indices;
-  Vector<uint> m_output_param_indices;
+  ArrayRef<uint> m_input_param_indices;
+  ArrayRef<uint> m_output_param_indices;
 
   friend MFNetworkBuilder;
 
@@ -77,8 +77,8 @@ class MFBuilderFunctionNode : public MFBuilderNode {
 class MFBuilderDummyNode : public MFBuilderNode {
  private:
   StringRefNull m_name;
-  Vector<StringRefNull> m_input_names;
-  Vector<StringRefNull> m_output_names;
+  MutableArrayRef<StringRefNull> m_input_names;
+  MutableArrayRef<StringRefNull> m_output_names;
 
   friend MFNetworkBuilder;
   friend MFBuilderSocket;
diff --git a/source/blender/functions/intern/multi_function_network.cc b/source/blender/functions/intern/multi_function_network.cc
index f19062ed938..0ebaa8dbc5d 100644
--- a/source/blender/functions/intern/multi_function_network.cc
+++ b/source/blender/functions/intern/multi_function_network.cc
@@ -13,6 +13,7 @@ void WM_clipboard_text_set(const char *buf, bool selection);
 namespace FN {
 
 using BLI::Map;
+using BLI::ScopedVector;
 using BLI::Set;
 using BLI::Stack;
 
@@ -44,8 +45,8 @@ MFNetworkBuilder::~MFNetworkBuilder()
 
 MFBuilderFunctionNode &MFNetworkBuilder::add_function(const MultiFunction &function)
 {
-  Vector<uint> input_param_indices;
-  Vector<uint> output_param_indices;
+  ScopedVector<uint> input_param_indices;
+  ScopedVector<uint> output_param_indices;
   for (uint param_index : function.param_indices()) {
     switch (function.param_type(param_index).interface_type()) {
       case MFParamType::InterfaceType::Input: {
@@ -70,33 +71,34 @@ MFBuilderFunctionNode &MFNetworkBuilder::add_function(const MultiFunction &funct
   node.m_network = this;
   node.m_is_dummy = false;
   node.m_function = &function;
-  node.m_input_param_indices = input_param_indices;
-  node.m_output_param_indices = output_param_indices;
+  node.m_input_param_indices = m_allocator.allocate_array_copy<uint>(input_param_indices);
+  node.m_output_param_indices = m_allocator.allocate_array_copy<uint>(output_param_indices);
+
+  node.m_inputs = m_allocator.construct_elements_and_pointer_array<MFBuilderInputSocket>(
+      input_param_indices.size());
+  node.m_outputs = m_allocator.construct_elements_and_pointer_array<MFBuilderOutputSocket>(
+      output_param_indices.size());
 
   for (uint i : input_param_indices.index_range()) {
-    uint param_index = input_param_indices[i];
-    MFParamType param = function.param_type(param_index);
+    MFParamType param = function.param_type(input_param_indices[i]);
     BLI_assert(param.is_input_or_mutable());
 
-    auto &input_socket = *m_allocator.construct<MFBuilderInputSocket>().release();
+    MFBuilderInputSocket &input_socket = *node.m_inputs[i];
     input_socket.m_data_type = param.data_type();
     input_socket.m_node = &node;
     input_socket.m_index = i;
     input_socket.m_is_output = false;
-    node.m_inputs.append(&input_socket);
   }
 
   for (uint i : output_param_indices.index_range()) {
-    uint param_index = output_param_indices[i];
-    MFParamType param = function.param_type(param_index);
+    MFParamType param = function.param_type(output_param_indices[i]);
     BLI_assert(param.is_output_or_mutable());
 
-    auto &output_socket = *m_allocator.construct<MFBuilderOutputSocket>().release();
+    MFBuilderOutputSocket &output_socket = *node.m_outputs[i];
     output_socket.m_data_type = param.data_type();
     output_socket.m_node = &node;
     output_socket.m_index = i;
     output_socket.m_is_output = true;
-    node.m_outputs.append(&output_socket);
   }
 
   return node;
@@ -108,6 +110,9 @@ MFBuilderDummyNode &MFNetworkBuilder::add_dummy(StringRef name,
                                                 ArrayRef<StringRef> input_names,
                                                 ArrayRef<StringRef> output_names)
 {
+  BLI_assert(input_types.size() == input_names.size());
+  BLI_assert(output_types.size() == output_names.size());
+
   auto &node = *m_allocator.construct<MFBuilderDummyNode>().release();
   m_dummy_nodes.add_new(&node);
 
@@ -115,23 +120,29 @@ MFBuilderDummyNode &MFNetworkBuilder::add_dummy(StringRef name,
   node.m_is_dummy = true;
   node.m_name = m_allocator.copy_string(name);
 
+  node.m_inputs = m_allocator.construct_elements_and_pointer_array<MFBuilderInputSocket>(
+      input_types.size());
+  node.m_outputs = m_allocator.construct_elements_and_pointer_array<MFBuilderOutputSocket>(
+      output_types.size());
+
+  node.m_input_names = m_allocator.allocate_array<StringRefNull>(input_types.size());
+  node.m_output_names = m_allocator.allocate_array<StringRefNull>(output_types.size());
+
   for (uint i : input_types.index_range()) {
-    auto &input_socket = *m_allocator.construct<MFBuilderInputSocket>().release();
+    MFBuilderInputSocket &input_socket = *node.m_inputs[i];
     input_socket.m_data_type = input_types[i];
     input_socket.m_node = &node;
     input_socket.m_index = i;
     input_socket.m_is_output = false;
-    node.m_inputs.append(&input_socket);
-    node.m_input_names.append(m_allocator.copy_string(input_names[i]));
+    node.m_input_names[i] = m_allocator.copy_string(input_names[i]);
   }
   for (uint i : output_types.index_range()) {
-    auto &output_socket = *m_allocator.construct<MFBuilderOutputSocket>().release();
+    MFBuilderOutputSocket &output_socket = *node.m_outputs[i];
     output_socket.m_data_type = output_types[i];
     output_socket.m_node = &node;
     output_socket.m_index = i;
     output_socket.m_is_output = true;
-    node.m_outputs.append(&output_socket);
-    node.m_output_names.append(m_allocator.copy_string(output_names[i]));
+    node.m_output_names[i] = m_allocator.copy_string(output_names[i]);
   }
   return node;
 }



More information about the Bf-blender-cvs mailing list