Standardize on using size_t in datastore and buffer code.

15 files changed, 70 insertions, 69 deletions

diff --git a/searchlib/src/vespa/searchlib/attribute/enumstorebase.h b/searchlib/src/vespa/searchlib/attribute/enumstorebase.h
index 48fbdd69ea1..7615592a798 100644
--- a/searchlib/src/vespa/searchlib/attribute/enumstorebase.h
+++ b/searchlib/src/vespa/searchlib/attribute/enumstorebase.h
@@ -212,16 +212,16 @@ protected:
 
     class EnumBufferType : public datastore::BufferType<char> {
     private:
-        uint64_t _minSizeNeeded; // lower cap for sizeNeeded
-        uint64_t _deadElems;     // dead elements in active buffer
-        bool     _pendingCompact;
-        bool     _wantCompact;
+        size_t _minSizeNeeded; // lower cap for sizeNeeded
+        size_t _deadElems;     // dead elements in active buffer
+        bool   _pendingCompact;
+        bool   _wantCompact;
     public:
         EnumBufferType();
 
         size_t calcArraysToAlloc(uint32_t bufferId, size_t sizeNeeded, bool resizing) const override;
 
-        void setSizeNeededAndDead(uint64_t sizeNeeded, uint64_t deadElems) {
+        void setSizeNeededAndDead(size_t sizeNeeded, size_t deadElems) {
             _minSizeNeeded = sizeNeeded;
             _deadElems = deadElems;
         }
diff --git a/searchlib/src/vespa/searchlib/datastore/array_store.h b/searchlib/src/vespa/searchlib/datastore/array_store.h
index 749e567a6ce..b4cc7d4eb59 100644
--- a/searchlib/src/vespa/searchlib/datastore/array_store.h
+++ b/searchlib/src/vespa/searchlib/datastore/array_store.h
@@ -39,7 +39,7 @@ private:
         using CleanContext = typename ParentType::CleanContext;
     public:
         LargeArrayType(const AllocSpec &spec);
-        virtual void cleanHold(void *buffer, uint64_t offset, uint64_t len, CleanContext cleanCtx) override;
+        virtual void cleanHold(void *buffer, size_t offset, size_t numElems, CleanContext cleanCtx) override;
     };
 
 
diff --git a/searchlib/src/vespa/searchlib/datastore/array_store.hpp b/searchlib/src/vespa/searchlib/datastore/array_store.hpp
index 6867593518d..7efaaa541cb 100644
--- a/searchlib/src/vespa/searchlib/datastore/array_store.hpp
+++ b/searchlib/src/vespa/searchlib/datastore/array_store.hpp
@@ -17,10 +17,10 @@ ArrayStore<EntryT, RefT>::LargeArrayType::LargeArrayType(const AllocSpec &spec)
 
 template <typename EntryT, typename RefT>
 void
-ArrayStore<EntryT, RefT>::LargeArrayType::cleanHold(void *buffer, uint64_t offset, uint64_t len, CleanContext cleanCtx)
+ArrayStore<EntryT, RefT>::LargeArrayType::cleanHold(void *buffer, size_t offset, size_t numElems, CleanContext cleanCtx)
 {
     LargeArray *elem = static_cast<LargeArray *>(buffer) + offset;
-    for (size_t i = 0; i < len; ++i) {
+    for (size_t i = 0; i < numElems; ++i) {
         cleanCtx.extraBytesCleaned(sizeof(EntryT) * elem->size());
         *elem = _emptyEntry;
         ++elem;
diff --git a/searchlib/src/vespa/searchlib/datastore/buffer_type.cpp b/searchlib/src/vespa/searchlib/datastore/buffer_type.cpp
index 157a73ddc20..3955a6cb399 100644
--- a/searchlib/src/vespa/searchlib/datastore/buffer_type.cpp
+++ b/searchlib/src/vespa/searchlib/datastore/buffer_type.cpp
@@ -13,7 +13,7 @@ constexpr float DEFAULT_ALLOC_GROW_FACTOR = 0.2;
 }
 
 void
-BufferTypeBase::CleanContext::extraBytesCleaned(uint64_t value)
+BufferTypeBase::CleanContext::extraBytesCleaned(size_t value)
 {
     assert(_extraBytes >= value);
     _extraBytes -= value;
diff --git a/searchlib/src/vespa/searchlib/datastore/buffer_type.h b/searchlib/src/vespa/searchlib/datastore/buffer_type.h
index 55a394b986a..116b45fe106 100644
--- a/searchlib/src/vespa/searchlib/datastore/buffer_type.h
+++ b/searchlib/src/vespa/searchlib/datastore/buffer_type.h
@@ -32,10 +32,10 @@ protected:
 public:
     class CleanContext {
     private:
-        uint64_t &_extraBytes;
+        size_t &_extraBytes;
     public:
-        CleanContext(uint64_t &extraBytes) : _extraBytes(extraBytes) {}
-        void extraBytesCleaned(uint64_t value);
+        CleanContext(size_t &extraBytes) : _extraBytes(extraBytes) {}
+        void extraBytesCleaned(size_t value);
     };
     
     BufferTypeBase(const BufferTypeBase &rhs) = delete;
@@ -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 numElems, CleanContext cleanCtx) = 0;
+    virtual void cleanHold(void *buffer, size_t offset, size_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);
@@ -91,7 +91,7 @@ public:
     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 numElems, CleanContext cleanCxt) override;
+    void cleanHold(void *buffer, size_t offset, size_t numElems, CleanContext cleanCxt) override;
     size_t elementSize() const override { return sizeof(EntryType); }
 };
 
@@ -150,7 +150,7 @@ BufferType<EntryType>::initializeReservedElements(void *buffer, size_t reservedE
 
 template <typename EntryType>
 void
-BufferType<EntryType>::cleanHold(void *buffer, uint64_t offset, uint64_t numElems, CleanContext)
+BufferType<EntryType>::cleanHold(void *buffer, size_t offset, size_t numElems, CleanContext)
 {
     EntryType *e = static_cast<EntryType *>(buffer) + offset;
     for (size_t j = numElems; j != 0; --j) {
diff --git a/searchlib/src/vespa/searchlib/datastore/bufferstate.cpp b/searchlib/src/vespa/searchlib/datastore/bufferstate.cpp
index 3424546a79f..638117c8c60 100644
--- a/searchlib/src/vespa/searchlib/datastore/bufferstate.cpp
+++ b/searchlib/src/vespa/searchlib/datastore/bufferstate.cpp
@@ -271,7 +271,7 @@ BufferState::disableElemHoldList()
 
 void
 BufferState::fallbackResize(uint32_t bufferId,
-                            uint64_t elementsNeeded,
+                            size_t elementsNeeded,
                             void *&buffer,
                             Alloc &holdBuffer)
 {
diff --git a/searchlib/src/vespa/searchlib/datastore/bufferstate.h b/searchlib/src/vespa/searchlib/datastore/bufferstate.h
index 696568720c0..1cc26d8dd18 100644
--- a/searchlib/src/vespa/searchlib/datastore/bufferstate.h
+++ b/searchlib/src/vespa/searchlib/datastore/bufferstate.h
@@ -45,10 +45,10 @@ public:
 private:
     size_t        _usedElems;
     size_t        _allocElems;
-    uint64_t      _deadElems;
+    size_t        _deadElems;
     State         _state;
     bool          _disableElemHoldList;
-    uint64_t      _holdElems;
+    size_t        _holdElems;
     // Number of bytes that are heap allocated by elements that are stored in this buffer.
     // For simple types this is 0.
     size_t        _extraUsedBytes;
@@ -142,23 +142,23 @@ public:
     size_t size() const { return _usedElems; }
     size_t capacity() const { return _allocElems; }
     size_t remaining() const { return _allocElems - _usedElems; }
-    void pushed_back(uint64_t numElems, size_t extraBytes = 0) {
+    void pushed_back(size_t numElems, size_t extraBytes = 0) {
         _usedElems += numElems;
         _extraUsedBytes += extraBytes;
     }
-    void cleanHold(void *buffer, uint64_t offset, uint64_t len) {
-        _typeHandler->cleanHold(buffer, offset, len, BufferTypeBase::CleanContext(_extraHoldBytes));
+    void cleanHold(void *buffer, size_t offset, size_t numElems) {
+        _typeHandler->cleanHold(buffer, offset, numElems, BufferTypeBase::CleanContext(_extraHoldBytes));
     }
     void dropBuffer(void *&buffer);
     uint32_t getTypeId() const { return _typeId; }
     uint32_t getArraySize() const { return _arraySize; }
-    uint64_t getDeadElems() const { return _deadElems; }
-    uint64_t getHoldElems() const { return _holdElems; }
+    size_t getDeadElems() const { return _deadElems; }
+    size_t getHoldElems() const { return _holdElems; }
     size_t getExtraUsedBytes() const { return _extraUsedBytes; }
     size_t getExtraHoldBytes() const { return _extraHoldBytes; }
     bool getCompacting() const { return _compacting; }
     void setCompacting() { _compacting = true; }
-    void fallbackResize(uint32_t bufferId, uint64_t elementsNeeded, void *&buffer, Alloc &holdBuffer);
+    void fallbackResize(uint32_t bufferId, size_t elementsNeeded, void *&buffer, Alloc &holdBuffer);
 
     bool isActive(uint32_t typeId) const {
         return ((_state == ACTIVE) && (_typeId == typeId));
@@ -170,9 +170,9 @@ public:
     const BufferTypeBase *getTypeHandler() const { return _typeHandler; }
     BufferTypeBase *getTypeHandler() { return _typeHandler; }
 
-    void incDeadElems(uint64_t value) { _deadElems += value; }
-    void incHoldElems(uint64_t value) { _holdElems += value; }
-    void decHoldElems(uint64_t value) {
+    void incDeadElems(size_t value) { _deadElems += value; }
+    void incHoldElems(size_t value) { _holdElems += value; }
+    void decHoldElems(size_t value) {
         assert(_holdElems >= value);
         _holdElems -= value;
     }
diff --git a/searchlib/src/vespa/searchlib/datastore/datastore.h b/searchlib/src/vespa/searchlib/datastore/datastore.h
index c0fccdfb776..66fbc37d4fc 100644
--- a/searchlib/src/vespa/searchlib/datastore/datastore.h
+++ b/searchlib/src/vespa/searchlib/datastore/datastore.h
@@ -42,7 +42,7 @@ public:
      * @param ref       Reference to dead stored features
      * @param dead      Number of newly dead elements
      */
-    void incDead(EntryRef ref, uint64_t deadElems) {
+    void incDead(EntryRef ref, size_t deadElems) {
         RefType intRef(ref);
         DataStoreBase::incDead(intRef.bufferId(), deadElems);
     }
@@ -50,12 +50,12 @@ public:
     /**
      * Free element(s).
      */
-    void freeElem(EntryRef ref, uint64_t numElems);
+    void freeElem(EntryRef ref, size_t numElems);
 
     /**
      * Hold element(s).
      */
-    void holdElem(EntryRef ref, uint64_t numElems, size_t extraBytes = 0);
+    void holdElem(EntryRef ref, size_t numElems, size_t extraBytes = 0);
 
     /**
      * Trim elem hold list, freeing elements that no longer needs to be held.
diff --git a/searchlib/src/vespa/searchlib/datastore/datastore.hpp b/searchlib/src/vespa/searchlib/datastore/datastore.hpp
index aa242d5b968..ff6c249627b 100644
--- a/searchlib/src/vespa/searchlib/datastore/datastore.hpp
+++ b/searchlib/src/vespa/searchlib/datastore/datastore.hpp
@@ -25,7 +25,7 @@ DataStoreT<RefT>::~DataStoreT()
 
 template <typename RefT>
 void
-DataStoreT<RefT>::freeElem(EntryRef ref, uint64_t numElems)
+DataStoreT<RefT>::freeElem(EntryRef ref, size_t numElems)
 {
     RefType intRef(ref);
     BufferState &state = getBufferState(intRef.bufferId());
@@ -47,10 +47,10 @@ DataStoreT<RefT>::freeElem(EntryRef ref, uint64_t numElems)
 
 template <typename RefT>
 void
-DataStoreT<RefT>::holdElem(EntryRef ref, uint64_t numElems, size_t extraBytes)
+DataStoreT<RefT>::holdElem(EntryRef ref, size_t numElems, size_t extraBytes)
 {
     RefType intRef(ref);
-    uint64_t alignedLen = RefType::align(numElems);
+    size_t alignedLen = RefType::align(numElems);
     BufferState &state = getBufferState(intRef.bufferId());
     assert(state.isActive());
     if (state.hasDisabledElemHoldList()) {
diff --git a/searchlib/src/vespa/searchlib/datastore/datastorebase.cpp b/searchlib/src/vespa/searchlib/datastore/datastorebase.cpp
index c922c337a18..4b4a20ecc4a 100644
--- a/searchlib/src/vespa/searchlib/datastore/datastorebase.cpp
+++ b/searchlib/src/vespa/searchlib/datastore/datastorebase.cpp
@@ -381,7 +381,7 @@ DataStoreBase::finishCompact(const std::vector<uint32_t> &toHold)
 }
 
 void
-DataStoreBase::fallbackResize(uint32_t bufferId, uint64_t elemsNeeded)
+DataStoreBase::fallbackResize(uint32_t bufferId, size_t elemsNeeded)
 {
     BufferState &state = getBufferState(bufferId);
     BufferState::Alloc toHoldBuffer;
diff --git a/searchlib/src/vespa/searchlib/datastore/datastorebase.h b/searchlib/src/vespa/searchlib/datastore/datastorebase.h
index d6171dc1c0c..4f86594dd58 100644
--- a/searchlib/src/vespa/searchlib/datastore/datastorebase.h
+++ b/searchlib/src/vespa/searchlib/datastore/datastorebase.h
@@ -24,9 +24,9 @@ public:
     {
     public:
         EntryRef _ref;
-        uint64_t _len;  // Aligned length
+        size_t _len;  // Aligned length
 
-        ElemHold1ListElem(EntryRef ref, uint64_t len)
+        ElemHold1ListElem(EntryRef ref, size_t len)
                 : _ref(ref),
                   _len(len)
         { }
@@ -90,14 +90,14 @@ public:
     class MemStats
     {
     public:
-        uint64_t _allocElems;
-        uint64_t _usedElems;
-        uint64_t _deadElems;
-        uint64_t _holdElems;
-        uint64_t _allocBytes;
-        uint64_t _usedBytes;
-        uint64_t _deadBytes;
-        uint64_t _holdBytes;
+        size_t _allocElems;
+        size_t _usedElems;
+        size_t _deadElems;
+        size_t _holdElems;
+        size_t _allocBytes;
+        size_t _usedBytes;
+        size_t _deadBytes;
+        size_t _holdBytes;
         uint32_t _freeBuffers;
         uint32_t _activeBuffers;
         uint32_t _holdBuffers;
@@ -266,19 +266,19 @@ public:
     void clearHoldLists();
 
     template <typename EntryType>
-    EntryType *getBufferEntry(uint32_t bufferId, uint64_t offset) {
+    EntryType *getBufferEntry(uint32_t bufferId, size_t offset) {
         return static_cast<EntryType *>(_buffers[bufferId].getBuffer()) + offset;
     }
 
     template <typename EntryType>
-    const EntryType *getBufferEntry(uint32_t bufferId, uint64_t offset) const {
+    const EntryType *getBufferEntry(uint32_t bufferId, size_t offset) const {
         return static_cast<const EntryType *>(_buffers[bufferId].getBuffer()) + offset;
     }
 
     void dropBuffers();
 
 
-    void incDead(uint32_t bufferId, uint64_t deadElems) {
+    void incDead(uint32_t bufferId, size_t deadElems) {
         BufferState &state = _states[bufferId];
         state.incDeadElems(deadElems);
     }
@@ -337,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 elementsNeeded);
+    void fallbackResize(uint32_t bufferId, size_t elementsNeeded);
 
     vespalib::GenerationHolder &getGenerationHolder() {
         return _genHolder;
diff --git a/searchlib/src/vespa/searchlib/datastore/entryref.cpp b/searchlib/src/vespa/searchlib/datastore/entryref.cpp
index f7224191d1b..649bfa7e4e9 100644
--- a/searchlib/src/vespa/searchlib/datastore/entryref.cpp
+++ b/searchlib/src/vespa/searchlib/datastore/entryref.cpp
@@ -4,14 +4,14 @@
 
 namespace search::datastore {
 
-template EntryRefT<24u, 8u>::EntryRefT(uint64_t, uint32_t);
-template EntryRefT<31u, 1u>::EntryRefT(uint64_t, uint32_t);
-template EntryRefT<22u,10u>::EntryRefT(uint64_t, uint32_t);
-template EntryRefT<19u,13u>::EntryRefT(uint64_t, uint32_t);
-template EntryRefT<18u, 6u>::EntryRefT(uint64_t, uint32_t);
-template EntryRefT<15u,17u>::EntryRefT(uint64_t, uint32_t);
-template EntryRefT<10u,22u>::EntryRefT(uint64_t, uint32_t);
-template EntryRefT<10u,10u>::EntryRefT(uint64_t, uint32_t);
-template EntryRefT< 3u, 2u>::EntryRefT(uint64_t, uint32_t);
+template EntryRefT<24u, 8u>::EntryRefT(size_t, uint32_t);
+template EntryRefT<31u, 1u>::EntryRefT(size_t, uint32_t);
+template EntryRefT<22u,10u>::EntryRefT(size_t, uint32_t);
+template EntryRefT<19u,13u>::EntryRefT(size_t, uint32_t);
+template EntryRefT<18u, 6u>::EntryRefT(size_t, uint32_t);
+template EntryRefT<15u,17u>::EntryRefT(size_t, uint32_t);
+template EntryRefT<10u,22u>::EntryRefT(size_t, uint32_t);
+template EntryRefT<10u,10u>::EntryRefT(size_t, uint32_t);
+template EntryRefT< 3u, 2u>::EntryRefT(size_t, uint32_t);
 
 }
diff --git a/searchlib/src/vespa/searchlib/datastore/entryref.h b/searchlib/src/vespa/searchlib/datastore/entryref.h
index 918e514c8df..a582d2020f9 100644
--- a/searchlib/src/vespa/searchlib/datastore/entryref.h
+++ b/searchlib/src/vespa/searchlib/datastore/entryref.h
@@ -2,6 +2,7 @@
 
 #pragma once
 
+#include <cstddef>
 #include <cstdint>
 
 namespace search::datastore {
@@ -27,15 +28,15 @@ template <uint32_t OffsetBits, uint32_t BufferBits = 32u - OffsetBits>
 class EntryRefT : public EntryRef {
 public:
     EntryRefT() : EntryRef() {}
-    EntryRefT(uint64_t offset_, uint32_t bufferId_);
+    EntryRefT(size_t offset_, uint32_t bufferId_);
     EntryRefT(const EntryRef & ref_) : EntryRef(ref_.ref()) {}
     uint32_t hash() const { return offset() + (bufferId() << OffsetBits); }
-    uint64_t offset() const { return _ref >> BufferBits; }
+    size_t offset() const { return _ref >> BufferBits; }
     uint32_t bufferId() const { return _ref & (numBuffers() - 1); }
-    static uint64_t offsetSize() { return 1ul << OffsetBits; }
+    static size_t offsetSize() { return 1ul << OffsetBits; }
     static uint32_t numBuffers() { return 1 << BufferBits; } 
-    static uint64_t align(uint64_t val) { return val; }
-    static uint64_t pad(uint64_t val) { (void) val; return 0ul; }
+    static size_t align(size_t val) { return val; }
+    static size_t pad(size_t val) { (void) val; return 0ul; }
     static constexpr bool isAlignedType = false;
 };
 
@@ -50,13 +51,13 @@ private:
     static const uint32_t PadConstant = ((1 << OffsetAlign) - 1);
 public:
     AlignedEntryRefT() : ParentType() {}
-    AlignedEntryRefT(uint64_t offset_, uint32_t bufferId_) :
+    AlignedEntryRefT(size_t offset_, uint32_t bufferId_) :
         ParentType(align(offset_) >> OffsetAlign, bufferId_) {}
     AlignedEntryRefT(const EntryRef & ref_) : ParentType(ref_) {}
-    uint64_t offset() const { return ParentType::offset() << OffsetAlign; }
-    static uint64_t offsetSize() { return ParentType::offsetSize() << OffsetAlign; }
-    static uint64_t align(uint64_t val) { return val + pad(val); }
-    static uint64_t pad(uint64_t val) { return (-val & PadConstant); }
+    size_t offset() const { return ParentType::offset() << OffsetAlign; }
+    static size_t offsetSize() { return ParentType::offsetSize() << OffsetAlign; }
+    static size_t align(size_t val) { return val + pad(val); }
+    static size_t pad(size_t val) { return (-val & PadConstant); }
     static constexpr bool isAlignedType = true;
 };
 
diff --git a/searchlib/src/vespa/searchlib/datastore/entryref.hpp b/searchlib/src/vespa/searchlib/datastore/entryref.hpp
index a7bb9f9b3ef..6e8b94f8989 100644
--- a/searchlib/src/vespa/searchlib/datastore/entryref.hpp
+++ b/searchlib/src/vespa/searchlib/datastore/entryref.hpp
@@ -8,7 +8,7 @@
 namespace search::datastore {
 
 template <uint32_t OffsetBits, uint32_t BufferBits>
-EntryRefT<OffsetBits, BufferBits>::EntryRefT(uint64_t offset_, uint32_t bufferId_) :
+EntryRefT<OffsetBits, BufferBits>::EntryRefT(size_t offset_, uint32_t bufferId_) :
     EntryRef((offset_ << BufferBits) + bufferId_)
 {
     ASSERT_ONCE_OR_LOG(offset_ < offsetSize(), "EntryRefT.offset_overflow", 10000);
diff --git a/searchlib/src/vespa/searchlib/datastore/free_list_raw_allocator.hpp b/searchlib/src/vespa/searchlib/datastore/free_list_raw_allocator.hpp
index 583bd865f23..dbb54247f58 100644
--- a/searchlib/src/vespa/searchlib/datastore/free_list_raw_allocator.hpp
+++ b/searchlib/src/vespa/searchlib/datastore/free_list_raw_allocator.hpp
@@ -25,7 +25,7 @@ FreeListRawAllocator<EntryT, RefT>::alloc(size_t numElems)
     assert(state.getArraySize() == numElems);
     RefT ref = state.popFreeList();
     // If entry ref is not aligned we must scale the offset according to array size as it was divided when the entry ref was created.
-    uint64_t offset = !RefT::isAlignedType ? ref.offset() * state.getArraySize() : ref.offset();
+    size_t offset = !RefT::isAlignedType ? ref.offset() * state.getArraySize() : ref.offset();
     EntryT *entry = _store.template getBufferEntry<EntryT>(ref.bufferId(), offset);
     return HandleType(ref, entry);
 }