Improved performance of LeafNode ValueIters

Signed-off-by: Nick Avramoussis <[email protected]>

Author: Idclip

openvdb/openvdb/tree/LeafNode.h

@@ -222,28 +222,36 @@ class LeafNode
         using BaseT = SparseIteratorBase<MaskIterT, ValueIter, NodeT, ValueT>;
 
         ValueIter() {}
-        ValueIter(const MaskIterT& iter, NodeT* parent): BaseT(iter, parent) {}
+        ValueIter(const MaskIterT& iter, NodeT* parent)
+            : BaseT(iter, parent)
+            // Unlike other value iterators, cache the buffer data as part of
+            // the iterators members to avoid the cost of going through the
+            // leaf buffer atomic/checking API
+            , mData(parent->buffer().data()) {}
 
-        ValueT& getItem(Index pos) const { return this->parent().getValue(pos); }
-        ValueT& getValue() const { return this->parent().getValue(this->pos()); }
+        ValueT& getItem(Index pos) const { return mData[pos]; }
+        ValueT& getValue() const { return this->getItem(this->pos()); }
 
         // Note: setItem() can't be called on const iterators.
-        void setItem(Index pos, const ValueT& value) const
-        {
-            this->parent().setValueOnly(pos, value);
-        }
+        void setItem(Index pos, const ValueT& value) { mData[pos] = value; }
         // Note: setValue() can't be called on const iterators.
-        void setValue(const ValueT& value) const
-        {
-            this->parent().setValueOnly(this->pos(), value);
-        }
+        void setValue(const ValueT& value) { this->setItem(this->pos(), value); }
 
         // Note: modifyItem() can't be called on const iterators.
         template<typename ModifyOp>
-        void modifyItem(Index n, const ModifyOp& op) const { this->parent().modifyValue(n, op); }
+        void modifyItem(Index n, const ModifyOp& op)
+        {
+            op(mData[n]);
+            this->parent().setValueOn(n);
+        }
         // Note: modifyValue() can't be called on const iterators.
         template<typename ModifyOp>
-        void modifyValue(const ModifyOp& op) const { this->parent().modifyValue(this->pos(), op); }
+        void modifyValue(const ModifyOp& op)
+        {
+            this->modifyItem(this->pos(), op);
+        }
+    private:
+        ValueT* mData;
     };
 
     /// Leaf nodes have no children, so their child iterators have no get/set accessors.
@@ -284,11 +292,11 @@ class LeafNode
     };
 
 public:
-    using ValueOnIter = ValueIter<MaskOnIterator, LeafNode, const ValueType, ValueOn>;
+    using ValueOnIter = ValueIter<MaskOnIterator, LeafNode, ValueType, ValueOn>;
     using ValueOnCIter = ValueIter<MaskOnIterator, const LeafNode, const ValueType, ValueOn>;
-    using ValueOffIter = ValueIter<MaskOffIterator, LeafNode, const ValueType, ValueOff>;
+    using ValueOffIter = ValueIter<MaskOffIterator, LeafNode, ValueType, ValueOff>;
     using ValueOffCIter = ValueIter<MaskOffIterator,const LeafNode,const ValueType,ValueOff>;
-    using ValueAllIter = ValueIter<MaskDenseIterator, LeafNode, const ValueType, ValueAll>;
+    using ValueAllIter = ValueIter<MaskDenseIterator, LeafNode, ValueType, ValueAll>;
     using ValueAllCIter = ValueIter<MaskDenseIterator,const LeafNode,const ValueType,ValueAll>;
     using ChildOnIter = ChildIter<MaskOnIterator, LeafNode, ChildOn>;
     using ChildOnCIter = ChildIter<MaskOnIterator, const LeafNode, ChildOn>;

pendingchanges/leaf_value_iters.txt

@@ -0,0 +1,6 @@
+OpenVDB:
+ - Improvements:
+    - Significantly improved the performance of all LeafNode ValueIterators,
+    especially when delay loading is enabled. Construction of a ValueIterator
+    on a leaf node now requests the leaf buffers ahead of iteration to avoid
+    expensive API calls.