Refactor calculation of buffer allocation.

4 files changed, 44 insertions, 27 deletions

diff --git a/searchlib/src/vespa/searchlib/datastore/buffer_type.cpp b/searchlib/src/vespa/searchlib/datastore/buffer_type.cpp
index 798c930a3e2..06922835733 100644
--- a/searchlib/src/vespa/searchlib/datastore/buffer_type.cpp
+++ b/searchlib/src/vespa/searchlib/datastore/buffer_type.cpp
@@ -112,7 +112,7 @@ BufferTypeBase::clampMaxClusters(uint32_t maxClusters)
 }
 
 size_t
-BufferTypeBase::calcClustersToAlloc(uint32_t bufferId, size_t sizeNeeded, bool resizing) const
+BufferTypeBase::calcClustersToAlloc(uint32_t bufferId, size_t elementsNeeded, bool resizing) const
 {
     size_t reservedElements = getReservedElements(bufferId);
     size_t usedElems = (resizing ? 0 : _activeUsedElems);
@@ -121,7 +121,7 @@ BufferTypeBase::calcClustersToAlloc(uint32_t bufferId, size_t sizeNeeded, bool r
     }
     assert((usedElems % _clusterSize) == 0);
     size_t usedClusters = usedElems / _clusterSize;
-    size_t needClusters = (sizeNeeded + (resizing ? usedElems : reservedElements) + _clusterSize - 1) / _clusterSize;
+    size_t needClusters = (elementsNeeded + (resizing ? usedElems : reservedElements) + _clusterSize - 1) / _clusterSize;
     size_t growClusters = (usedClusters * _allocGrowFactor);
     size_t wantClusters = std::max((resizing ? usedClusters : 0u) + growClusters,
                                    static_cast<size_t>(_minClusters));
diff --git a/searchlib/src/vespa/searchlib/datastore/buffer_type.h b/searchlib/src/vespa/searchlib/datastore/buffer_type.h
index 321100bb811..adeaa7f4f72 100644
--- a/searchlib/src/vespa/searchlib/datastore/buffer_type.h
+++ b/searchlib/src/vespa/searchlib/datastore/buffer_type.h
@@ -60,12 +60,12 @@ public:
     /**
      * Calculate number of clusters to allocate for new buffer.
      *
-     * @param sizeNeeded number of elements needed now
+     * @param elementsNeeded number of elements needed now
      * @param clusterRefSize number of clusters expressable via reference type
      *
      * @return number of clusters to allocate for new buffer
      */
-    virtual size_t calcClustersToAlloc(uint32_t bufferId, size_t sizeNeeded, bool resizing) const;
+    virtual size_t calcClustersToAlloc(uint32_t bufferId, size_t elementsNeeded, bool resizing) const;
 
     void clampMaxClusters(uint32_t maxClusters);
 
diff --git a/searchlib/src/vespa/searchlib/datastore/bufferstate.cpp b/searchlib/src/vespa/searchlib/datastore/bufferstate.cpp
index c2e7c9358e0..c4ef2124189 100644
--- a/searchlib/src/vespa/searchlib/datastore/bufferstate.cpp
+++ b/searchlib/src/vespa/searchlib/datastore/bufferstate.cpp
@@ -45,11 +45,32 @@ BufferState::~BufferState()
     assert(_freeList.empty());
 }
 
