Clarify variable names.

6 files changed, 87 insertions, 102 deletions

diff --git a/searchlib/src/vespa/searchlib/datastore/buffer_type.cpp b/searchlib/src/vespa/searchlib/datastore/buffer_type.cpp
index e209ae78dee..157a73ddc20 100644
--- a/searchlib/src/vespa/searchlib/datastore/buffer_type.cpp
+++ b/searchlib/src/vespa/searchlib/datastore/buffer_type.cpp
@@ -74,11 +74,11 @@ BufferTypeBase::onActive(uint32_t bufferId, size_t *usedElems, size_t &deadElems
     flushLastUsed();
     ++_activeBuffers;
     _lastUsedElems = usedElems;
-    size_t reservedElements = getReservedElements(bufferId);
-    if (reservedElements != 0u) {
-        initializeReservedElements(buffer, reservedElements);
-        *usedElems = reservedElements;
-        deadElems = reservedElements;
+    size_t reservedElems = getReservedElements(bufferId);
+    if (reservedElems != 0u) {
+        initializeReservedElements(buffer, reservedElems);
+        *usedElems = reservedElems;
+        deadElems = reservedElems;
     }
 }
 
@@ -112,16 +112,16 @@ BufferTypeBase::clampMaxArrays(uint32_t maxArrays)
 }
 
 size_t
-BufferTypeBase::calcArraysToAlloc(uint32_t bufferId, size_t elementsNeeded, bool resizing) const
+BufferTypeBase::calcArraysToAlloc(uint32_t bufferId, size_t elemsNeeded, bool resizing) const
 {
-    size_t reservedElements = getReservedElements(bufferId);
+    size_t reservedElems = getReservedElements(bufferId);
     size_t usedElems = (resizing ? 0 : _activeUsedElems);
     if (_lastUsedElems != nullptr) {
         usedElems += *_lastUsedElems;
     }
     assert((usedElems % _arraySize) == 0);
     size_t usedArrays = usedElems / _arraySize;
-    size_t neededArrays = (elementsNeeded + (resizing ? usedElems : reservedElements) + _arraySize - 1) / _arraySize;
+    size_t neededArrays = (elemsNeeded + (resizing ? usedElems : reservedElems) + _arraySize - 1) / _arraySize;
     size_t growArrays = (usedArrays * _allocGrowFactor);
     size_t wantedArrays = std::max((resizing ? usedArrays : 0u) + growArrays,
                                    static_cast<size_t>(_minArrays));
diff --git a/searchlib/src/vespa/searchlib/datastore/buffer_type.h b/searchlib/src/vespa/searchlib/datastore/buffer_type.h
index 9f7c1ffb4c9..55a394b986a 100644
--- a/searchlib/src/vespa/searchlib/datastore/buffer_type.h
+++ b/searchlib/src/vespa/searchlib/datastore/buffer_type.h
@@ -44,8 +44,8 @@ public:
     BufferTypeBase(uint32_t arraySize, uint32_t minArrays, uint32_t maxArrays,
                    uint32_t numArraysForNewBuffer, float allocGrowFactor);
     virtual ~BufferTypeBase();
-    virtual void destroyElements(void *buffer, size_t numElements) = 0;
-    virtual void fallbackCopy(void *newBuffer, const void *oldBuffer, size_t numElements) = 0;
+    virtual void destroyElements(void *buffer, size_t numElems) = 0;
+    virtual void fallbackCopy(void *newBuffer, const void *oldBuffer, size_t numElems) = 0;
     // Return number of reserved elements at start of buffer, to avoid
     // invalid reference and handle data at negative offset (alignment
     // hacks) as used by dense tensor store.
@@ -53,7 +53,7 @@ public:
     // Initialize reserved elements at start of buffer.
     virtual void initializeReservedElements(void *buffer, size_t reservedElements) = 0;
     virtual size_t elementSize() const = 0;
-    virtual void cleanHold(void *buffer, uint64_t offset, uint64_t len, CleanContext cleanCtx) = 0;
+    virtual void cleanHold(void *buffer, uint64_t offset, uint64_t numElems, CleanContext cleanCtx) = 0;
     size_t getArraySize() const { return _arraySize; }
     void flushLastUsed();
     virtual void onActive(uint32_t bufferId, size_t *usedElems, size_t &deadElems, void *buffer);
@@ -88,10 +88,10 @@ public:
     BufferType(uint32_t arraySize, uint32_t minArrays, uint32_t maxArrays,
                uint32_t numArraysForNewBuffer, float allocGrowFactor);
     ~BufferType();
-    void destroyElements(void *buffer, size_t numElements) override;
-    void fallbackCopy(void *newBuffer, const void *oldBuffer, size_t numElements) override;
+    void destroyElements(void *buffer, size_t numElems) override;
+    void fallbackCopy(void *newBuffer, const void *oldBuffer, size_t numElems) override;
     void initializeReservedElements(void *buffer, size_t reservedElements) override;
-    void cleanHold(void *buffer, uint64_t offset, uint64_t len, CleanContext cleanCxt) override;
+    void cleanHold(void *buffer, uint64_t offset, uint64_t numElems, CleanContext cleanCxt) override;
     size_t elementSize() const override { return sizeof(EntryType); }
 };
 
