andreacavalli/rocksdb
0
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Fix db_properties_test for ASSERT_STATUS_CHECKED (#7490)

Browse Source 
Summary:
Add all status handling in db_properties_test so that it can pass ASSERT_STATUS_CHECKED.

Pull Request resolved: https://github.com/facebook/rocksdb/pull/7490

Test Plan: Run the test with ASSERT_STATUS_CHECKED

Reviewed By: jay-zhuang

Differential Revision: D24065382

fbshipit-source-id: e008916155196891478c964df0226545308ca71d
This commit is contained in:
sdong 2020-10-01 17:45:52 -07:00 committed by Facebook GitHub Bot
parent 685cabdafa
commit 94fc676d3f
4 changed files with 104 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Makefile
View File

@ -590,6 +590,7 @@ ifdef ASSERT_STATUS_CHECKED
db_with_timestamp_basic_test \ db_with_timestamp_basic_test \
db_with_timestamp_compaction_test \ db_with_timestamp_compaction_test \
db_options_test \ db_options_test \
db_properties_test \
options_file_test \ options_file_test \
defer_test \ defer_test \
filename_test \ filename_test \

184
db/db_properties_test.cc
View File

@ -53,12 +53,12 @@ TEST_F(DBPropertiesTest, Empty) {
// Block sync calls // Block sync calls
env_->delay_sstable_sync_.store(true, std::memory_order_release); env_->delay_sstable_sync_.store(true, std::memory_order_release);
Put(1, "k1", std::string(100000, 'x')); // Fill memtable ASSERT_OK(Put(1, "k1", std::string(100000, 'x'))); // Fill memtable
ASSERT_TRUE(dbfull()->GetProperty( ASSERT_TRUE(dbfull()->GetProperty(
handles_[1], "rocksdb.num-entries-active-mem-table", &num)); handles_[1], "rocksdb.num-entries-active-mem-table", &num));
ASSERT_EQ("2", num); ASSERT_EQ("2", num);
Put(1, "k2", std::string(100000, 'y')); // Trigger compaction ASSERT_OK(Put(1, "k2", std::string(100000, 'y'))); // Trigger compaction
ASSERT_TRUE(dbfull()->GetProperty( ASSERT_TRUE(dbfull()->GetProperty(
handles_[1], "rocksdb.num-entries-active-mem-table", &num)); handles_[1], "rocksdb.num-entries-active-mem-table", &num));
ASSERT_EQ("1", num); ASSERT_EQ("1", num);
@ -98,10 +98,10 @@ TEST_F(DBPropertiesTest, CurrentVersionNumber) {
uint64_t v1, v2, v3; uint64_t v1, v2, v3;
ASSERT_TRUE( ASSERT_TRUE(
dbfull()->GetIntProperty("rocksdb.current-super-version-number", &v1)); dbfull()->GetIntProperty("rocksdb.current-super-version-number", &v1));
Put("12345678", ""); ASSERT_OK(Put("12345678", ""));
ASSERT_TRUE( ASSERT_TRUE(
dbfull()->GetIntProperty("rocksdb.current-super-version-number", &v2)); dbfull()->GetIntProperty("rocksdb.current-super-version-number", &v2));
Flush(); ASSERT_OK(Flush());
ASSERT_TRUE( ASSERT_TRUE(
dbfull()->GetIntProperty("rocksdb.current-super-version-number", &v3)); dbfull()->GetIntProperty("rocksdb.current-super-version-number", &v3));
@ -127,8 +127,8 @@ TEST_F(DBPropertiesTest, GetAggregatedIntPropertyTest) {
Random rnd(301); Random rnd(301);
for (auto* handle : handles_) { for (auto* handle : handles_) {
for (int i = 0; i < kKeyNum; ++i) { for (int i = 0; i < kKeyNum; ++i) {
db_->Put(WriteOptions(), handle, rnd.RandomString(kKeySize), ASSERT_OK(db_->Put(WriteOptions(), handle, rnd.RandomString(kKeySize),
rnd.RandomString(kValueSize)); rnd.RandomString(kValueSize)));
} }
} }
@ -154,7 +154,7 @@ TEST_F(DBPropertiesTest, GetAggregatedIntPropertyTest) {
DB::Properties::kEstimateTableReadersMem, &before_flush_trm)); DB::Properties::kEstimateTableReadersMem, &before_flush_trm));
// Issue flush and expect larger memory usage of table readers. // Issue flush and expect larger memory usage of table readers.
db_->Flush(FlushOptions(), handle); ASSERT_OK(db_->Flush(FlushOptions(), handle));
ASSERT_TRUE(db_->GetAggregatedIntProperty( ASSERT_TRUE(db_->GetAggregatedIntProperty(
DB::Properties::kEstimateTableReadersMem, &after_flush_trm)); DB::Properties::kEstimateTableReadersMem, &after_flush_trm));
@ -300,9 +300,9 @@ TEST_F(DBPropertiesTest, ValidateSampleNumber) {
for (int i = 0; i < files; i++) { for (int i = 0; i < files; i++) {
int rows = files / 10; int rows = files / 10;
for (int j = 0; j < rows; j++) { for (int j = 0; j < rows; j++) {
db_->Put(WriteOptions(), std::to_string(++key), "foo"); ASSERT_OK(db_->Put(WriteOptions(), std::to_string(++key), "foo"));
} }
db_->Flush(FlushOptions()); ASSERT_OK(db_->Flush(FlushOptions()));
} }
} }
std::string num; std::string num;
@ -347,23 +347,24 @@ TEST_F(DBPropertiesTest, AggregatedTableProperties) {
Random rnd(5632); Random rnd(5632);
for (int table = 1; table <= kTableCount; ++table) { for (int table = 1; table <= kTableCount; ++table) {
for (int i = 0; i < kPutsPerTable; ++i) { for (int i = 0; i < kPutsPerTable; ++i) {
db_->Put(WriteOptions(), rnd.RandomString(kKeySize), ASSERT_OK(db_->Put(WriteOptions(), rnd.RandomString(kKeySize),
rnd.RandomString(kValueSize)); rnd.RandomString(kValueSize)));
} }
for (int i = 0; i < kDeletionsPerTable; i++) { for (int i = 0; i < kDeletionsPerTable; i++) {
db_->Delete(WriteOptions(), rnd.RandomString(kKeySize)); ASSERT_OK(db_->Delete(WriteOptions(), rnd.RandomString(kKeySize)));
} }
for (int i = 0; i < kMergeOperandsPerTable; i++) { for (int i = 0; i < kMergeOperandsPerTable; i++) {
db_->Merge(WriteOptions(), rnd.RandomString(kKeySize), ASSERT_OK(db_->Merge(WriteOptions(), rnd.RandomString(kKeySize),
rnd.RandomString(kValueSize)); rnd.RandomString(kValueSize)));
} }
for (int i = 0; i < kRangeDeletionsPerTable; i++) { for (int i = 0; i < kRangeDeletionsPerTable; i++) {
std::string start = rnd.RandomString(kKeySize); std::string start = rnd.RandomString(kKeySize);
std::string end = start; std::string end = start;
end.resize(kValueSize); end.resize(kValueSize);
db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(), start, end); ASSERT_OK(db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(),
start, end));
} }
db_->Flush(FlushOptions()); ASSERT_OK(db_->Flush(FlushOptions()));
} }
std::string property; std::string property;
db_->GetProperty(DB::Properties::kAggregatedTableProperties, &property); db_->GetProperty(DB::Properties::kAggregatedTableProperties, &property);
@ -410,11 +411,11 @@ TEST_F(DBPropertiesTest, ReadLatencyHistogramByLevel) {
int key_index = 0; int key_index = 0;
Random rnd(301); Random rnd(301);
for (int num = 0; num < 8; num++) { for (int num = 0; num < 8; num++) {
Put("foo", "bar"); ASSERT_OK(Put("foo", "bar"));
GenerateNewFile(&rnd, &key_index); GenerateNewFile(&rnd, &key_index);
dbfull()->TEST_WaitForCompact(); ASSERT_OK(dbfull()->TEST_WaitForCompact());
} }
dbfull()->TEST_WaitForCompact(); ASSERT_OK(dbfull()->TEST_WaitForCompact());
std::string prop; std::string prop;
ASSERT_TRUE(dbfull()->GetProperty("rocksdb.dbstats", &prop)); ASSERT_TRUE(dbfull()->GetProperty("rocksdb.dbstats", &prop));
@ -430,7 +431,7 @@ TEST_F(DBPropertiesTest, ReadLatencyHistogramByLevel) {
// Reopen and issue Get(). See thee latency tracked // Reopen and issue Get(). See thee latency tracked
ReopenWithColumnFamilies({"default", "pikachu"}, options); ReopenWithColumnFamilies({"default", "pikachu"}, options);
dbfull()->TEST_WaitForCompact(); ASSERT_OK(dbfull()->TEST_WaitForCompact());
for (int key = 0; key < key_index; key++) { for (int key = 0; key < key_index; key++) {
Get(Key(key)); Get(Key(key));
} }
@ -458,6 +459,7 @@ TEST_F(DBPropertiesTest, ReadLatencyHistogramByLevel) {
std::unique_ptr<Iterator> iter(db_->NewIterator(ReadOptions())); std::unique_ptr<Iterator> iter(db_->NewIterator(ReadOptions()));
for (iter->Seek(Key(0)); iter->Valid(); iter->Next()) { for (iter->Seek(Key(0)); iter->Valid(); iter->Next()) {
} }
ASSERT_OK(iter->status());
} }
ASSERT_TRUE(dbfull()->GetProperty("rocksdb.cf-file-histogram", &prop)); ASSERT_TRUE(dbfull()->GetProperty("rocksdb.cf-file-histogram", &prop));
ASSERT_NE(std::string::npos, prop.find("** Level 0 read latency histogram")); ASSERT_NE(std::string::npos, prop.find("** Level 0 read latency histogram"));
@ -471,9 +473,9 @@ TEST_F(DBPropertiesTest, ReadLatencyHistogramByLevel) {
ASSERT_EQ(std::string::npos, prop.find("** Level 1 read latency histogram")); ASSERT_EQ(std::string::npos, prop.find("** Level 1 read latency histogram"));
ASSERT_EQ(std::string::npos, prop.find("** Level 2 read latency histogram")); ASSERT_EQ(std::string::npos, prop.find("** Level 2 read latency histogram"));
// put something and read it back , CF 1 should show histogram. // put something and read it back , CF 1 should show histogram.
Put(1, "foo", "bar"); ASSERT_OK(Put(1, "foo", "bar"));
Flush(1); ASSERT_OK(Flush(1));
dbfull()->TEST_WaitForCompact(); ASSERT_OK(dbfull()->TEST_WaitForCompact());
ASSERT_EQ("bar", Get(1, "foo")); ASSERT_EQ("bar", Get(1, "foo"));
ASSERT_TRUE( ASSERT_TRUE(
@ -499,7 +501,7 @@ TEST_F(DBPropertiesTest, ReadLatencyHistogramByLevel) {
ASSERT_EQ(std::string::npos, prop.find("** Level 2 read latency histogram")); ASSERT_EQ(std::string::npos, prop.find("** Level 2 read latency histogram"));
// Clear internal stats // Clear internal stats
dbfull()->ResetStats(); ASSERT_OK(dbfull()->ResetStats());
ASSERT_TRUE(dbfull()->GetProperty("rocksdb.cfstats", &prop)); ASSERT_TRUE(dbfull()->GetProperty("rocksdb.cfstats", &prop));
ASSERT_EQ(std::string::npos, prop.find("** Level 0 read latency histogram")); ASSERT_EQ(std::string::npos, prop.find("** Level 0 read latency histogram"));
ASSERT_EQ(std::string::npos, prop.find("** Level 1 read latency histogram")); ASSERT_EQ(std::string::npos, prop.find("** Level 1 read latency histogram"));
@ -547,24 +549,25 @@ TEST_F(DBPropertiesTest, AggregatedTablePropertiesAtLevel) {
TableProperties tp, sum_tp, expected_tp; TableProperties tp, sum_tp, expected_tp;
for (int table = 1; table <= kTableCount; ++table) { for (int table = 1; table <= kTableCount; ++table) {
for (int i = 0; i < kPutsPerTable; ++i) { for (int i = 0; i < kPutsPerTable; ++i) {
db_->Put(WriteOptions(), rnd.RandomString(kKeySize), ASSERT_OK(db_->Put(WriteOptions(), rnd.RandomString(kKeySize),
rnd.RandomString(kValueSize)); rnd.RandomString(kValueSize)));
} }
for (int i = 0; i < kDeletionsPerTable; i++) { for (int i = 0; i < kDeletionsPerTable; i++) {
db_->Delete(WriteOptions(), rnd.RandomString(kKeySize)); ASSERT_OK(db_->Delete(WriteOptions(), rnd.RandomString(kKeySize)));
} }
for (int i = 0; i < kMergeOperandsPerTable; i++) { for (int i = 0; i < kMergeOperandsPerTable; i++) {
db_->Merge(WriteOptions(), rnd.RandomString(kKeySize), ASSERT_OK(db_->Merge(WriteOptions(), rnd.RandomString(kKeySize),
rnd.RandomString(kValueSize)); rnd.RandomString(kValueSize)));
} }
for (int i = 0; i < kRangeDeletionsPerTable; i++) { for (int i = 0; i < kRangeDeletionsPerTable; i++) {
std::string start = rnd.RandomString(kKeySize); std::string start = rnd.RandomString(kKeySize);
std::string end = start; std::string end = start;
end.resize(kValueSize); end.resize(kValueSize);
db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(), start, end); ASSERT_OK(db_->DeleteRange(WriteOptions(), db_->DefaultColumnFamily(),
start, end));
} }
db_->Flush(FlushOptions()); ASSERT_OK(db_->Flush(FlushOptions()));
db_->CompactRange(CompactRangeOptions(), nullptr, nullptr); ASSERT_OK(db_->CompactRange(CompactRangeOptions(), nullptr, nullptr));
ResetTableProperties(&sum_tp); ResetTableProperties(&sum_tp);
for (int level = 0; level < kMaxLevel; ++level) { for (int level = 0; level < kMaxLevel; ++level) {
db_->GetProperty( db_->GetProperty(
@ -829,7 +832,7 @@ TEST_F(DBPropertiesTest, DISABLED_GetProperty) {
// Wait for compaction to be done. This is important because otherwise RocksDB // Wait for compaction to be done. This is important because otherwise RocksDB
// might schedule a compaction when reopening the database, failing assertion // might schedule a compaction when reopening the database, failing assertion
// (A) as a result. // (A) as a result.
dbfull()->TEST_WaitForCompact(); ASSERT_OK(dbfull()->TEST_WaitForCompact());
options.max_open_files = 10; options.max_open_files = 10;
Reopen(options); Reopen(options);
// After reopening, no table reader is loaded, so no memory for table readers // After reopening, no table reader is loaded, so no memory for table readers
@ -857,7 +860,7 @@ TEST_F(DBPropertiesTest, DISABLED_GetProperty) {
std::unique_ptr<Iterator> iter1(dbfull()->NewIterator(ReadOptions())); std::unique_ptr<Iterator> iter1(dbfull()->NewIterator(ReadOptions()));
ASSERT_OK(dbfull()->Put(writeOpt, "k6", big_value)); ASSERT_OK(dbfull()->Put(writeOpt, "k6", big_value));
Flush(); ASSERT_OK(Flush());
ASSERT_TRUE( ASSERT_TRUE(
dbfull()->GetIntProperty("rocksdb.num-live-versions", &int_num)); dbfull()->GetIntProperty("rocksdb.num-live-versions", &int_num));
ASSERT_EQ(int_num, 2U); ASSERT_EQ(int_num, 2U);
@ -866,7 +869,7 @@ TEST_F(DBPropertiesTest, DISABLED_GetProperty) {
std::unique_ptr<Iterator> iter2(dbfull()->NewIterator(ReadOptions())); std::unique_ptr<Iterator> iter2(dbfull()->NewIterator(ReadOptions()));
ASSERT_OK(dbfull()->Put(writeOpt, "k7", big_value)); ASSERT_OK(dbfull()->Put(writeOpt, "k7", big_value));
Flush(); ASSERT_OK(Flush());
ASSERT_TRUE( ASSERT_TRUE(
dbfull()->GetIntProperty("rocksdb.num-live-versions", &int_num)); dbfull()->GetIntProperty("rocksdb.num-live-versions", &int_num));
ASSERT_EQ(int_num, 3U); ASSERT_EQ(int_num, 3U);
@ -921,11 +924,12 @@ TEST_F(DBPropertiesTest, ApproximateMemoryUsage) {
for (int r = 0; r < kNumRounds; ++r) { for (int r = 0; r < kNumRounds; ++r) {
for (int f = 0; f < kFlushesPerRound; ++f) { for (int f = 0; f < kFlushesPerRound; ++f) {
for (int w = 0; w < kWritesPerFlush; ++w) { for (int w = 0; w < kWritesPerFlush; ++w) {
Put(rnd.RandomString(kKeySize), rnd.RandomString(kValueSize)); ASSERT_OK(
Put(rnd.RandomString(kKeySize), rnd.RandomString(kValueSize)));
} }
} }
// Make sure that there is no flush between getting the two properties. // Make sure that there is no flush between getting the two properties.
dbfull()->TEST_WaitForFlushMemTable(); ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
dbfull()->GetIntProperty("rocksdb.cur-size-all-mem-tables", &unflushed_mem); dbfull()->GetIntProperty("rocksdb.cur-size-all-mem-tables", &unflushed_mem);
dbfull()->GetIntProperty("rocksdb.size-all-mem-tables", &all_mem); dbfull()->GetIntProperty("rocksdb.size-all-mem-tables", &all_mem);
// in no iterator case, these two number should be the same. // in no iterator case, these two number should be the same.
@ -939,12 +943,13 @@ TEST_F(DBPropertiesTest, ApproximateMemoryUsage) {
iters.push_back(db_->NewIterator(ReadOptions())); iters.push_back(db_->NewIterator(ReadOptions()));
for (int f = 0; f < kFlushesPerRound; ++f) { for (int f = 0; f < kFlushesPerRound; ++f) {
for (int w = 0; w < kWritesPerFlush; ++w) { for (int w = 0; w < kWritesPerFlush; ++w) {
Put(rnd.RandomString(kKeySize), rnd.RandomString(kValueSize)); ASSERT_OK(
Put(rnd.RandomString(kKeySize), rnd.RandomString(kValueSize)));
} }
} }
// Force flush to prevent flush from happening between getting the // Force flush to prevent flush from happening between getting the
// properties or after getting the properties and before the new round. // properties or after getting the properties and before the new round.
Flush(); ASSERT_OK(Flush());
// In the second round, add iterators. // In the second round, add iterators.
dbfull()->GetIntProperty("rocksdb.cur-size-active-mem-table", &active_mem); dbfull()->GetIntProperty("rocksdb.cur-size-active-mem-table", &active_mem);
@ -959,6 +964,7 @@ TEST_F(DBPropertiesTest, ApproximateMemoryUsage) {
// Phase 3. Delete iterators and expect "size-all-mem-tables" shrinks // Phase 3. Delete iterators and expect "size-all-mem-tables" shrinks
// whenever we release an iterator. // whenever we release an iterator.
for (auto* iter : iters) { for (auto* iter : iters) {
ASSERT_OK(iter->status());
delete iter; delete iter;
dbfull()->GetIntProperty("rocksdb.size-all-mem-tables", &all_mem); dbfull()->GetIntProperty("rocksdb.size-all-mem-tables", &all_mem);
// Expect the size shrinking // Expect the size shrinking
@ -1008,19 +1014,19 @@ TEST_F(DBPropertiesTest, EstimatePendingCompBytes) {
uint64_t int_num; uint64_t int_num;
ASSERT_OK(dbfull()->Put(writeOpt, "k1", big_value)); ASSERT_OK(dbfull()->Put(writeOpt, "k1", big_value));
Flush(); ASSERT_OK(Flush());
ASSERT_TRUE(dbfull()->GetIntProperty( ASSERT_TRUE(dbfull()->GetIntProperty(
"rocksdb.estimate-pending-compaction-bytes", &int_num)); "rocksdb.estimate-pending-compaction-bytes", &int_num));
ASSERT_EQ(int_num, 0U); ASSERT_EQ(int_num, 0U);
ASSERT_OK(dbfull()->Put(writeOpt, "k2", big_value)); ASSERT_OK(dbfull()->Put(writeOpt, "k2", big_value));
Flush(); ASSERT_OK(Flush());
ASSERT_TRUE(dbfull()->GetIntProperty( ASSERT_TRUE(dbfull()->GetIntProperty(
"rocksdb.estimate-pending-compaction-bytes", &int_num)); "rocksdb.estimate-pending-compaction-bytes", &int_num));
ASSERT_GT(int_num, 0U); ASSERT_GT(int_num, 0U);
ASSERT_OK(dbfull()->Put(writeOpt, "k3", big_value)); ASSERT_OK(dbfull()->Put(writeOpt, "k3", big_value));
Flush(); ASSERT_OK(Flush());
ASSERT_TRUE(dbfull()->GetIntProperty( ASSERT_TRUE(dbfull()->GetIntProperty(
"rocksdb.estimate-pending-compaction-bytes", &int_num)); "rocksdb.estimate-pending-compaction-bytes", &int_num));
ASSERT_GT(int_num, 0U); ASSERT_GT(int_num, 0U);
@ -1028,7 +1034,7 @@ TEST_F(DBPropertiesTest, EstimatePendingCompBytes) {
sleeping_task_low.WakeUp(); sleeping_task_low.WakeUp();
sleeping_task_low.WaitUntilDone(); sleeping_task_low.WaitUntilDone();
dbfull()->TEST_WaitForCompact(); ASSERT_OK(dbfull()->TEST_WaitForCompact());
ASSERT_TRUE(dbfull()->GetIntProperty( ASSERT_TRUE(dbfull()->GetIntProperty(
"rocksdb.estimate-pending-compaction-bytes", &int_num)); "rocksdb.estimate-pending-compaction-bytes", &int_num));
ASSERT_EQ(int_num, 0U); ASSERT_EQ(int_num, 0U);
@ -1058,7 +1064,7 @@ TEST_F(DBPropertiesTest, EstimateCompressionRatio) {
std::string key = ToString(i) + ToString(j) + "key"; std::string key = ToString(i) + ToString(j) + "key";
ASSERT_OK(dbfull()->Put(WriteOptions(), key, kVal)); ASSERT_OK(dbfull()->Put(WriteOptions(), key, kVal));
} }
Flush(); ASSERT_OK(Flush());
} }
// no compression at L0, so ratio is less than one // no compression at L0, so ratio is less than one
@ -1066,7 +1072,7 @@ TEST_F(DBPropertiesTest, EstimateCompressionRatio) {
ASSERT_GT(CompressionRatioAtLevel(0), 0.0); ASSERT_GT(CompressionRatioAtLevel(0), 0.0);
ASSERT_EQ(CompressionRatioAtLevel(1), -1.0); ASSERT_EQ(CompressionRatioAtLevel(1), -1.0);
dbfull()->TEST_CompactRange(0, nullptr, nullptr); ASSERT_OK(dbfull()->TEST_CompactRange(0, nullptr, nullptr));
ASSERT_EQ(CompressionRatioAtLevel(0), -1.0); ASSERT_EQ(CompressionRatioAtLevel(0), -1.0);
// Data at L1 should be highly compressed thanks to Snappy and redundant data // Data at L1 should be highly compressed thanks to Snappy and redundant data
@ -1181,9 +1187,9 @@ TEST_F(DBPropertiesTest, GetUserDefinedTableProperties) {
// Create 4 tables // Create 4 tables
for (int table = 0; table < 4; ++table) { for (int table = 0; table < 4; ++table) {
for (int i = 0; i < 10 + table; ++i) { for (int i = 0; i < 10 + table; ++i) {
db_->Put(WriteOptions(), ToString(table * 100 + i), "val"); ASSERT_OK(db_->Put(WriteOptions(), ToString(table * 100 + i), "val"));
} }
db_->Flush(FlushOptions()); ASSERT_OK(db_->Flush(FlushOptions()));
} }
TablePropertiesCollection props; TablePropertiesCollection props;
@ -1205,7 +1211,7 @@ TEST_F(DBPropertiesTest, GetUserDefinedTableProperties) {
ASSERT_GT(collector_factory->num_created_, 0U); ASSERT_GT(collector_factory->num_created_, 0U);
collector_factory->num_created_ = 0; collector_factory->num_created_ = 0;
dbfull()->TEST_CompactRange(0, nullptr, nullptr); ASSERT_OK(dbfull()->TEST_CompactRange(0, nullptr, nullptr));
ASSERT_GT(collector_factory->num_created_, 0U); ASSERT_GT(collector_factory->num_created_, 0U);
} }
#endif // ROCKSDB_LITE #endif // ROCKSDB_LITE
@ -1221,9 +1227,9 @@ TEST_F(DBPropertiesTest, UserDefinedTablePropertiesContext) {
// Create 2 files // Create 2 files
for (int table = 0; table < 2; ++table) { for (int table = 0; table < 2; ++table) {
for (int i = 0; i < 10 + table; ++i) { for (int i = 0; i < 10 + table; ++i) {
Put(1, ToString(table * 100 + i), "val"); ASSERT_OK(Put(1, ToString(table * 100 + i), "val"));
} }
Flush(1); ASSERT_OK(Flush(1));
} }
ASSERT_GT(collector_factory->num_created_, 0U); ASSERT_GT(collector_factory->num_created_, 0U);
@ -1231,15 +1237,15 @@ TEST_F(DBPropertiesTest, UserDefinedTablePropertiesContext) {
// Trigger automatic compactions. // Trigger automatic compactions.
for (int table = 0; table < 3; ++table) { for (int table = 0; table < 3; ++table) {
for (int i = 0; i < 10 + table; ++i) { for (int i = 0; i < 10 + table; ++i) {
Put(1, ToString(table * 100 + i), "val"); ASSERT_OK(Put(1, ToString(table * 100 + i), "val"));
} }
Flush(1); ASSERT_OK(Flush(1));
dbfull()->TEST_WaitForCompact(); ASSERT_OK(dbfull()->TEST_WaitForCompact());
} }
ASSERT_GT(collector_factory->num_created_, 0U); ASSERT_GT(collector_factory->num_created_, 0U);
collector_factory->num_created_ = 0; collector_factory->num_created_ = 0;
dbfull()->TEST_CompactRange(0, nullptr, nullptr, handles_[1]); ASSERT_OK(dbfull()->TEST_CompactRange(0, nullptr, nullptr, handles_[1]));
ASSERT_GT(collector_factory->num_created_, 0U); ASSERT_GT(collector_factory->num_created_, 0U);
// Come back to write to default column family // Come back to write to default column family
@ -1248,9 +1254,9 @@ TEST_F(DBPropertiesTest, UserDefinedTablePropertiesContext) {
// Create 4 tables in default column family // Create 4 tables in default column family
for (int table = 0; table < 2; ++table) { for (int table = 0; table < 2; ++table) {
for (int i = 0; i < 10 + table; ++i) { for (int i = 0; i < 10 + table; ++i) {
Put(ToString(table * 100 + i), "val"); ASSERT_OK(Put(ToString(table * 100 + i), "val"));
} }
Flush(); ASSERT_OK(Flush());
} }
ASSERT_GT(collector_factory->num_created_, 0U); ASSERT_GT(collector_factory->num_created_, 0U);
@ -1258,15 +1264,15 @@ TEST_F(DBPropertiesTest, UserDefinedTablePropertiesContext) {
// Trigger automatic compactions. // Trigger automatic compactions.
for (int table = 0; table < 3; ++table) { for (int table = 0; table < 3; ++table) {
for (int i = 0; i < 10 + table; ++i) { for (int i = 0; i < 10 + table; ++i) {
Put(ToString(table * 100 + i), "val"); ASSERT_OK(Put(ToString(table * 100 + i), "val"));
} }
Flush(); ASSERT_OK(Flush());
dbfull()->TEST_WaitForCompact(); ASSERT_OK(dbfull()->TEST_WaitForCompact());
} }
ASSERT_GT(collector_factory->num_created_, 0U); ASSERT_GT(collector_factory->num_created_, 0U);
collector_factory->num_created_ = 0; collector_factory->num_created_ = 0;
dbfull()->TEST_CompactRange(0, nullptr, nullptr); ASSERT_OK(dbfull()->TEST_CompactRange(0, nullptr, nullptr));
ASSERT_GT(collector_factory->num_created_, 0U); ASSERT_GT(collector_factory->num_created_, 0U);
} }
@ -1300,15 +1306,15 @@ TEST_F(DBPropertiesTest, TablePropertiesNeedCompactTest) {
ASSERT_OK(Put(Key(i), rnd.RandomString(102))); ASSERT_OK(Put(Key(i), rnd.RandomString(102)));
ASSERT_OK(Put(Key(kMaxKey + i), rnd.RandomString(102))); ASSERT_OK(Put(Key(kMaxKey + i), rnd.RandomString(102)));
} }
Flush(); ASSERT_OK(Flush());
dbfull()->TEST_WaitForCompact(); ASSERT_OK(dbfull()->TEST_WaitForCompact());
if (NumTableFilesAtLevel(0) == 1) { if (NumTableFilesAtLevel(0) == 1) {
// Clear Level 0 so that when later flush a file with deletions, // Clear Level 0 so that when later flush a file with deletions,
// we don't trigger an organic compaction. // we don't trigger an organic compaction.
ASSERT_OK(Put(Key(0), "")); ASSERT_OK(Put(Key(0), ""));
ASSERT_OK(Put(Key(kMaxKey * 2), "")); ASSERT_OK(Put(Key(kMaxKey * 2), ""));
Flush(); ASSERT_OK(Flush());
dbfull()->TEST_WaitForCompact(); ASSERT_OK(dbfull()->TEST_WaitForCompact());
} }
ASSERT_EQ(NumTableFilesAtLevel(0), 0); ASSERT_EQ(NumTableFilesAtLevel(0), 0);
@ -1320,17 +1326,18 @@ TEST_F(DBPropertiesTest, TablePropertiesNeedCompactTest) {
iter->Next(); iter->Next();
++c; ++c;
} }
ASSERT_OK(iter->status());
ASSERT_EQ(c, 200); ASSERT_EQ(c, 200);
} }
Delete(Key(0)); ASSERT_OK(Delete(Key(0)));
for (int i = kMaxKey - 100; i < kMaxKey + 100; i++) { for (int i = kMaxKey - 100; i < kMaxKey + 100; i++) {
Delete(Key(i)); ASSERT_OK(Delete(Key(i)));
} }
Delete(Key(kMaxKey * 2)); ASSERT_OK(Delete(Key(kMaxKey * 2)));
Flush(); ASSERT_OK(Flush());
dbfull()->TEST_WaitForCompact(); ASSERT_OK(dbfull()->TEST_WaitForCompact());
{ {
SetPerfLevel(kEnableCount); SetPerfLevel(kEnableCount);
@ -1341,6 +1348,7 @@ TEST_F(DBPropertiesTest, TablePropertiesNeedCompactTest) {
while (iter->Valid() && iter->key().compare(Key(kMaxKey + 100)) < 0) { while (iter->Valid() && iter->key().compare(Key(kMaxKey + 100)) < 0) {
iter->Next(); iter->Next();
} }
ASSERT_OK(iter->status());
ASSERT_EQ(c, 0); ASSERT_EQ(c, 0);
ASSERT_LT(get_perf_context()->internal_delete_skipped_count, 30u); ASSERT_LT(get_perf_context()->internal_delete_skipped_count, 30u);
ASSERT_LT(get_perf_context()->internal_key_skipped_count, 30u); ASSERT_LT(get_perf_context()->internal_key_skipped_count, 30u);
@ -1371,14 +1379,14 @@ TEST_F(DBPropertiesTest, NeedCompactHintPersistentTest) {
for (int i = 0; i < kMaxKey; i++) { for (int i = 0; i < kMaxKey; i++) {
ASSERT_OK(Put(Key(i), "")); ASSERT_OK(Put(Key(i), ""));
} }
Flush(); ASSERT_OK(Flush());
dbfull()->TEST_WaitForFlushMemTable(); ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
for (int i = 1; i < kMaxKey - 1; i++) { for (int i = 1; i < kMaxKey - 1; i++) {
Delete(Key(i)); ASSERT_OK(Delete(Key(i)));
} }
Flush(); ASSERT_OK(Flush());
dbfull()->TEST_WaitForFlushMemTable(); ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
ASSERT_EQ(NumTableFilesAtLevel(0), 2); ASSERT_EQ(NumTableFilesAtLevel(0), 2);
// Restart the DB. Although number of files didn't reach // Restart the DB. Although number of files didn't reach
@ -1386,7 +1394,7 @@ TEST_F(DBPropertiesTest, NeedCompactHintPersistentTest) {
// still be triggered because of the need-compaction hint. // still be triggered because of the need-compaction hint.
options.disable_auto_compactions = false; options.disable_auto_compactions = false;
Reopen(options); Reopen(options);
dbfull()->TEST_WaitForCompact(); ASSERT_OK(dbfull()->TEST_WaitForCompact());
ASSERT_EQ(NumTableFilesAtLevel(0), 0); ASSERT_EQ(NumTableFilesAtLevel(0), 0);
{ {
SetPerfLevel(kEnableCount); SetPerfLevel(kEnableCount);
@ -1396,6 +1404,7 @@ TEST_F(DBPropertiesTest, NeedCompactHintPersistentTest) {
for (iter->Seek(Key(0)); iter->Valid(); iter->Next()) { for (iter->Seek(Key(0)); iter->Valid(); iter->Next()) {
c++; c++;
} }
ASSERT_OK(iter->status());
ASSERT_EQ(c, 2); ASSERT_EQ(c, 2);
ASSERT_EQ(get_perf_context()->internal_delete_skipped_count, 0); ASSERT_EQ(get_perf_context()->internal_delete_skipped_count, 0);
// We iterate every key twice. Is it a bug? // We iterate every key twice. Is it a bug?
@ -1407,9 +1416,9 @@ TEST_F(DBPropertiesTest, NeedCompactHintPersistentTest) {
TEST_F(DBPropertiesTest, EstimateNumKeysUnderflow) { TEST_F(DBPropertiesTest, EstimateNumKeysUnderflow) {
Options options; Options options;
Reopen(options); Reopen(options);
Put("foo", "bar"); ASSERT_OK(Put("foo", "bar"));
Delete("foo"); ASSERT_OK(Delete("foo"));
Delete("foo"); ASSERT_OK(Delete("foo"));
uint64_t num_keys = 0; uint64_t num_keys = 0;
ASSERT_TRUE(dbfull()->GetIntProperty("rocksdb.estimate-num-keys", &num_keys)); ASSERT_TRUE(dbfull()->GetIntProperty("rocksdb.estimate-num-keys", &num_keys));
ASSERT_EQ(0, num_keys); ASSERT_EQ(0, num_keys);
@ -1587,11 +1596,11 @@ TEST_F(DBPropertiesTest, MinObsoleteSstNumberToKeep) {
for (int i = 0; i < kNumL0Files; ++i) { for (int i = 0; i < kNumL0Files; ++i) {
// Make sure they overlap in keyspace to prevent trivial move // Make sure they overlap in keyspace to prevent trivial move
Put("key1", "val"); ASSERT_OK(Put("key1", "val"));
Put("key2", "val"); ASSERT_OK(Put("key2", "val"));
Flush(); ASSERT_OK(Flush());
} }
dbfull()->TEST_WaitForCompact(); ASSERT_OK(dbfull()->TEST_WaitForCompact());
ASSERT_TRUE(listener->Validated()); ASSERT_TRUE(listener->Validated());
} }
@ -1649,7 +1658,8 @@ TEST_F(DBPropertiesTest, BlockCacheProperties) {
// Insert unpinned item to the cache and check size. // Insert unpinned item to the cache and check size.
constexpr size_t kSize1 = 50; constexpr size_t kSize1 = 50;
block_cache->Insert("item1", nullptr /*value*/, kSize1, nullptr /*deleter*/); ASSERT_OK(block_cache->Insert("item1", nullptr /*value*/, kSize1,
nullptr /*deleter*/));
ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kBlockCacheCapacity, &value)); ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kBlockCacheCapacity, &value));
ASSERT_EQ(kCapacity, value); ASSERT_EQ(kCapacity, value);
ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kBlockCacheUsage, &value)); ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kBlockCacheUsage, &value));
@ -1661,8 +1671,8 @@ TEST_F(DBPropertiesTest, BlockCacheProperties) {
// Insert pinned item to the cache and check size. // Insert pinned item to the cache and check size.
constexpr size_t kSize2 = 30; constexpr size_t kSize2 = 30;
Cache::Handle* item2 = nullptr; Cache::Handle* item2 = nullptr;
block_cache->Insert("item2", nullptr /*value*/, kSize2, nullptr /*deleter*/, ASSERT_OK(block_cache->Insert("item2", nullptr /*value*/, kSize2,
&item2); nullptr /*deleter*/, &item2));
ASSERT_NE(nullptr, item2); ASSERT_NE(nullptr, item2);
ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kBlockCacheCapacity, &value)); ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kBlockCacheCapacity, &value));
ASSERT_EQ(kCapacity, value); ASSERT_EQ(kCapacity, value);
@ -1675,8 +1685,8 @@ TEST_F(DBPropertiesTest, BlockCacheProperties) {
// Insert another pinned item to make the cache over-sized. // Insert another pinned item to make the cache over-sized.
constexpr size_t kSize3 = 80; constexpr size_t kSize3 = 80;
Cache::Handle* item3 = nullptr; Cache::Handle* item3 = nullptr;
block_cache->Insert("item3", nullptr /*value*/, kSize3, nullptr /*deleter*/, ASSERT_OK(block_cache->Insert("item3", nullptr /*value*/, kSize3,
&item3); nullptr /*deleter*/, &item3));
ASSERT_NE(nullptr, item2); ASSERT_NE(nullptr, item2);
ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kBlockCacheCapacity, &value)); ASSERT_TRUE(db_->GetIntProperty(DB::Properties::kBlockCacheCapacity, &value));
ASSERT_EQ(kCapacity, value); ASSERT_EQ(kCapacity, value);

8
db/db_test_util.cc
View File

@ -1235,8 +1235,8 @@ void DBTestBase::GenerateNewFile(int cf, Random* rnd, int* key_idx,
(*key_idx)++; (*key_idx)++;
} }
if (!nowait) { if (!nowait) {
dbfull()->TEST_WaitForFlushMemTable(); ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
dbfull()->TEST_WaitForCompact(); ASSERT_OK(dbfull()->TEST_WaitForCompact());
} }
} }
@ -1247,8 +1247,8 @@ void DBTestBase::GenerateNewFile(Random* rnd, int* key_idx, bool nowait) {
(*key_idx)++; (*key_idx)++;
} }
if (!nowait) { if (!nowait) {
dbfull()->TEST_WaitForFlushMemTable(); ASSERT_OK(dbfull()->TEST_WaitForFlushMemTable());
dbfull()->TEST_WaitForCompact(); ASSERT_OK(dbfull()->TEST_WaitForCompact());
} }
} }

5
db/table_cache.cc
View File

@ -625,7 +625,6 @@ size_t TableCache::GetMemoryUsageByTableReader(
const FileOptions& file_options, const FileOptions& file_options,
const InternalKeyComparator& internal_comparator, const FileDescriptor& fd, const InternalKeyComparator& internal_comparator, const FileDescriptor& fd,
const SliceTransform* prefix_extractor) { const SliceTransform* prefix_extractor) {
Status s;
auto table_reader = fd.table_reader; auto table_reader = fd.table_reader;
// table already been pre-loaded? // table already been pre-loaded?
if (table_reader) { if (table_reader) {
@ -633,8 +632,8 @@ size_t TableCache::GetMemoryUsageByTableReader(
} }
Cache::Handle* table_handle = nullptr; Cache::Handle* table_handle = nullptr;
s = FindTable(ReadOptions(), file_options, internal_comparator, fd, Status s = FindTable(ReadOptions(), file_options, internal_comparator, fd,
&table_handle, prefix_extractor, true); &table_handle, prefix_extractor, true);
if (!s.ok()) { if (!s.ok()) {
return 0; return 0;
} }