- override, code unification.

- colocate the buffer and the typeId since they are frequently used together.

4 files changed, 160 insertions, 358 deletions

diff --git a/searchlib/src/vespa/searchlib/attribute/enumstorebase.h b/searchlib/src/vespa/searchlib/attribute/enumstorebase.h
index c57bbb5dc98..1c7dee0b559 100644
--- a/searchlib/src/vespa/searchlib/attribute/enumstorebase.h
+++ b/searchlib/src/vespa/searchlib/attribute/enumstorebase.h
@@ -42,9 +42,7 @@ struct CompareEnumIndex
 {
     typedef EnumStoreIndex Index;
 
-    inline bool
-    operator()(const Index &lhs, const Index &rhs) const
-    {
+    bool operator()(const Index &lhs, const Index &rhs) const {
         return lhs.ref() < rhs.ref();
     }
 };
@@ -63,77 +61,38 @@ protected:
 
 public:
     EnumStoreDictBase(EnumStoreBase &enumStore);
-
-    virtual
-    ~EnumStoreDictBase(void);
-
-    virtual void
-    freezeTree(void) = 0;
-
-    virtual uint32_t
-    getNumUniques(void) const = 0;
-    
-    virtual MemoryUsage
-    getTreeMemoryUsage(void) const = 0;
-
-    virtual void
-    reEnumerate(void) = 0;
-
-    virtual void
-    writeAllValues(BufferWriter &writer,
-                   btree::BTreeNode::Ref rootRef) const = 0;
-
-    virtual ssize_t
-    deserialize(const void *src, size_t available,
-                IndexVector &idx) = 0;
-
-    virtual void
-    fixupRefCounts(const EnumVector &hist) = 0;
-
-    virtual void
-    freeUnusedEnums(const EnumStoreComparator &cmp,
-                    const EnumStoreComparator *fcmp) = 0;
-
-    virtual void
-    freeUnusedEnums(const IndexVector &toRemove,
-                    const EnumStoreComparator &cmp,
-                    const EnumStoreComparator *fcmp) = 0;
-
-    virtual bool
-    findIndex(const EnumStoreComparator &cmp, Index &idx) const = 0;
-
-    virtual bool
-    findFrozenIndex(const EnumStoreComparator &cmp, Index &idx) const = 0;
-
-    virtual void
-    onReset(void) = 0;
-
-    virtual void
-    onTransferHoldLists(generation_t generation) = 0;
-
-    virtual void
-    onTrimHoldLists(generation_t firstUsed) = 0;
-
-    virtual btree::BTreeNode::Ref
-    getFrozenRootRef(void) const = 0;
-
-    virtual uint32_t
-    lookupFrozenTerm(btree::BTreeNode::Ref frozenRootRef,
-                     const EnumStoreComparator &comp) const = 0;
-
-    virtual uint32_t
-    lookupFrozenRange(btree::BTreeNode::Ref frozenRootRef,
-                      const EnumStoreComparator &low,
-                      const EnumStoreComparator &high) const = 0;
-
-    virtual EnumPostingTree &
-    getPostingDictionary(void) = 0;
-
-    virtual const EnumPostingTree &
-    getPostingDictionary(void) const = 0;
-
-    virtual bool
-    hasData(void) const = 0;
+    virtual ~EnumStoreDictBase();
+
+    virtual void freezeTree() = 0;
+    virtual uint32_t getNumUniques() const = 0;
+    virtual MemoryUsage getTreeMemoryUsage() const = 0;
+    virtual void reEnumerate() = 0;
+    virtual void writeAllValues(BufferWriter &writer, btree::BTreeNode::Ref rootRef) const = 0;
+    virtual ssize_t deserialize(const void *src, size_t available, IndexVector &idx) = 0;
+
+    virtual void fixupRefCounts(const EnumVector &hist) = 0;
+    virtual void freeUnusedEnums(const EnumStoreComparator &cmp,
+                                 const EnumStoreComparator *fcmp) = 0;
+    virtual void freeUnusedEnums(const IndexVector &toRemove,
+                                 const EnumStoreComparator &cmp,
+                                 const EnumStoreComparator *fcmp) = 0;
+    virtual bool findIndex(const EnumStoreComparator &cmp, Index &idx) const = 0;
+    virtual bool findFrozenIndex(const EnumStoreComparator &cmp, Index &idx) const = 0;
+    virtual void onReset() = 0;
+    virtual void onTransferHoldLists(generation_t generation) = 0;
+    virtual void onTrimHoldLists(generation_t firstUsed) = 0;
+    virtual btree::BTreeNode::Ref getFrozenRootRef() const = 0;
+
+    virtual uint32_t lookupFrozenTerm(btree::BTreeNode::Ref frozenRootRef,
+                                      const EnumStoreComparator &comp) const = 0;
+
+    virtual uint32_t lookupFrozenRange(btree::BTreeNode::Ref frozenRootRef,
+                                       const EnumStoreComparator &low,
+                                       const EnumStoreComparator &high) const = 0;
+
+    virtual EnumPostingTree &getPostingDictionary() = 0;
+    virtual const EnumPostingTree &getPostingDictionary() const = 0;
+    virtual bool hasData() const = 0;
 };
 
 
