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

Move slow valgrind tests behind -DROCKSDB_FULL_VALGRIND_RUN (#8475)

Browse Source 
Summary:
Various tests had disabled valgrind due to it slowing down and timing
out (as is the case right now) the CI runs. Where a test was disabled with no comment,
I assumed slowness was the cause. For these tests that were slow under
valgrind, as well as the ones identified in https://github.com/facebook/rocksdb/issues/8352, this PR moves them
behind the compiler flag `-DROCKSDB_FULL_VALGRIND_RUN`.

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

Test Plan: running `make full_valgrind_test`, `make valgrind_test`, `make check`; will verify they appear working correctly

Reviewed By: jay-zhuang

Differential Revision: D29504843

Pulled By: ajkr

fbshipit-source-id: 2aac90749cfbd30d5ce11cb29a07a1b9314eeea7
This commit is contained in:
Andrew Kryczka 2021-07-07 11:13:09 -07:00 committed by Facebook GitHub Bot
parent 714ce5041d
commit ed8eb436db
16 changed files with 73 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
Makefile
View File

@ -344,6 +344,12 @@ ifdef ROCKSDB_VALGRIND_RUN
PLATFORM_CCFLAGS += -DROCKSDB_VALGRIND_RUN PLATFORM_CCFLAGS += -DROCKSDB_VALGRIND_RUN
PLATFORM_CXXFLAGS += -DROCKSDB_VALGRIND_RUN PLATFORM_CXXFLAGS += -DROCKSDB_VALGRIND_RUN
endif endif
ifdef ROCKSDB_FULL_VALGRIND_RUN
# Some tests are slow when run under valgrind and are only run when
# explicitly requested via the ROCKSDB_FULL_VALGRIND_RUN compiler flag.
PLATFORM_CCFLAGS += -DROCKSDB_VALGRIND_RUN -DROCKSDB_FULL_VALGRIND_RUN
PLATFORM_CXXFLAGS += -DROCKSDB_VALGRIND_RUN -DROCKSDB_FULL_VALGRIND_RUN
endif
ifndef DISABLE_JEMALLOC ifndef DISABLE_JEMALLOC
ifdef JEMALLOC ifdef JEMALLOC
@ -1046,6 +1052,12 @@ ubsan_crash_test_with_best_efforts_recovery: clean
COMPILE_WITH_UBSAN=1 $(MAKE) crash_test_with_best_efforts_recovery COMPILE_WITH_UBSAN=1 $(MAKE) crash_test_with_best_efforts_recovery
$(MAKE) clean $(MAKE) clean
full_valgrind_test:
ROCKSDB_FULL_VALGRIND_RUN=1 DISABLE_JEMALLOC=1 $(MAKE) valgrind_check
full_valgrind_test_some:
ROCKSDB_FULL_VALGRIND_RUN=1 DISABLE_JEMALLOC=1 $(MAKE) valgrind_check_some
valgrind_test: valgrind_test:
ROCKSDB_VALGRIND_RUN=1 DISABLE_JEMALLOC=1 $(MAKE) valgrind_check ROCKSDB_VALGRIND_RUN=1 DISABLE_JEMALLOC=1 $(MAKE) valgrind_check

4
db/db_bloom_filter_test.cc
View File

@ -527,7 +527,7 @@ TEST_P(DBBloomFilterTestWithParam, BloomFilter) {
} while (ChangeCompactOptions()); } while (ChangeCompactOptions());
} }
#ifndef ROCKSDB_VALGRIND_RUN #if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
FormatDef, DBBloomFilterTestDefFormatVersion, FormatDef, DBBloomFilterTestDefFormatVersion,
::testing::Values( ::testing::Values(
@ -551,7 +551,7 @@ INSTANTIATE_TEST_CASE_P(
test::kLatestFormatVersion), test::kLatestFormatVersion),
std::make_tuple(BFP::kAutoBloom, true, test::kLatestFormatVersion), std::make_tuple(BFP::kAutoBloom, true, test::kLatestFormatVersion),
std::make_tuple(BFP::kAutoBloom, false, test::kLatestFormatVersion))); std::make_tuple(BFP::kAutoBloom, false, test::kLatestFormatVersion)));
#endif // ROCKSDB_VALGRIND_RUN #endif // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
TEST_F(DBBloomFilterTest, BloomFilterRate) { TEST_F(DBBloomFilterTest, BloomFilterRate) {
while (ChangeFilterOptions()) { while (ChangeFilterOptions()) {

6
db/db_compaction_filter_test.cc
View File

@ -46,7 +46,7 @@ class DBTestCompactionFilterWithCompactParam
} }
}; };
#ifndef ROCKSDB_VALGRIND_RUN #if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
CompactionFilterWithOption, DBTestCompactionFilterWithCompactParam, CompactionFilterWithOption, DBTestCompactionFilterWithCompactParam,
::testing::Values(DBTestBase::OptionConfig::kDefault, ::testing::Values(DBTestBase::OptionConfig::kDefault,
@ -55,11 +55,11 @@ INSTANTIATE_TEST_CASE_P(
DBTestBase::OptionConfig::kLevelSubcompactions, DBTestBase::OptionConfig::kLevelSubcompactions,
DBTestBase::OptionConfig::kUniversalSubcompactions)); DBTestBase::OptionConfig::kUniversalSubcompactions));
#else #else
// Run fewer cases in valgrind // Run fewer cases in non-full valgrind to save time.
INSTANTIATE_TEST_CASE_P(CompactionFilterWithOption, INSTANTIATE_TEST_CASE_P(CompactionFilterWithOption,
DBTestCompactionFilterWithCompactParam, DBTestCompactionFilterWithCompactParam,
::testing::Values(DBTestBase::OptionConfig::kDefault)); ::testing::Values(DBTestBase::OptionConfig::kDefault));
#endif // ROCKSDB_VALGRIND_RUN #endif // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
class KeepFilter : public CompactionFilter { class KeepFilter : public CompactionFilter {
public: public:

4
db/db_compaction_test.cc
View File

@ -301,7 +301,7 @@ const SstFileMetaData* PickFileRandomly(
} }
} // anonymous namespace } // anonymous namespace
#ifndef ROCKSDB_VALGRIND_RUN #if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
// All the TEST_P tests run once with sub_compactions disabled (i.e. // All the TEST_P tests run once with sub_compactions disabled (i.e.
// options.max_subcompactions = 1) and once with it enabled // options.max_subcompactions = 1) and once with it enabled
TEST_P(DBCompactionTestWithParam, CompactionDeletionTrigger) { TEST_P(DBCompactionTestWithParam, CompactionDeletionTrigger) {
@ -366,7 +366,7 @@ TEST_P(DBCompactionTestWithParam, CompactionDeletionTrigger) {
} }
} }
} }
#endif // ROCKSDB_VALGRIND_RUN #endif // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
TEST_P(DBCompactionTestWithParam, CompactionsPreserveDeletes) { TEST_P(DBCompactionTestWithParam, CompactionsPreserveDeletes) {
// For each options type we test following // For each options type we test following

2
db/db_iterator_test.cc
View File

@ -1536,9 +1536,11 @@ class DBIteratorTestForPinnedData : public DBIteratorTest {
} }
}; };
#if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
TEST_P(DBIteratorTestForPinnedData, PinnedDataIteratorRandomizedNormal) { TEST_P(DBIteratorTestForPinnedData, PinnedDataIteratorRandomizedNormal) {
PinnedDataIteratorRandomized(TestConfig::NORMAL); PinnedDataIteratorRandomized(TestConfig::NORMAL);
} }
#endif // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
TEST_P(DBIteratorTestForPinnedData, PinnedDataIteratorRandomizedCLoseAndOpen) { TEST_P(DBIteratorTestForPinnedData, PinnedDataIteratorRandomizedCLoseAndOpen) {
PinnedDataIteratorRandomized(TestConfig::CLOSE_AND_OPEN); PinnedDataIteratorRandomized(TestConfig::CLOSE_AND_OPEN);

4
db/db_test.cc
View File

@ -3211,7 +3211,7 @@ class ModelDB : public DB {
std::string name_ = ""; std::string name_ = "";
}; };
#ifndef ROCKSDB_VALGRIND_RUN #if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
static std::string RandomKey(Random* rnd, int minimum = 0) { static std::string RandomKey(Random* rnd, int minimum = 0) {
int len; int len;
do { do {
@ -3366,7 +3366,7 @@ TEST_P(DBTestRandomized, Randomized) {
if (model_snap != nullptr) model.ReleaseSnapshot(model_snap); if (model_snap != nullptr) model.ReleaseSnapshot(model_snap);
if (db_snap != nullptr) db_->ReleaseSnapshot(db_snap); if (db_snap != nullptr) db_->ReleaseSnapshot(db_snap);
} }
#endif // ROCKSDB_VALGRIND_RUN #endif // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
TEST_F(DBTest, BlockBasedTablePrefixIndexTest) { TEST_F(DBTest, BlockBasedTablePrefixIndexTest) {
// create a DB with block prefix index // create a DB with block prefix index

8
db/db_universal_compaction_test.cc
View File

@ -635,7 +635,7 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionTargetLevel) {
ASSERT_EQ("0,0,0,0,1", FilesPerLevel(0)); ASSERT_EQ("0,0,0,0,1", FilesPerLevel(0));
} }
#ifndef ROCKSDB_VALGRIND_RUN #if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
class DBTestUniversalCompactionMultiLevels class DBTestUniversalCompactionMultiLevels
: public DBTestUniversalCompactionBase { : public DBTestUniversalCompactionBase {
public: public:
@ -912,7 +912,7 @@ TEST_P(DBTestUniversalCompactionParallel, PickByFileNumberBug) {
INSTANTIATE_TEST_CASE_P(Parallel, DBTestUniversalCompactionParallel, INSTANTIATE_TEST_CASE_P(Parallel, DBTestUniversalCompactionParallel,
::testing::Combine(::testing::Values(1, 10), ::testing::Combine(::testing::Values(1, 10),
::testing::Values(false))); ::testing::Values(false)));
#endif // ROCKSDB_VALGRIND_RUN #endif // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
TEST_P(DBTestUniversalCompaction, UniversalCompactionOptions) { TEST_P(DBTestUniversalCompaction, UniversalCompactionOptions) {
Options options = CurrentOptions(); Options options = CurrentOptions();
@ -1128,7 +1128,7 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionCompressRatio2) {
ASSERT_LT(TotalSize(), 120000U * 12 * 0.82 + 120000 * 2); ASSERT_LT(TotalSize(), 120000U * 12 * 0.82 + 120000 * 2);
} }
#ifndef ROCKSDB_VALGRIND_RUN #if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
// Test that checks trivial move in universal compaction // Test that checks trivial move in universal compaction
TEST_P(DBTestUniversalCompaction, UniversalCompactionTrivialMoveTest1) { TEST_P(DBTestUniversalCompaction, UniversalCompactionTrivialMoveTest1) {
int32_t trivial_move = 0; int32_t trivial_move = 0;
@ -1221,7 +1221,7 @@ TEST_P(DBTestUniversalCompaction, UniversalCompactionTrivialMoveTest2) {
ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing(); ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
} }
#endif // ROCKSDB_VALGRIND_RUN #endif // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
TEST_P(DBTestUniversalCompaction, UniversalCompactionFourPaths) { TEST_P(DBTestUniversalCompaction, UniversalCompactionFourPaths) {
Options options = CurrentOptions(); Options options = CurrentOptions();

4
db/db_with_timestamp_basic_test.cc
View File

@ -1494,6 +1494,7 @@ TEST_F(DBBasicTestWithTimestamp, CompactDeletionWithTimestampMarkerToBottom) {
Close(); Close();
} }
#if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
class DBBasicTestWithTimestampFilterPrefixSettings class DBBasicTestWithTimestampFilterPrefixSettings
: public DBBasicTestWithTimestampBase, : public DBBasicTestWithTimestampBase,
public testing::WithParamInterface< public testing::WithParamInterface<
@ -1625,6 +1626,7 @@ INSTANTIATE_TEST_CASE_P(
BlockBasedTableOptions::IndexType::kHashSearch, BlockBasedTableOptions::IndexType::kHashSearch,
BlockBasedTableOptions::IndexType::kTwoLevelIndexSearch, BlockBasedTableOptions::IndexType::kTwoLevelIndexSearch,
BlockBasedTableOptions::IndexType::kBinarySearchWithFirstKey))); BlockBasedTableOptions::IndexType::kBinarySearchWithFirstKey)));
#endif // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
class DataVisibilityTest : public DBBasicTestWithTimestampBase { class DataVisibilityTest : public DBBasicTestWithTimestampBase {
public: public:
@ -2215,6 +2217,7 @@ TEST_F(DataVisibilityTest, MultiGetCrossCF) {
Close(); Close();
} }
#if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
class DBBasicTestWithTimestampCompressionSettings class DBBasicTestWithTimestampCompressionSettings
: public DBBasicTestWithTimestampBase, : public DBBasicTestWithTimestampBase,
public testing::WithParamInterface< public testing::WithParamInterface<
@ -2954,6 +2957,7 @@ INSTANTIATE_TEST_CASE_P(
BlockBasedTableOptions::IndexType::kHashSearch, BlockBasedTableOptions::IndexType::kHashSearch,
BlockBasedTableOptions::IndexType::kTwoLevelIndexSearch, BlockBasedTableOptions::IndexType::kTwoLevelIndexSearch,
BlockBasedTableOptions::IndexType::kBinarySearchWithFirstKey))); BlockBasedTableOptions::IndexType::kBinarySearchWithFirstKey)));
#endif // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
} // namespace ROCKSDB_NAMESPACE } // namespace ROCKSDB_NAMESPACE

