From e91d1a21a6ad7dc4eb4ce46c5b3f6ad550357640 Mon Sep 17 00:00:00 2001 From: Peter Dillinger Date: Thu, 26 Mar 2020 19:34:06 -0700 Subject: [PATCH] Streamline persistent_cache_test for testing efficiency (#6601) Summary: This test was written like a stress test, using up to 3x26GB RSS memory during parallel 'make check'. Now, while this code is mostly dormant, I've made the "for Travis" versions of the expensive tests the canonical versions and disabled the expensive versions. This has the side benefit of removing some arbitrary conditional compilation. For unknown reason, the super expensive tests were gated on Snappy_Supported, which appears to be irrelevant, so I removed it. The tests can be fixed / improved / migrated to stress test if/when they are deemed important again. Pull Request resolved: https://github.com/facebook/rocksdb/pull/6601 Test Plan: make check + CI ./persistent_cache_test Before: ... [==========] 10 tests from 2 test cases ran. (114541 ms total) [ PASSED ] 10 tests. YOU HAVE 1 DISABLED TEST After: ... [==========] 3 tests from 2 test cases ran. (1714 ms total) [ PASSED ] 3 tests. YOU HAVE 10 DISABLED TESTS Reviewed By: siying Differential Revision: D20680983 Pulled By: pdillinger fbshipit-source-id: 2be0fde13eeb0a71110ac7f5477cfe63996a509e --- .../persistent_cache/persistent_cache_test.cc | 41 ++++++++++--------- 1 file changed, 22 insertions(+), 19 deletions(-) diff --git a/utilities/persistent_cache/persistent_cache_test.cc b/utilities/persistent_cache/persistent_cache_test.cc index dce6e08e0..e7d6a313b 100644 --- a/utilities/persistent_cache/persistent_cache_test.cc +++ b/utilities/persistent_cache/persistent_cache_test.cc @@ -160,7 +160,6 @@ TEST_F(PersistentCacheTierTest, DISABLED_BlockCacheInsertWithFileCreateError) { ROCKSDB_NAMESPACE::SyncPoint::GetInstance()->ClearAllCallBacks(); } -#if defined(TRAVIS) || defined(ROCKSDB_VALGRIND_RUN) // Travis is unable to handle the normal version of the tests running out of // fds, out of space and timeouts. This is an easier version of the test // specifically written for Travis @@ -177,9 +176,10 @@ TEST_F(PersistentCacheTierTest, BasicTest) { /*memory_size=*/static_cast(1 * 1024 * 1024)); RunInsertTest(/*nthreads=*/1, /*max_keys=*/1024); } -#else + // Volatile cache tests -TEST_F(PersistentCacheTierTest, VolatileCacheInsert) { +// DISABLED for now (somewhat expensive) +TEST_F(PersistentCacheTierTest, DISABLED_VolatileCacheInsert) { for (auto nthreads : {1, 5}) { for (auto max_keys : {10 * 1024 * kStressFactor, 1 * 1024 * 1024 * kStressFactor}) { @@ -189,7 +189,8 @@ TEST_F(PersistentCacheTierTest, VolatileCacheInsert) { } } -TEST_F(PersistentCacheTierTest, VolatileCacheInsertWithEviction) { +// DISABLED for now (somewhat expensive) +TEST_F(PersistentCacheTierTest, DISABLED_VolatileCacheInsertWithEviction) { for (auto nthreads : {1, 5}) { for (auto max_keys : {1 * 1024 * 1024 * kStressFactor}) { cache_ = std::make_shared( @@ -200,7 +201,8 @@ TEST_F(PersistentCacheTierTest, VolatileCacheInsertWithEviction) { } // Block cache tests -TEST_F(PersistentCacheTierTest, BlockCacheInsert) { +// DISABLED for now (expensive) +TEST_F(PersistentCacheTierTest, DISABLED_BlockCacheInsert) { for (auto direct_writes : {true, false}) { for (auto nthreads : {1, 5}) { for (auto max_keys : @@ -214,7 +216,8 @@ TEST_F(PersistentCacheTierTest, BlockCacheInsert) { } } -TEST_F(PersistentCacheTierTest, BlockCacheInsertWithEviction) { +// DISABLED for now (somewhat expensive) +TEST_F(PersistentCacheTierTest, DISABLED_BlockCacheInsertWithEviction) { for (auto nthreads : {1, 5}) { for (auto max_keys : {1 * 1024 * 1024 * kStressFactor}) { cache_ = NewBlockCache(Env::Default(), path_, @@ -225,7 +228,8 @@ TEST_F(PersistentCacheTierTest, BlockCacheInsertWithEviction) { } // Tiered cache tests -TEST_F(PersistentCacheTierTest, TieredCacheInsert) { +// DISABLED for now (expensive) +TEST_F(PersistentCacheTierTest, DISABLED_TieredCacheInsert) { for (auto nthreads : {1, 5}) { for (auto max_keys : {10 * 1024 * kStressFactor, 1 * 1024 * 1024 * kStressFactor}) { @@ -238,7 +242,8 @@ TEST_F(PersistentCacheTierTest, TieredCacheInsert) { // the tests causes a lot of file deletions which Travis limited testing // environment cannot handle -TEST_F(PersistentCacheTierTest, TieredCacheInsertWithEviction) { +// DISABLED for now (somewhat expensive) +TEST_F(PersistentCacheTierTest, DISABLED_TieredCacheInsertWithEviction) { for (auto nthreads : {1, 5}) { for (auto max_keys : {1 * 1024 * 1024 * kStressFactor}) { cache_ = NewTieredCache( @@ -249,7 +254,6 @@ TEST_F(PersistentCacheTierTest, TieredCacheInsertWithEviction) { } } } -#endif std::shared_ptr MakeVolatileCache( const std::string& /*dbname*/) { @@ -308,9 +312,6 @@ PersistentCacheDBTest::PersistentCacheDBTest() : DBTestBase("/cache_test") { void PersistentCacheDBTest::RunTest( const std::function(bool)>& new_pcache, const size_t max_keys = 100 * 1024, const size_t max_usecase = 5) { - if (!Snappy_Supported()) { - return; - } // number of insertion interations int num_iter = static_cast(max_keys * kStressFactor); @@ -438,30 +439,32 @@ void PersistentCacheDBTest::RunTest( } } -#if defined(TRAVIS) || defined(ROCKSDB_VALGRIND_RUN) // Travis is unable to handle the normal version of the tests running out of // fds, out of space and timeouts. This is an easier version of the test -// specifically written for Travis +// specifically written for Travis. +// Now used generally because main tests are too expensive as unit tests. TEST_F(PersistentCacheDBTest, BasicTest) { RunTest(std::bind(&MakeBlockCache, dbname_), /*max_keys=*/1024, /*max_usecase=*/1); } -#else + // test table with block page cache -TEST_F(PersistentCacheDBTest, BlockCacheTest) { +// DISABLED for now (very expensive, especially memory) +TEST_F(PersistentCacheDBTest, DISABLED_BlockCacheTest) { RunTest(std::bind(&MakeBlockCache, dbname_)); } // test table with volatile page cache -TEST_F(PersistentCacheDBTest, VolatileCacheTest) { +// DISABLED for now (very expensive, especially memory) +TEST_F(PersistentCacheDBTest, DISABLED_VolatileCacheTest) { RunTest(std::bind(&MakeVolatileCache, dbname_)); } // test table with tiered page cache -TEST_F(PersistentCacheDBTest, TieredCacheTest) { +// DISABLED for now (very expensive, especially memory) +TEST_F(PersistentCacheDBTest, DISABLED_TieredCacheTest) { RunTest(std::bind(&MakeTieredCache, dbname_)); } -#endif } // namespace ROCKSDB_NAMESPACE