From 5631c631d0473a15d2215f636e9673c42b37f2ef Mon Sep 17 00:00:00 2001 From: LTLA Date: Mon, 10 Jul 2023 15:47:47 -0700 Subject: [PATCH] Improved the names for the custom chunk manager. --- include/tatami/chunked/CustomChunkManager.hpp | 140 +++++++------ tests/src/chunked/CustomChunkManager.cpp | 192 ++++++++++-------- 2 files changed, 184 insertions(+), 148 deletions(-) diff --git a/include/tatami/chunked/CustomChunkManager.hpp b/include/tatami/chunked/CustomChunkManager.hpp index 456528c5..61a9cabc 100644 --- a/include/tatami/chunked/CustomChunkManager.hpp +++ b/include/tatami/chunked/CustomChunkManager.hpp @@ -78,50 +78,62 @@ class CustomChunkManager { public: static constexpr bool sparse_chunk = Chunk_::sparse; + typedef typename Chunk_::value_type Chunkval; typedef typename Chunk_::index_type Chunkdex; - struct SparseCache { - SparseCache(size_t primary_dim) : cache_indices(primary_dim), cache_values(primary_dim) {} - - std::vector > cache_indices; - std::vector > cache_values; - - std::vector buffer_indptrs; - std::vector buffer_indices; - std::vector buffer_values; + struct SparseWorkspace { + std::vector values; + std::vector indices; + std::vector indptrs; + }; + struct SparseSlab { + SparseSlab(size_t primary_dim) : indices(primary_dim), values(primary_dim) {} + std::vector > values; + std::vector > indices; void clear() { - for (auto& x : cache_indices) { + for (auto& x : indices) { x.clear(); } - for (auto& x : cache_values) { + for (auto& x : values) { x.clear(); } } }; - struct DenseCache { - DenseCache(size_t length, size_t primary_dim) : cache(length * primary_dim) {} - - std::vector cache; + struct DenseWorkspace { + std::vector values; + }; - std::vector buffer; + struct DenseSlab { + DenseSlab(size_t length, size_t primary_dim) : values(length * primary_dim) {} + std::vector values; }; - typedef typename std::conditional::type Cache; + typedef typename std::conditional::type Workspace; + + Workspace create_workspace() const { + if constexpr(sparse_chunk) { + return SparseWorkspace(); + } else { + return DenseWorkspace(); + } + } + + typedef typename std::conditional::type Slab; template - Cache create_chunk_cache(size_t length) const { + Slab create_slab(size_t length) const { if constexpr(sparse_chunk) { - return SparseCache(exact_ ? 1 : get_primary_chunkdim()); + return SparseSlab(exact_ ? 1 : get_primary_chunkdim()); } else { - return DenseCache(length, exact_ ? 1 : get_primary_chunkdim()); + return DenseSlab(length, exact_ ? 1 : get_primary_chunkdim()); } } public: template - void extract(size_t primary_chunk_index, size_t primary_chunk_offset, size_t primary_maxdim, size_t start, size_t length, Cache& cache) const { + void extract(size_t primary_chunk_index, size_t primary_chunk_offset, size_t primary_maxdim, size_t start, size_t length, Slab& slab, Workspace& work) const { if (!length) { return; } @@ -144,7 +156,7 @@ class CustomChunkManager { size_t secondary_start_pos = start_chunk_index * secondary_chunkdim; if constexpr(sparse_chunk) { - cache.clear(); + slab.clear(); } for (size_t c = start_chunk_index; c < end_chunk_index; ++c) { @@ -153,39 +165,39 @@ class CustomChunkManager { size_t to = (c + 1 == end_chunk_index ? start + length - secondary_start_pos : secondary_chunkdim); if constexpr(sparse_chunk) { - chunk.inflate(cache.buffer_values, cache.buffer_indices, cache.buffer_indptrs); + chunk.inflate(work.values, work.indices, work.indptrs); Chunkdex secondary_offset = secondary_start_pos; if (chunk.row_major == accrow_) { auto refine_start_and_end = [&](size_t& start, size_t& end) -> void { if (from) { - auto it = cache.buffer_indices.begin(); + auto it = work.indices.begin(); start = std::lower_bound(it + start, it + end, static_cast(from)) - it; } if (to != secondary_chunkdim) { - auto it = cache.buffer_indices.begin(); + auto it = work.indices.begin(); end = std::lower_bound(it + start, it + end, static_cast(to)) - it; } }; if constexpr(exact_) { - auto start = cache.buffer_indptrs[primary_chunk_offset], end = cache.buffer_indptrs[primary_chunk_offset + 1]; + auto start = work.indptrs[primary_chunk_offset], end = work.indptrs[primary_chunk_offset + 1]; if (start < end) { refine_start_and_end(start, end); - cache.cache_values[0].insert(cache.cache_values[0].end(), cache.buffer_values.begin() + start, cache.buffer_values.begin() + end); + slab.values[0].insert(slab.values[0].end(), work.values.begin() + start, work.values.begin() + end); for (size_t i = start; i < end; ++i) { - cache.cache_indices[0].push_back(cache.buffer_indices[i] + secondary_offset); + slab.indices[0].push_back(work.indices[i] + secondary_offset); } } } else { for (size_t p = 0; p < primary_end_pos; ++p) { - auto start = cache.buffer_indptrs[p], end = cache.buffer_indptrs[p + 1]; + auto start = work.indptrs[p], end = work.indptrs[p + 1]; if (start < end) { refine_start_and_end(start, end); - cache.cache_values[p].insert(cache.cache_values[p].end(), cache.buffer_values.begin() + start, cache.buffer_values.begin() + end); + slab.values[p].insert(slab.values[p].end(), work.values.begin() + start, work.values.begin() + end); for (size_t i = start; i < end; ++i) { - cache.cache_indices[p].push_back(cache.buffer_indices[i] + secondary_offset); + slab.indices[p].push_back(work.indices[i] + secondary_offset); } } } @@ -195,31 +207,31 @@ class CustomChunkManager { if constexpr(exact_) { Chunkdex target = primary_chunk_offset; for (size_t s = from; s < to; ++s) { - auto start = cache.buffer_indptrs[s], end = cache.buffer_indptrs[s + 1]; - auto it = cache.buffer_indices.begin(); + auto start = work.indptrs[s], end = work.indptrs[s + 1]; + auto it = work.indices.begin(); start = std::lower_bound(it + start, it + end, target) - it; - if (start != end && cache.buffer_indices[start] == target) { - cache.cache_values[0].push_back(cache.buffer_values[start]); - cache.cache_indices[0].push_back(s + secondary_offset); + if (start != end && work.indices[start] == target) { + slab.values[0].push_back(work.values[start]); + slab.indices[0].push_back(s + secondary_offset); } } } else { for (size_t s = from; s < to; ++s) { - auto start = cache.buffer_indptrs[s], end = cache.buffer_indptrs[s + 1]; + auto start = work.indptrs[s], end = work.indptrs[s + 1]; for (size_t i = start; i < end; ++i) { - auto p = cache.buffer_indices[i]; - cache.cache_values[p].push_back(cache.buffer_values[i]); - cache.cache_indices[p].push_back(s + secondary_offset); + auto p = work.indices[i]; + slab.values[p].push_back(work.values[i]); + slab.indices[p].push_back(s + secondary_offset); } } } } } else { - chunk.inflate(cache.buffer); - auto bptr = cache.buffer.data(); - auto cptr = cache.cache.data() + dense_cache_offset; + chunk.inflate(work.values); + auto bptr = work.values.data(); + auto cptr = slab.values.data() + dense_cache_offset; if (chunk.row_major == accrow_) { if constexpr(exact_) { @@ -269,7 +281,7 @@ class CustomChunkManager { public: template - void extract(size_t primary_chunk_index, size_t primary_chunk_offset, size_t primary_maxdim, const std::vector& indices, Cache& cache) const { + void extract(size_t primary_chunk_index, size_t primary_chunk_offset, size_t primary_maxdim, const std::vector& indices, Slab& slab, Workspace& work) const { if (indices.empty()) { return; } @@ -293,7 +305,7 @@ class CustomChunkManager { size_t secondary_start_pos = start_chunk_index * secondary_chunkdim; if constexpr(sparse_chunk) { - cache.clear(); + slab.clear(); } for (size_t c = start_chunk_index; c < primary_num_chunks && iIt != indices.end(); ++c) { @@ -308,18 +320,18 @@ class CustomChunkManager { const auto& chunk = chunks[offset]; if constexpr(sparse_chunk) { - chunk.inflate(cache.buffer_values, cache.buffer_indices, cache.buffer_indptrs); + chunk.inflate(work.values, work.indices, work.indptrs); Chunkdex secondary_offset = secondary_start_pos; auto collect_sparse = [&](size_t start, size_t end, size_t pout) -> void { if (collected.front()) { - auto it = cache.buffer_indices.begin(); + auto it = work.indices.begin(); start = std::lower_bound(it + start, it + end, static_cast(collected.front())) - it; } auto cIt = collected.begin(); for (size_t i = start; i < end; ++i) { - Index_ target = cache.buffer_indices[i]; + Index_ target = work.indices[i]; while (cIt != collected.end() && *cIt < target) { ++cIt; } @@ -327,8 +339,8 @@ class CustomChunkManager { break; } if (*cIt == target) { - cache.cache_values[pout].push_back(cache.buffer_values[i]); - cache.cache_indices[pout].push_back(cache.buffer_indices[i] + secondary_offset); + slab.values[pout].push_back(work.values[i]); + slab.indices[pout].push_back(work.indices[i] + secondary_offset); ++cIt; } } @@ -336,14 +348,14 @@ class CustomChunkManager { if (chunk.row_major == accrow_) { if constexpr(exact_) { - auto start = cache.buffer_indptrs[primary_chunk_offset], end = cache.buffer_indptrs[primary_chunk_offset + 1]; + auto start = work.indptrs[primary_chunk_offset], end = work.indptrs[primary_chunk_offset + 1]; if (start < end) { collect_sparse(start, end, 0); } } else { for (size_t p = 0; p < primary_end_pos; ++p) { - auto start = cache.buffer_indptrs[p], end = cache.buffer_indptrs[p + 1]; + auto start = work.indptrs[p], end = work.indptrs[p + 1]; if (start < end) { collect_sparse(start, end, p); } @@ -354,31 +366,31 @@ class CustomChunkManager { if constexpr(exact_) { Chunkdex target = primary_chunk_offset; for (auto s : collected) { - auto start = cache.buffer_indptrs[s], end = cache.buffer_indptrs[s + 1]; - auto it = cache.buffer_indices.begin(); + auto start = work.indptrs[s], end = work.indptrs[s + 1]; + auto it = work.indices.begin(); start = std::lower_bound(it + start, it + end, target) - it; - if (start != end && cache.buffer_indices[start] == target) { - cache.cache_values[0].push_back(cache.buffer_values[start]); - cache.cache_indices[0].push_back(s + secondary_offset); + if (start != end && work.indices[start] == target) { + slab.values[0].push_back(work.values[start]); + slab.indices[0].push_back(s + secondary_offset); } } } else { for (auto s : collected) { - auto start = cache.buffer_indptrs[s], end = cache.buffer_indptrs[s + 1]; + auto start = work.indptrs[s], end = work.indptrs[s + 1]; for (size_t i = start; i < end; ++i) { - auto p = cache.buffer_indices[i]; - cache.cache_values[p].push_back(cache.buffer_values[i]); - cache.cache_indices[p].push_back(s + secondary_offset); + auto p = work.indices[i]; + slab.values[p].push_back(work.values[i]); + slab.indices[p].push_back(s + secondary_offset); } } } } } else { - chunk.inflate(cache.buffer); - auto bptr = cache.buffer.data(); - auto cptr = cache.cache.data() + dense_cache_offset; + chunk.inflate(work.values); + auto bptr = work.values.data(); + auto cptr = slab.values.data() + dense_cache_offset; if (chunk.row_major == accrow_) { if constexpr(exact_) { diff --git a/tests/src/chunked/CustomChunkManager.cpp b/tests/src/chunked/CustomChunkManager.cpp index 07a136cc..95a1d02d 100644 --- a/tests/src/chunked/CustomChunkManager.cpp +++ b/tests/src/chunked/CustomChunkManager.cpp @@ -79,8 +79,10 @@ TEST_P(CustomDenseChunkManagerFullTest, Row) { auto param = GetParam(); assemble(std::get<0>(param), std::get<1>(param), std::get<2>(param), std::get<3>(param)); - auto cache = manager.create_chunk_cache(ref->ncol()); - auto ecache = manager.create_chunk_cache(ref->ncol()); + auto slab = manager.create_slab(ref->ncol()); + auto eslab = manager.create_slab(ref->ncol()); + auto work = manager.create_workspace(); + std::vector tmp1(ref->ncol()), tmp2(ref->ncol()); auto ref_ext = ref->dense_row(); int lastr = -1; @@ -89,9 +91,9 @@ TEST_P(CustomDenseChunkManagerFullTest, Row) { for (int r = 0; r < ref->nrow(); ++r) { int requiredr = r / manager.chunk_nrow; if (requiredr != lastr) { - manager.extract(requiredr, r % manager.chunk_nrow, ref->nrow(), 0, ref->ncol(), cache); + manager.extract(requiredr, r % manager.chunk_nrow, ref->nrow(), 0, ref->ncol(), slab, work); lastr = requiredr; - ccptr = cache.cache.data(); + ccptr = slab.values.data(); } ref_ext->fetch_copy(r, tmp1.data()); @@ -100,8 +102,8 @@ TEST_P(CustomDenseChunkManagerFullTest, Row) { ccptr += ref->ncol(); // Testing with exact. - manager.extract(requiredr, r % manager.chunk_nrow, ref->nrow(), 0, ref->ncol(), ecache); - EXPECT_EQ(tmp1, ecache.cache); + manager.extract(requiredr, r % manager.chunk_nrow, ref->nrow(), 0, ref->ncol(), eslab, work); + EXPECT_EQ(tmp1, eslab.values); } } @@ -109,8 +111,10 @@ TEST_P(CustomDenseChunkManagerFullTest, Column) { auto param = GetParam(); assemble(std::get<0>(param), std::get<1>(param), std::get<2>(param), std::get<3>(param)); - auto cache = manager.create_chunk_cache(ref->nrow()); - auto ecache = manager.create_chunk_cache(ref->nrow()); + auto slab = manager.create_slab(ref->nrow()); + auto eslab = manager.create_slab(ref->nrow()); + auto work = manager.create_workspace(); + std::vector tmp1(ref->nrow()), tmp2(ref->nrow()); auto ref_ext = ref->dense_column(); int lastc = -1; @@ -119,9 +123,9 @@ TEST_P(CustomDenseChunkManagerFullTest, Column) { for (int c = 0; c < ref->ncol(); ++c) { int requiredc = c / manager.chunk_ncol; if (requiredc != lastc) { - manager.extract(requiredc, c % manager.chunk_ncol, ref->ncol(), 0, ref->nrow(), cache); + manager.extract(requiredc, c % manager.chunk_ncol, ref->ncol(), 0, ref->nrow(), slab, work); lastc = requiredc; - ccptr = cache.cache.data(); + ccptr = slab.values.data(); } ref_ext->fetch_copy(c, tmp1.data()); @@ -130,8 +134,8 @@ TEST_P(CustomDenseChunkManagerFullTest, Column) { ccptr += ref->nrow(); // Testing with exact. - manager.extract(requiredc, c % manager.chunk_ncol, ref->ncol(), 0, ref->nrow(), ecache); - EXPECT_EQ(tmp1, ecache.cache); + manager.extract(requiredc, c % manager.chunk_ncol, ref->ncol(), 0, ref->nrow(), eslab, work); + EXPECT_EQ(tmp1, eslab.values); } } @@ -170,8 +174,10 @@ TEST_P(CustomDenseChunkManagerBlockTest, Row) { int start = bounds.first * ref->ncol(); int len = bounds.second * ref->ncol() - start; - auto cache = manager.create_chunk_cache(len); - auto ecache = manager.create_chunk_cache(len); + auto slab = manager.create_slab(len); + auto eslab = manager.create_slab(len); + auto work = manager.create_workspace(); + std::vector tmp1(len), tmp2(len); auto ref_ext = ref->dense_row(start, len); int lastr = -1; @@ -180,9 +186,9 @@ TEST_P(CustomDenseChunkManagerBlockTest, Row) { for (int r = 0; r < ref->nrow(); ++r) { int requiredr = r / manager.chunk_nrow; if (requiredr != lastr) { - manager.extract(requiredr, r % manager.chunk_nrow, ref->nrow(), start, len, cache); + manager.extract(requiredr, r % manager.chunk_nrow, ref->nrow(), start, len, slab, work); lastr = requiredr; - ccptr = cache.cache.data(); + ccptr = slab.values.data(); } ref_ext->fetch_copy(r, tmp1.data()); @@ -191,8 +197,8 @@ TEST_P(CustomDenseChunkManagerBlockTest, Row) { ccptr += len; // Testing with exact. - manager.extract(requiredr, r % manager.chunk_nrow, ref->nrow(), start, len, ecache); - EXPECT_EQ(tmp1, ecache.cache); + manager.extract(requiredr, r % manager.chunk_nrow, ref->nrow(), start, len, eslab, work); + EXPECT_EQ(tmp1, eslab.values); } } @@ -204,8 +210,10 @@ TEST_P(CustomDenseChunkManagerBlockTest, Column) { int start = bounds.first * ref->nrow(); int len = bounds.second * ref->nrow() - start; - auto cache = manager.create_chunk_cache(len); - auto ecache = manager.create_chunk_cache(len); + auto slab = manager.create_slab(len); + auto eslab = manager.create_slab(len); + auto work = manager.create_workspace(); + std::vector tmp1(len), tmp2(len); auto ref_ext = ref->dense_column(start, len); int lastc = -1; @@ -214,9 +222,9 @@ TEST_P(CustomDenseChunkManagerBlockTest, Column) { for (int c = 0; c < ref->ncol(); ++c) { int requiredc = c / manager.chunk_ncol; if (requiredc != lastc) { - manager.extract(requiredc, c % manager.chunk_ncol, ref->ncol(), start, len, cache); + manager.extract(requiredc, c % manager.chunk_ncol, ref->ncol(), start, len, slab, work); lastc = requiredc; - ccptr = cache.cache.data(); + ccptr = slab.values.data(); } ref_ext->fetch_copy(c, tmp1.data()); @@ -225,8 +233,8 @@ TEST_P(CustomDenseChunkManagerBlockTest, Column) { ccptr += len; // Testing with exact. - manager.extract(requiredc, c % manager.chunk_ncol, ref->ncol(), start, len, ecache); - EXPECT_EQ(tmp1, ecache.cache); + manager.extract(requiredc, c % manager.chunk_ncol, ref->ncol(), start, len, eslab, work); + EXPECT_EQ(tmp1, eslab.values); } } @@ -278,8 +286,10 @@ TEST_P(CustomDenseChunkManagerIndexTest, Row) { assemble(std::get<0>(param), std::get<1>(param), std::get<3>(param), std::get<4>(param)); auto indices = get_indices(std::get<2>(param), ref->ncol()); - auto cache = manager.create_chunk_cache(indices.size()); - auto ecache = manager.create_chunk_cache(indices.size()); + auto slab = manager.create_slab(indices.size()); + auto eslab = manager.create_slab(indices.size()); + auto work = manager.create_workspace(); + std::vector tmp1(indices.size()), tmp2(indices.size()); auto ref_ext = ref->dense_row(indices); int lastr = -1; @@ -288,9 +298,9 @@ TEST_P(CustomDenseChunkManagerIndexTest, Row) { for (int r = 0; r < ref->nrow(); ++r) { int requiredr = r / manager.chunk_nrow; if (requiredr != lastr) { - manager.extract(requiredr, r % manager.chunk_nrow, ref->nrow(), indices, cache); + manager.extract(requiredr, r % manager.chunk_nrow, ref->nrow(), indices, slab, work); lastr = requiredr; - ccptr = cache.cache.data(); + ccptr = slab.values.data(); } ref_ext->fetch_copy(r, tmp1.data()); @@ -299,8 +309,8 @@ TEST_P(CustomDenseChunkManagerIndexTest, Row) { ccptr += indices.size(); // Testing with exact. - manager.extract(requiredr, r % manager.chunk_nrow, ref->nrow(), indices, ecache); - EXPECT_EQ(tmp1, ecache.cache); + manager.extract(requiredr, r % manager.chunk_nrow, ref->nrow(), indices, eslab, work); + EXPECT_EQ(tmp1, eslab.values); } } @@ -309,8 +319,10 @@ TEST_P(CustomDenseChunkManagerIndexTest, Column) { assemble(std::get<0>(param), std::get<1>(param), std::get<3>(param), std::get<4>(param)); auto indices = get_indices(std::get<2>(param), ref->nrow()); - auto cache = manager.create_chunk_cache(indices.size()); - auto ecache = manager.create_chunk_cache(indices.size()); + auto slab = manager.create_slab(indices.size()); + auto eslab = manager.create_slab(indices.size()); + auto work = manager.create_workspace(); + std::vector tmp1(indices.size()), tmp2(indices.size()); auto ref_ext = ref->dense_column(indices); int lastc = -1; @@ -319,9 +331,9 @@ TEST_P(CustomDenseChunkManagerIndexTest, Column) { for (int c = 0; c < ref->ncol(); ++c) { int requiredc = c / manager.chunk_ncol; if (requiredc != lastc) { - manager.extract(requiredc, c % manager.chunk_ncol, ref->ncol(), indices, cache); + manager.extract(requiredc, c % manager.chunk_ncol, ref->ncol(), indices, slab, work); lastc = requiredc; - ccptr = cache.cache.data(); + ccptr = slab.values.data(); } ref_ext->fetch_copy(c, tmp1.data()); @@ -330,8 +342,8 @@ TEST_P(CustomDenseChunkManagerIndexTest, Column) { ccptr += indices.size(); // Testing with exact. - manager.extract(requiredc, c % manager.chunk_ncol, ref->ncol(), indices, ecache); - EXPECT_EQ(tmp1, ecache.cache); + manager.extract(requiredc, c % manager.chunk_ncol, ref->ncol(), indices, eslab, work); + EXPECT_EQ(tmp1, eslab.values); } } @@ -455,8 +467,10 @@ TEST_P(CustomSparseChunkManagerFullTest, Row) { auto param = GetParam(); assemble(std::get<0>(param), std::get<1>(param), std::get<2>(param), std::get<3>(param)); - auto cache = manager.create_chunk_cache(ref->ncol()); - auto ecache = manager.create_chunk_cache(ref->ncol()); + auto slab = manager.create_slab(ref->ncol()); + auto eslab = manager.create_slab(ref->ncol()); + auto work = manager.create_workspace(); + auto ref_ext = ref->sparse_row(); int lastr = -1; @@ -464,18 +478,18 @@ TEST_P(CustomSparseChunkManagerFullTest, Row) { int requiredr = r / manager.chunk_nrow; int offsetr = r % manager.chunk_nrow; if (requiredr != lastr) { - manager.extract(requiredr, offsetr, ref->nrow(), 0, ref->ncol(), cache); + manager.extract(requiredr, offsetr, ref->nrow(), 0, ref->ncol(), slab, work); lastr = requiredr; } auto ref_range = ref_ext->fetch(r); - EXPECT_EQ(ref_range.value, cache.cache_values[offsetr]); - EXPECT_EQ(ref_range.index, cache.cache_indices[offsetr]); + EXPECT_EQ(ref_range.value, slab.values[offsetr]); + EXPECT_EQ(ref_range.index, slab.indices[offsetr]); // Testing with exact. - manager.extract(requiredr, offsetr, ref->nrow(), 0, ref->ncol(), ecache); - EXPECT_EQ(ref_range.value, ecache.cache_values[0]); - EXPECT_EQ(ref_range.index, ecache.cache_indices[0]); + manager.extract(requiredr, offsetr, ref->nrow(), 0, ref->ncol(), eslab, work); + EXPECT_EQ(ref_range.value, eslab.values[0]); + EXPECT_EQ(ref_range.index, eslab.indices[0]); } } @@ -483,8 +497,10 @@ TEST_P(CustomSparseChunkManagerFullTest, Column) { auto param = GetParam(); assemble(std::get<0>(param), std::get<1>(param), std::get<2>(param), std::get<3>(param)); - auto cache = manager.create_chunk_cache(ref->nrow()); - auto ecache = manager.create_chunk_cache(ref->nrow()); + auto slab = manager.create_slab(ref->nrow()); + auto eslab = manager.create_slab(ref->nrow()); + auto work = manager.create_workspace(); + auto ref_ext = ref->sparse_column(); int lastc = -1; @@ -492,18 +508,18 @@ TEST_P(CustomSparseChunkManagerFullTest, Column) { int requiredc = c / manager.chunk_ncol; int offsetc = c % manager.chunk_ncol; if (requiredc != lastc) { - manager.extract(requiredc, offsetc, ref->ncol(), 0, ref->nrow(), cache); + manager.extract(requiredc, offsetc, ref->ncol(), 0, ref->nrow(), slab, work); lastc = requiredc; } auto ref_range = ref_ext->fetch(c); - EXPECT_EQ(ref_range.value, cache.cache_values[offsetc]); - EXPECT_EQ(ref_range.index, cache.cache_indices[offsetc]); + EXPECT_EQ(ref_range.value, slab.values[offsetc]); + EXPECT_EQ(ref_range.index, slab.indices[offsetc]); // Testing with exact. - manager.extract(requiredc, offsetc, ref->ncol(), 0, ref->nrow(), ecache); - EXPECT_EQ(ref_range.value, ecache.cache_values[0]); - EXPECT_EQ(ref_range.index, ecache.cache_indices[0]); + manager.extract(requiredc, offsetc, ref->ncol(), 0, ref->nrow(), eslab, work); + EXPECT_EQ(ref_range.value, eslab.values[0]); + EXPECT_EQ(ref_range.index, eslab.indices[0]); } } @@ -542,8 +558,10 @@ TEST_P(CustomSparseChunkManagerBlockTest, Row) { int start = bounds.first * ref->ncol(); int len = bounds.second * ref->ncol() - start; - auto cache = manager.create_chunk_cache(len); - auto ecache = manager.create_chunk_cache(len); + auto slab = manager.create_slab(len); + auto eslab = manager.create_slab(len); + auto work = manager.create_workspace(); + auto ref_ext = ref->sparse_row(start, len); int lastr = -1; @@ -551,18 +569,18 @@ TEST_P(CustomSparseChunkManagerBlockTest, Row) { int requiredr = r / manager.chunk_nrow; int offsetr = r % manager.chunk_nrow; if (requiredr != lastr) { - manager.extract(requiredr, offsetr, ref->nrow(), start, len, cache); + manager.extract(requiredr, offsetr, ref->nrow(), start, len, slab, work); lastr = requiredr; } auto ref_range = ref_ext->fetch(r); - EXPECT_EQ(ref_range.value, cache.cache_values[offsetr]); - EXPECT_EQ(ref_range.index, cache.cache_indices[offsetr]); + EXPECT_EQ(ref_range.value, slab.values[offsetr]); + EXPECT_EQ(ref_range.index, slab.indices[offsetr]); // Testing with exact. - manager.extract(requiredr, offsetr, ref->nrow(), start, len, ecache); - EXPECT_EQ(ref_range.value, ecache.cache_values[0]); - EXPECT_EQ(ref_range.index, ecache.cache_indices[0]); + manager.extract(requiredr, offsetr, ref->nrow(), start, len, eslab, work); + EXPECT_EQ(ref_range.value, eslab.values[0]); + EXPECT_EQ(ref_range.index, eslab.indices[0]); } } @@ -574,8 +592,10 @@ TEST_P(CustomSparseChunkManagerBlockTest, Column) { int start = bounds.first * ref->nrow(); int len = bounds.second * ref->nrow() - start; - auto cache = manager.create_chunk_cache(len); - auto ecache = manager.create_chunk_cache(len); + auto slab = manager.create_slab(len); + auto eslab = manager.create_slab(len); + auto work = manager.create_workspace(); + auto ref_ext = ref->sparse_column(start, len); int lastc = -1; @@ -583,18 +603,18 @@ TEST_P(CustomSparseChunkManagerBlockTest, Column) { int requiredc = c / manager.chunk_ncol; int offsetc = c % manager.chunk_ncol; if (requiredc != lastc) { - manager.extract(requiredc, offsetc, ref->ncol(), start, len, cache); + manager.extract(requiredc, offsetc, ref->ncol(), start, len, slab, work); lastc = requiredc; } auto ref_range = ref_ext->fetch(c); - EXPECT_EQ(ref_range.value, cache.cache_values[offsetc]); - EXPECT_EQ(ref_range.index, cache.cache_indices[offsetc]); + EXPECT_EQ(ref_range.value, slab.values[offsetc]); + EXPECT_EQ(ref_range.index, slab.indices[offsetc]); // Testing with exact. - manager.extract(requiredc, offsetc, ref->ncol(), start, len, ecache); - EXPECT_EQ(ref_range.value, ecache.cache_values[0]); - EXPECT_EQ(ref_range.index, ecache.cache_indices[0]); + manager.extract(requiredc, offsetc, ref->ncol(), start, len, eslab, work); + EXPECT_EQ(ref_range.value, eslab.values[0]); + EXPECT_EQ(ref_range.index, eslab.indices[0]); } } @@ -646,8 +666,10 @@ TEST_P(CustomSparseChunkManagerIndexTest, Row) { assemble(std::get<0>(param), std::get<1>(param), std::get<3>(param), std::get<4>(param)); auto indices = get_indices(std::get<2>(param), ref->ncol()); - auto cache = manager.create_chunk_cache(indices.size()); - auto ecache = manager.create_chunk_cache(indices.size()); + auto slab = manager.create_slab(indices.size()); + auto eslab = manager.create_slab(indices.size()); + auto work = manager.create_workspace(); + auto ref_ext = ref->sparse_row(indices); int lastr = -1; @@ -655,18 +677,18 @@ TEST_P(CustomSparseChunkManagerIndexTest, Row) { int requiredr = r / manager.chunk_nrow; int offsetr = r % manager.chunk_nrow; if (requiredr != lastr) { - manager.extract(requiredr, offsetr, ref->nrow(), indices, cache); + manager.extract(requiredr, offsetr, ref->nrow(), indices, slab, work); lastr = requiredr; } auto ref_range = ref_ext->fetch(r); - EXPECT_EQ(ref_range.value, cache.cache_values[offsetr]); - EXPECT_EQ(ref_range.index, cache.cache_indices[offsetr]); + EXPECT_EQ(ref_range.value, slab.values[offsetr]); + EXPECT_EQ(ref_range.index, slab.indices[offsetr]); // Testing with exact. - manager.extract(requiredr, offsetr, ref->nrow(), indices, ecache); - EXPECT_EQ(ref_range.value, ecache.cache_values[0]); - EXPECT_EQ(ref_range.index, ecache.cache_indices[0]); + manager.extract(requiredr, offsetr, ref->nrow(), indices, eslab, work); + EXPECT_EQ(ref_range.value, eslab.values[0]); + EXPECT_EQ(ref_range.index, eslab.indices[0]); } } @@ -675,8 +697,10 @@ TEST_P(CustomSparseChunkManagerIndexTest, Column) { assemble(std::get<0>(param), std::get<1>(param), std::get<3>(param), std::get<4>(param)); auto indices = get_indices(std::get<2>(param), ref->nrow()); - auto cache = manager.create_chunk_cache(indices.size()); - auto ecache = manager.create_chunk_cache(indices.size()); + auto slab = manager.create_slab(indices.size()); + auto eslab = manager.create_slab(indices.size()); + auto work = manager.create_workspace(); + std::vector tmp1(indices.size()), tmp2(indices.size()); auto ref_ext = ref->sparse_column(indices); int lastc = -1; @@ -685,18 +709,18 @@ TEST_P(CustomSparseChunkManagerIndexTest, Column) { int requiredc = c / manager.chunk_ncol; int offsetc = c % manager.chunk_ncol; if (requiredc != lastc) { - manager.extract(requiredc, offsetc, ref->ncol(), indices, cache); + manager.extract(requiredc, offsetc, ref->ncol(), indices, slab, work); lastc = requiredc; } auto ref_range = ref_ext->fetch(c); - EXPECT_EQ(ref_range.value, cache.cache_values[offsetc]); - EXPECT_EQ(ref_range.index, cache.cache_indices[offsetc]); + EXPECT_EQ(ref_range.value, slab.values[offsetc]); + EXPECT_EQ(ref_range.index, slab.indices[offsetc]); // Testing with exact. - manager.extract(requiredc, offsetc, ref->ncol(), indices, ecache); - EXPECT_EQ(ref_range.value, ecache.cache_values[0]); - EXPECT_EQ(ref_range.index, ecache.cache_indices[0]); + manager.extract(requiredc, offsetc, ref->ncol(), indices, eslab, work); + EXPECT_EQ(ref_range.value, eslab.values[0]); + EXPECT_EQ(ref_range.index, eslab.indices[0]); } }