[Bf-blender-cvs] [2430d76b1ee] functions: Write to output buffer directly instead of doing a copy in the end
Jacques Lucke
noreply at git.blender.org
Wed Jan 29 21:05:39 CET 2020
Commit: 2430d76b1ee0cb1492fe9edbfd502d39882c2fc6
Author: Jacques Lucke
Date: Wed Jan 29 21:05:07 2020 +0100
Branches: functions
https://developer.blender.org/rB2430d76b1ee0cb1492fe9edbfd502d39882c2fc6
Write to output buffer directly instead of doing a copy in the end
===================================================================
M source/blender/blenlib/BLI_buffer_cache.h
M source/blender/functions/intern/multi_functions/network.cc
M source/blender/functions/intern/multi_functions/network.h
===================================================================
diff --git a/source/blender/blenlib/BLI_buffer_cache.h b/source/blender/blenlib/BLI_buffer_cache.h
index 2c7ef82c2dc..6d590b4f5ff 100644
--- a/source/blender/blenlib/BLI_buffer_cache.h
+++ b/source/blender/blenlib/BLI_buffer_cache.h
@@ -54,7 +54,6 @@ class BufferCache {
if (head->buffer_size_in_bytes == padded_size) {
void *user_ptr = head->user_ptr();
m_cached_buffers.remove_and_reorder(i);
- // std::cout << "Reuse buffer\n";
return user_ptr;
}
}
@@ -63,7 +62,6 @@ class BufferCache {
padded_size + Alignment, Alignment, "allocate in BufferCache");
new_head->buffer_size_in_bytes = padded_size;
m_all_buffers.append(new_head);
- // std::cout << "New buffer\n";
return new_head->user_ptr();
}
diff --git a/source/blender/functions/intern/multi_functions/network.cc b/source/blender/functions/intern/multi_functions/network.cc
index 0fc63e60331..500aa63e2a4 100644
--- a/source/blender/functions/intern/multi_functions/network.cc
+++ b/source/blender/functions/intern/multi_functions/network.cc
@@ -7,48 +7,80 @@ namespace FN {
using BLI::BufferCache;
using BLI::ScopedVector;
-namespace OutputValueType {
+namespace {
+
+namespace ValueType {
enum Enum {
- SingleInputFromCaller,
- VectorInputFromCaller,
- Single,
- Vector,
+ InputSingle,
+ InputVector,
+ OutputSingle,
+ OutputVector,
+ OwnSingle,
+ OwnVector,
};
}
-struct OutputValue {
- OutputValueType::Enum type;
+struct Value {
+ ValueType::Enum type;
- OutputValue(OutputValueType::Enum type) : type(type)
+ Value(ValueType::Enum type) : type(type)
{
}
};
-struct SingleInputFromCallerValue : public OutputValue {
+struct InputSingleValue : public Value {
GenericVirtualListRef list_ref;
- SingleInputFromCallerValue(GenericVirtualListRef list_ref)
- : OutputValue(OutputValueType::SingleInputFromCaller), list_ref(list_ref)
+ InputSingleValue(GenericVirtualListRef list_ref)
+ : Value(ValueType::InputSingle), list_ref(list_ref)
{
}
};
-struct VectorInputFromCallerValue : public OutputValue {
+struct InputVectorValue : public Value {
GenericVirtualListListRef list_list_ref;
- VectorInputFromCallerValue(GenericVirtualListListRef list_list_ref)
- : OutputValue(OutputValueType::VectorInputFromCaller), list_list_ref(list_list_ref)
+ InputVectorValue(GenericVirtualListListRef list_list_ref)
+ : Value(ValueType::InputVector), list_list_ref(list_list_ref)
{
}
};
-struct SingleValue : public OutputValue {
+struct OutputValue : public Value {
+ bool is_computed = false;
+
+ OutputValue(ValueType::Enum type) : Value(type)
+ {
+ }
+};
+
+struct OutputSingleValue : public OutputValue {
+ GenericMutableArrayRef array_ref;
+
+ OutputSingleValue(GenericMutableArrayRef array_ref)
+ : OutputValue(ValueType::OutputSingle), array_ref(array_ref)
+ {
+ }
+};
+
+struct OutputVectorValue : public OutputValue {
+ GenericVectorArray *vector_array;
+
+ OutputVectorValue(GenericVectorArray &vector_array)
+ : OutputValue(ValueType::OutputVector), vector_array(&vector_array)
+ {
+ }
+};
+
+struct OwnSingleValue : public Value {
GenericMutableArrayRef array_ref;
int max_remaining_users;
bool is_single_allocated;
- SingleValue(GenericMutableArrayRef array_ref, int max_remaining_users, bool is_single_allocated)
- : OutputValue(OutputValueType::Single),
+ OwnSingleValue(GenericMutableArrayRef array_ref,
+ int max_remaining_users,
+ bool is_single_allocated)
+ : Value(ValueType::OwnSingle),
array_ref(array_ref),
max_remaining_users(max_remaining_users),
is_single_allocated(is_single_allocated)
@@ -56,24 +88,26 @@ struct SingleValue : public OutputValue {
}
};
-struct VectorValue : public OutputValue {
+struct OwnVectorValue : public Value {
GenericVectorArray *vector_array;
int max_remaining_users;
- VectorValue(GenericVectorArray &vector_array, int max_remaining_users)
- : OutputValue(OutputValueType::Vector),
+ OwnVectorValue(GenericVectorArray &vector_array, int max_remaining_users)
+ : Value(ValueType::OwnVector),
vector_array(&vector_array),
max_remaining_users(max_remaining_users)
{
}
};
+} // namespace
+
class NetworkEvaluationStorage {
private:
MonotonicAllocator<256> m_allocator;
BufferCache &m_buffer_cache;
IndexMask m_mask;
- Array<OutputValue *> m_value_per_output_id;
+ Array<Value *> m_value_per_output_id;
uint m_min_array_size;
public:
@@ -87,12 +121,12 @@ class NetworkEvaluationStorage {
~NetworkEvaluationStorage()
{
- for (OutputValue *any_value : m_value_per_output_id) {
+ for (Value *any_value : m_value_per_output_id) {
if (any_value == nullptr) {
continue;
}
- else if (any_value->type == OutputValueType::Single) {
- SingleValue *value = (SingleValue *)any_value;
+ else if (any_value->type == ValueType::OwnSingle) {
+ OwnSingleValue *value = (OwnSingleValue *)any_value;
GenericMutableArrayRef array_ref = value->array_ref;
const CPPType &type = array_ref.type();
if (value->is_single_allocated) {
@@ -103,8 +137,8 @@ class NetworkEvaluationStorage {
m_buffer_cache.deallocate(array_ref.buffer());
}
}
- else if (any_value->type == OutputValueType::Vector) {
- VectorValue *value = (VectorValue *)any_value;
+ else if (any_value->type == ValueType::OwnVector) {
+ OwnVectorValue *value = (OwnVectorValue *)any_value;
delete value->vector_array;
}
}
@@ -117,44 +151,79 @@ class NetworkEvaluationStorage {
bool socket_is_computed(const MFOutputSocket &socket)
{
- OutputValue *any_value = m_value_per_output_id[socket.id()];
- return any_value != nullptr;
+ Value *any_value = m_value_per_output_id[socket.id()];
+ if (any_value == nullptr) {
+ return false;
+ }
+ if (ELEM(any_value->type, ValueType::OutputSingle, ValueType::OutputVector)) {
+ return ((OutputValue *)any_value)->is_computed;
+ }
+ return true;
}
bool is_same_value_for_every_index(const MFOutputSocket &socket)
{
- OutputValue *any_value = m_value_per_output_id[socket.id()];
+ Value *any_value = m_value_per_output_id[socket.id()];
switch (any_value->type) {
- case OutputValueType::Single:
- return ((SingleValue *)any_value)->array_ref.size() == 1;
- case OutputValueType::Vector:
- return ((VectorValue *)any_value)->vector_array->size() == 1;
- case OutputValueType::SingleInputFromCaller:
- return ((SingleInputFromCallerValue *)any_value)->list_ref.is_single_element();
- case OutputValueType::VectorInputFromCaller:
- return ((VectorInputFromCallerValue *)any_value)->list_list_ref.is_single_list();
+ case ValueType::OwnSingle:
+ return ((OwnSingleValue *)any_value)->array_ref.size() == 1;
+ case ValueType::OwnVector:
+ return ((OwnVectorValue *)any_value)->vector_array->size() == 1;
+ case ValueType::InputSingle:
+ return ((InputSingleValue *)any_value)->list_ref.is_single_element();
+ case ValueType::InputVector:
+ return ((InputVectorValue *)any_value)->list_list_ref.is_single_list();
+ case ValueType::OutputSingle:
+ return ((OutputSingleValue *)any_value)->array_ref.size() == 1;
+ case ValueType::OutputVector:
+ return ((OutputVectorValue *)any_value)->vector_array->size() == 1;
}
BLI_assert(false);
return false;
}
+ bool socket_has_buffer_for_output(const MFOutputSocket &socket)
+ {
+ Value *any_value = m_value_per_output_id[socket.id()];
+ if (any_value == nullptr) {
+ return false;
+ }
+
+ BLI_assert(ELEM(any_value->type, ValueType::OutputSingle, ValueType::OutputVector));
+ return true;
+ }
+
+ void finish_output_socket(const MFOutputSocket &socket)
+ {
+ Value *any_value = m_value_per_output_id[socket.id()];
+ if (any_value == nullptr) {
+ return;
+ }
+
+ if (ELEM(any_value->type, ValueType::OutputSingle, ValueType::OutputVector)) {
+ ((OutputValue *)any_value)->is_computed = true;
+ }
+ }
+
void finish_input_socket(const MFInputSocket &socket)
{
const MFOutputSocket &origin = socket.origin();
- OutputValue *any_value = m_value_per_output_id[origin.id()];
+ Value *any_value = m_value_per_output_id[origin.id()];
if (any_value == nullptr) {
/* Can happen when a value has been forward to the next node. */
return;
}
switch (any_value->type) {
- case OutputValueType::SingleInputFromCaller:
- case OutputValueType::VectorInputFromCaller: {
+ case ValueType::InputSingle:
+ case ValueType::OutputSingle:
+ case ValueType::InputVector:
+ case ValueType::OutputVector: {
break;
}
- case OutputValueType::Single: {
- SingleValue *value = (SingleValue *)any_value;
+ case ValueType::OwnSingle: {
+ OwnSingleValue *value = (OwnSingleValue *)any_value;
BLI_assert(value->max_remaining_users >= 1);
value->max_remaining_users--;
if (value->max_remaining_users == 0) {
@@ -171,8 +240,8 @@ class NetworkEvaluationStorage {
}
break;
}
- case OutputValueType::Vector: {
- VectorValue *value = (VectorValue *)any_value;
+ case ValueType::OwnVector: {
+ OwnVectorValue *value = (OwnVectorValue *)any_value;
BLI_assert(value->max_remaining_users >= 1);
value->max_remaining_users--;
if (value->max_remaining_users == 0) {
@@ -187,80 +256,128 @@ class NetworkEvaluationStorage {
/* Add function inputs from caller to the storage.
********************************************************/
- void add_single_from_caller(const MFOutputSocket &socket, GenericVirtualListRef list_ref)
+ void add_single_input_from_caller(const MFOutputSocket &socket, GenericVirtualListRef list_ref)
{
BLI_assert(m_value_per_output_id[socket.id()] == nullptr);
BLI_assert(list_ref.size() >= m_min_array_size);
- auto *value = m_allocator.construct<
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list