Cleanup and test elem_cache_t

joto · joto · commit 2b07a346440c · 2020-03-31T21:19:28.000+02:00
diff --git a/src/middle-ram.hpp b/src/middle-ram.hpp
@@ -21,62 +21,69 @@ struct options_t;
 template <typename T, size_t N>
 class cache_block_t
 {
-    std::array<std::unique_ptr<T>, N> arr;
+    std::array<std::unique_ptr<T>, N> m_arr;
 
 public:
-    void set(size_t idx, T *ele) { arr[idx].reset(ele); }
+    void set(size_t idx, T *ele) noexcept { m_arr[idx].reset(ele); }
 
-    T const *get(size_t idx) const { return arr[idx].get(); }
+    T const *get(size_t idx) const noexcept { return m_arr[idx].get(); }
 };
 
 template <typename T, size_t BLOCK_SHIFT>
 class elem_cache_t
 {
-    constexpr static size_t per_block() { return 1 << BLOCK_SHIFT; }
-    constexpr static size_t num_blocks() { return 1 << (32 - BLOCK_SHIFT); }
+    constexpr static size_t per_block() noexcept { return 1ULL << BLOCK_SHIFT; }
 
-    constexpr static size_t id2block(osmid_t id)
+    constexpr static size_t num_blocks() noexcept
+    {
+        return 1ULL << (32U - BLOCK_SHIFT);
+    }
+
+    constexpr static size_t id2block(osmid_t id) noexcept
     {
         /* + NUM_BLOCKS/2 allows for negative IDs */
-        return (id >> BLOCK_SHIFT) + num_blocks() / 2;
+        return (static_cast<size_t>(id) >> BLOCK_SHIFT) + num_blocks() / 2;
     }
 
-    constexpr static size_t id2offset(osmid_t id)
+    constexpr static size_t id2offset(osmid_t id) noexcept
     {
-        return id & (per_block() - 1);
+        return static_cast<size_t>(id) & (per_block() - 1U);
     }
 
-    typedef cache_block_t<T, 1 << BLOCK_SHIFT> element_t;
-    std::vector<std::unique_ptr<element_t>> arr;
+    using element_t = cache_block_t<T, 1U << BLOCK_SHIFT>;
+
+    std::vector<std::unique_ptr<element_t>> m_blocks;
 
 public:
-    elem_cache_t() : arr(num_blocks()) {}
+    elem_cache_t() : m_blocks(num_blocks()) {}
 
     void set(osmid_t id, T *ele)
     {
-        const size_t block = id2block(id);
+        size_t const block = id2block(id);
+        assert(block < m_blocks.size());
 
-        if (!arr[block]) {
-            arr[block].reset(new element_t());
+        if (!m_blocks[block]) {
+            m_blocks[block].reset(new element_t{});
         }
 
-        arr[block]->set(id2offset(id), ele);
+        m_blocks[block]->set(id2offset(id), ele);
     }
 
     T const *get(osmid_t id) const
     {
-        const size_t block = id2block(id);
+        size_t const block = id2block(id);
+        assert(block < m_blocks.size());
 
-        if (!arr[block]) {
+        if (!m_blocks[block]) {
             return 0;
         }
 
-        return arr[block]->get(id2offset(id));
+        return m_blocks[block]->get(id2offset(id));
     }
 
     void clear()
     {
-        for (auto &ele : arr) {
+        for (auto &ele : m_blocks) {
             ele.reset();
         }
     }
diff --git a/tests/test-middle.cpp b/tests/test-middle.cpp
@@ -88,6 +88,25 @@ struct options_ram_flatnode
     }
 };
 
+TEST_CASE("elem_cache_t")
+{
+    elem_cache_t<int, 10> cache;
+
+    cache.set(3, new int{23});
+    cache.set(5, new int{42});
+    REQUIRE(*cache.get(3) == 23);
+    REQUIRE(*cache.get(5) == 42);
+    REQUIRE(cache.get(2) == nullptr);
+    cache.set(2, new int{56});
+    REQUIRE(*cache.get(2) == 56);
+    cache.set(3, new int{0});
+    REQUIRE(*cache.get(3) == 0);
+    cache.clear();
+    REQUIRE(cache.get(1) == nullptr);
+    REQUIRE(cache.get(2) == nullptr);
+    REQUIRE(cache.get(3) == nullptr);
+}
+
 TEMPLATE_TEST_CASE("middle import", "", options_slim_default,
                    options_slim_dense_cache, options_ram_optimized,
                    options_ram_flatnode)

Original file line number	Diff line number	Diff line change
`@@ -21,62 +21,69 @@ struct options_t;`
`21`	`21`	`template <typename T, size_t N>`
`22`	`22`	`class cache_block_t`
`23`	`23`	`{`
`24`		`- std::array<std::unique_ptr<T>, N> arr;`
	`24`	`+ std::array<std::unique_ptr<T>, N> m_arr;`
`25`	`25`
`26`	`26`	`public:`
`27`		`- void set(size_t idx, T *ele) { arr[idx].reset(ele); }`
	`27`	`+ void set(size_t idx, T *ele) noexcept { m_arr[idx].reset(ele); }`
`28`	`28`
`29`		`- T const *get(size_t idx) const { return arr[idx].get(); }`
	`29`	`+ T const *get(size_t idx) const noexcept { return m_arr[idx].get(); }`
`30`	`30`	`};`
`31`	`31`
`32`	`32`	`template <typename T, size_t BLOCK_SHIFT>`
`33`	`33`	`class elem_cache_t`
`34`	`34`	`{`
`35`		`- constexpr static size_t per_block() { return 1 << BLOCK_SHIFT; }`
`36`		`- constexpr static size_t num_blocks() { return 1 << (32 - BLOCK_SHIFT); }`
	`35`	`+ constexpr static size_t per_block() noexcept { return 1ULL << BLOCK_SHIFT; }`
`37`	`36`
`38`		`- constexpr static size_t id2block(osmid_t id)`
	`37`	`+ constexpr static size_t num_blocks() noexcept`
	`38`	`+ {`
	`39`	`+ return 1ULL << (32U - BLOCK_SHIFT);`
	`40`	`+ }`
	`41`	`+`
	`42`	`+ constexpr static size_t id2block(osmid_t id) noexcept`
`39`	`43`	`{`
`40`	`44`	`/* + NUM_BLOCKS/2 allows for negative IDs */`
`41`		`- return (id >> BLOCK_SHIFT) + num_blocks() / 2;`
	`45`	`+ return (static_cast<size_t>(id) >> BLOCK_SHIFT) + num_blocks() / 2;`
`42`	`46`	`}`
`43`	`47`
`44`		`- constexpr static size_t id2offset(osmid_t id)`
	`48`	`+ constexpr static size_t id2offset(osmid_t id) noexcept`
`45`	`49`	`{`
`46`		`- return id & (per_block() - 1);`
	`50`	`+ return static_cast<size_t>(id) & (per_block() - 1U);`
`47`	`51`	`}`
`48`	`52`
`49`		`- typedef cache_block_t<T, 1 << BLOCK_SHIFT> element_t;`
`50`		`- std::vector<std::unique_ptr<element_t>> arr;`
	`53`	`+ using element_t = cache_block_t<T, 1U << BLOCK_SHIFT>;`
	`54`	`+`
	`55`	`+ std::vector<std::unique_ptr<element_t>> m_blocks;`
`51`	`56`
`52`	`57`	`public:`
`53`		`- elem_cache_t() : arr(num_blocks()) {}`
	`58`	`+ elem_cache_t() : m_blocks(num_blocks()) {}`
`54`	`59`
`55`	`60`	`void set(osmid_t id, T *ele)`
`56`	`61`	`{`
`57`		`- const size_t block = id2block(id);`
	`62`	`+ size_t const block = id2block(id);`
	`63`	`+ assert(block < m_blocks.size());`
`58`	`64`
`59`		`- if (!arr[block]) {`
`60`		`- arr[block].reset(new element_t());`
	`65`	`+ if (!m_blocks[block]) {`
	`66`	`+ m_blocks[block].reset(new element_t{});`
`61`	`67`	`}`
`62`	`68`
`63`		`- arr[block]->set(id2offset(id), ele);`
	`69`	`+ m_blocks[block]->set(id2offset(id), ele);`
`64`	`70`	`}`
`65`	`71`
`66`	`72`	`T const *get(osmid_t id) const`
`67`	`73`	`{`
`68`		`- const size_t block = id2block(id);`
	`74`	`+ size_t const block = id2block(id);`
	`75`	`+ assert(block < m_blocks.size());`
`69`	`76`
`70`		`- if (!arr[block]) {`
	`77`	`+ if (!m_blocks[block]) {`
`71`	`78`	`return 0;`
`72`	`79`	`}`
`73`	`80`
`74`		`- return arr[block]->get(id2offset(id));`
	`81`	`+ return m_blocks[block]->get(id2offset(id));`
`75`	`82`	`}`
`76`	`83`
`77`	`84`	`void clear()`
`78`	`85`	`{`
`79`		`- for (auto &ele : arr) {`
	`86`	`+ for (auto &ele : m_blocks) {`
`80`	`87`	`ele.reset();`
`81`	`88`	`}`
`82`	`89`	`}`