4
db/external_sst_file_test.cc
View File

@ -1398,6 +1398,7 @@ TEST_F(ExternalSSTFileTest, IngestNonExistingFile) {
ASSERT_EQ(1, num_sst_files); ASSERT_EQ(1, num_sst_files);
} }
#if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
TEST_F(ExternalSSTFileTest, CompactDuringAddFileRandom) { TEST_F(ExternalSSTFileTest, CompactDuringAddFileRandom) {
env_->skip_fsync_ = true; env_->skip_fsync_ = true;
Options options = CurrentOptions(); Options options = CurrentOptions();
@ -1455,6 +1456,7 @@ TEST_F(ExternalSSTFileTest, CompactDuringAddFileRandom) {
} }
} }
} }
#endif // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
TEST_F(ExternalSSTFileTest, PickedLevelDynamic) { TEST_F(ExternalSSTFileTest, PickedLevelDynamic) {
env_->skip_fsync_ = true; env_->skip_fsync_ = true;
@ -1716,6 +1718,7 @@ TEST_F(ExternalSSTFileTest, WithUnorderedWrite) {
SyncPoint::GetInstance()->ClearAllCallBacks(); SyncPoint::GetInstance()->ClearAllCallBacks();
} }
#if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoRandomized) { TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoRandomized) {
env_->skip_fsync_ = true; env_->skip_fsync_ = true;
Options options = CurrentOptions(); Options options = CurrentOptions();
@ -1757,6 +1760,7 @@ TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoRandomized) {
VerifyDBFromMap(true_data, &kcnt, false); VerifyDBFromMap(true_data, &kcnt, false);
} }
} }
#endif // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoAssignedLevel) { TEST_P(ExternalSSTFileTest, IngestFileWithGlobalSeqnoAssignedLevel) {
Options options = CurrentOptions(); Options options = CurrentOptions();

