diff options
author | Tor Egge <Tor.Egge@online.no> | 2023-04-03 14:00:07 +0200 |
---|---|---|
committer | Tor Egge <Tor.Egge@online.no> | 2023-04-03 14:35:10 +0200 |
commit | 806854e81621d238bc7390e6fd92ca355d78a177 (patch) | |
tree | a5353749a5b6b669516318ddcd8210874859e93b /vespalib/src | |
parent | 8b01e7c51102866fcb22a44f295ce6c7639b48eb (diff) |
Use ElemT as template parameter for BufferType, SmallArrayBufferType,
LargeArrayBufferType and ArrayStore.
Diffstat (limited to 'vespalib/src')
8 files changed, 112 insertions, 109 deletions
diff --git a/vespalib/src/vespa/vespalib/datastore/array_store.h b/vespalib/src/vespa/vespalib/datastore/array_store.h index c2b65d72f03..2093b7ab923 100644 --- a/vespalib/src/vespa/vespalib/datastore/array_store.h +++ b/vespalib/src/vespa/vespalib/datastore/array_store.h @@ -19,7 +19,7 @@ namespace vespalib::datastore { /** - * Datastore for storing arrays of type EntryT that is accessed via a 32-bit EntryRef. + * Datastore for storing arrays of type ElemT that is accessed via a 32-bit EntryRef. * * The default EntryRef type uses 19 bits for offset (524288 values) and 13 bits for buffer id (8192 buffers). * @@ -29,16 +29,18 @@ namespace vespalib::datastore { * * The max value of maxSmallArrayTypeId is (2^bufferBits - 1). */ -template <typename EntryT, typename RefT = EntryRefT<19>, typename TypeMapperT = ArrayStoreSimpleTypeMapper<EntryT> > +template <typename ElemT, typename RefT = EntryRefT<19>, typename TypeMapperT = ArrayStoreSimpleTypeMapper<ElemT> > class ArrayStore : public ICompactable { public: using AllocSpec = ArrayStoreConfig::AllocSpec; - using ArrayRef = vespalib::ArrayRef<EntryT>; - using ConstArrayRef = vespalib::ConstArrayRef<EntryT>; + using ArrayRef = vespalib::ArrayRef<ElemT>; + using ConstArrayRef = vespalib::ConstArrayRef<ElemT>; using DataStoreType = DataStoreT<RefT>; - using LargeArray = vespalib::Array<EntryT>; + using ElemType = ElemT; + using LargeArray = vespalib::Array<ElemT>; using LargeBufferType = typename TypeMapperT::LargeBufferType; + using RefType = RefT; using SmallBufferType = typename TypeMapperT::SmallBufferType; using TypeMapper = TypeMapperT; private: @@ -58,7 +60,7 @@ private: EntryRef addLargeArray(const ConstArrayRef &array); EntryRef allocate_large_array(size_t array_size); ConstArrayRef getSmallArray(RefT ref, size_t arraySize) const { - const EntryT *buf = _store.template getEntryArray<EntryT>(ref, arraySize); + const ElemT *buf = _store.template getEntryArray<ElemT>(ref, arraySize); return ConstArrayRef(buf, arraySize); } ConstArrayRef getLargeArray(RefT ref) const { @@ -85,7 +87,7 @@ public: } /** - * Allocate an array of the given size without any instantiation of EntryT elements. + * Allocate an array of the given size without any instantiation of ElemT elements. * * Use get_writable() to get a reference to the array for writing. * diff --git a/vespalib/src/vespa/vespalib/datastore/array_store.hpp b/vespalib/src/vespa/vespalib/datastore/array_store.hpp index 301cff1e414..3ccde2e16a9 100644 --- a/vespalib/src/vespa/vespalib/datastore/array_store.hpp +++ b/vespalib/src/vespa/vespalib/datastore/array_store.hpp @@ -15,9 +15,9 @@ namespace vespalib::datastore { -template <typename EntryT, typename RefT, typename TypeMapperT> +template <typename ElemT, typename RefT, typename TypeMapperT> void -ArrayStore<EntryT, RefT, TypeMapperT>::initArrayTypes(const ArrayStoreConfig &cfg, std::shared_ptr<alloc::MemoryAllocator> memory_allocator) +ArrayStore<ElemT, RefT, TypeMapperT>::initArrayTypes(const ArrayStoreConfig &cfg, std::shared_ptr<alloc::MemoryAllocator> memory_allocator) { _largeArrayTypeId = _store.addType(&_largeArrayType); assert(_largeArrayTypeId == 0); @@ -31,14 +31,14 @@ ArrayStore<EntryT, RefT, TypeMapperT>::initArrayTypes(const ArrayStoreConfig &cf } } -template <typename EntryT, typename RefT, typename TypeMapperT> -ArrayStore<EntryT, RefT, TypeMapperT>::ArrayStore(const ArrayStoreConfig &cfg, std::shared_ptr<alloc::MemoryAllocator> memory_allocator) +template <typename ElemT, typename RefT, typename TypeMapperT> +ArrayStore<ElemT, RefT, TypeMapperT>::ArrayStore(const ArrayStoreConfig &cfg, std::shared_ptr<alloc::MemoryAllocator> memory_allocator) : ArrayStore(cfg, memory_allocator, TypeMapper()) { } -template <typename EntryT, typename RefT, typename TypeMapperT> -ArrayStore<EntryT, RefT, TypeMapperT>::ArrayStore(const ArrayStoreConfig &cfg, std::shared_ptr<alloc::MemoryAllocator> memory_allocator, +template <typename ElemT, typename RefT, typename TypeMapperT> +ArrayStore<ElemT, RefT, TypeMapperT>::ArrayStore(const ArrayStoreConfig &cfg, std::shared_ptr<alloc::MemoryAllocator> memory_allocator, TypeMapper&& mapper) : _largeArrayTypeId(0), _maxSmallArrayTypeId(cfg.maxSmallArrayTypeId()), @@ -56,25 +56,25 @@ ArrayStore<EntryT, RefT, TypeMapperT>::ArrayStore(const ArrayStoreConfig &cfg, s } } -template <typename EntryT, typename RefT, typename TypeMapperT> +template <typename ElemT, typename RefT, typename TypeMapperT> vespalib::MemoryUsage -ArrayStore<EntryT, RefT, TypeMapperT>::getMemoryUsage() const { +ArrayStore<ElemT, RefT, TypeMapperT>::getMemoryUsage() const { vespalib::MemoryUsage usage = _store.getMemoryUsage(); usage.incAllocatedBytes(_smallArrayTypes.capacity() * sizeof(SmallBufferType)); usage.incUsedBytes(_smallArrayTypes.size() * sizeof(SmallBufferType)); return usage; } -template <typename EntryT, typename RefT, typename TypeMapperT> -ArrayStore<EntryT, RefT, TypeMapperT>::~ArrayStore() +template <typename ElemT, typename RefT, typename TypeMapperT> +ArrayStore<ElemT, RefT, TypeMapperT>::~ArrayStore() { _store.reclaim_all_memory(); _store.dropBuffers(); } -template <typename EntryT, typename RefT, typename TypeMapperT> +template <typename ElemT, typename RefT, typename TypeMapperT> EntryRef -ArrayStore<EntryT, RefT, TypeMapperT>::add(const ConstArrayRef &array) +ArrayStore<ElemT, RefT, TypeMapperT>::add(const ConstArrayRef &array) { if (array.size() == 0) { return EntryRef(); @@ -86,9 +86,9 @@ ArrayStore<EntryT, RefT, TypeMapperT>::add(const ConstArrayRef &array) } } -template <typename EntryT, typename RefT, typename TypeMapperT> +template <typename ElemT, typename RefT, typename TypeMapperT> EntryRef -ArrayStore<EntryT, RefT, TypeMapperT>::allocate(size_t array_size) +ArrayStore<ElemT, RefT, TypeMapperT>::allocate(size_t array_size) { if (array_size == 0) { return EntryRef(); @@ -100,49 +100,49 @@ ArrayStore<EntryT, RefT, TypeMapperT>::allocate(size_t array_size) } } -template <typename EntryT, typename RefT, typename TypeMapperT> +template <typename ElemT, typename RefT, typename TypeMapperT> EntryRef -ArrayStore<EntryT, RefT, TypeMapperT>::addSmallArray(const ConstArrayRef &array) +ArrayStore<ElemT, RefT, TypeMapperT>::addSmallArray(const ConstArrayRef &array) { uint32_t typeId = _mapper.get_type_id(array.size()); - using NoOpReclaimer = DefaultReclaimer<EntryT>; - return _store.template freeListAllocator<EntryT, NoOpReclaimer>(typeId).allocArray(array).ref; + using NoOpReclaimer = DefaultReclaimer<ElemT>; + return _store.template freeListAllocator<ElemT, NoOpReclaimer>(typeId).allocArray(array).ref; } -template <typename EntryT, typename RefT, typename TypeMapperT> +template <typename ElemT, typename RefT, typename TypeMapperT> EntryRef -ArrayStore<EntryT, RefT, TypeMapperT>::allocate_small_array(size_t array_size) +ArrayStore<ElemT, RefT, TypeMapperT>::allocate_small_array(size_t array_size) { uint32_t type_id = _mapper.get_type_id(array_size); - return _store.template freeListRawAllocator<EntryT>(type_id).alloc(array_size).ref; + return _store.template freeListRawAllocator<ElemT>(type_id).alloc(array_size).ref; } -template <typename EntryT, typename RefT, typename TypeMapperT> +template <typename ElemT, typename RefT, typename TypeMapperT> EntryRef -ArrayStore<EntryT, RefT, TypeMapperT>::addLargeArray(const ConstArrayRef &array) +ArrayStore<ElemT, RefT, TypeMapperT>::addLargeArray(const ConstArrayRef &array) { using NoOpReclaimer = DefaultReclaimer<LargeArray>; auto handle = _store.template freeListAllocator<LargeArray, NoOpReclaimer>(_largeArrayTypeId) .alloc(array.cbegin(), array.cend()); auto& state = _store.getBufferState(RefT(handle.ref).bufferId()); - state.stats().inc_extra_used_bytes(sizeof(EntryT) * array.size()); + state.stats().inc_extra_used_bytes(sizeof(ElemT) * array.size()); return handle.ref; } -template <typename EntryT, typename RefT, typename TypeMapperT> +template <typename ElemT, typename RefT, typename TypeMapperT> EntryRef -ArrayStore<EntryT, RefT, TypeMapperT>::allocate_large_array(size_t array_size) +ArrayStore<ElemT, RefT, TypeMapperT>::allocate_large_array(size_t array_size) { using NoOpReclaimer = DefaultReclaimer<LargeArray>; auto handle = _store.template freeListAllocator<LargeArray, NoOpReclaimer>(_largeArrayTypeId).alloc(array_size); auto& state = _store.getBufferState(RefT(handle.ref).bufferId()); - state.stats().inc_extra_used_bytes(sizeof(EntryT) * array_size); + state.stats().inc_extra_used_bytes(sizeof(ElemT) * array_size); return handle.ref; } -template <typename EntryT, typename RefT, typename TypeMapperT> +template <typename ElemT, typename RefT, typename TypeMapperT> void -ArrayStore<EntryT, RefT, TypeMapperT>::remove(EntryRef ref) +ArrayStore<ElemT, RefT, TypeMapperT>::remove(EntryRef ref) { if (ref.valid()) { RefT internalRef(ref); @@ -151,43 +151,43 @@ ArrayStore<EntryT, RefT, TypeMapperT>::remove(EntryRef ref) size_t arraySize = _mapper.get_array_size(typeId); _store.holdElem(ref, arraySize); } else { - _store.holdElem(ref, 1, sizeof(EntryT) * get(ref).size()); + _store.holdElem(ref, 1, sizeof(ElemT) * get(ref).size()); } } } -template <typename EntryT, typename RefT, typename TypeMapperT> +template <typename ElemT, typename RefT, typename TypeMapperT> EntryRef -ArrayStore<EntryT, RefT, TypeMapperT>::move_on_compact(EntryRef ref) +ArrayStore<ElemT, RefT, TypeMapperT>::move_on_compact(EntryRef ref) { return add(get(ref)); } -template <typename EntryT, typename RefT, typename TypeMapperT> +template <typename ElemT, typename RefT, typename TypeMapperT> ICompactionContext::UP -ArrayStore<EntryT, RefT, TypeMapperT>::compact_worst(const CompactionStrategy &compaction_strategy) +ArrayStore<ElemT, RefT, TypeMapperT>::compact_worst(const CompactionStrategy &compaction_strategy) { auto compacting_buffers = _store.start_compact_worst_buffers(_compaction_spec, compaction_strategy); return std::make_unique<CompactionContext>(*this, std::move(compacting_buffers)); } -template <typename EntryT, typename RefT, typename TypeMapperT> +template <typename ElemT, typename RefT, typename TypeMapperT> std::unique_ptr<CompactingBuffers> -ArrayStore<EntryT, RefT, TypeMapperT>::start_compact_worst_buffers(const CompactionStrategy &compaction_strategy) +ArrayStore<ElemT, RefT, TypeMapperT>::start_compact_worst_buffers(const CompactionStrategy &compaction_strategy) { return _store.start_compact_worst_buffers(_compaction_spec, compaction_strategy); } -template <typename EntryT, typename RefT, typename TypeMapperT> +template <typename ElemT, typename RefT, typename TypeMapperT> vespalib::AddressSpace -ArrayStore<EntryT, RefT, TypeMapperT>::addressSpaceUsage() const +ArrayStore<ElemT, RefT, TypeMapperT>::addressSpaceUsage() const { return _store.getAddressSpaceUsage(); } -template <typename EntryT, typename RefT, typename TypeMapperT> +template <typename ElemT, typename RefT, typename TypeMapperT> vespalib::MemoryUsage -ArrayStore<EntryT, RefT, TypeMapperT>::update_stat(const CompactionStrategy& compaction_strategy) +ArrayStore<ElemT, RefT, TypeMapperT>::update_stat(const CompactionStrategy& compaction_strategy) { auto address_space_usage = _store.getAddressSpaceUsage(); auto memory_usage = getMemoryUsage(); @@ -195,17 +195,17 @@ ArrayStore<EntryT, RefT, TypeMapperT>::update_stat(const CompactionStrategy& com return memory_usage; } -template <typename EntryT, typename RefT, typename TypeMapperT> +template <typename ElemT, typename RefT, typename TypeMapperT> const BufferState & -ArrayStore<EntryT, RefT, TypeMapperT>::bufferState(EntryRef ref) +ArrayStore<ElemT, RefT, TypeMapperT>::bufferState(EntryRef ref) { RefT internalRef(ref); return _store.getBufferState(internalRef.bufferId()); } -template <typename EntryT, typename RefT, typename TypeMapperT> +template <typename ElemT, typename RefT, typename TypeMapperT> ArrayStoreConfig -ArrayStore<EntryT, RefT, TypeMapperT>::optimizedConfigForHugePage(uint32_t maxSmallArrayTypeId, +ArrayStore<ElemT, RefT, TypeMapperT>::optimizedConfigForHugePage(uint32_t maxSmallArrayTypeId, size_t hugePageSize, size_t smallPageSize, size_t minNumArraysForNewBuffer, @@ -220,9 +220,9 @@ ArrayStore<EntryT, RefT, TypeMapperT>::optimizedConfigForHugePage(uint32_t maxSm allocGrowFactor); } -template <typename EntryT, typename RefT, typename TypeMapperT> +template <typename ElemT, typename RefT, typename TypeMapperT> ArrayStoreConfig -ArrayStore<EntryT, RefT, TypeMapperT>::optimizedConfigForHugePage(uint32_t maxSmallArrayTypeId, +ArrayStore<ElemT, RefT, TypeMapperT>::optimizedConfigForHugePage(uint32_t maxSmallArrayTypeId, const TypeMapper& mapper, size_t hugePageSize, size_t smallPageSize, @@ -233,7 +233,7 @@ ArrayStore<EntryT, RefT, TypeMapperT>::optimizedConfigForHugePage(uint32_t maxSm [&](uint32_t type_id) noexcept { return mapper.get_array_size(type_id); }, hugePageSize, smallPageSize, - sizeof(EntryT), + sizeof(ElemT), RefT::offsetSize(), minNumArraysForNewBuffer, allocGrowFactor); diff --git a/vespalib/src/vespa/vespalib/datastore/buffer_type.h b/vespalib/src/vespa/vespalib/datastore/buffer_type.h index bedbb2c984e..625ad147d36 100644 --- a/vespalib/src/vespa/vespalib/datastore/buffer_type.h +++ b/vespalib/src/vespa/vespalib/datastore/buffer_type.h @@ -126,13 +126,16 @@ protected: }; /** - * Concrete class used to manage allocation and de-allocation of elements of type EntryType in data store buffers. + * Concrete class used to manage allocation and de-allocation of elements of type ElemType in data store buffers. */ -template <typename EntryType, typename EmptyType = EntryType> +template <typename ElemT, typename EmptyT = ElemT> class BufferType : public BufferTypeBase { +public: + using ElemType = ElemT; + using EmptyType = EmptyT; protected: - static const EntryType& empty_entry() noexcept; + static const ElemType& empty_entry() noexcept; public: BufferType() noexcept : BufferType(1,1,1) {} @@ -148,7 +151,7 @@ public: void fallbackCopy(void *newBuffer, const void *oldBuffer, ElemCount numElems) override; void initializeReservedElements(void *buffer, ElemCount reservedElements) override; void cleanHold(void *buffer, size_t offset, ElemCount numElems, CleanContext cleanCxt) override; - size_t elementSize() const override { return sizeof(EntryType); } + size_t elementSize() const override { return sizeof(ElemType); } }; extern template class BufferType<char>; diff --git a/vespalib/src/vespa/vespalib/datastore/buffer_type.hpp b/vespalib/src/vespa/vespalib/datastore/buffer_type.hpp index 72c8f574a70..504194e1791 100644 --- a/vespalib/src/vespa/vespalib/datastore/buffer_type.hpp +++ b/vespalib/src/vespa/vespalib/datastore/buffer_type.hpp @@ -6,63 +6,61 @@ namespace vespalib::datastore { -template <typename EntryType, typename EmptyType> -BufferType<EntryType, EmptyType>::BufferType(uint32_t arraySize, uint32_t minArrays, uint32_t maxArrays) noexcept +template <typename ElemT, typename EmptyT> +BufferType<ElemT, EmptyT>::BufferType(uint32_t arraySize, uint32_t minArrays, uint32_t maxArrays) noexcept : BufferTypeBase(arraySize, minArrays, maxArrays) { } -template <typename EntryType, typename EmptyType> -BufferType<EntryType, EmptyType>::BufferType(uint32_t arraySize, uint32_t minArrays, uint32_t maxArrays, +template <typename ElemT, typename EmptyT> +BufferType<ElemT, EmptyT>::BufferType(uint32_t arraySize, uint32_t minArrays, uint32_t maxArrays, uint32_t numArraysForNewBuffer, float allocGrowFactor) noexcept : BufferTypeBase(arraySize, minArrays, maxArrays, numArraysForNewBuffer, allocGrowFactor) { } -template <typename EntryType, typename EmptyType> -BufferType<EntryType, EmptyType>::~BufferType() = default; +template <typename ElemT, typename EmptyT> +BufferType<ElemT, EmptyT>::~BufferType() = default; -template <typename EntryType, typename EmptyType> +template <typename ElemT, typename EmptyT> void -BufferType<EntryType, EmptyType>::destroyElements(void *buffer, ElemCount numElems) +BufferType<ElemT, EmptyT>::destroyElements(void *buffer, ElemCount numElems) { - EntryType *e = static_cast<EntryType *>(buffer); + ElemType *e = static_cast<ElemType *>(buffer); for (size_t j = numElems; j != 0; --j) { - e->~EntryType(); + e->~ElemType(); ++e; } } -template <typename EntryType, typename EmptyType> +template <typename ElemT, typename EmptyT> void -BufferType<EntryType, EmptyType>::fallbackCopy(void *newBuffer, - const void *oldBuffer, - ElemCount numElems) +BufferType<ElemT, EmptyT>::fallbackCopy(void *newBuffer, const void *oldBuffer, ElemCount numElems) { - EntryType *d = static_cast<EntryType *>(newBuffer); - const EntryType *s = static_cast<const EntryType *>(oldBuffer); + ElemType *d = static_cast<ElemType *>(newBuffer); + const ElemType *s = static_cast<const ElemType *>(oldBuffer); for (size_t j = numElems; j != 0; --j) { - new (static_cast<void *>(d)) EntryType(*s); + new (static_cast<void *>(d)) ElemType(*s); ++s; ++d; } } -template <typename EntryType, typename EmptyType> +template <typename ElemT, typename EmptyT> void -BufferType<EntryType, EmptyType>::initializeReservedElements(void *buffer, ElemCount reservedElems) +BufferType<ElemT, EmptyT>::initializeReservedElements(void *buffer, ElemCount reservedElems) { - EntryType *e = static_cast<EntryType *>(buffer); + ElemType *e = static_cast<ElemType *>(buffer); const auto& empty = empty_entry(); for (size_t j = reservedElems; j != 0; --j) { - new (static_cast<void *>(e)) EntryType(empty); + new (static_cast<void *>(e)) ElemType(empty); ++e; } } -template <typename EntryType, typename EmptyType> +template <typename ElemT, typename EmptyT> void -BufferType<EntryType, EmptyType>::cleanHold(void *buffer, size_t offset, ElemCount numElems, CleanContext) +BufferType<ElemT, EmptyT>::cleanHold(void *buffer, size_t offset, ElemCount numElems, CleanContext) { - EntryType *e = static_cast<EntryType *>(buffer) + offset; + ElemType *e = static_cast<ElemType *>(buffer) + offset; const auto& empty = empty_entry(); for (size_t j = numElems; j != 0; --j) { *e = empty; @@ -70,14 +68,14 @@ BufferType<EntryType, EmptyType>::cleanHold(void *buffer, size_t offset, ElemCou } } -template <typename EntryType, typename EmptyType> -const EntryType& -BufferType<EntryType, EmptyType>::empty_entry() noexcept +template <typename ElemT, typename EmptyT> +const ElemT& +BufferType<ElemT, EmptyT>::empty_entry() noexcept { - // It's possible for EntryType to wrap e.g. an Alloc instance, which has a transitive + // It's possible for ElemType to wrap e.g. an Alloc instance, which has a transitive // dependency on globally constructed allocator object(s). To avoid issues with global // construction order, initialize the sentinel on the first access. - static EntryType empty = EmptyType(); + static ElemType empty = EmptyType(); return empty; } diff --git a/vespalib/src/vespa/vespalib/datastore/large_array_buffer_type.h b/vespalib/src/vespa/vespalib/datastore/large_array_buffer_type.h index 600925969a3..6fd5d694fb1 100644 --- a/vespalib/src/vespa/vespalib/datastore/large_array_buffer_type.h +++ b/vespalib/src/vespa/vespalib/datastore/large_array_buffer_type.h @@ -14,11 +14,11 @@ namespace vespalib::datastore { /* * Class representing buffer type for large arrays in ArrayStore */ -template <typename EntryT> -class LargeArrayBufferType : public BufferType<Array<EntryT>> +template <typename ElemT> +class LargeArrayBufferType : public BufferType<Array<ElemT>> { using AllocSpec = ArrayStoreConfig::AllocSpec; - using ArrayType = Array<EntryT>; + using ArrayType = Array<ElemT>; using ParentType = BufferType<ArrayType>; using ParentType::empty_entry; using CleanContext = typename ParentType::CleanContext; diff --git a/vespalib/src/vespa/vespalib/datastore/large_array_buffer_type.hpp b/vespalib/src/vespa/vespalib/datastore/large_array_buffer_type.hpp index 3042bbff73f..102c13ef1cc 100644 --- a/vespalib/src/vespa/vespalib/datastore/large_array_buffer_type.hpp +++ b/vespalib/src/vespa/vespalib/datastore/large_array_buffer_type.hpp @@ -7,32 +7,32 @@ namespace vespalib::datastore { -template <typename EntryT> -LargeArrayBufferType<EntryT>::LargeArrayBufferType(const AllocSpec& spec, std::shared_ptr<alloc::MemoryAllocator> memory_allocator) noexcept - : BufferType<Array<EntryT>>(1u, spec.minArraysInBuffer, spec.maxArraysInBuffer, spec.numArraysForNewBuffer, spec.allocGrowFactor), +template <typename ElemT> +LargeArrayBufferType<ElemT>::LargeArrayBufferType(const AllocSpec& spec, std::shared_ptr<alloc::MemoryAllocator> memory_allocator) noexcept + : BufferType<Array<ElemT>>(1u, spec.minArraysInBuffer, spec.maxArraysInBuffer, spec.numArraysForNewBuffer, spec.allocGrowFactor), _memory_allocator(std::move(memory_allocator)) { } -template <typename EntryT> -LargeArrayBufferType<EntryT>::~LargeArrayBufferType() = default; +template <typename ElemT> +LargeArrayBufferType<ElemT>::~LargeArrayBufferType() = default; -template <typename EntryT> +template <typename ElemT> void -LargeArrayBufferType<EntryT>::cleanHold(void* buffer, size_t offset, ElemCount numElems, CleanContext cleanCtx) +LargeArrayBufferType<ElemT>::cleanHold(void* buffer, size_t offset, ElemCount numElems, CleanContext cleanCtx) { ArrayType* elem = static_cast<ArrayType*>(buffer) + offset; const auto& empty = empty_entry(); for (size_t i = 0; i < numElems; ++i) { - cleanCtx.extraBytesCleaned(sizeof(EntryT) * elem->size()); + cleanCtx.extraBytesCleaned(sizeof(ElemT) * elem->size()); *elem = empty; ++elem; } } -template <typename EntryT> +template <typename ElemT> const vespalib::alloc::MemoryAllocator* -LargeArrayBufferType<EntryT>::get_memory_allocator() const +LargeArrayBufferType<ElemT>::get_memory_allocator() const { return _memory_allocator.get(); } diff --git a/vespalib/src/vespa/vespalib/datastore/small_array_buffer_type.h b/vespalib/src/vespa/vespalib/datastore/small_array_buffer_type.h index 676a9d3790f..6bb6601839d 100644 --- a/vespalib/src/vespa/vespalib/datastore/small_array_buffer_type.h +++ b/vespalib/src/vespa/vespalib/datastore/small_array_buffer_type.h @@ -13,8 +13,8 @@ namespace vespalib::datastore { /* * Class representing buffer type for small arrays in ArrayStore */ -template <typename EntryT> -class SmallArrayBufferType : public BufferType<EntryT> +template <typename ElemT> +class SmallArrayBufferType : public BufferType<ElemT> { using AllocSpec = ArrayStoreConfig::AllocSpec; std::shared_ptr<alloc::MemoryAllocator> _memory_allocator; diff --git a/vespalib/src/vespa/vespalib/datastore/small_array_buffer_type.hpp b/vespalib/src/vespa/vespalib/datastore/small_array_buffer_type.hpp index 414804417eb..b38d8f84275 100644 --- a/vespalib/src/vespa/vespalib/datastore/small_array_buffer_type.hpp +++ b/vespalib/src/vespa/vespalib/datastore/small_array_buffer_type.hpp @@ -6,19 +6,19 @@ namespace vespalib::datastore { -template <typename EntryT> -SmallArrayBufferType<EntryT>::SmallArrayBufferType(uint32_t array_size, const AllocSpec& spec, std::shared_ptr<alloc::MemoryAllocator> memory_allocator) noexcept - : BufferType<EntryT>(array_size, spec.minArraysInBuffer, spec.maxArraysInBuffer, spec.numArraysForNewBuffer, spec.allocGrowFactor), +template <typename ElemT> +SmallArrayBufferType<ElemT>::SmallArrayBufferType(uint32_t array_size, const AllocSpec& spec, std::shared_ptr<alloc::MemoryAllocator> memory_allocator) noexcept + : BufferType<ElemT>(array_size, spec.minArraysInBuffer, spec.maxArraysInBuffer, spec.numArraysForNewBuffer, spec.allocGrowFactor), _memory_allocator(std::move(memory_allocator)) { } -template <typename EntryT> -SmallArrayBufferType<EntryT>::~SmallArrayBufferType() = default; +template <typename ElemT> +SmallArrayBufferType<ElemT>::~SmallArrayBufferType() = default; -template <typename EntryT> +template <typename ElemT> const vespalib::alloc::MemoryAllocator* -SmallArrayBufferType<EntryT>::get_memory_allocator() const +SmallArrayBufferType<ElemT>::get_memory_allocator() const { return _memory_allocator.get(); } |