@@ -113,10 +113,10 @@ BufferType<EntryType>::~BufferType() { }
 
 template <typename EntryType>
 void
-BufferType<EntryType>::destroyElements(void *buffer, size_t numElements)
+BufferType<EntryType>::destroyElements(void *buffer, size_t numElems)
 {
     EntryType *e = static_cast<EntryType *>(buffer);
-    for (size_t j = numElements; j != 0; --j) {
+    for (size_t j = numElems; j != 0; --j) {
         e->~EntryType();
         ++e;
     }
@@ -126,11 +126,11 @@ template <typename EntryType>
 void
 BufferType<EntryType>::fallbackCopy(void *newBuffer,
                                     const void *oldBuffer,
-                                    size_t numElements)
+                                    size_t numElems)
 {
     EntryType *d = static_cast<EntryType *>(newBuffer);
     const EntryType *s = static_cast<const EntryType *>(oldBuffer);
-    for (size_t j = numElements; j != 0; --j) {
+    for (size_t j = numElems; j != 0; --j) {
         new (static_cast<void *>(d)) EntryType(*s);
         ++s;
         ++d;
@@ -150,10 +150,10 @@ BufferType<EntryType>::initializeReservedElements(void *buffer, size_t reservedE
 
 template <typename EntryType>
 void
-BufferType<EntryType>::cleanHold(void *buffer, uint64_t offset, uint64_t len, CleanContext)
+BufferType<EntryType>::cleanHold(void *buffer, uint64_t offset, uint64_t numElems, CleanContext)
 {
     EntryType *e = static_cast<EntryType *>(buffer) + offset;
-    for (size_t j = len; j != 0; --j) {
+    for (size_t j = numElems; j != 0; --j) {
         *e = _emptyEntry;
         ++e;
     }
diff --git a/searchlib/src/vespa/searchlib/datastore/datastore.h b/searchlib/src/vespa/searchlib/datastore/datastore.h
index 316ec34dc85..c0fccdfb776 100644
--- a/searchlib/src/vespa/searchlib/datastore/datastore.h
+++ b/searchlib/src/vespa/searchlib/datastore/datastore.h
@@ -21,6 +21,9 @@ struct DefaultReclaimer {
 
 namespace search::datastore {
 
+/**
+ * Concrete data store using the given EntryRef type to reference stored data.
+ */
 template <typename RefT = EntryRefT<22> >
 class DataStoreT : public DataStoreBase
 {
@@ -39,20 +42,20 @@ public:
      * @param ref       Reference to dead stored features
      * @param dead      Number of newly dead elements
      */
-    void incDead(EntryRef ref, uint64_t dead) {
+    void incDead(EntryRef ref, uint64_t deadElems) {
         RefType intRef(ref);
-        DataStoreBase::incDead(intRef.bufferId(), dead);
+        DataStoreBase::incDead(intRef.bufferId(), deadElems);
     }
 
     /**
-     * Free element.
+     * Free element(s).
      */
-    void freeElem(EntryRef ref, uint64_t len);
+    void freeElem(EntryRef ref, uint64_t numElems);
 
     /**
-     * Hold element.
+     * Hold element(s).
      */
-    void holdElem(EntryRef ref, uint64_t len, size_t extraBytes = 0);
+    void holdElem(EntryRef ref, uint64_t numElems, size_t extraBytes = 0);
 
     /**
      * Trim elem hold list, freeing elements that no longer needs to be held.
@@ -81,7 +84,9 @@ public:
 
 };
 
-
+/**
+ * Concrete data store storing elements of type EntryType, using the given EntryRef type to reference stored data.
+ */
 template <typename EntryType, typename RefT = EntryRefT<22> >
 class DataStore : public DataStoreT<RefT>
 {
diff --git a/searchlib/src/vespa/searchlib/datastore/datastore.hpp b/searchlib/src/vespa/searchlib/datastore/datastore.hpp
index 6f45d2eeeff..aa242d5b968 100644
--- a/searchlib/src/vespa/searchlib/datastore/datastore.hpp
+++ b/searchlib/src/vespa/searchlib/datastore/datastore.hpp
@@ -18,21 +18,19 @@ DataStoreT<RefT>::DataStoreT()
 {
 }
 
-
 template <typename RefT>
 DataStoreT<RefT>::~DataStoreT()
 {
 }
 
-
 template <typename RefT>
 void
-DataStoreT<RefT>::freeElem(EntryRef ref, uint64_t len)
+DataStoreT<RefT>::freeElem(EntryRef ref, uint64_t numElems)
 {
     RefType intRef(ref);
     BufferState &state = getBufferState(intRef.bufferId());
     if (state.isActive()) {
-        if (state.freeListList() != NULL && len == state.getArraySize()) {
+        if (state.freeListList() != NULL && numElems == state.getArraySize()) {
             if (state.freeList().empty()) {
                 state.addToFreeListList();
             }
@@ -41,19 +39,18 @@ DataStoreT<RefT>::freeElem(EntryRef ref, uint64_t len)
     } else {
         assert(state.isOnHold());
     }
-    state.incDeadElems(len);
+    state.incDeadElems(numElems);
     state.cleanHold(getBuffer(intRef.bufferId()),
                     (intRef.offset() / RefType::align(1)) *
-                    state.getArraySize(), len);
+                    state.getArraySize(), numElems);
 }
 
-
 template <typename RefT>
 void
-DataStoreT<RefT>::holdElem(EntryRef ref, uint64_t len, size_t extraBytes)
+DataStoreT<RefT>::holdElem(EntryRef ref, uint64_t numElems, size_t extraBytes)
 {
     RefType intRef(ref);
-    uint64_t alignedLen = RefType::align(len);
+    uint64_t alignedLen = RefType::align(numElems);
     BufferState &state = getBufferState(intRef.bufferId());
     assert(state.isActive());
     if (state.hasDisabledElemHoldList()) {
@@ -65,7 +62,6 @@ DataStoreT<RefT>::holdElem(EntryRef ref, uint64_t len, size_t extraBytes)
     state.incExtraHoldBytes(extraBytes);
 }
 
-
 template <typename RefT>
 void
 DataStoreT<RefT>::trimElemHoldList(generation_t usedGen)
@@ -89,7 +85,6 @@ DataStoreT<RefT>::trimElemHoldList(generation_t usedGen)
     }
 }
 
-
 template <typename RefT>
 void
 DataStoreT<RefT>::clearElemHoldList()
diff --git a/searchlib/src/vespa/searchlib/datastore/datastorebase.cpp b/searchlib/src/vespa/searchlib/datastore/datastorebase.cpp
index dcb6e83e6c1..c922c337a18 100644
--- a/searchlib/src/vespa/searchlib/datastore/datastorebase.cpp
+++ b/searchlib/src/vespa/searchlib/datastore/datastorebase.cpp
@@ -26,7 +26,8 @@ constexpr size_t TOODEAD_SLACK = 0x4000u;
  * up completely will be wasted work, as data will have to be moved again
  * rather soon.
  */
-bool activeWriteBufferTooDead(const BufferState &state)
+bool
+activeWriteBufferTooDead(const BufferState &state)
 {
     size_t deadElems = state.getDeadElems();
     size_t deadBytes = deadElems * state.getArraySize();
@@ -35,12 +36,12 @@ bool activeWriteBufferTooDead(const BufferState &state)
 
 }
 
-DataStoreBase::FallbackHold::FallbackHold(size_t size,
-        BufferState::Alloc &&buffer,
-        size_t usedElems,
-        BufferTypeBase *typeHandler,
-        uint32_t typeId)
-    : GenerationHeldBase(size),
+DataStoreBase::FallbackHold::FallbackHold(size_t bytesSize,
+                                          BufferState::Alloc &&buffer,
+                                          size_t usedElems,
+                                          BufferTypeBase *typeHandler,
+                                          uint32_t typeId)
+    : GenerationHeldBase(bytesSize),
       _buffer(std::move(buffer)),
       _usedElems(usedElems),
       _typeHandler(typeHandler),
@@ -48,21 +49,18 @@ DataStoreBase::FallbackHold::FallbackHold(size_t size,
 {
 }
 
-
 DataStoreBase::FallbackHold::~FallbackHold()
 {
     _typeHandler->destroyElements(_buffer.get(), _usedElems);
 }
 
-
-class DataStoreBase::BufferHold : public GenerationHeldBase
-{
+class DataStoreBase::BufferHold : public GenerationHeldBase {
     DataStoreBase &_dsb;
     uint32_t _bufferId;
 
 public:
-    BufferHold(size_t size, DataStoreBase &dsb, uint32_t bufferId)
-        : GenerationHeldBase(size),
+    BufferHold(size_t bytesSize, DataStoreBase &dsb, uint32_t bufferId)
+        : GenerationHeldBase(bytesSize),
           _dsb(dsb),
           _bufferId(bufferId)
     {
@@ -74,7 +72,6 @@ public:
     }
 };
 
-
 DataStoreBase::DataStoreBase(uint32_t numBuffers, size_t maxArrays)
     : _buffers(numBuffers),
       _activeBufferIds(),
@@ -91,7 +88,6 @@ DataStoreBase::DataStoreBase(uint32_t numBuffers, size_t maxArrays)
 {
 }
 
-
 DataStoreBase::~DataStoreBase()
 {
     disableFreeLists();
@@ -100,37 +96,34 @@ DataStoreBase::~DataStoreBase()
     assert(_elemHold2List.empty());
 }
 
-
 void
-DataStoreBase::switchActiveBuffer(uint32_t typeId, size_t sizeNeeded)
+DataStoreBase::switchActiveBuffer(uint32_t typeId, size_t elemsNeeded)
 {
     size_t activeBufferId = _activeBufferIds[typeId];
     do {
         // start using next buffer
         activeBufferId = nextBufferId(activeBufferId);
     } while (!_states[activeBufferId].isFree());
-    onActive(activeBufferId, typeId, sizeNeeded);
+    onActive(activeBufferId, typeId, elemsNeeded);
     _activeBufferIds[typeId] = activeBufferId;
 }
 
-
 void
-DataStoreBase::switchOrGrowActiveBuffer(uint32_t typeId, size_t sizeNeeded)
+DataStoreBase::switchOrGrowActiveBuffer(uint32_t typeId, size_t elemsNeeded)
 {
     auto typeHandler = _typeHandlers[typeId];
     uint32_t arraySize = typeHandler->getArraySize();
     size_t numArraysForNewBuffer = typeHandler->getNumArraysForNewBuffer();
     size_t numEntriesForNewBuffer = numArraysForNewBuffer * arraySize;
     uint32_t bufferId = _activeBufferIds[typeId];
-    if (sizeNeeded + _states[bufferId].size() >= numEntriesForNewBuffer) {
+    if (elemsNeeded + _states[bufferId].size() >= numEntriesForNewBuffer) {
         // Don't try to resize existing buffer, new buffer will be large enough
-        switchActiveBuffer(typeId, sizeNeeded);
+        switchActiveBuffer(typeId, elemsNeeded);
     } else {
-        fallbackResize(bufferId, sizeNeeded);
+        fallbackResize(bufferId, elemsNeeded);
     }
 }
 
-
 void
 DataStoreBase::initActiveBuffers()
 {
@@ -146,7 +139,6 @@ DataStoreBase::initActiveBuffers()
     }
 }
 
-
 uint32_t
 DataStoreBase::addType(BufferTypeBase *typeHandler)
 {
@@ -169,32 +161,28 @@ DataStoreBase::transferElemHoldList(generation_t generation)
     _elemHold1List.clear();
 }
 
-
 void
 DataStoreBase::transferHoldLists(generation_t generation)
 {
     _genHolder.transferHoldLists(generation);
-    if (hasElemHold1())
+    if (hasElemHold1()) {
         transferElemHoldList(generation);
+    }
 }
 
-
 void
 DataStoreBase::doneHoldBuffer(uint32_t bufferId)
 {
     _states[bufferId].onFree(_buffers[bufferId].getBuffer());
 }
 
-
 void
 DataStoreBase::trimHoldLists(generation_t usedGen)
 {
     trimElemHoldList(usedGen);  // Trim entries before trimming buffers
-
     _genHolder.trimHoldLists(usedGen);
 }
 
-
 void
 DataStoreBase::clearHoldLists()
 {
@@ -203,7 +191,6 @@ DataStoreBase::clearHoldLists()
     _genHolder.clearHoldLists();
 }
 
-
 void
 DataStoreBase::dropBuffers()
 {
@@ -214,7 +201,6 @@ DataStoreBase::dropBuffers()
     _genHolder.clearHoldLists();
 }
 
-
 MemoryUsage
 DataStoreBase::getMemoryUsage() const
 {
@@ -227,7 +213,6 @@ DataStoreBase::getMemoryUsage() const
     return usage;
 }
 
-
 void
 DataStoreBase::holdBuffer(uint32_t bufferId)
 {
@@ -237,7 +222,6 @@ DataStoreBase::holdBuffer(uint32_t bufferId)
     _genHolder.hold(std::move(hold));
 }
 
-
 void
 DataStoreBase::enableFreeLists()
 {
@@ -250,7 +234,6 @@ DataStoreBase::enableFreeLists()
     _freeListsEnabled = true;
 }
 
-
 void
 DataStoreBase::disableFreeLists()
 {
@@ -260,7 +243,6 @@ DataStoreBase::disableFreeLists()
     _freeListsEnabled = false;
 }
 
-
 void
 DataStoreBase::enableFreeList(uint32_t bufferId)
 {
@@ -272,14 +254,12 @@ DataStoreBase::enableFreeList(uint32_t bufferId)
     }
 }
 
-
 void
 DataStoreBase::disableFreeList(uint32_t bufferId)
 {
-    _states[bufferId].setFreeListList(NULL);
+    _states[bufferId].setFreeListList(nullptr);
 }
 
-
 void
 DataStoreBase::disableElemHoldList()
 {
@@ -360,7 +340,7 @@ DataStoreBase::getAddressSpaceUsage() const
 }
 
 void
-DataStoreBase::onActive(uint32_t bufferId, uint32_t typeId, size_t sizeNeeded)
+DataStoreBase::onActive(uint32_t bufferId, uint32_t typeId, size_t elemsNeeded)
 {
     assert(typeId < _typeHandlers.size());
     assert(bufferId < _numBuffers);
@@ -368,7 +348,7 @@ DataStoreBase::onActive(uint32_t bufferId, uint32_t typeId, size_t sizeNeeded)
     BufferState &state = _states[bufferId];
     state.onActive(bufferId, typeId,
                    _typeHandlers[typeId],
-                   sizeNeeded,
+                   elemsNeeded,
                    _buffers[bufferId].getBuffer());
     enableFreeList(bufferId);
 }
@@ -400,16 +380,15 @@ DataStoreBase::finishCompact(const std::vector<uint32_t> &toHold)
     }
 }
 
-
 void
-DataStoreBase::fallbackResize(uint32_t bufferId, uint64_t sizeNeeded)
+DataStoreBase::fallbackResize(uint32_t bufferId, uint64_t elemsNeeded)
 {
     BufferState &state = getBufferState(bufferId);
     BufferState::Alloc toHoldBuffer;
     size_t oldUsedElems = state.size();
     size_t oldAllocElems = state.capacity();
     size_t elementSize = state.getTypeHandler()->elementSize();
-    state.fallbackResize(bufferId, sizeNeeded,
+    state.fallbackResize(bufferId, elemsNeeded,
                          _buffers[bufferId].getBuffer(),
                          toHoldBuffer);
     GenerationHeldBase::UP
@@ -423,9 +402,9 @@ DataStoreBase::fallbackResize(uint32_t bufferId, uint64_t sizeNeeded)
     }
 }
 
-
 uint32_t
-DataStoreBase::startCompactWorstBuffer(uint32_t typeId) {
+DataStoreBase::startCompactWorstBuffer(uint32_t typeId)
+{
     uint32_t activeBufferId = getActiveBufferId(typeId);
     const BufferTypeBase *typeHandler = _typeHandlers[typeId];
     assert(typeHandler->getActiveBuffers() >= 1u);
diff --git a/searchlib/src/vespa/searchlib/datastore/datastorebase.h b/searchlib/src/vespa/searchlib/datastore/datastorebase.h
index c37698d3d4e..d6171dc1c0c 100644
--- a/searchlib/src/vespa/searchlib/datastore/datastorebase.h
+++ b/searchlib/src/vespa/searchlib/datastore/datastorebase.h
@@ -11,6 +11,11 @@
 
 namespace search::datastore {
 
+/**
+ * Abstract class used to store data of potential different types in underlying memory buffers.
+ *
+ * Reference to stored data is via a 32-bit handle (EntryRef).
+ */
 class DataStoreBase
 {
 public:
@@ -73,7 +78,7 @@ protected:
         BufferTypeBase    *_typeHandler;
         uint32_t           _typeId;
 
-        FallbackHold(size_t size, BufferState::Alloc &&buffer, size_t usedElems,
+        FallbackHold(size_t bytesSize, BufferState::Alloc &&buffer, size_t usedElems,
                      BufferTypeBase *typeHandler, uint32_t typeId);
 
         ~FallbackHold() override;
@@ -194,14 +199,14 @@ public:
      * Ensure that active buffer has a given number of elements free at end.
      * Switch to new buffer if current buffer is too full.
      *
-     * @param typeId        registered data type for buffer.
-     * @param sizeNeeded    Number of elements needed to be free
+     * @param typeId      registered data type for buffer.
+     * @param elemsNeeded Number of elements needed to be free
      */
-    void ensureBufferCapacity(uint32_t typeId, size_t sizeNeeded) {
-        if (__builtin_expect(sizeNeeded >
+    void ensureBufferCapacity(uint32_t typeId, size_t elemsNeeded) {
+        if (__builtin_expect(elemsNeeded >
                              _states[_activeBufferIds[typeId]].remaining(),
                              false)) {
-            switchOrGrowActiveBuffer(typeId, sizeNeeded);
+            switchOrGrowActiveBuffer(typeId, elemsNeeded);
         }
     }
 
@@ -216,12 +221,12 @@ public:
      * Switch to new active buffer, typically in preparation for compaction
      * or when current active buffer no longer has free space.
      *
-     * @param typeId        registered data type for buffer.
-     * @param sizeNeeded    Number of elements needed to be free
+     * @param typeId      registered data type for buffer.
+     * @param elemsNeeded Number of elements needed to be free
      */
-    void switchActiveBuffer(uint32_t typeId, size_t sizeNeeded);
+    void switchActiveBuffer(uint32_t typeId, size_t elemsNeeded);
 
-    void switchOrGrowActiveBuffer(uint32_t typeId, size_t sizeNeeded);
+    void switchOrGrowActiveBuffer(uint32_t typeId, size_t elemsNeeded);
 
     MemoryUsage getMemoryUsage() const;
 
@@ -273,9 +278,9 @@ public:
     void dropBuffers();
 
 
-    void incDead(uint32_t bufferId, uint64_t dead) {
+    void incDead(uint32_t bufferId, uint64_t deadElems) {
         BufferState &state = _states[bufferId];
-        state.incDeadElems(dead);
+        state.incDeadElems(deadElems);
     }
 
     /**
@@ -318,11 +323,12 @@ private:
     /**
      * Switch buffer state to active.
      *
-     * @param bufferId      Id of buffer to be active.
-     * @param typeId        registered data type for buffer.
-     * @param sizeNeeded    Number of elements needed to be free
+     * @param bufferId    Id of buffer to be active.
+     * @param typeId      registered data type for buffer.
+     * @param elemsNeeded Number of elements needed to be free
      */
-    void onActive(uint32_t bufferId, uint32_t typeId, size_t sizeNeeded);
+    void onActive(uint32_t bufferId, uint32_t typeId, size_t elemsNeeded);
+
 public:
     uint32_t getTypeId(uint32_t bufferId) const {
         return _buffers[bufferId].getTypeId();
@@ -331,7 +337,7 @@ public:
     std::vector<uint32_t> startCompact(uint32_t typeId);
 
     void finishCompact(const std::vector<uint32_t> &toHold);
-    void fallbackResize(uint32_t bufferId, uint64_t sizeNeeded);
+    void fallbackResize(uint32_t bufferId, uint64_t elementsNeeded);
 
     vespalib::GenerationHolder &getGenerationHolder() {
         return _genHolder;