@@ -146,93 +105,48 @@ protected:
 public:
     EnumStoreDict(EnumStoreBase &enumStore);
 
-    virtual
-    ~EnumStoreDict(void);
-
-    const Dictionary &
-    getDictionary() const
-    {
-        return _dict;
-    }
-
-    Dictionary &
-    getDictionary()
-    {
-        return _dict;
-    }
-    
-    virtual void
-    freezeTree(void);
+    virtual ~EnumStoreDict();
 
-    virtual uint32_t
-    getNumUniques(void) const;
+    const Dictionary &getDictionary() const { return _dict; }
+    Dictionary &getDictionary() { return _dict; }
     
-    virtual MemoryUsage
-    getTreeMemoryUsage(void) const;
-
-    virtual void
-    reEnumerate(void);
-
-    virtual void
-    writeAllValues(BufferWriter &writer,
-                   btree::BTreeNode::Ref rootRef) const override;
-
-    virtual ssize_t
-    deserialize(const void *src, size_t available,
-                IndexVector &idx);
-
-    virtual void
-    fixupRefCounts(const EnumVector &hist);
-
-    void
-    removeUnusedEnums(const IndexSet &unused,
-                      const EnumStoreComparator &cmp,
-                      const EnumStoreComparator *fcmp);
-
-    virtual void
-    freeUnusedEnums(const EnumStoreComparator &cmp,
-                    const EnumStoreComparator *fcmp);
-
-    virtual void
-    freeUnusedEnums(const IndexVector &toRemove,
-                    const EnumStoreComparator &cmp,
-                    const EnumStoreComparator *fcmp);
-
-    virtual bool
-    findIndex(const EnumStoreComparator &cmp, Index &idx) const;
-
-    virtual bool
-    findFrozenIndex(const EnumStoreComparator &cmp, Index &idx) const;
-
-    virtual void
-    onReset(void);
-
-    virtual void
-    onTransferHoldLists(generation_t generation);
-
-    virtual void
-    onTrimHoldLists(generation_t firstUsed);
-
-    virtual btree::BTreeNode::Ref
-    getFrozenRootRef(void) const;
-
-    virtual uint32_t
-    lookupFrozenTerm(btree::BTreeNode::Ref frozenRootRef,
-                     const EnumStoreComparator &comp) const;
-
-    virtual uint32_t
-    lookupFrozenRange(btree::BTreeNode::Ref frozenRootRef,
-                      const EnumStoreComparator &low,
-                      const EnumStoreComparator &high) const;
-
-    virtual EnumPostingTree &
-    getPostingDictionary(void);
-
-    virtual const EnumPostingTree &
-    getPostingDictionary(void) const;
-
-    virtual bool
-    hasData(void) const;
+    void freezeTree() override;
+    uint32_t getNumUniques() const override;
+    MemoryUsage getTreeMemoryUsage() const override;
+    void reEnumerate() override;
+    void writeAllValues(BufferWriter &writer, btree::BTreeNode::Ref rootRef) const override;
+    ssize_t deserialize(const void *src, size_t available, IndexVector &idx) override;
+    void fixupRefCounts(const EnumVector &hist) override;
+
+    void removeUnusedEnums(const IndexSet &unused,
+                           const EnumStoreComparator &cmp,
+                           const EnumStoreComparator *fcmp);
+
+    void freeUnusedEnums(const EnumStoreComparator &cmp,
+                         const EnumStoreComparator *fcmp) override;
+
+    void freeUnusedEnums(const IndexVector &toRemove,
+                         const EnumStoreComparator &cmp,
+                         const EnumStoreComparator *fcmp) override;
+
+    bool findIndex(const EnumStoreComparator &cmp, Index &idx) const override;
+    bool findFrozenIndex(const EnumStoreComparator &cmp, Index &idx) const override;
+    void onReset() override;
+    void onTransferHoldLists(generation_t generation) override;
+    void onTrimHoldLists(generation_t firstUsed) override;
+    btree::BTreeNode::Ref getFrozenRootRef() const override;
+
+    uint32_t lookupFrozenTerm(btree::BTreeNode::Ref frozenRootRef,
+                              const EnumStoreComparator &comp) const override;
+
+    uint32_t lookupFrozenRange(btree::BTreeNode::Ref frozenRootRef,
+                               const EnumStoreComparator &low,
+                               const EnumStoreComparator &high) const override;
+
+    EnumPostingTree & getPostingDictionary() override;
+    const EnumPostingTree & getPostingDictionary() const override;
+
+    bool hasData() const override;
 };
 
 
