]>
Commit | Line | Data |
---|---|---|
7c673cae | 1 | // Copyright (c) 2011-present, 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 | // Copyright (c) 2011 The LevelDB Authors. All rights reserved. | |
7 | // Use of this source code is governed by a BSD-style license that can be | |
8 | // found in the LICENSE file. See the AUTHORS file for names of contributors. | |
9 | ||
10 | #ifndef NDEBUG | |
11 | ||
12 | #include "db/db_impl.h" | |
11fdf7f2 | 13 | #include "db/error_handler.h" |
7c673cae FG |
14 | #include "monitoring/thread_status_updater.h" |
15 | ||
16 | namespace rocksdb { | |
17 | ||
18 | uint64_t DBImpl::TEST_GetLevel0TotalSize() { | |
19 | InstrumentedMutexLock l(&mutex_); | |
20 | return default_cf_handle_->cfd()->current()->storage_info()->NumLevelBytes(0); | |
21 | } | |
22 | ||
11fdf7f2 | 23 | void DBImpl::TEST_SwitchWAL() { |
7c673cae FG |
24 | WriteContext write_context; |
25 | InstrumentedMutexLock l(&mutex_); | |
11fdf7f2 TL |
26 | SwitchWAL(&write_context); |
27 | } | |
28 | ||
29 | bool DBImpl::TEST_WALBufferIsEmpty() { | |
30 | InstrumentedMutexLock wl(&log_write_mutex_); | |
31 | log::Writer* cur_log_writer = logs_.back().writer; | |
32 | return cur_log_writer->TEST_BufferIsEmpty(); | |
7c673cae FG |
33 | } |
34 | ||
35 | int64_t DBImpl::TEST_MaxNextLevelOverlappingBytes( | |
36 | ColumnFamilyHandle* column_family) { | |
37 | ColumnFamilyData* cfd; | |
38 | if (column_family == nullptr) { | |
39 | cfd = default_cf_handle_->cfd(); | |
40 | } else { | |
41 | auto cfh = reinterpret_cast<ColumnFamilyHandleImpl*>(column_family); | |
42 | cfd = cfh->cfd(); | |
43 | } | |
44 | InstrumentedMutexLock l(&mutex_); | |
45 | return cfd->current()->storage_info()->MaxNextLevelOverlappingBytes(); | |
46 | } | |
47 | ||
48 | void DBImpl::TEST_GetFilesMetaData( | |
49 | ColumnFamilyHandle* column_family, | |
50 | std::vector<std::vector<FileMetaData>>* metadata) { | |
51 | auto cfh = reinterpret_cast<ColumnFamilyHandleImpl*>(column_family); | |
52 | auto cfd = cfh->cfd(); | |
53 | InstrumentedMutexLock l(&mutex_); | |
54 | metadata->resize(NumberLevels()); | |
55 | for (int level = 0; level < NumberLevels(); level++) { | |
56 | const std::vector<FileMetaData*>& files = | |
57 | cfd->current()->storage_info()->LevelFiles(level); | |
58 | ||
59 | (*metadata)[level].clear(); | |
60 | for (const auto& f : files) { | |
61 | (*metadata)[level].push_back(*f); | |
62 | } | |
63 | } | |
64 | } | |
65 | ||
66 | uint64_t DBImpl::TEST_Current_Manifest_FileNo() { | |
67 | return versions_->manifest_file_number(); | |
68 | } | |
69 | ||
11fdf7f2 TL |
70 | uint64_t DBImpl::TEST_Current_Next_FileNo() { |
71 | return versions_->current_next_file_number(); | |
72 | } | |
73 | ||
7c673cae FG |
74 | Status DBImpl::TEST_CompactRange(int level, const Slice* begin, |
75 | const Slice* end, | |
76 | ColumnFamilyHandle* column_family, | |
77 | bool disallow_trivial_move) { | |
78 | ColumnFamilyData* cfd; | |
79 | if (column_family == nullptr) { | |
80 | cfd = default_cf_handle_->cfd(); | |
81 | } else { | |
82 | auto cfh = reinterpret_cast<ColumnFamilyHandleImpl*>(column_family); | |
83 | cfd = cfh->cfd(); | |
84 | } | |
85 | int output_level = | |
86 | (cfd->ioptions()->compaction_style == kCompactionStyleUniversal || | |
87 | cfd->ioptions()->compaction_style == kCompactionStyleFIFO) | |
88 | ? level | |
89 | : level + 1; | |
11fdf7f2 | 90 | return RunManualCompaction(cfd, level, output_level, 0, 0, begin, end, true, |
7c673cae FG |
91 | disallow_trivial_move); |
92 | } | |
93 | ||
11fdf7f2 TL |
94 | Status DBImpl::TEST_SwitchMemtable(ColumnFamilyData* cfd) { |
95 | WriteContext write_context; | |
96 | InstrumentedMutexLock l(&mutex_); | |
97 | if (cfd == nullptr) { | |
98 | cfd = default_cf_handle_->cfd(); | |
99 | } | |
100 | return SwitchMemtable(cfd, &write_context); | |
101 | } | |
102 | ||
103 | Status DBImpl::TEST_FlushMemTable(bool wait, bool allow_write_stall, | |
104 | ColumnFamilyHandle* cfh) { | |
7c673cae FG |
105 | FlushOptions fo; |
106 | fo.wait = wait; | |
11fdf7f2 | 107 | fo.allow_write_stall = allow_write_stall; |
7c673cae FG |
108 | ColumnFamilyData* cfd; |
109 | if (cfh == nullptr) { | |
110 | cfd = default_cf_handle_->cfd(); | |
111 | } else { | |
112 | auto cfhi = reinterpret_cast<ColumnFamilyHandleImpl*>(cfh); | |
113 | cfd = cfhi->cfd(); | |
114 | } | |
11fdf7f2 | 115 | return FlushMemTable(cfd, fo, FlushReason::kTest); |
7c673cae FG |
116 | } |
117 | ||
118 | Status DBImpl::TEST_WaitForFlushMemTable(ColumnFamilyHandle* column_family) { | |
119 | ColumnFamilyData* cfd; | |
120 | if (column_family == nullptr) { | |
121 | cfd = default_cf_handle_->cfd(); | |
122 | } else { | |
123 | auto cfh = reinterpret_cast<ColumnFamilyHandleImpl*>(column_family); | |
124 | cfd = cfh->cfd(); | |
125 | } | |
126 | return WaitForFlushMemTable(cfd); | |
127 | } | |
128 | ||
11fdf7f2 | 129 | Status DBImpl::TEST_WaitForCompact(bool wait_unscheduled) { |
7c673cae FG |
130 | // Wait until the compaction completes |
131 | ||
132 | // TODO: a bug here. This function actually does not necessarily | |
133 | // wait for compact. It actually waits for scheduled compaction | |
134 | // OR flush to finish. | |
135 | ||
136 | InstrumentedMutexLock l(&mutex_); | |
11fdf7f2 TL |
137 | while ((bg_bottom_compaction_scheduled_ || bg_compaction_scheduled_ || |
138 | bg_flush_scheduled_ || | |
139 | (wait_unscheduled && unscheduled_compactions_)) && | |
140 | (error_handler_.GetBGError() == Status::OK())) { | |
7c673cae FG |
141 | bg_cv_.Wait(); |
142 | } | |
11fdf7f2 | 143 | return error_handler_.GetBGError(); |
7c673cae FG |
144 | } |
145 | ||
146 | void DBImpl::TEST_LockMutex() { | |
147 | mutex_.Lock(); | |
148 | } | |
149 | ||
150 | void DBImpl::TEST_UnlockMutex() { | |
151 | mutex_.Unlock(); | |
152 | } | |
153 | ||
154 | void* DBImpl::TEST_BeginWrite() { | |
155 | auto w = new WriteThread::Writer(); | |
156 | write_thread_.EnterUnbatched(w, &mutex_); | |
157 | return reinterpret_cast<void*>(w); | |
158 | } | |
159 | ||
160 | void DBImpl::TEST_EndWrite(void* w) { | |
161 | auto writer = reinterpret_cast<WriteThread::Writer*>(w); | |
162 | write_thread_.ExitUnbatched(writer); | |
163 | delete writer; | |
164 | } | |
165 | ||
166 | size_t DBImpl::TEST_LogsToFreeSize() { | |
167 | InstrumentedMutexLock l(&mutex_); | |
168 | return logs_to_free_.size(); | |
169 | } | |
170 | ||
171 | uint64_t DBImpl::TEST_LogfileNumber() { | |
172 | InstrumentedMutexLock l(&mutex_); | |
173 | return logfile_number_; | |
174 | } | |
175 | ||
176 | Status DBImpl::TEST_GetAllImmutableCFOptions( | |
177 | std::unordered_map<std::string, const ImmutableCFOptions*>* iopts_map) { | |
178 | std::vector<std::string> cf_names; | |
179 | std::vector<const ImmutableCFOptions*> iopts; | |
180 | { | |
181 | InstrumentedMutexLock l(&mutex_); | |
182 | for (auto cfd : *versions_->GetColumnFamilySet()) { | |
183 | cf_names.push_back(cfd->GetName()); | |
184 | iopts.push_back(cfd->ioptions()); | |
185 | } | |
186 | } | |
187 | iopts_map->clear(); | |
188 | for (size_t i = 0; i < cf_names.size(); ++i) { | |
189 | iopts_map->insert({cf_names[i], iopts[i]}); | |
190 | } | |
191 | ||
192 | return Status::OK(); | |
193 | } | |
194 | ||
195 | uint64_t DBImpl::TEST_FindMinLogContainingOutstandingPrep() { | |
11fdf7f2 TL |
196 | return logs_with_prep_tracker_.FindMinLogContainingOutstandingPrep(); |
197 | } | |
198 | ||
199 | size_t DBImpl::TEST_PreparedSectionCompletedSize() { | |
200 | return logs_with_prep_tracker_.TEST_PreparedSectionCompletedSize(); | |
201 | } | |
202 | ||
203 | size_t DBImpl::TEST_LogsWithPrepSize() { | |
204 | return logs_with_prep_tracker_.TEST_LogsWithPrepSize(); | |
7c673cae FG |
205 | } |
206 | ||
207 | uint64_t DBImpl::TEST_FindMinPrepLogReferencedByMemTable() { | |
11fdf7f2 TL |
208 | autovector<MemTable*> empty_list; |
209 | return FindMinPrepLogReferencedByMemTable(versions_.get(), nullptr, | |
210 | empty_list); | |
7c673cae FG |
211 | } |
212 | ||
213 | Status DBImpl::TEST_GetLatestMutableCFOptions( | |
214 | ColumnFamilyHandle* column_family, MutableCFOptions* mutable_cf_options) { | |
215 | InstrumentedMutexLock l(&mutex_); | |
216 | ||
217 | auto cfh = reinterpret_cast<ColumnFamilyHandleImpl*>(column_family); | |
218 | *mutable_cf_options = *cfh->cfd()->GetLatestMutableCFOptions(); | |
219 | return Status::OK(); | |
220 | } | |
221 | ||
222 | int DBImpl::TEST_BGCompactionsAllowed() const { | |
223 | InstrumentedMutexLock l(&mutex_); | |
11fdf7f2 TL |
224 | return GetBGJobLimits().max_compactions; |
225 | } | |
226 | ||
227 | int DBImpl::TEST_BGFlushesAllowed() const { | |
228 | InstrumentedMutexLock l(&mutex_); | |
229 | return GetBGJobLimits().max_flushes; | |
230 | } | |
231 | ||
232 | SequenceNumber DBImpl::TEST_GetLastVisibleSequence() const { | |
233 | if (last_seq_same_as_publish_seq_) { | |
234 | return versions_->LastSequence(); | |
235 | } else { | |
236 | return versions_->LastAllocatedSequence(); | |
237 | } | |
238 | } | |
239 | ||
240 | size_t DBImpl::TEST_GetWalPreallocateBlockSize( | |
241 | uint64_t write_buffer_size) const { | |
242 | InstrumentedMutexLock l(&mutex_); | |
243 | return GetWalPreallocateBlockSize(write_buffer_size); | |
7c673cae FG |
244 | } |
245 | ||
246 | } // namespace rocksdb | |
247 | #endif // NDEBUG |