]>
Commit | Line | Data |
---|---|---|
7c673cae | 1 | // Copyright (c) 2013, Facebook, Inc. All rights reserved. |
11fdf7f2 TL |
2 | // This source code is licensed under both the GPLv2 (found in the |
3 | // COPYING file in the root directory) and Apache 2.0 License | |
4 | // (found in the LICENSE.Apache file in the root directory). | |
7c673cae FG |
5 | // |
6 | #ifndef ROCKSDB_LITE | |
7 | ||
7c673cae FG |
8 | #include "utilities/persistent_cache/persistent_cache_tier.h" |
9 | ||
f67539c2 | 10 | #include <cinttypes> |
7c673cae | 11 | #include <sstream> |
f67539c2 | 12 | #include <string> |
7c673cae | 13 | |
f67539c2 | 14 | namespace ROCKSDB_NAMESPACE { |
7c673cae FG |
15 | |
16 | std::string PersistentCacheConfig::ToString() const { | |
17 | std::string ret; | |
18 | ret.reserve(20000); | |
19 | const int kBufferSize = 200; | |
20 | char buffer[kBufferSize]; | |
21 | ||
22 | snprintf(buffer, kBufferSize, " path: %s\n", path.c_str()); | |
23 | ret.append(buffer); | |
24 | snprintf(buffer, kBufferSize, " enable_direct_reads: %d\n", | |
25 | enable_direct_reads); | |
26 | ret.append(buffer); | |
27 | snprintf(buffer, kBufferSize, " enable_direct_writes: %d\n", | |
28 | enable_direct_writes); | |
29 | ret.append(buffer); | |
30 | snprintf(buffer, kBufferSize, " cache_size: %" PRIu64 "\n", cache_size); | |
31 | ret.append(buffer); | |
32 | snprintf(buffer, kBufferSize, " cache_file_size: %" PRIu32 "\n", | |
33 | cache_file_size); | |
34 | ret.append(buffer); | |
35 | snprintf(buffer, kBufferSize, " writer_qdepth: %" PRIu32 "\n", | |
36 | writer_qdepth); | |
37 | ret.append(buffer); | |
38 | snprintf(buffer, kBufferSize, " pipeline_writes: %d\n", pipeline_writes); | |
39 | ret.append(buffer); | |
40 | snprintf(buffer, kBufferSize, | |
41 | " max_write_pipeline_backlog_size: %" PRIu64 "\n", | |
42 | max_write_pipeline_backlog_size); | |
43 | ret.append(buffer); | |
44 | snprintf(buffer, kBufferSize, " write_buffer_size: %" PRIu32 "\n", | |
45 | write_buffer_size); | |
46 | ret.append(buffer); | |
47 | snprintf(buffer, kBufferSize, " writer_dispatch_size: %" PRIu64 "\n", | |
48 | writer_dispatch_size); | |
49 | ret.append(buffer); | |
50 | snprintf(buffer, kBufferSize, " is_compressed: %d\n", is_compressed); | |
51 | ret.append(buffer); | |
52 | ||
53 | return ret; | |
54 | } | |
55 | ||
56 | // | |
57 | // PersistentCacheTier implementation | |
58 | // | |
59 | Status PersistentCacheTier::Open() { | |
60 | if (next_tier_) { | |
61 | return next_tier_->Open(); | |
62 | } | |
63 | return Status::OK(); | |
64 | } | |
65 | ||
66 | Status PersistentCacheTier::Close() { | |
67 | if (next_tier_) { | |
68 | return next_tier_->Close(); | |
69 | } | |
70 | return Status::OK(); | |
71 | } | |
72 | ||
11fdf7f2 | 73 | bool PersistentCacheTier::Reserve(const size_t /*size*/) { |
7c673cae FG |
74 | // default implementation is a pass through |
75 | return true; | |
76 | } | |
77 | ||
11fdf7f2 | 78 | bool PersistentCacheTier::Erase(const Slice& /*key*/) { |
7c673cae FG |
79 | // default implementation is a pass through since not all cache tiers might |
80 | // support erase | |
81 | return true; | |
82 | } | |
83 | ||
84 | std::string PersistentCacheTier::PrintStats() { | |
85 | std::ostringstream os; | |
86 | for (auto tier_stats : Stats()) { | |
87 | os << "---- next tier -----" << std::endl; | |
88 | for (auto stat : tier_stats) { | |
89 | os << stat.first << ": " << stat.second << std::endl; | |
90 | } | |
91 | } | |
92 | return os.str(); | |
93 | } | |
94 | ||
95 | PersistentCache::StatsType PersistentCacheTier::Stats() { | |
96 | if (next_tier_) { | |
97 | return next_tier_->Stats(); | |
98 | } | |
99 | return PersistentCache::StatsType{}; | |
100 | } | |
101 | ||
20effc67 TL |
102 | uint64_t PersistentCacheTier::NewId() { |
103 | return last_id_.fetch_add(1, std::memory_order_relaxed); | |
104 | } | |
105 | ||
7c673cae FG |
106 | // |
107 | // PersistentTieredCache implementation | |
108 | // | |
109 | PersistentTieredCache::~PersistentTieredCache() { assert(tiers_.empty()); } | |
110 | ||
111 | Status PersistentTieredCache::Open() { | |
112 | assert(!tiers_.empty()); | |
113 | return tiers_.front()->Open(); | |
114 | } | |
115 | ||
116 | Status PersistentTieredCache::Close() { | |
117 | assert(!tiers_.empty()); | |
118 | Status status = tiers_.front()->Close(); | |
119 | if (status.ok()) { | |
120 | tiers_.clear(); | |
121 | } | |
122 | return status; | |
123 | } | |
124 | ||
125 | bool PersistentTieredCache::Erase(const Slice& key) { | |
126 | assert(!tiers_.empty()); | |
127 | return tiers_.front()->Erase(key); | |
128 | } | |
129 | ||
130 | PersistentCache::StatsType PersistentTieredCache::Stats() { | |
131 | assert(!tiers_.empty()); | |
132 | return tiers_.front()->Stats(); | |
133 | } | |
134 | ||
135 | std::string PersistentTieredCache::PrintStats() { | |
136 | assert(!tiers_.empty()); | |
137 | return tiers_.front()->PrintStats(); | |
138 | } | |
139 | ||
140 | Status PersistentTieredCache::Insert(const Slice& page_key, const char* data, | |
141 | const size_t size) { | |
142 | assert(!tiers_.empty()); | |
143 | return tiers_.front()->Insert(page_key, data, size); | |
144 | } | |
145 | ||
146 | Status PersistentTieredCache::Lookup(const Slice& page_key, | |
147 | std::unique_ptr<char[]>* data, | |
148 | size_t* size) { | |
149 | assert(!tiers_.empty()); | |
150 | return tiers_.front()->Lookup(page_key, data, size); | |
151 | } | |
152 | ||
153 | void PersistentTieredCache::AddTier(const Tier& tier) { | |
154 | if (!tiers_.empty()) { | |
155 | tiers_.back()->set_next_tier(tier); | |
156 | } | |
157 | tiers_.push_back(tier); | |
158 | } | |
159 | ||
160 | bool PersistentTieredCache::IsCompressed() { | |
161 | assert(tiers_.size()); | |
162 | return tiers_.front()->IsCompressed(); | |
163 | } | |
164 | ||
f67539c2 | 165 | } // namespace ROCKSDB_NAMESPACE |
7c673cae FG |
166 | |
167 | #endif |