Merge pull request #27484 from vespa-engine/toregge/rename-max-small-array-type-id-to-max-type-id

Rename maxSmallArrayTypeId to max_type_id.

13 files changed, 45 insertions, 45 deletions

diff --git a/searchlib/src/tests/tensor/tensor_buffer_type_mapper/tensor_buffer_type_mapper_test.cpp b/searchlib/src/tests/tensor/tensor_buffer_type_mapper/tensor_buffer_type_mapper_test.cpp
index 17612f08271..08c0901de01 100644
--- a/searchlib/src/tests/tensor/tensor_buffer_type_mapper/tensor_buffer_type_mapper_test.cpp
+++ b/searchlib/src/tests/tensor/tensor_buffer_type_mapper/tensor_buffer_type_mapper_test.cpp
@@ -153,7 +153,7 @@ TEST_P(TensorBufferTypeMapperTest, large_arrays_grows_exponentially)
 TEST_P(TensorBufferTypeMapperTest, avoid_array_size_overflow)
 {
     TensorBufferTypeMapper mapper(400, 2.0, &_ops);
-    EXPECT_GE(30, mapper.get_max_small_array_type_id(1000));
+    EXPECT_GE(30, mapper.get_max_type_id(1000));
 }
 
 GTEST_MAIN_RUN_ALL_TESTS()
diff --git a/searchlib/src/vespa/searchlib/attribute/multi_value_mapping.hpp b/searchlib/src/vespa/searchlib/attribute/multi_value_mapping.hpp
index ab1f32e8dc2..99808b11e92 100644
--- a/searchlib/src/vespa/searchlib/attribute/multi_value_mapping.hpp
+++ b/searchlib/src/vespa/searchlib/attribute/multi_value_mapping.hpp
@@ -12,7 +12,7 @@ MultiValueMapping<ElemT,RefT>::MultiValueMapping(const vespalib::datastore::Arra
                                                   const vespalib::GrowStrategy &gs,
                                                   std::shared_ptr<vespalib::alloc::MemoryAllocator> memory_allocator)
   : MultiValueMappingBase(gs, ArrayStore::getGenerationHolderLocation(_store), memory_allocator),
-    _store(storeCfg, std::move(memory_allocator), ArrayStoreTypeMapper(storeCfg.maxSmallArrayTypeId(), array_store_grow_factor))
+    _store(storeCfg, std::move(memory_allocator), ArrayStoreTypeMapper(storeCfg.max_type_id(), array_store_grow_factor))
 {
 }
 