2
db/write_callback_test.cc
View File

@ -84,6 +84,7 @@ class MockWriteCallback : public WriteCallback {
bool AllowWriteBatching() override { return allow_batching_; } bool AllowWriteBatching() override { return allow_batching_; }
}; };
#if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
class WriteCallbackPTest class WriteCallbackPTest
: public WriteCallbackTest, : public WriteCallbackTest,
public ::testing::WithParamInterface< public ::testing::WithParamInterface<
@ -376,6 +377,7 @@ INSTANTIATE_TEST_CASE_P(WriteCallbackPTest, WriteCallbackPTest,
::testing::Bool(), ::testing::Bool(), ::testing::Bool(), ::testing::Bool(),
::testing::Bool(), ::testing::Bool(), ::testing::Bool(), ::testing::Bool(),
::testing::Bool())); ::testing::Bool()));
#endif // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
TEST_F(WriteCallbackTest, WriteCallBackTest) { TEST_F(WriteCallbackTest, WriteCallBackTest) {
Options options; Options options;

4
memtable/inlineskiplist_test.cc
View File

@ -309,7 +309,7 @@ TEST_F(InlineSkipTest, InsertWithHint_CompatibleWithInsertWithoutHint) {
Validate(&list); Validate(&list);
} }
#ifndef ROCKSDB_VALGRIND_RUN #if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
// We want to make sure that with a single writer and multiple // We want to make sure that with a single writer and multiple
// concurrent readers (with no synchronization other than when a // concurrent readers (with no synchronization other than when a
// reader's iterator is created), the reader always observes all the // reader's iterator is created), the reader always observes all the
@ -654,7 +654,7 @@ TEST_F(InlineSkipTest, ConcurrentInsertWithHint3) {
RunConcurrentInsert(3, true); RunConcurrentInsert(3, true);
} }
#endif // ROCKSDB_VALGRIND_RUN #endif // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
} // namespace ROCKSDB_NAMESPACE } // namespace ROCKSDB_NAMESPACE
int main(int argc, char** argv) { int main(int argc, char** argv) {

4
table/table_test.cc
View File

@ -3627,7 +3627,7 @@ TEST_F(GeneralTableTest, ApproximateOffsetOfCompressed) {
} }
} }
#ifndef ROCKSDB_VALGRIND_RUN #if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
TEST_P(ParameterizedHarnessTest, RandomizedHarnessTest) { TEST_P(ParameterizedHarnessTest, RandomizedHarnessTest) {
Random rnd(test::RandomSeed() + 5); Random rnd(test::RandomSeed() + 5);
for (int num_entries = 0; num_entries < 2000; for (int num_entries = 0; num_entries < 2000;
@ -3662,7 +3662,7 @@ TEST_F(DBHarnessTest, RandomizedLongDB) {
ASSERT_GT(files, 0); ASSERT_GT(files, 0);
} }
#endif // ROCKSDB_LITE #endif // ROCKSDB_LITE
#endif // ROCKSDB_VALGRIND_RUN #endif // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
class MemTableTest : public testing::Test { class MemTableTest : public testing::Test {
public: public:

6
utilities/backupable/backupable_db_test.cc
View File

@ -1048,6 +1048,7 @@ TEST_P(BackupEngineTestWithParam, VerifyBackup) {
CloseDBAndBackupEngine(); CloseDBAndBackupEngine();
} }
#if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
// open DB, write, close DB, backup, restore, repeat // open DB, write, close DB, backup, restore, repeat
TEST_P(BackupEngineTestWithParam, OfflineIntegrationTest) { TEST_P(BackupEngineTestWithParam, OfflineIntegrationTest) {
// has to be a big number, so that it triggers the memtable flush // has to be a big number, so that it triggers the memtable flush
@ -1158,6 +1159,7 @@ TEST_P(BackupEngineTestWithParam, OnlineIntegrationTest) {
CloseBackupEngine(); CloseBackupEngine();
} }
#endif // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
INSTANTIATE_TEST_CASE_P(BackupEngineTestWithParam, BackupEngineTestWithParam, INSTANTIATE_TEST_CASE_P(BackupEngineTestWithParam, BackupEngineTestWithParam,
::testing::Bool()); ::testing::Bool());
@ -1548,6 +1550,7 @@ TEST_F(BackupEngineTest, BlobFileCorruptedBeforeBackup) {
CloseDBAndBackupEngine(); CloseDBAndBackupEngine();
} }
#if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
// Test if BackupEngine will fail to create new backup if some table has been // Test if BackupEngine will fail to create new backup if some table has been
// corrupted and the table file checksum is stored in the DB manifest for the // corrupted and the table file checksum is stored in the DB manifest for the
// case when backup table files will be stored in a shared directory // case when backup table files will be stored in a shared directory
@ -1606,6 +1609,7 @@ TEST_P(BackupEngineTestWithParam, BlobFileCorruptedBeforeBackup) {
ASSERT_NOK(backup_engine_->CreateNewBackup(db_.get())); ASSERT_NOK(backup_engine_->CreateNewBackup(db_.get()));
CloseDBAndBackupEngine(); CloseDBAndBackupEngine();
} }
#endif // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
TEST_F(BackupEngineTest, TableFileWithoutDbChecksumCorruptedDuringBackup) { TEST_F(BackupEngineTest, TableFileWithoutDbChecksumCorruptedDuringBackup) {
const int keys_iteration = 50000; const int keys_iteration = 50000;
@ -2526,6 +2530,7 @@ TEST_F(BackupEngineTest, KeepLogFiles) {
AssertBackupConsistency(0, 0, 500, 600, true); AssertBackupConsistency(0, 0, 500, 600, true);
} }
#if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
class BackupEngineRateLimitingTestWithParam class BackupEngineRateLimitingTestWithParam
: public BackupEngineTest, : public BackupEngineTest,
public testing::WithParamInterface< public testing::WithParamInterface<
@ -2600,6 +2605,7 @@ TEST_P(BackupEngineRateLimitingTestWithParam, RateLimiting) {
AssertBackupConsistency(0, 0, 100000, 100010); AssertBackupConsistency(0, 0, 100000, 100010);
} }
#endif // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
TEST_F(BackupEngineTest, ReadOnlyBackupEngine) { TEST_F(BackupEngineTest, ReadOnlyBackupEngine) {
DestroyDB(dbname_, options_); DestroyDB(dbname_, options_);

27
utilities/transactions/transaction_test.cc
View File

@ -62,8 +62,9 @@ INSTANTIATE_TEST_CASE_P(
std::make_tuple(true, true, WRITE_PREPARED, kOrderedWrite), std::make_tuple(true, true, WRITE_PREPARED, kOrderedWrite),
std::make_tuple(true, true, WRITE_UNPREPARED, kOrderedWrite))); std::make_tuple(true, true, WRITE_UNPREPARED, kOrderedWrite)));
// MySQLStyleTransactionTest takes far too long for valgrind to run. // MySQLStyleTransactionTest takes far too long for valgrind to run. Only do it
#ifndef ROCKSDB_VALGRIND_RUN // in full mode (`ROCKSDB_FULL_VALGRIND_RUN` compiler flag is set).
#if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
MySQLStyleTransactionTest, MySQLStyleTransactionTest, MySQLStyleTransactionTest, MySQLStyleTransactionTest,
::testing::Values( ::testing::Values(
@ -79,7 +80,7 @@ INSTANTIATE_TEST_CASE_P(
std::make_tuple(false, true, WRITE_UNPREPARED, kOrderedWrite, true), std::make_tuple(false, true, WRITE_UNPREPARED, kOrderedWrite, true),
std::make_tuple(false, true, WRITE_PREPARED, kUnorderedWrite, false), std::make_tuple(false, true, WRITE_PREPARED, kUnorderedWrite, false),
std::make_tuple(false, true, WRITE_PREPARED, kUnorderedWrite, true))); std::make_tuple(false, true, WRITE_PREPARED, kUnorderedWrite, true)));
#endif // ROCKSDB_VALGRIND_RUN #endif // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
TEST_P(TransactionTest, DoubleEmptyWrite) { TEST_P(TransactionTest, DoubleEmptyWrite) {
WriteOptions write_options; WriteOptions write_options;
@ -686,7 +687,7 @@ TEST_P(TransactionTest, DeadlockCycleShared) {
} }
} }
#ifndef ROCKSDB_VALGRIND_RUN #if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
TEST_P(TransactionStressTest, DeadlockCycle) { TEST_P(TransactionStressTest, DeadlockCycle) {
WriteOptions write_options; WriteOptions write_options;
ReadOptions read_options; ReadOptions read_options;
@ -849,7 +850,7 @@ TEST_P(TransactionStressTest, DeadlockStress) {
t.join(); t.join();
} }
} }
#endif // ROCKSDB_VALGRIND_RUN #endif // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
TEST_P(TransactionTest, CommitTimeBatchFailTest) { TEST_P(TransactionTest, CommitTimeBatchFailTest) {
WriteOptions write_options; WriteOptions write_options;
@ -1182,7 +1183,7 @@ TEST_P(TransactionTest, TwoPhaseEmptyWriteTest) {
} }
} }
#ifndef ROCKSDB_VALGRIND_RUN #if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
TEST_P(TransactionStressTest, TwoPhaseExpirationTest) { TEST_P(TransactionStressTest, TwoPhaseExpirationTest) {
Status s; Status s;
@ -1420,7 +1421,7 @@ TEST_P(TransactionTest, PersistentTwoPhaseTransactionTest) {
// deleting transaction should unregister transaction // deleting transaction should unregister transaction
ASSERT_EQ(db->GetTransactionByName("xid"), nullptr); ASSERT_EQ(db->GetTransactionByName("xid"), nullptr);
} }
#endif // ROCKSDB_VALGRIND_RUN #endif // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
// TODO this test needs to be updated with serial commits // TODO this test needs to be updated with serial commits
TEST_P(TransactionTest, DISABLED_TwoPhaseMultiThreadTest) { TEST_P(TransactionTest, DISABLED_TwoPhaseMultiThreadTest) {
@ -1504,6 +1505,7 @@ TEST_P(TransactionTest, DISABLED_TwoPhaseMultiThreadTest) {
} }
} }
#if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
TEST_P(TransactionStressTest, TwoPhaseLongPrepareTest) { TEST_P(TransactionStressTest, TwoPhaseLongPrepareTest) {
WriteOptions write_options; WriteOptions write_options;
write_options.sync = true; write_options.sync = true;
@ -1614,6 +1616,7 @@ TEST_P(TransactionTest, TwoPhaseSequenceTest) {
ASSERT_EQ(s, Status::OK()); ASSERT_EQ(s, Status::OK());
ASSERT_EQ(value, "bar4"); ASSERT_EQ(value, "bar4");
} }
#endif // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
TEST_P(TransactionTest, TwoPhaseDoubleRecoveryTest) { TEST_P(TransactionTest, TwoPhaseDoubleRecoveryTest) {
WriteOptions write_options; WriteOptions write_options;
@ -5356,7 +5359,7 @@ TEST_P(TransactionStressTest, ExpiredTransactionDataRace1) {
ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing(); ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->DisableProcessing();
} }
#ifndef ROCKSDB_VALGRIND_RUN #if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
namespace { namespace {
// cmt_delay_ms is the delay between prepare and commit // cmt_delay_ms is the delay between prepare and commit
// first_id is the id of the first transaction // first_id is the id of the first transaction
@ -5486,7 +5489,7 @@ TEST_P(MySQLStyleTransactionTest, TransactionStressTest) {
!TAKE_SNAPSHOT); !TAKE_SNAPSHOT);
ASSERT_OK(s); ASSERT_OK(s);
} }
#endif // ROCKSDB_VALGRIND_RUN #endif // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
TEST_P(TransactionTest, MemoryLimitTest) { TEST_P(TransactionTest, MemoryLimitTest) {
TransactionOptions txn_options; TransactionOptions txn_options;
@ -5520,6 +5523,7 @@ TEST_P(TransactionTest, MemoryLimitTest) {
delete txn; delete txn;
} }
#if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
// This test clarifies the existing expectation from the sequence number // This test clarifies the existing expectation from the sequence number
// algorithm. It could detect mistakes in updating the code but it is not // algorithm. It could detect mistakes in updating the code but it is not
// necessarily the one acceptable way. If the algorithm is legitimately changed, // necessarily the one acceptable way. If the algorithm is legitimately changed,
@ -5643,6 +5647,7 @@ TEST_P(TransactionStressTest, SeqAdvanceTest) {
ASSERT_OK(ReOpen()); ASSERT_OK(ReOpen());
} }
} }
#endif // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
// Verify that the optimization would not compromize the correctness // Verify that the optimization would not compromize the correctness
TEST_P(TransactionTest, Optimizations) { TEST_P(TransactionTest, Optimizations) {
@ -5693,7 +5698,7 @@ class ThreeBytewiseComparator : public Comparator {
} }
}; };
#ifndef ROCKSDB_VALGRIND_RUN #if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
TEST_P(TransactionTest, GetWithoutSnapshot) { TEST_P(TransactionTest, GetWithoutSnapshot) {
WriteOptions write_options; WriteOptions write_options;
std::atomic<bool> finish = {false}; std::atomic<bool> finish = {false};
@ -5722,7 +5727,7 @@ TEST_P(TransactionTest, GetWithoutSnapshot) {
commit_thread.join(); commit_thread.join();
read_thread.join(); read_thread.join();
} }
#endif // ROCKSDB_VALGRIND_RUN #endif // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
// Test that the transactional db can handle duplicate keys in the write batch // Test that the transactional db can handle duplicate keys in the write batch
TEST_P(TransactionTest, DuplicateKeys) { TEST_P(TransactionTest, DuplicateKeys) {

16
utilities/transactions/write_prepared_transaction_test.cc
View File

@ -542,7 +542,7 @@ class WritePreparedTransactionTest
std::get<2>(GetParam()), std::get<3>(GetParam())){}; std::get<2>(GetParam()), std::get<3>(GetParam())){};
}; };
#ifndef ROCKSDB_VALGRIND_RUN #if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
class SnapshotConcurrentAccessTest class SnapshotConcurrentAccessTest
: public WritePreparedTransactionTestBase, : public WritePreparedTransactionTestBase,
virtual public ::testing::WithParamInterface<std::tuple< virtual public ::testing::WithParamInterface<std::tuple<
@ -561,7 +561,7 @@ class SnapshotConcurrentAccessTest
size_t split_id_; size_t split_id_;
size_t split_cnt_; size_t split_cnt_;
}; };
#endif // ROCKSDB_VALGRIND_RUN #endif // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
class SeqAdvanceConcurrentTest class SeqAdvanceConcurrentTest
: public WritePreparedTransactionTestBase, : public WritePreparedTransactionTestBase,
@ -591,7 +591,7 @@ INSTANTIATE_TEST_CASE_P(
std::make_tuple(false, true, WRITE_PREPARED, kOrderedWrite), std::make_tuple(false, true, WRITE_PREPARED, kOrderedWrite),
std::make_tuple(false, true, WRITE_PREPARED, kUnorderedWrite))); std::make_tuple(false, true, WRITE_PREPARED, kUnorderedWrite)));
#ifndef ROCKSDB_VALGRIND_RUN #if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
INSTANTIATE_TEST_CASE_P( INSTANTIATE_TEST_CASE_P(
TwoWriteQueues, SnapshotConcurrentAccessTest, TwoWriteQueues, SnapshotConcurrentAccessTest,
::testing::Values( ::testing::Values(
@ -698,7 +698,7 @@ INSTANTIATE_TEST_CASE_P(
std::make_tuple(false, false, WRITE_PREPARED, kOrderedWrite, 7, 10), std::make_tuple(false, false, WRITE_PREPARED, kOrderedWrite, 7, 10),
std::make_tuple(false, false, WRITE_PREPARED, kOrderedWrite, 8, 10), std::make_tuple(false, false, WRITE_PREPARED, kOrderedWrite, 8, 10),
std::make_tuple(false, false, WRITE_PREPARED, kOrderedWrite, 9, 10))); std::make_tuple(false, false, WRITE_PREPARED, kOrderedWrite, 9, 10)));
#endif // ROCKSDB_VALGRIND_RUN #endif // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
TEST_P(WritePreparedTransactionTest, CommitMap) { TEST_P(WritePreparedTransactionTest, CommitMap) {
WritePreparedTxnDB* wp_db = dynamic_cast<WritePreparedTxnDB*>(db); WritePreparedTxnDB* wp_db = dynamic_cast<WritePreparedTxnDB*>(db);
@ -1171,7 +1171,7 @@ TEST_P(WritePreparedTransactionTest, CheckAgainstSnapshots) {
// This test is too slow for travis // This test is too slow for travis
#ifndef TRAVIS #ifndef TRAVIS
#ifndef ROCKSDB_VALGRIND_RUN #if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
// Test that CheckAgainstSnapshots will not miss a live snapshot if it is run in // Test that CheckAgainstSnapshots will not miss a live snapshot if it is run in
// parallel with UpdateSnapshots. // parallel with UpdateSnapshots.
TEST_P(SnapshotConcurrentAccessTest, SnapshotConcurrentAccess) { TEST_P(SnapshotConcurrentAccessTest, SnapshotConcurrentAccess) {
@ -1251,7 +1251,7 @@ TEST_P(SnapshotConcurrentAccessTest, SnapshotConcurrentAccess) {
} }
printf("\n"); printf("\n");
} }
#endif // ROCKSDB_VALGRIND_RUN #endif // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
#endif // TRAVIS #endif // TRAVIS
// This test clarifies the contract of AdvanceMaxEvictedSeq method // This test clarifies the contract of AdvanceMaxEvictedSeq method
@ -1580,7 +1580,7 @@ TEST_P(WritePreparedTransactionTest, AdvanceMaxEvictedSeqWithDuplicates) {
delete txn0; delete txn0;
} }
#ifndef ROCKSDB_VALGRIND_RUN #if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
// Stress SmallestUnCommittedSeq, which reads from both prepared_txns_ and // Stress SmallestUnCommittedSeq, which reads from both prepared_txns_ and
// delayed_prepared_, when is run concurrently with advancing max_evicted_seq, // delayed_prepared_, when is run concurrently with advancing max_evicted_seq,
// which moves prepared txns from prepared_txns_ to delayed_prepared_. // which moves prepared txns from prepared_txns_ to delayed_prepared_.
@ -1642,7 +1642,7 @@ TEST_P(WritePreparedTransactionTest, SmallestUnCommittedSeq) {
delete txn; delete txn;
} }
} }
#endif // ROCKSDB_VALGRIND_RUN #endif // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
TEST_P(SeqAdvanceConcurrentTest, SeqAdvanceConcurrent) { TEST_P(SeqAdvanceConcurrentTest, SeqAdvanceConcurrent) {
// Given the sequential run of txns, with this timeout we should never see a // Given the sequential run of txns, with this timeout we should never see a

4
utilities/transactions/write_unprepared_transaction_test.cc
View File

@ -136,7 +136,7 @@ TEST_P(WriteUnpreparedTransactionTest, ReadYourOwnWrite) {
} }
} }
#ifndef ROCKSDB_VALGRIND_RUN #if !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
TEST_P(WriteUnpreparedStressTest, ReadYourOwnWriteStress) { TEST_P(WriteUnpreparedStressTest, ReadYourOwnWriteStress) {
// This is a stress test where different threads are writing random keys, and // This is a stress test where different threads are writing random keys, and
// then before committing or aborting the transaction, it validates to see // then before committing or aborting the transaction, it validates to see
@ -314,7 +314,7 @@ TEST_P(WriteUnpreparedStressTest, ReadYourOwnWriteStress) {
t.join(); t.join();
} }
} }
#endif // ROCKSDB_VALGRIND_RUN #endif // !defined(ROCKSDB_VALGRIND_RUN) || defined(ROCKSDB_FULL_VALGRIND_RUN)
// This tests how write unprepared behaves during recovery when the DB crashes // This tests how write unprepared behaves during recovery when the DB crashes
// after a transaction has either been unprepared or prepared, and tests if // after a transaction has either been unprepared or prepared, and tests if