mirror of
https://github.com/facebook/rocksdb.git
synced 2024-11-28 05:43:50 +00:00
2fbe32b0c1
Summary:
Note: This PR is the 3rd PR of a bigger PR stack (https://github.com/facebook/rocksdb/issues/9073) and depends on the second PR (https://github.com/facebook/rocksdb/pull/9071). **See changes from this PR only 00447324d0**
Context:
pdillinger brought up a good [point](https://github.com/facebook/rocksdb/pull/9073#discussion_r741478309) about lacking RAII support for per cache reservation in `CacheReservationManager` when reviewing https://github.com/facebook/rocksdb/pull/9073.
To summarize the discussion, the current API `CacheReservationManager::UpdateCacheReservation()` requires callers to explicitly calculate and pass in a correct`new_mem_used` to release a cache reservation (if they don't want to rely on the clean-up during `CacheReservationManager`'s destruction - such as they want to release it earlier).
While this implementation has convenience in some use-case such as `WriteBufferManager`, where [reservation](https://github.com/facebook/rocksdb/blob/main/memtable/write_buffer_manager.cc#L69-L91) and [release](https://github.com/facebook/rocksdb/blob/main/memtable/write_buffer_manager.cc#L109-L129) amounts do not necessarily correspond symmetrically and thus a flexible `new_mem_used` inputing is needed, it can be prone to caller's calculation error as well as cause a mass of codes in releasing cache in other use-case such as filter construction, where reservation and release amounts do correspond symmetrically and many code paths requiring a cache release, as [pointed](https://github.com/facebook/rocksdb/pull/9073#discussion_r741478309) out by pdillinger.
Therefore we decided to provide a new API in `CacheReservationManager` to update reservation with better RAII support for per cache reservation, using a handle to manage the life time of that particular cache reservation.
- Added a new class `CacheReservationHandle`
- Added a new API `CacheReservationManager::MakeCacheReservation()` that outputs a `CacheReservationHandle` for managing the reservation
- Updated class comments to clarify two different cache reservation methods
Tests:
- Passing new tests
Pull Request resolved: https://github.com/facebook/rocksdb/pull/9130
Reviewed By: pdillinger
Differential Revision: D32199446
Pulled By: hx235
fbshipit-source-id: 1cba7c636e5ecfb55b0c1e0c2d218cc9b5b30b4e
515 lines
23 KiB
C++
515 lines
23 KiB
C++
// Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
|
|
// This source code is licensed under both the GPLv2 (found in the
|
|
// COPYING file in the root directory) and Apache 2.0 License
|
|
// (found in the LICENSE.Apache file in the root directory).
|
|
//
|
|
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file. See the AUTHORS file for names of contributors.
|
|
#include "cache/cache_reservation_manager.h"
|
|
|
|
#include <cstddef>
|
|
#include <cstring>
|
|
#include <memory>
|
|
|
|
#include "cache/cache_entry_roles.h"
|
|
#include "rocksdb/cache.h"
|
|
#include "rocksdb/slice.h"
|
|
#include "table/block_based/block_based_table_reader.h"
|
|
#include "test_util/testharness.h"
|
|
#include "util/coding.h"
|
|
|
|
namespace ROCKSDB_NAMESPACE {
|
|
class CacheReservationManagerTest : public ::testing::Test {
|
|
protected:
|
|
static constexpr std::size_t kSizeDummyEntry =
|
|
CacheReservationManager::GetDummyEntrySize();
|
|
static constexpr std::size_t kCacheCapacity = 4096 * kSizeDummyEntry;
|
|
static constexpr int kNumShardBits = 0; // 2^0 shard
|
|
static const std::size_t kCacheKeyPrefixSize =
|
|
BlockBasedTable::kMaxCacheKeyPrefixSize + kMaxVarint64Length;
|
|
static constexpr std::size_t kMetaDataChargeOverhead = 10000;
|
|
|
|
std::shared_ptr<Cache> cache = NewLRUCache(kCacheCapacity, kNumShardBits);
|
|
std::unique_ptr<CacheReservationManager> test_cache_rev_mng;
|
|
|
|
CacheReservationManagerTest() {
|
|
test_cache_rev_mng.reset(new CacheReservationManager(cache));
|
|
}
|
|
};
|
|
|
|
TEST_F(CacheReservationManagerTest, GenerateCacheKey) {
|
|
// The first cache reservation manager owning the cache will have
|
|
// cache->NewId() = 1
|
|
constexpr std::size_t kCacheNewId = 1;
|
|
// The first key generated inside of cache reservation manager will have
|
|
// next_cache_key_id = 0
|
|
constexpr std::size_t kCacheKeyId = 0;
|
|
|
|
char expected_cache_key[kCacheKeyPrefixSize + kMaxVarint64Length];
|
|
std::memset(expected_cache_key, 0, kCacheKeyPrefixSize + kMaxVarint64Length);
|
|
|
|
EncodeVarint64(expected_cache_key, kCacheNewId);
|
|
char* end =
|
|
EncodeVarint64(expected_cache_key + kCacheKeyPrefixSize, kCacheKeyId);
|
|
Slice expected_cache_key_slice(
|
|
expected_cache_key, static_cast<std::size_t>(end - expected_cache_key));
|
|
|
|
std::size_t new_mem_used = 1 * kSizeDummyEntry;
|
|
Status s =
|
|
test_cache_rev_mng
|
|
->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
|
|
new_mem_used);
|
|
ASSERT_EQ(s, Status::OK());
|
|
ASSERT_GE(cache->GetPinnedUsage(), 1 * kSizeDummyEntry);
|
|
ASSERT_LT(cache->GetPinnedUsage(),
|
|
1 * kSizeDummyEntry + kMetaDataChargeOverhead);
|
|
|
|
Cache::Handle* handle = cache->Lookup(expected_cache_key_slice);
|
|
EXPECT_NE(handle, nullptr)
|
|
<< "Failed to generate the cache key for the dummy entry correctly";
|
|
// Clean up the returned handle from Lookup() to prevent memory leak
|
|
cache->Release(handle);
|
|
}
|
|
|
|
TEST_F(CacheReservationManagerTest, KeepCacheReservationTheSame) {
|
|
std::size_t new_mem_used = 1 * kSizeDummyEntry;
|
|
Status s =
|
|
test_cache_rev_mng
|
|
->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
|
|
new_mem_used);
|
|
ASSERT_EQ(s, Status::OK());
|
|
ASSERT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
|
|
1 * kSizeDummyEntry);
|
|
ASSERT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used);
|
|
std::size_t initial_pinned_usage = cache->GetPinnedUsage();
|
|
ASSERT_GE(initial_pinned_usage, 1 * kSizeDummyEntry);
|
|
ASSERT_LT(initial_pinned_usage,
|
|
1 * kSizeDummyEntry + kMetaDataChargeOverhead);
|
|
|
|
s = test_cache_rev_mng
|
|
->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
|
|
new_mem_used);
|
|
EXPECT_EQ(s, Status::OK())
|
|
<< "Failed to keep cache reservation the same when new_mem_used equals "
|
|
"to current cache reservation";
|
|
EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
|
|
1 * kSizeDummyEntry)
|
|
<< "Failed to bookkeep correctly when new_mem_used equals to current "
|
|
"cache reservation";
|
|
EXPECT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used)
|
|
<< "Failed to bookkeep the used memory correctly when new_mem_used "
|
|
"equals to current cache reservation";
|
|
EXPECT_EQ(cache->GetPinnedUsage(), initial_pinned_usage)
|
|
<< "Failed to keep underlying dummy entries the same when new_mem_used "
|
|
"equals to current cache reservation";
|
|
}
|
|
|
|
TEST_F(CacheReservationManagerTest,
|
|
IncreaseCacheReservationByMultiplesOfDummyEntrySize) {
|
|
std::size_t new_mem_used = 2 * kSizeDummyEntry;
|
|
Status s =
|
|
test_cache_rev_mng
|
|
->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
|
|
new_mem_used);
|
|
EXPECT_EQ(s, Status::OK())
|
|
<< "Failed to increase cache reservation correctly";
|
|
EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
|
|
2 * kSizeDummyEntry)
|
|
<< "Failed to bookkeep cache reservation increase correctly";
|
|
EXPECT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used)
|
|
<< "Failed to bookkeep the used memory correctly";
|
|
EXPECT_GE(cache->GetPinnedUsage(), 2 * kSizeDummyEntry)
|
|
<< "Failed to increase underlying dummy entries in cache correctly";
|
|
EXPECT_LT(cache->GetPinnedUsage(),
|
|
2 * kSizeDummyEntry + kMetaDataChargeOverhead)
|
|
<< "Failed to increase underlying dummy entries in cache correctly";
|
|
}
|
|
|
|
TEST_F(CacheReservationManagerTest,
|
|
IncreaseCacheReservationNotByMultiplesOfDummyEntrySize) {
|
|
std::size_t new_mem_used = 2 * kSizeDummyEntry + kSizeDummyEntry / 2;
|
|
Status s =
|
|
test_cache_rev_mng
|
|
->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
|
|
new_mem_used);
|
|
EXPECT_EQ(s, Status::OK())
|
|
<< "Failed to increase cache reservation correctly";
|
|
EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
|
|
3 * kSizeDummyEntry)
|
|
<< "Failed to bookkeep cache reservation increase correctly";
|
|
EXPECT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used)
|
|
<< "Failed to bookkeep the used memory correctly";
|
|
EXPECT_GE(cache->GetPinnedUsage(), 3 * kSizeDummyEntry)
|
|
<< "Failed to increase underlying dummy entries in cache correctly";
|
|
EXPECT_LT(cache->GetPinnedUsage(),
|
|
3 * kSizeDummyEntry + kMetaDataChargeOverhead)
|
|
<< "Failed to increase underlying dummy entries in cache correctly";
|
|
}
|
|
|
|
TEST(CacheReservationManagerIncreaseReservcationOnFullCacheTest,
|
|
IncreaseCacheReservationOnFullCache) {
|
|
;
|
|
constexpr std::size_t kSizeDummyEntry =
|
|
CacheReservationManager::GetDummyEntrySize();
|
|
constexpr std::size_t kSmallCacheCapacity = 4 * kSizeDummyEntry;
|
|
constexpr std::size_t kBigCacheCapacity = 4096 * kSizeDummyEntry;
|
|
constexpr std::size_t kMetaDataChargeOverhead = 10000;
|
|
|
|
LRUCacheOptions lo;
|
|
lo.capacity = kSmallCacheCapacity;
|
|
lo.num_shard_bits = 0; // 2^0 shard
|
|
lo.strict_capacity_limit = true;
|
|
std::shared_ptr<Cache> cache = NewLRUCache(lo);
|
|
std::unique_ptr<CacheReservationManager> test_cache_rev_mng(
|
|
new CacheReservationManager(cache));
|
|
|
|
std::size_t new_mem_used = kSmallCacheCapacity + 1;
|
|
Status s =
|
|
test_cache_rev_mng
|
|
->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
|
|
new_mem_used);
|
|
EXPECT_EQ(s, Status::Incomplete())
|
|
<< "Failed to return status to indicate failure of dummy entry insertion "
|
|
"during cache reservation on full cache";
|
|
EXPECT_GE(test_cache_rev_mng->GetTotalReservedCacheSize(),
|
|
1 * kSizeDummyEntry)
|
|
<< "Failed to bookkeep correctly before cache resevation failure happens "
|
|
"due to full cache";
|
|
EXPECT_LE(test_cache_rev_mng->GetTotalReservedCacheSize(),
|
|
kSmallCacheCapacity)
|
|
<< "Failed to bookkeep correctly (i.e, bookkeep only successful dummy "
|
|
"entry insertions) when encountering cache resevation failure due to "
|
|
"full cache";
|
|
EXPECT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used)
|
|
<< "Failed to bookkeep the used memory correctly";
|
|
EXPECT_GE(cache->GetPinnedUsage(), 1 * kSizeDummyEntry)
|
|
<< "Failed to insert underlying dummy entries correctly when "
|
|
"encountering cache resevation failure due to full cache";
|
|
EXPECT_LE(cache->GetPinnedUsage(), kSmallCacheCapacity)
|
|
<< "Failed to insert underlying dummy entries correctly when "
|
|
"encountering cache resevation failure due to full cache";
|
|
|
|
new_mem_used = kSmallCacheCapacity / 2; // 2 dummy entries
|
|
s = test_cache_rev_mng
|
|
->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
|
|
new_mem_used);
|
|
EXPECT_EQ(s, Status::OK())
|
|
<< "Failed to decrease cache reservation after encountering cache "
|
|
"reservation failure due to full cache";
|
|
EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
|
|
2 * kSizeDummyEntry)
|
|
<< "Failed to bookkeep cache reservation decrease correctly after "
|
|
"encountering cache reservation due to full cache";
|
|
EXPECT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used)
|
|
<< "Failed to bookkeep the used memory correctly";
|
|
EXPECT_GE(cache->GetPinnedUsage(), 2 * kSizeDummyEntry)
|
|
<< "Failed to release underlying dummy entries correctly on cache "
|
|
"reservation decrease after encountering cache resevation failure due "
|
|
"to full cache";
|
|
EXPECT_LT(cache->GetPinnedUsage(),
|
|
2 * kSizeDummyEntry + kMetaDataChargeOverhead)
|
|
<< "Failed to release underlying dummy entries correctly on cache "
|
|
"reservation decrease after encountering cache resevation failure due "
|
|
"to full cache";
|
|
|
|
// Create cache full again for subsequent tests
|
|
new_mem_used = kSmallCacheCapacity + 1;
|
|
s = test_cache_rev_mng
|
|
->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
|
|
new_mem_used);
|
|
EXPECT_EQ(s, Status::Incomplete())
|
|
<< "Failed to return status to indicate failure of dummy entry insertion "
|
|
"during cache reservation on full cache";
|
|
EXPECT_GE(test_cache_rev_mng->GetTotalReservedCacheSize(),
|
|
1 * kSizeDummyEntry)
|
|
<< "Failed to bookkeep correctly before cache resevation failure happens "
|
|
"due to full cache";
|
|
EXPECT_LE(test_cache_rev_mng->GetTotalReservedCacheSize(),
|
|
kSmallCacheCapacity)
|
|
<< "Failed to bookkeep correctly (i.e, bookkeep only successful dummy "
|
|
"entry insertions) when encountering cache resevation failure due to "
|
|
"full cache";
|
|
EXPECT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used)
|
|
<< "Failed to bookkeep the used memory correctly";
|
|
EXPECT_GE(cache->GetPinnedUsage(), 1 * kSizeDummyEntry)
|
|
<< "Failed to insert underlying dummy entries correctly when "
|
|
"encountering cache resevation failure due to full cache";
|
|
EXPECT_LE(cache->GetPinnedUsage(), kSmallCacheCapacity)
|
|
<< "Failed to insert underlying dummy entries correctly when "
|
|
"encountering cache resevation failure due to full cache";
|
|
|
|
// Increase cache capacity so the previously failed insertion can fully
|
|
// succeed
|
|
cache->SetCapacity(kBigCacheCapacity);
|
|
new_mem_used = kSmallCacheCapacity + 1;
|
|
s = test_cache_rev_mng
|
|
->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
|
|
new_mem_used);
|
|
EXPECT_EQ(s, Status::OK())
|
|
<< "Failed to increase cache reservation after increasing cache capacity "
|
|
"and mitigating cache full error";
|
|
EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
|
|
5 * kSizeDummyEntry)
|
|
<< "Failed to bookkeep cache reservation increase correctly after "
|
|
"increasing cache capacity and mitigating cache full error";
|
|
EXPECT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used)
|
|
<< "Failed to bookkeep the used memory correctly";
|
|
EXPECT_GE(cache->GetPinnedUsage(), 5 * kSizeDummyEntry)
|
|
<< "Failed to insert underlying dummy entries correctly after increasing "
|
|
"cache capacity and mitigating cache full error";
|
|
EXPECT_LT(cache->GetPinnedUsage(),
|
|
5 * kSizeDummyEntry + kMetaDataChargeOverhead)
|
|
<< "Failed to insert underlying dummy entries correctly after increasing "
|
|
"cache capacity and mitigating cache full error";
|
|
}
|
|
|
|
TEST_F(CacheReservationManagerTest,
|
|
DecreaseCacheReservationByMultiplesOfDummyEntrySize) {
|
|
std::size_t new_mem_used = 2 * kSizeDummyEntry;
|
|
Status s =
|
|
test_cache_rev_mng
|
|
->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
|
|
new_mem_used);
|
|
ASSERT_EQ(s, Status::OK());
|
|
ASSERT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
|
|
2 * kSizeDummyEntry);
|
|
ASSERT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used);
|
|
ASSERT_GE(cache->GetPinnedUsage(), 2 * kSizeDummyEntry);
|
|
ASSERT_LT(cache->GetPinnedUsage(),
|
|
2 * kSizeDummyEntry + kMetaDataChargeOverhead);
|
|
|
|
new_mem_used = 1 * kSizeDummyEntry;
|
|
s = test_cache_rev_mng
|
|
->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
|
|
new_mem_used);
|
|
EXPECT_EQ(s, Status::OK())
|
|
<< "Failed to decrease cache reservation correctly";
|
|
EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
|
|
1 * kSizeDummyEntry)
|
|
<< "Failed to bookkeep cache reservation decrease correctly";
|
|
EXPECT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used)
|
|
<< "Failed to bookkeep the used memory correctly";
|
|
EXPECT_GE(cache->GetPinnedUsage(), 1 * kSizeDummyEntry)
|
|
<< "Failed to decrease underlying dummy entries in cache correctly";
|
|
EXPECT_LT(cache->GetPinnedUsage(),
|
|
1 * kSizeDummyEntry + kMetaDataChargeOverhead)
|
|
<< "Failed to decrease underlying dummy entries in cache correctly";
|
|
}
|
|
|
|
TEST_F(CacheReservationManagerTest,
|
|
DecreaseCacheReservationNotByMultiplesOfDummyEntrySize) {
|
|
std::size_t new_mem_used = 2 * kSizeDummyEntry;
|
|
Status s =
|
|
test_cache_rev_mng
|
|
->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
|
|
new_mem_used);
|
|
ASSERT_EQ(s, Status::OK());
|
|
ASSERT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
|
|
2 * kSizeDummyEntry);
|
|
ASSERT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used);
|
|
ASSERT_GE(cache->GetPinnedUsage(), 2 * kSizeDummyEntry);
|
|
ASSERT_LT(cache->GetPinnedUsage(),
|
|
2 * kSizeDummyEntry + kMetaDataChargeOverhead);
|
|
|
|
new_mem_used = kSizeDummyEntry / 2;
|
|
s = test_cache_rev_mng
|
|
->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
|
|
new_mem_used);
|
|
EXPECT_EQ(s, Status::OK())
|
|
<< "Failed to decrease cache reservation correctly";
|
|
EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
|
|
1 * kSizeDummyEntry)
|
|
<< "Failed to bookkeep cache reservation decrease correctly";
|
|
EXPECT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used)
|
|
<< "Failed to bookkeep the used memory correctly";
|
|
EXPECT_GE(cache->GetPinnedUsage(), 1 * kSizeDummyEntry)
|
|
<< "Failed to decrease underlying dummy entries in cache correctly";
|
|
EXPECT_LT(cache->GetPinnedUsage(),
|
|
1 * kSizeDummyEntry + kMetaDataChargeOverhead)
|
|
<< "Failed to decrease underlying dummy entries in cache correctly";
|
|
}
|
|
|
|
TEST(CacheReservationManagerWithDelayedDecreaseTest,
|
|
DecreaseCacheReservationWithDelayedDecrease) {
|
|
constexpr std::size_t kSizeDummyEntry =
|
|
CacheReservationManager::GetDummyEntrySize();
|
|
constexpr std::size_t kCacheCapacity = 4096 * kSizeDummyEntry;
|
|
constexpr std::size_t kMetaDataChargeOverhead = 10000;
|
|
|
|
LRUCacheOptions lo;
|
|
lo.capacity = kCacheCapacity;
|
|
lo.num_shard_bits = 0;
|
|
std::shared_ptr<Cache> cache = NewLRUCache(lo);
|
|
std::unique_ptr<CacheReservationManager> test_cache_rev_mng(
|
|
new CacheReservationManager(cache, true /* delayed_decrease */));
|
|
|
|
std::size_t new_mem_used = 8 * kSizeDummyEntry;
|
|
Status s =
|
|
test_cache_rev_mng
|
|
->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
|
|
new_mem_used);
|
|
ASSERT_EQ(s, Status::OK());
|
|
ASSERT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
|
|
8 * kSizeDummyEntry);
|
|
ASSERT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used);
|
|
std::size_t initial_pinned_usage = cache->GetPinnedUsage();
|
|
ASSERT_GE(initial_pinned_usage, 8 * kSizeDummyEntry);
|
|
ASSERT_LT(initial_pinned_usage,
|
|
8 * kSizeDummyEntry + kMetaDataChargeOverhead);
|
|
|
|
new_mem_used = 6 * kSizeDummyEntry;
|
|
s = test_cache_rev_mng
|
|
->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
|
|
new_mem_used);
|
|
EXPECT_EQ(s, Status::OK()) << "Failed to delay decreasing cache reservation";
|
|
EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
|
|
8 * kSizeDummyEntry)
|
|
<< "Failed to bookkeep correctly when delaying cache reservation "
|
|
"decrease";
|
|
EXPECT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used)
|
|
<< "Failed to bookkeep the used memory correctly";
|
|
EXPECT_EQ(cache->GetPinnedUsage(), initial_pinned_usage)
|
|
<< "Failed to delay decreasing underlying dummy entries in cache";
|
|
|
|
new_mem_used = 7 * kSizeDummyEntry;
|
|
s = test_cache_rev_mng
|
|
->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
|
|
new_mem_used);
|
|
EXPECT_EQ(s, Status::OK()) << "Failed to delay decreasing cache reservation";
|
|
EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
|
|
8 * kSizeDummyEntry)
|
|
<< "Failed to bookkeep correctly when delaying cache reservation "
|
|
"decrease";
|
|
EXPECT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used)
|
|
<< "Failed to bookkeep the used memory correctly";
|
|
EXPECT_EQ(cache->GetPinnedUsage(), initial_pinned_usage)
|
|
<< "Failed to delay decreasing underlying dummy entries in cache";
|
|
|
|
new_mem_used = 6 * kSizeDummyEntry - 1;
|
|
s = test_cache_rev_mng
|
|
->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
|
|
new_mem_used);
|
|
EXPECT_EQ(s, Status::OK())
|
|
<< "Failed to decrease cache reservation correctly when new_mem_used < "
|
|
"GetTotalReservedCacheSize() * 3 / 4 on delayed decrease mode";
|
|
EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(),
|
|
6 * kSizeDummyEntry)
|
|
<< "Failed to bookkeep correctly when new_mem_used < "
|
|
"GetTotalReservedCacheSize() * 3 / 4 on delayed decrease mode";
|
|
EXPECT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), new_mem_used)
|
|
<< "Failed to bookkeep the used memory correctly";
|
|
EXPECT_GE(cache->GetPinnedUsage(), 6 * kSizeDummyEntry)
|
|
<< "Failed to decrease underlying dummy entries in cache when "
|
|
"new_mem_used < GetTotalReservedCacheSize() * 3 / 4 on delayed "
|
|
"decrease mode";
|
|
EXPECT_LT(cache->GetPinnedUsage(),
|
|
6 * kSizeDummyEntry + kMetaDataChargeOverhead)
|
|
<< "Failed to decrease underlying dummy entries in cache when "
|
|
"new_mem_used < GetTotalReservedCacheSize() * 3 / 4 on delayed "
|
|
"decrease mode";
|
|
}
|
|
|
|
TEST(CacheReservationManagerDestructorTest,
|
|
ReleaseRemainingDummyEntriesOnDestruction) {
|
|
constexpr std::size_t kSizeDummyEntry =
|
|
CacheReservationManager::GetDummyEntrySize();
|
|
constexpr std::size_t kCacheCapacity = 4096 * kSizeDummyEntry;
|
|
constexpr std::size_t kMetaDataChargeOverhead = 10000;
|
|
|
|
LRUCacheOptions lo;
|
|
lo.capacity = kCacheCapacity;
|
|
lo.num_shard_bits = 0;
|
|
std::shared_ptr<Cache> cache = NewLRUCache(lo);
|
|
{
|
|
std::unique_ptr<CacheReservationManager> test_cache_rev_mng(
|
|
new CacheReservationManager(cache));
|
|
std::size_t new_mem_used = 1 * kSizeDummyEntry;
|
|
Status s =
|
|
test_cache_rev_mng
|
|
->UpdateCacheReservation<ROCKSDB_NAMESPACE::CacheEntryRole::kMisc>(
|
|
new_mem_used);
|
|
ASSERT_EQ(s, Status::OK());
|
|
ASSERT_GE(cache->GetPinnedUsage(), 1 * kSizeDummyEntry);
|
|
ASSERT_LT(cache->GetPinnedUsage(),
|
|
1 * kSizeDummyEntry + kMetaDataChargeOverhead);
|
|
}
|
|
EXPECT_EQ(cache->GetPinnedUsage(), 0 * kSizeDummyEntry)
|
|
<< "Failed to release remaining underlying dummy entries in cache in "
|
|
"CacheReservationManager's destructor";
|
|
}
|
|
|
|
TEST(CacheReservationHandleTest, HandleTest) {
|
|
constexpr std::size_t kOneGigabyte = 1024 * 1024 * 1024;
|
|
constexpr std::size_t kSizeDummyEntry = 256 * 1024;
|
|
constexpr std::size_t kMetaDataChargeOverhead = 10000;
|
|
|
|
LRUCacheOptions lo;
|
|
lo.capacity = kOneGigabyte;
|
|
lo.num_shard_bits = 0;
|
|
std::shared_ptr<Cache> cache = NewLRUCache(lo);
|
|
|
|
std::shared_ptr<CacheReservationManager> test_cache_rev_mng(
|
|
std::make_shared<CacheReservationManager>(cache));
|
|
|
|
std::size_t mem_used = 0;
|
|
const std::size_t incremental_mem_used_handle_1 = 1 * kSizeDummyEntry;
|
|
const std::size_t incremental_mem_used_handle_2 = 2 * kSizeDummyEntry;
|
|
std::unique_ptr<CacheReservationHandle<CacheEntryRole::kMisc>> handle_1,
|
|
handle_2;
|
|
|
|
// To test consecutive CacheReservationManager::MakeCacheReservation works
|
|
// correctly in terms of returning the handle as well as updating cache
|
|
// reservation and the latest total memory used
|
|
Status s = test_cache_rev_mng->MakeCacheReservation<CacheEntryRole::kMisc>(
|
|
incremental_mem_used_handle_1, &handle_1);
|
|
mem_used = mem_used + incremental_mem_used_handle_1;
|
|
ASSERT_EQ(s, Status::OK());
|
|
EXPECT_TRUE(handle_1 != nullptr);
|
|
EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(), mem_used);
|
|
EXPECT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), mem_used);
|
|
EXPECT_GE(cache->GetPinnedUsage(), mem_used);
|
|
EXPECT_LT(cache->GetPinnedUsage(), mem_used + kMetaDataChargeOverhead);
|
|
|
|
s = test_cache_rev_mng->MakeCacheReservation<CacheEntryRole::kMisc>(
|
|
incremental_mem_used_handle_2, &handle_2);
|
|
mem_used = mem_used + incremental_mem_used_handle_2;
|
|
ASSERT_EQ(s, Status::OK());
|
|
EXPECT_TRUE(handle_2 != nullptr);
|
|
EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(), mem_used);
|
|
EXPECT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), mem_used);
|
|
EXPECT_GE(cache->GetPinnedUsage(), mem_used);
|
|
EXPECT_LT(cache->GetPinnedUsage(), mem_used + kMetaDataChargeOverhead);
|
|
|
|
// To test CacheReservationHandle::~CacheReservationHandle() works correctly
|
|
// in releasing the cache reserved for the handle
|
|
handle_1.reset();
|
|
EXPECT_TRUE(handle_1 == nullptr);
|
|
mem_used = mem_used - incremental_mem_used_handle_1;
|
|
EXPECT_EQ(test_cache_rev_mng->GetTotalReservedCacheSize(), mem_used);
|
|
EXPECT_EQ(test_cache_rev_mng->GetTotalMemoryUsed(), mem_used);
|
|
EXPECT_GE(cache->GetPinnedUsage(), mem_used);
|
|
EXPECT_LT(cache->GetPinnedUsage(), mem_used + kMetaDataChargeOverhead);
|
|
|
|
// To test the actual CacheReservationManager object won't be deallocated
|
|
// as long as there remain handles pointing to it.
|
|
// We strongly recommend deallocating CacheReservationManager object only
|
|
// after all its handles are deallocated to keep things easy to reasonate
|
|
test_cache_rev_mng.reset();
|
|
EXPECT_GE(cache->GetPinnedUsage(), mem_used);
|
|
EXPECT_LT(cache->GetPinnedUsage(), mem_used + kMetaDataChargeOverhead);
|
|
|
|
handle_2.reset();
|
|
// The CacheReservationManager object is now deallocated since all the handles
|
|
// and its original pointer is gone
|
|
mem_used = mem_used - incremental_mem_used_handle_2;
|
|
EXPECT_EQ(mem_used, 0);
|
|
EXPECT_EQ(cache->GetPinnedUsage(), mem_used);
|
|
}
|
|
} // namespace ROCKSDB_NAMESPACE
|
|
|
|
int main(int argc, char** argv) {
|
|
::testing::InitGoogleTest(&argc, argv);
|
|
return RUN_ALL_TESTS();
|
|
}
|