diff --git a/searchlib/src/vespa/searchlib/tensor/hnsw_nodeid_mapping.cpp b/searchlib/src/vespa/searchlib/tensor/hnsw_nodeid_mapping.cpp
index a908ebd7210..a78d9cefc64 100644
--- a/searchlib/src/vespa/searchlib/tensor/hnsw_nodeid_mapping.cpp
+++ b/searchlib/src/vespa/searchlib/tensor/hnsw_nodeid_mapping.cpp
@@ -12,7 +12,7 @@ using vespalib::datastore::EntryRef;
 
 namespace {
 
-constexpr uint32_t max_small_array_type_id = 64;
+constexpr uint32_t max_type_id = 64;
 constexpr size_t min_num_arrays_for_new_buffer = 512_Ki;
 constexpr float alloc_grow_factor = 0.3;
 
@@ -46,7 +46,7 @@ HnswNodeidMapping::HnswNodeidMapping()
     : _refs(1),
       _grow_strategy(16, 1.0, 0, 0), // These are the same parameters as the default in rcuvector.h
       _nodeid_limit(1), // Starting with nodeid=1 matches that we also start with docid=1.
-      _nodeids(NodeidStore::optimizedConfigForHugePage(max_small_array_type_id,
+      _nodeids(NodeidStore::optimizedConfigForHugePage(max_type_id,
                                                        vespalib::alloc::MemoryAllocator::HUGEPAGE_SIZE,
                                                        vespalib::alloc::MemoryAllocator::PAGE_SIZE,
                                                        min_num_arrays_for_new_buffer,
diff --git a/vespalib/src/tests/datastore/array_store/array_store_test.cpp b/vespalib/src/tests/datastore/array_store/array_store_test.cpp
index c9f1230346c..e21674e9436 100644
--- a/vespalib/src/tests/datastore/array_store/array_store_test.cpp
+++ b/vespalib/src/tests/datastore/array_store/array_store_test.cpp
@@ -74,7 +74,7 @@ struct ArrayStoreTest : public TestT
           type_mapper_grow_factor(type_mapper_grow_factor_in)
     {}
     explicit ArrayStoreTest(const ArrayStoreConfig &storeCfg)
-        : type_mapper(storeCfg.maxSmallArrayTypeId(), 2.0),
+        : type_mapper(storeCfg.max_type_id(), 2.0),
           store(storeCfg, std::make_unique<MemoryAllocatorObserver>(stats), TypeMapperType(type_mapper)),
           refStore(),
           generation(1),
@@ -290,7 +290,7 @@ TYPED_TEST(NumberStoreTest, control_type_mapper)
     if constexpr (TestFixture::simple_type_mapper) {
         GTEST_SKIP() << "Skipping test due to using simple type mapper";
     } else {
-        EXPECT_EQ(3, this->type_mapper.get_max_small_array_type_id(1000));
+        EXPECT_EQ(3, this->type_mapper.get_max_type_id(1000));
         EXPECT_FALSE(this->type_mapper.is_dynamic_buffer(0));
         EXPECT_FALSE(this->type_mapper.is_dynamic_buffer(1));
         EXPECT_EQ(1, this->type_mapper.get_array_size(1));
diff --git a/vespalib/src/tests/datastore/array_store_config/array_store_config_test.cpp b/vespalib/src/tests/datastore/array_store_config/array_store_config_test.cpp
index 16abd065a55..71c1341ae74 100644
--- a/vespalib/src/tests/datastore/array_store_config/array_store_config_test.cpp
+++ b/vespalib/src/tests/datastore/array_store_config/array_store_config_test.cpp
@@ -15,15 +15,15 @@ struct Fixture
     using EntryRefType = EntryRefT<18>;
     ArrayStoreConfig cfg;
 
-    Fixture(uint32_t maxSmallArrayTypeId,
+    Fixture(uint32_t max_type_id,
             const AllocSpec &defaultSpec)
-        : cfg(maxSmallArrayTypeId, defaultSpec) {}
+        : cfg(max_type_id, defaultSpec) {}
 
-    Fixture(uint32_t maxSmallArrayTypeId,
+    Fixture(uint32_t max_type_id,
             size_t hugePageSize,
             size_t smallPageSize,
             size_t min_num_entries_for_new_buffer)
-        : cfg(ArrayStoreConfig::optimizeForHugePage(maxSmallArrayTypeId,
+        : cfg(ArrayStoreConfig::optimizeForHugePage(max_type_id,
                                                     [](size_t type_id) noexcept { return type_id * sizeof(int); },
                                                     hugePageSize, smallPageSize,
                                                     EntryRefType::offsetSize(),
@@ -55,7 +55,7 @@ constexpr size_t MB = KB * KB;
 
 TEST_F("require that default allocation spec is given for all array sizes", Fixture(3, makeSpec(4, 32, 8)))
 {
-    EXPECT_EQUAL(3u, f.cfg.maxSmallArrayTypeId());
+    EXPECT_EQUAL(3u, f.cfg.max_type_id());
     TEST_DO(f.assertSpec(0, makeSpec(4, 32, 8)));
     TEST_DO(f.assertSpec(1, makeSpec(4, 32, 8)));
     TEST_DO(f.assertSpec(2, makeSpec(4, 32, 8)));
@@ -67,7 +67,7 @@ TEST_F("require that we can generate config optimized for a given huge page", Fi
                                                                                       4 * KB,
                                                                                       8 * KB))
 {
-    EXPECT_EQUAL(1_Ki, f.cfg.maxSmallArrayTypeId());
+    EXPECT_EQUAL(1_Ki, f.cfg.max_type_id());
     TEST_DO(f.assertSpec(0, 8 * KB)); // large arrays
     TEST_DO(f.assertSpec(1, 256 * KB));
     TEST_DO(f.assertSpec(2, 256 * KB));
diff --git a/vespalib/src/tests/datastore/array_store_dynamic_type_mapper/array_store_dynamic_type_mapper_test.cpp b/vespalib/src/tests/datastore/array_store_dynamic_type_mapper/array_store_dynamic_type_mapper_test.cpp
index 86b80aaa695..7ead0b97269 100644
--- a/vespalib/src/tests/datastore/array_store_dynamic_type_mapper/array_store_dynamic_type_mapper_test.cpp
+++ b/vespalib/src/tests/datastore/array_store_dynamic_type_mapper/array_store_dynamic_type_mapper_test.cpp
@@ -111,7 +111,7 @@ uint32_t
 TestBase<ElemT>::calc_max_buffer_type_id(double grow_factor)
 {
     ArrayStoreDynamicTypeMapper<ElemT> mapper(1000, grow_factor);
-    return mapper.get_max_small_array_type_id(1000);
+    return mapper.get_max_type_id(1000);
 }
 
 using ArrayStoreDynamicTypeMapperCharTest = TestBase<char>;
diff --git a/vespalib/src/vespa/vespalib/datastore/array_store.h b/vespalib/src/vespa/vespalib/datastore/array_store.h
index 31b06b1f869..bff3a5cc5b2 100644
--- a/vespalib/src/vespa/vespalib/datastore/array_store.h
+++ b/vespalib/src/vespa/vespalib/datastore/array_store.h
@@ -26,7 +26,7 @@ namespace vespalib::datastore {
  * The default EntryRef type uses 19 bits for offset (524288 values) and 13
  * bits for buffer id (8192 buffers).
  *
- * Buffer type ids [1,maxSmallArrayTypeId] are used to allocate small
+ * Buffer type ids [1,max_type_id] are used to allocate small
  * arrays in datastore buffers.
  *
  * The simple type mapper (ArrayStoreSimpleTypeMapper) uses a 1-to-1
@@ -40,7 +40,7 @@ namespace vespalib::datastore {
  * Buffer type id 0 is used to heap allocate large arrays as
  * vespalib::Array instances.
  *
- * The max value of maxSmallArrayTypeId is (2^(bufferBits - 3) - 1).
+ * The max value of max_type_id is (2^(bufferBits - 3) - 1).
  */
 template <typename ElemT, typename RefT = EntryRefT<19>, typename TypeMapperT = ArrayStoreSimpleTypeMapper<ElemT> >
 class ArrayStore : public ICompactable
@@ -74,7 +74,7 @@ public:
     using DynamicBufferTypeVector = typename check_dynamic_buffer_type_member<TypeMapper>::vector_type;
 private:
     uint32_t                     _largeArrayTypeId;
-    uint32_t                     _maxSmallArrayTypeId;
+    uint32_t                     _max_type_id;
     size_t                       _maxSmallArraySize;
     DataStoreType                _store;
     TypeMapper                   _mapper;
@@ -193,13 +193,13 @@ public:
 
     const TypeMapper& get_mapper() const noexcept { return _mapper; }
 
-    static ArrayStoreConfig optimizedConfigForHugePage(uint32_t maxSmallArrayTypeId,
+    static ArrayStoreConfig optimizedConfigForHugePage(uint32_t max_type_id,
                                                        size_t hugePageSize,
                                                        size_t smallPageSize,
                                                        size_t min_num_entries_for_new_buffer,
                                                        float allocGrowFactor);
 
-    static ArrayStoreConfig optimizedConfigForHugePage(uint32_t maxSmallArrayTypeId,
+    static ArrayStoreConfig optimizedConfigForHugePage(uint32_t max_type_id,
                                                        const TypeMapper& mapper,
                                                        size_t hugePageSize,
                                                        size_t smallPageSize,
diff --git a/vespalib/src/vespa/vespalib/datastore/array_store.hpp b/vespalib/src/vespa/vespalib/datastore/array_store.hpp
index 8957e1f60aa..211176b8ad0 100644
--- a/vespalib/src/vespa/vespalib/datastore/array_store.hpp
+++ b/vespalib/src/vespa/vespalib/datastore/array_store.hpp
@@ -35,15 +35,15 @@ ArrayStore<ElemT, RefT, TypeMapperT>::initArrayTypes(const ArrayStoreConfig &cfg
 {
     _largeArrayTypeId = _store.addType(&_largeArrayType);
     assert(_largeArrayTypeId == 0);
-    _smallArrayTypes.reserve(_maxSmallArrayTypeId);
+    _smallArrayTypes.reserve(_max_type_id);
     if constexpr (has_dynamic_buffer_type) {
-        auto dynamic_buffer_types = _mapper.count_dynamic_buffer_types(_maxSmallArrayTypeId);
-        _smallArrayTypes.reserve(_maxSmallArrayTypeId - dynamic_buffer_types);
+        auto dynamic_buffer_types = _mapper.count_dynamic_buffer_types(_max_type_id);
+        _smallArrayTypes.reserve(_max_type_id - dynamic_buffer_types);
         _dynamicArrayTypes.reserve(dynamic_buffer_types);
      } else {
-        _smallArrayTypes.reserve(_maxSmallArrayTypeId);
+        _smallArrayTypes.reserve(_max_type_id);
     }
-    for (uint32_t type_id = 1; type_id <= _maxSmallArrayTypeId; ++type_id) {
+    for (uint32_t type_id = 1; type_id <= _max_type_id; ++type_id) {
         uint32_t act_type_id = _store.addType(initArrayType(cfg, memory_allocator, type_id));
         assert(type_id == act_type_id);
     }
@@ -59,8 +59,8 @@ 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()),
-      _maxSmallArraySize(mapper.get_array_size(_maxSmallArrayTypeId)),
+      _max_type_id(cfg.max_type_id()),
+      _maxSmallArraySize(mapper.get_array_size(_max_type_id)),
       _store(),
       _mapper(std::move(mapper)),
       _smallArrayTypes(),
@@ -249,14 +249,14 @@ ArrayStore<ElemT, RefT, TypeMapperT>::bufferState(EntryRef ref)
 
 template <typename ElemT, typename RefT, typename TypeMapperT>
 ArrayStoreConfig
-ArrayStore<ElemT, RefT, TypeMapperT>::optimizedConfigForHugePage(uint32_t maxSmallArrayTypeId,
-                                                                  size_t hugePageSize,
-                                                                  size_t smallPageSize,
-                                                                  size_t min_num_entries_for_new_buffer,
-                                                                  float allocGrowFactor)
+ArrayStore<ElemT, RefT, TypeMapperT>::optimizedConfigForHugePage(uint32_t max_type_id,
+                                                                 size_t hugePageSize,
+                                                                 size_t smallPageSize,
+                                                                 size_t min_num_entries_for_new_buffer,
+                                                                 float allocGrowFactor)
 {
     TypeMapper mapper;
-    return optimizedConfigForHugePage(maxSmallArrayTypeId,
+    return optimizedConfigForHugePage(max_type_id,
                                       mapper,
                                       hugePageSize,
                                       smallPageSize,
@@ -266,14 +266,14 @@ ArrayStore<ElemT, RefT, TypeMapperT>::optimizedConfigForHugePage(uint32_t maxSma
 
 template <typename ElemT, typename RefT, typename TypeMapperT>
 ArrayStoreConfig
-ArrayStore<ElemT, RefT, TypeMapperT>::optimizedConfigForHugePage(uint32_t maxSmallArrayTypeId,
+ArrayStore<ElemT, RefT, TypeMapperT>::optimizedConfigForHugePage(uint32_t max_type_id,
                                                                   const TypeMapper& mapper,
                                                                   size_t hugePageSize,
                                                                   size_t smallPageSize,
                                                                   size_t min_num_entries_for_new_buffer,
                                                                   float allocGrowFactor)
 {
-    return ArrayStoreConfig::optimizeForHugePage(mapper.get_max_small_array_type_id(maxSmallArrayTypeId),
+    return ArrayStoreConfig::optimizeForHugePage(mapper.get_max_type_id(max_type_id),
                                                  [&](uint32_t type_id) noexcept { return mapper.get_entry_size(type_id); },
                                                  hugePageSize,
                                                  smallPageSize,
diff --git a/vespalib/src/vespa/vespalib/datastore/array_store_config.cpp b/vespalib/src/vespa/vespalib/datastore/array_store_config.cpp
index ee81938b49d..c7f0b69a85e 100644
--- a/vespalib/src/vespa/vespalib/datastore/array_store_config.cpp
+++ b/vespalib/src/vespa/vespalib/datastore/array_store_config.cpp
@@ -5,11 +5,11 @@
 
 namespace vespalib::datastore {
 
-ArrayStoreConfig::ArrayStoreConfig(uint32_t maxSmallArrayTypeId, const AllocSpec &defaultSpec)
+ArrayStoreConfig::ArrayStoreConfig(uint32_t max_type_id, const AllocSpec &defaultSpec)
     : _allocSpecs(),
       _enable_free_lists(false)
 {
-    for (uint32_t type_id = 0; type_id < (maxSmallArrayTypeId + 1); ++type_id) {
+    for (uint32_t type_id = 0; type_id < (max_type_id + 1); ++type_id) {
         _allocSpecs.push_back(defaultSpec);
     }
 }
@@ -45,7 +45,7 @@ alignToSmallPageSize(size_t value, size_t minLimit, size_t smallPageSize)
 }
 
 ArrayStoreConfig
-ArrayStoreConfig::optimizeForHugePage(uint32_t maxSmallArrayTypeId,
+ArrayStoreConfig::optimizeForHugePage(uint32_t max_type_id,
                                       std::function<size_t(uint32_t)> type_id_to_entry_size,
                                       size_t hugePageSize,
                                       size_t smallPageSize,
@@ -55,7 +55,7 @@ ArrayStoreConfig::optimizeForHugePage(uint32_t maxSmallArrayTypeId,
 {
     AllocSpecVector allocSpecs;
     allocSpecs.emplace_back(0, maxEntryRefOffset, min_num_entries_for_new_buffer, allocGrowFactor); // large array spec;
-    for (uint32_t type_id = 1; type_id <= maxSmallArrayTypeId; ++type_id) {
+    for (uint32_t type_id = 1; type_id <= max_type_id; ++type_id) {
         size_t entry_size = type_id_to_entry_size(type_id);
         size_t num_entries_for_new_buffer = hugePageSize / entry_size;
         num_entries_for_new_buffer = capToLimits(num_entries_for_new_buffer, min_num_entries_for_new_buffer, maxEntryRefOffset);
diff --git a/vespalib/src/vespa/vespalib/datastore/array_store_config.h b/vespalib/src/vespa/vespalib/datastore/array_store_config.h
index d581e5958f0..3b62609d0f1 100644
--- a/vespalib/src/vespa/vespalib/datastore/array_store_config.h
+++ b/vespalib/src/vespa/vespalib/datastore/array_store_config.h
@@ -52,12 +52,12 @@ private:
 
 public:
     /**
-     * Setup an array store where buffer type ids [1-maxSmallArrayTypeId] are used to allocate small arrays in datastore buffers
+     * Setup an array store where buffer type ids [1-max_type_id] are used to allocate small arrays in datastore buffers
      * with the given default allocation spec. Larger arrays are heap allocated.
      */
-    ArrayStoreConfig(uint32_t maxSmallArrayTypeId, const AllocSpec &defaultSpec);
+    ArrayStoreConfig(uint32_t max_type_id, const AllocSpec &defaultSpec);
 
-    uint32_t maxSmallArrayTypeId() const { return _allocSpecs.size() - 1; }
+    uint32_t max_type_id() const { return _allocSpecs.size() - 1; }
     const AllocSpec &spec_for_type_id(uint32_t type_id) const;
     ArrayStoreConfig& enable_free_lists(bool enable) & noexcept {
         _enable_free_lists = enable;
@@ -72,7 +72,7 @@ public:
     /**
      * Generate a config that is optimized for the given memory huge page size.
      */
-    static ArrayStoreConfig optimizeForHugePage(uint32_t maxSmallArrayTypeId,
+    static ArrayStoreConfig optimizeForHugePage(uint32_t max_type_id,
                                                 std::function<size_t(uint32_t)> type_id_to_entry_size,
                                                 size_t hugePageSize,
                                                 size_t smallPageSize,
diff --git a/vespalib/src/vespa/vespalib/datastore/array_store_simple_type_mapper.h b/vespalib/src/vespa/vespalib/datastore/array_store_simple_type_mapper.h
index e43ee704071..314ef3c8aca 100644
--- a/vespalib/src/vespa/vespalib/datastore/array_store_simple_type_mapper.h
+++ b/vespalib/src/vespa/vespalib/datastore/array_store_simple_type_mapper.h
@@ -24,7 +24,7 @@ public:
     uint32_t get_type_id(size_t array_size) const noexcept { return array_size; }
     size_t get_array_size(uint32_t type_id) const noexcept { return type_id; }
     size_t get_entry_size(uint32_t type_id) const noexcept { return get_array_size(type_id) * sizeof(ElemT); }
-    static uint32_t get_max_small_array_type_id(uint32_t max_small_array_type_id) noexcept { return max_small_array_type_id; }
+    static uint32_t get_max_type_id(uint32_t max_type_id) noexcept { return max_type_id; }
 };
 
 }
diff --git a/vespalib/src/vespa/vespalib/datastore/array_store_type_mapper.cpp b/vespalib/src/vespa/vespalib/datastore/array_store_type_mapper.cpp
index 520fb4cc4ef..c8a9b7ed2a4 100644
--- a/vespalib/src/vespa/vespalib/datastore/array_store_type_mapper.cpp
+++ b/vespalib/src/vespa/vespalib/datastore/array_store_type_mapper.cpp
@@ -33,10 +33,10 @@ ArrayStoreTypeMapper::get_array_size(uint32_t type_id) const
 }
 
 uint32_t
-ArrayStoreTypeMapper::get_max_small_array_type_id(uint32_t max_small_array_type_id) const noexcept
+ArrayStoreTypeMapper::get_max_type_id(uint32_t max_type_id) const noexcept
 {
     auto clamp_type_id = _array_sizes.size() - 1;
-    return (clamp_type_id < max_small_array_type_id) ? clamp_type_id : max_small_array_type_id;
+    return (clamp_type_id < max_type_id) ? clamp_type_id : max_type_id;
 }
 
 }
diff --git a/vespalib/src/vespa/vespalib/datastore/array_store_type_mapper.h b/vespalib/src/vespa/vespalib/datastore/array_store_type_mapper.h
index a73b6ef2e97..c7b57f73259 100644
--- a/vespalib/src/vespa/vespalib/datastore/array_store_type_mapper.h
+++ b/vespalib/src/vespa/vespalib/datastore/array_store_type_mapper.h
@@ -25,7 +25,7 @@ public:
 
     uint32_t get_type_id(size_t array_size) const;
     size_t get_array_size(uint32_t type_id) const;
-    uint32_t get_max_small_array_type_id(uint32_t max_small_array_type_id) const noexcept;
+    uint32_t get_max_type_id(uint32_t max_type_id) const noexcept;
 };
 
 }