+namespace {
+
+struct AllocResult {
+    size_t elements;
+    size_t bytes;
+    AllocResult(size_t elements_, size_t bytes_) : elements(elements_), bytes(bytes_) {}
+};
+
+AllocResult
+calcAllocation(uint32_t bufferId,
+               BufferTypeBase &typeHandler,
+               size_t elementsNeeded,
+               bool resizing)
+{
+    size_t allocClusters = typeHandler.calcClustersToAlloc(bufferId, elementsNeeded, resizing);
+    size_t allocElements = allocClusters * typeHandler.getClusterSize();
+    size_t allocBytes = allocElements * typeHandler.elementSize();
+    return AllocResult(allocElements, allocBytes);
+}
+
+}
 
 void
 BufferState::onActive(uint32_t bufferId, uint32_t typeId,
                       BufferTypeBase *typeHandler,
-                      size_t sizeNeeded,
+                      size_t elementsNeeded,
                       void *&buffer)
 {
     assert(buffer == NULL);
@@ -69,13 +90,12 @@ BufferState::onActive(uint32_t bufferId, uint32_t typeId,
 
     size_t reservedElements = typeHandler->getReservedElements(bufferId);
     (void) reservedElements;
-    size_t allocClusters = typeHandler->calcClustersToAlloc(bufferId, sizeNeeded, false);
-    size_t allocSize = allocClusters * typeHandler->getClusterSize();
-    assert(allocSize >= reservedElements + sizeNeeded);
-    _buffer.create(allocSize * typeHandler->elementSize()).swap(_buffer);
+    AllocResult alloc = calcAllocation(bufferId, *typeHandler, elementsNeeded, false);
+    assert(alloc.elements >= reservedElements + elementsNeeded);
+    _buffer.create(alloc.bytes).swap(_buffer);
     buffer = _buffer.get();
-    assert(buffer != NULL || allocSize == 0u);
-    _allocElems = allocSize;
+    assert(buffer != NULL || alloc.elements == 0u);
+    _allocElems = alloc.elements;
     _state = ACTIVE;
     _typeHandler = typeHandler;
     _typeId = typeId;
@@ -227,26 +247,23 @@ BufferState::disableElemHoldList()
 
 void
 BufferState::fallbackResize(uint32_t bufferId,
-                            uint64_t sizeNeeded,
+                            uint64_t elementsNeeded,
                             void *&buffer,
                             Alloc &holdBuffer)
 {
     assert(_state == ACTIVE);
     assert(_typeHandler != NULL);
     assert(holdBuffer.get() == NULL);
-    size_t allocClusters = _typeHandler->calcClustersToAlloc(bufferId,
-                                                             sizeNeeded,
-                                                             true);
-    size_t allocSize = allocClusters * _typeHandler->getClusterSize();
-    assert(allocSize >= _usedElems + sizeNeeded);
-    assert(allocSize > _allocElems);
-    Alloc newBuffer = _buffer.create(allocSize * _typeHandler->elementSize());
+    AllocResult alloc = calcAllocation(bufferId, *_typeHandler, elementsNeeded, true);
+    assert(alloc.elements >= _usedElems + elementsNeeded);
+    assert(alloc.elements > _allocElems);
+    Alloc newBuffer = _buffer.create(alloc.bytes);
     _typeHandler->fallbackCopy(newBuffer.get(), buffer, _usedElems);
     holdBuffer.swap(_buffer);
     std::atomic_thread_fence(std::memory_order_release);
     _buffer = std::move(newBuffer);
     buffer = _buffer.get();
-    _allocElems = allocSize;
+    _allocElems = alloc.elements;
     std::atomic_thread_fence(std::memory_order_release);
 }
 
diff --git a/searchlib/src/vespa/searchlib/datastore/bufferstate.h b/searchlib/src/vespa/searchlib/datastore/bufferstate.h
index 5f579c43751..15c8202a525 100644
--- a/searchlib/src/vespa/searchlib/datastore/bufferstate.h
+++ b/searchlib/src/vespa/searchlib/datastore/bufferstate.h
@@ -73,14 +73,14 @@ public:
     /**
      * Transition from FREE to ACTIVE state.
      *
-     * @param bufferId      Id of buffer to be active.
-     * @param typeId        registered data type for buffer.
-     * @param typeHandler   type handler for registered data type.
-     * @param sizeNeeded    Number of elements needed to be free
-     * @param buffer        start of buffer.
+     * @param bufferId       Id of buffer to be active.
+     * @param typeId         registered data type for buffer.
+     * @param typeHandler    type handler for registered data type.
+     * @param elementsNeeded Number of elements needed to be free
+     * @param buffer         start of buffer.
      */
     void onActive(uint32_t bufferId, uint32_t typeId, BufferTypeBase *typeHandler,
-                  size_t sizeNeeded, void *&buffer);
+                  size_t elementsNeeded, void *&buffer);
 
     /**
      * Transition from ACTIVE to HOLD state.
@@ -151,7 +151,7 @@ public:
     size_t getExtraHoldBytes() const { return _extraHoldBytes; }
     bool getCompacting() const { return _compacting; }
     void setCompacting() { _compacting = true; }
-    void fallbackResize(uint32_t bufferId, uint64_t sizeNeeded, void *&buffer, Alloc &holdBuffer);
+    void fallbackResize(uint32_t bufferId, uint64_t elementsNeeded, void *&buffer, Alloc &holdBuffer);
 
     bool isActive(uint32_t typeId) const {
         return ((_state == ACTIVE) && (_typeId == typeId));