@@ -250,50 +164,32 @@ public:
     protected:
         char * _data;
     public:
-        EntryBase(void * data)
-            :
-            _data(static_cast<char *>(data))
-        {
-        }
+        EntryBase(void * data) : _data(static_cast<char *>(data)) {}
 
-        uint32_t
-        getEnum() const
-        {
-            uint32_t *src = reinterpret_cast<uint32_t *>(_data);
-            return *src;
+        uint32_t getEnum() const {
+            return *reinterpret_cast<uint32_t *>(_data);
         }
 
-        uint32_t
-        getRefCount(void) const
-        {
-            uint32_t *src = reinterpret_cast<uint32_t *>(_data) + 1;
-            return *src;
+        uint32_t getRefCount() const {
+            return *(reinterpret_cast<uint32_t *>(_data) + 1);
         }
 
-        void
-        incRefCount(void)
-        {
+        void incRefCount() {
             uint32_t *dst = reinterpret_cast<uint32_t *>(_data) + 1;
             ++(*dst);
         }
 
-        void
-        decRefCount(void)
-        {
+        void decRefCount() {
             uint32_t *dst = reinterpret_cast<uint32_t *>(_data) + 1;
             --(*dst);
         }
 
-        void
-        setEnum(uint32_t enumValue)
-        {
+        void setEnum(uint32_t enumValue) {
             uint32_t *dst = reinterpret_cast<uint32_t *>(_data);
             *dst = enumValue;
         }
 
-        void
-        setRefCount(uint32_t refCount)
-        {
+        void setRefCount(uint32_t refCount) {
             uint32_t *dst = reinterpret_cast<uint32_t *>(_data) + 1;
             *dst = refCount;
         }
@@ -309,43 +205,27 @@ protected:
     private:
         uint64_t _minSizeNeeded; // lower cap for sizeNeeded
         uint64_t _deadElems;     // dead elements in active buffer
-        bool _pendingCompact;
-        bool _wantCompact;
+        bool     _pendingCompact;
+        bool     _wantCompact;
     public:
         EnumBufferType();
 
-        virtual size_t calcClustersToAlloc(uint32_t bufferId, size_t sizeNeeded, bool resizing) const override;
+        size_t calcClustersToAlloc(uint32_t bufferId, size_t sizeNeeded, bool resizing) const override;
 
         void setSizeNeededAndDead(uint64_t sizeNeeded, uint64_t deadElems) {
             _minSizeNeeded = sizeNeeded;
             _deadElems = deadElems;
         }
 
-        virtual void
-        onFree(size_t usedElems)
-        {
+        void onFree(size_t usedElems) override {
             datastore::BufferType<char>::onFree(usedElems);
             _pendingCompact = _wantCompact;
             _wantCompact = false;
         }
 
-        void
-        setWantCompact(void)
-        {
-            _wantCompact = true;
-        }
-
-        bool
-        getPendingCompact(void) const
-        {
-            return _pendingCompact;
-        }
-
-        void
-        clearPendingCompact(void)
-        {
-            _pendingCompact = false;
-        }
+        void setWantCompact() { _wantCompact = true; }
+        bool getPendingCompact() const { return _pendingCompact; }
+        void clearPendingCompact() { _pendingCompact = false; }
     };
 
     EnumStoreDictBase    *_enumDict;
@@ -359,8 +239,7 @@ protected:
 
     static const uint32_t TYPE_ID = 0;
 
-    EnumStoreBase(uint64_t initBufferSize,
-                  bool hasPostings);
+    EnumStoreBase(uint64_t initBufferSize, bool hasPostings);
 
     virtual ~EnumStoreBase();
 
@@ -382,8 +261,7 @@ protected:
     bool preCompact(uint64_t bytesNeeded);
 
 public:
-    void
-    reset(uint64_t initBufferSize);
+    void reset(uint64_t initBufferSize);
 
     virtual uint32_t getFixedSize() const = 0;
     size_t getMaxEnumOffset() const {
@@ -396,80 +274,44 @@ public:
     void decRefCount(Index idx)           { getEntryBase(idx).decRefCount(); }
     
     // Only use when reading from enumerated attribute save files
-    void
-    fixupRefCount(Index idx, uint32_t refCount)
-    {
+    void fixupRefCount(Index idx, uint32_t refCount) {
         getEntryBase(idx).setRefCount(refCount);
     } 
     
     template <typename Tree>
-    void
-    fixupRefCounts(const EnumVector &hist,
-                   Tree &tree);
+    void fixupRefCounts(const EnumVector &hist, Tree &tree);
 
     void clearIndexMap()                  { IndexVector().swap(_indexMap); }
     uint32_t getLastEnum()          const { return _nextEnum ? _nextEnum - 1 : _nextEnum; }
-
-    inline uint32_t
-    getNumUniques() const
-    {
-        return _enumDict->getNumUniques();
-    }
+    uint32_t getNumUniques() const { return _enumDict->getNumUniques(); }
 
     uint32_t getRemaining() const {
         return _store.getBufferState(_store.getActiveBufferId(TYPE_ID)).remaining();
     }
     MemoryUsage getMemoryUsage() const;
-
-    inline MemoryUsage
-    getTreeMemoryUsage() const
-    {
-        return _enumDict->getTreeMemoryUsage();
-    }
+    MemoryUsage getTreeMemoryUsage() const { return _enumDict->getTreeMemoryUsage(); }
 
     AddressSpace getAddressSpaceUsage() const;
 
     bool getCurrentIndex(Index oldIdx, Index & newIdx) const;
 
-    void
-    transferHoldLists(generation_t generation);
-
+    void transferHoldLists(generation_t generation);
     void trimHoldLists(generation_t firstUsed);
 
     static void failNewSize(uint64_t minNewSize, uint64_t maxSize);
 
     // Align buffers and entries to 4 bytes boundary.
-    static uint64_t alignBufferSize(uint64_t val) {
-        return Index::align(val);
-    }
-    static uint32_t alignEntrySize(uint32_t val) {
-        return Index::align(val);
-    }
-
-    void
-    fallbackResize(uint64_t bytesNeeded);
-
-    bool
-    getPendingCompact(void) const
-    {
-        return _type.getPendingCompact();
-    }
+    static uint64_t alignBufferSize(uint64_t val) { return Index::align(val); }
+    static uint32_t alignEntrySize(uint32_t val) { return Index::align(val); }
 
-    void
-    clearPendingCompact(void)
-    {
-        _type.clearPendingCompact();
-    }
+    void fallbackResize(uint64_t bytesNeeded);
+    bool getPendingCompact() const { return _type.getPendingCompact(); }
+    void clearPendingCompact() { _type.clearPendingCompact(); }
 
     template <typename Tree>
-    void
-    reEnumerate(const Tree &tree);
+    void reEnumerate(const Tree &tree);
 
-    inline void
-    reEnumerate(void)
-    {
-        _enumDict->reEnumerate();
-    }
+    void reEnumerate() { _enumDict->reEnumerate(); }
 
     // Disable reenumeration during compaction.
     void disableReEnumerate() const;
@@ -477,89 +319,43 @@ public:
     // Allow reenumeration during compaction.
     void enableReEnumerate() const;
 
-    virtual void writeValues(BufferWriter &writer,
-                             const Index *idxs, size_t count) const = 0;
-
-    void writeEnumValues(BufferWriter &writer,
-                         const Index *idxs, size_t count) const;
+    virtual void writeValues(BufferWriter &writer, const Index *idxs, size_t count) const = 0;
 
-    virtual ssize_t
-    deserialize(const void *src, size_t available, size_t &initSpace) = 0;
+    void writeEnumValues(BufferWriter &writer, const Index *idxs, size_t count) const;
 
-    virtual ssize_t
-    deserialize(const void *src, size_t available, Index &idx) = 0;
+    virtual ssize_t deserialize(const void *src, size_t available, size_t &initSpace) = 0;
+    virtual ssize_t deserialize(const void *src, size_t available, Index &idx) = 0;
+    virtual bool foldedChange(const Index &idx1, const Index &idx2) = 0;
 
-    virtual bool
-    foldedChange(const Index &idx1, const Index &idx2) = 0;
-
-    ssize_t
-    deserialize0(const void *src, size_t available, IndexVector &idx);
+    ssize_t deserialize0(const void *src, size_t available, IndexVector &idx);
 
     template <typename Tree>
-    ssize_t
-    deserialize(const void *src, size_t available, IndexVector &idx,
-                Tree &tree);
-
-    inline ssize_t
-    deserialize(const void *src, size_t available,
-                IndexVector &idx)
-    {
-        return _enumDict->deserialize(src, available, idx);
-    }
-
-    virtual void
-    freeUnusedEnum(Index idx, IndexSet &unused) = 0;
-
-    virtual void
-    freeUnusedEnums(bool movePostingIdx) = 0;
-
-    virtual void
-    freeUnusedEnums(const IndexVector &toRemove) = 0;
-
-    inline void
-    fixupRefCounts(const EnumVector &hist)
-    {
-        _enumDict->fixupRefCounts(hist);
-    }
+    ssize_t deserialize(const void *src, size_t available, IndexVector &idx, Tree &tree);
 
-    inline void
-    freezeTree(void)
-    {
-        _enumDict->freezeTree();
+    ssize_t deserialize(const void *src, size_t available, IndexVector &idx) {
+        return _enumDict->deserialize(src, available, idx);
     }
 
-    virtual bool
-    performCompaction(uint64_t bytesNeeded) = 0;
+    virtual void freeUnusedEnum(Index idx, IndexSet &unused) = 0;
+    virtual void freeUnusedEnums(bool movePostingIdx) = 0;
+    virtual void freeUnusedEnums(const IndexVector &toRemove) = 0;
 
-    EnumStoreDictBase &
-    getEnumStoreDict(void)
-    {
-        return *_enumDict;
-    }
+    void fixupRefCounts(const EnumVector &hist) { _enumDict->fixupRefCounts(hist); }
+    void freezeTree() { _enumDict->freezeTree(); }
 
-    const EnumStoreDictBase &
-    getEnumStoreDict(void) const
-    {
-        return *_enumDict;
-    }
+    virtual bool performCompaction(uint64_t bytesNeeded) = 0;
 
-    EnumPostingTree &
-    getPostingDictionary(void)
-    {
-        return _enumDict->getPostingDictionary();
-    }
+    EnumStoreDictBase &getEnumStoreDict() { return *_enumDict; }
+    const EnumStoreDictBase &getEnumStoreDict() const { return *_enumDict; }
+    EnumPostingTree &getPostingDictionary() { return _enumDict->getPostingDictionary(); }
 
-    const EnumPostingTree &
-    getPostingDictionary(void) const
-    {
+    const EnumPostingTree &getPostingDictionary() const {
         return _enumDict->getPostingDictionary();
     }
 };
 
-
 vespalib::asciistream & operator << (vespalib::asciistream & os, const EnumStoreBase::Index & idx);
 
-
 /**
  * Base comparator class needed by the btree.
  **/
@@ -582,11 +378,9 @@ public:
     typedef EnumStoreBase::Index EnumIndex;
     EnumStoreComparatorWrapper(const EnumStoreComparator &comp)
         : _comp(comp)
-    {
-    }
+    { }
 
-    inline bool operator()(const EnumIndex &lhs, const EnumIndex &rhs) const
-    {
+    bool operator()(const EnumIndex &lhs, const EnumIndex &rhs) const {
         return _comp(lhs, rhs);
     }
 };
@@ -595,4 +389,3 @@ extern template class
 datastore::DataStoreT<datastore::AlignedEntryRefT<31, 4> >;
 
 }
-
diff --git a/searchlib/src/vespa/searchlib/datastore/datastore.hpp b/searchlib/src/vespa/searchlib/datastore/datastore.hpp
index f4d80795c87..3b09d2f57af 100644
--- a/searchlib/src/vespa/searchlib/datastore/datastore.hpp
+++ b/searchlib/src/vespa/searchlib/datastore/datastore.hpp
@@ -12,7 +12,7 @@ namespace search {
 namespace datastore {
 
 template <typename RefT>
-DataStoreT<RefT>::DataStoreT(void)
+DataStoreT<RefT>::DataStoreT()
     : DataStoreBase(RefType::numBuffers(),
                     RefType::offsetSize() / RefType::align(1))
 {
@@ -20,7 +20,7 @@ DataStoreT<RefT>::DataStoreT(void)
 
 
 template <typename RefT>
-DataStoreT<RefT>::~DataStoreT(void)
+DataStoreT<RefT>::~DataStoreT()
 {
 }
 
@@ -42,7 +42,7 @@ DataStoreT<RefT>::freeElem(EntryRef ref, uint64_t len)
         assert(state.isOnHold());
     }
     state.incDeadElems(len);
-    state.cleanHold(_buffers[intRef.bufferId()],
+    state.cleanHold(getBuffer(intRef.bufferId()),
                     (intRef.offset() / RefType::align(1)) *
                     state.getClusterSize(), len);
 }
@@ -92,7 +92,7 @@ DataStoreT<RefT>::trimElemHoldList(generation_t usedGen)
 
 template <typename RefT>
 void
-DataStoreT<RefT>::clearElemHoldList(void)
+DataStoreT<RefT>::clearElemHoldList()
 {
     ElemHold2List &elemHold2List = _elemHold2List;
 
@@ -134,7 +134,7 @@ DataStoreT<RefT>::rawAllocator(uint32_t typeId)
 
 
 template <typename EntryType, typename RefT>
-DataStore<EntryType, RefT>::DataStore(void)
+DataStore<EntryType, RefT>::DataStore()
     : ParentType(),
       _type(1, RefType::offsetSize(), RefType::offsetSize())
 {
@@ -143,7 +143,7 @@ DataStore<EntryType, RefT>::DataStore(void)
 }
 
 template <typename EntryType, typename RefT>
-DataStore<EntryType, RefT>::~DataStore(void)
+DataStore<EntryType, RefT>::~DataStore()
 {
     dropBuffers();	// Drop buffers before type handlers are dropped
 }
diff --git a/searchlib/src/vespa/searchlib/datastore/datastorebase.cpp b/searchlib/src/vespa/searchlib/datastore/datastorebase.cpp
index e73dcb2d43a..e4726a5228d 100644
--- a/searchlib/src/vespa/searchlib/datastore/datastorebase.cpp
+++ b/searchlib/src/vespa/searchlib/datastore/datastorebase.cpp
@@ -77,7 +77,6 @@ public:
 
 DataStoreBase::DataStoreBase(uint32_t numBuffers, size_t maxClusters)
     : _buffers(numBuffers),
-      _typeIds(numBuffers),
       _activeBufferIds(),
       _states(numBuffers),
       _typeHandlers(),
@@ -183,7 +182,7 @@ DataStoreBase::transferHoldLists(generation_t generation)
 void
 DataStoreBase::doneHoldBuffer(uint32_t bufferId)
 {
-    _states[bufferId].onFree(_buffers[bufferId]);
+    _states[bufferId].onFree(_buffers[bufferId].getBuffer());
 }
 
 
@@ -210,7 +209,7 @@ DataStoreBase::dropBuffers()
 {
     uint32_t numBuffers = _buffers.size();
     for (uint32_t bufferId = 0; bufferId < numBuffers; ++bufferId) {
-        _states[bufferId].dropBuffer(_buffers[bufferId]);
+        _states[bufferId].dropBuffer(_buffers[bufferId].getBuffer());
     }
     _genHolder.clearHoldLists();
 }
@@ -365,11 +364,12 @@ DataStoreBase::onActive(uint32_t bufferId, uint32_t typeId, size_t sizeNeeded)
 {
     assert(typeId < _typeHandlers.size());
     assert(bufferId < _numBuffers);
+    _buffers[bufferId].setTypeId(typeId);
     BufferState &state = _states[bufferId];
     state.onActive(bufferId, typeId,
                    _typeHandlers[typeId],
                    sizeNeeded,
-                   _buffers[bufferId]);
+                   _buffers[bufferId].getBuffer());
     enableFreeList(bufferId);
 }
 
@@ -409,9 +409,8 @@ DataStoreBase::fallbackResize(uint32_t bufferId, uint64_t sizeNeeded)
     size_t oldUsedElems = state.size();
     size_t oldAllocElems = state.capacity();
     size_t elementSize = state.getTypeHandler()->elementSize();
-    state.fallbackResize(bufferId,
-                         sizeNeeded,
-                         _buffers[bufferId],
+    state.fallbackResize(bufferId, sizeNeeded,
+                         _buffers[bufferId].getBuffer(),
                          toHoldBuffer);
     GenerationHeldBase::UP
         hold(new FallbackHold(oldAllocElems * elementSize,
diff --git a/searchlib/src/vespa/searchlib/datastore/datastorebase.h b/searchlib/src/vespa/searchlib/datastore/datastorebase.h
index c6aa098cb9f..250b90880b7 100644
--- a/searchlib/src/vespa/searchlib/datastore/datastorebase.h
+++ b/searchlib/src/vespa/searchlib/datastore/datastorebase.h
@@ -36,20 +36,32 @@ protected:
     typedef vespalib::GenerationHandler::generation_t generation_t;
     typedef vespalib::GenerationHandler::sgeneration_t sgeneration_t;
 
-    std::vector<void *>   _buffers; // For fast mapping with known types
 private:
-    std::vector<uint32_t> _typeIds; // Cached,compact access to frequently used typeId
+    class BufferAndTypeId {
+    public:
+        using B = void *;
+        BufferAndTypeId() : BufferAndTypeId(nullptr, 0) { }
+        BufferAndTypeId(B buffer, uint32_t typeId) : _buffer(buffer), _typeId(typeId) { }
+        B getBuffer() const { return _buffer; }
+        B & getBuffer() { return _buffer; }
+        uint32_t getTypeId() const { return _typeId; }
+        void setTypeId(uint32_t typeId) { _typeId = typeId; }
+    private:
+        B          _buffer;
+        uint32_t   _typeId;
+    };
+    std::vector<BufferAndTypeId> _buffers; // For fast mapping with known types
 protected:
     std::vector<uint32_t> _activeBufferIds; // typeId -> active buffer
 
+    void * getBuffer(uint32_t bufferId) { return _buffers[bufferId].getBuffer(); }
     // Hold list at freeze, when knowing how long elements must be held
     class ElemHold2ListElem : public ElemHold1ListElem
     {
     public:
         generation_t _generation;
 
-        ElemHold2ListElem(const ElemHold1ListElem &hold1,
-                          generation_t generation)
+        ElemHold2ListElem(const ElemHold1ListElem &hold1, generation_t generation)
             : ElemHold1ListElem(hold1),
               _generation(generation)
         { }
@@ -66,11 +78,8 @@ protected:
         BufferTypeBase    *_typeHandler;
         uint32_t           _typeId;
 
-        FallbackHold(size_t size,
-                     BufferState::Alloc &&buffer,
-                     size_t usedElems,
-                     BufferTypeBase *typeHandler,
-                     uint32_t typeId);
+        FallbackHold(size_t size, BufferState::Alloc &&buffer, size_t usedElems,
+                     BufferTypeBase *typeHandler, uint32_t typeId);
 
         virtual ~FallbackHold();
     };
@@ -165,7 +174,7 @@ protected:
      * @return			active buffer
      */
     void *activeBuffer(uint32_t typeId) {
-        return _buffers[_activeBufferIds[typeId]];
+        return _buffers[_activeBufferIds[typeId]].getBuffer();
     }
 
     /**
@@ -256,12 +265,12 @@ public:
 
     template <typename EntryType>
     EntryType *getBufferEntry(uint32_t bufferId, uint64_t offset) {
-        return static_cast<EntryType *>(_buffers[bufferId]) + offset;
+        return static_cast<EntryType *>(_buffers[bufferId].getBuffer()) + offset;
     }
 
     template <typename EntryType>
     const EntryType *getBufferEntry(uint32_t bufferId, uint64_t offset) const {
-        return static_cast<const EntryType *>(_buffers[bufferId]) + offset;
+        return static_cast<const EntryType *>(_buffers[bufferId].getBuffer()) + offset;
     }
 
     void dropBuffers();
@@ -308,6 +317,7 @@ public:
      */
     void setInitializing(bool initializing) { _initializing = initializing; }
 
+private:
     /**
      * Switch buffer state to active.
      *
@@ -316,9 +326,9 @@ public:
      * @param sizeNeeded	Number of elements needed to be free
      */
     void onActive(uint32_t bufferId, uint32_t typeId, size_t sizeNeeded);
-
+public:
     uint32_t getTypeId(uint32_t bufferId) const {
-        return _states[bufferId].getTypeId();
+        return _buffers[bufferId].getTypeId();
     }
 
     std::vector<uint32_t> startCompact(uint32_t typeId);