Page MenuHomePhabricator
Differential D4641 Diff 14636 src/test/cuckoocache_tests.cpp

Changeset View

Standalone View

View Options

src/test/cuckoocache_tests.cpp

Show All 28 Lines
/** /**
* Test that no values not inserted into the cache are read out of it. * Test that no values not inserted into the cache are read out of it.
* *
* There are no repeats in the first 200000 insecure_GetRandHash calls * There are no repeats in the first 200000 insecure_GetRandHash calls
*/ */
BOOST_AUTO_TEST_CASE(test_cuckoocache_no_fakes) { BOOST_AUTO_TEST_CASE(test_cuckoocache_no_fakes) {
SeedInsecureRand(true); SeedInsecureRand(true);
CuckooCache::cache<uint256, SignatureCacheHasher> cc{}; CuckooCache::cache<CuckooCache::KeyOnly<uint256>, SignatureCacheHasher>
cc{};
size_t megabytes = 4; size_t megabytes = 4;
cc.setup_bytes(megabytes << 20); cc.setup_bytes(megabytes << 20);
for (int x = 0; x < 100000; ++x) { for (int x = 0; x < 100000; ++x) {
cc.insert(InsecureRand256()); cc.insert(InsecureRand256());
} }
for (int x = 0; x < 100000; ++x) { for (int x = 0; x < 100000; ++x) {
BOOST_CHECK(!cc.contains(InsecureRand256(), false)); BOOST_CHECK(!cc.contains(InsecureRand256(), false));
} }
▲ Show 20 Lines • Show All 64 Lines • ▼ Show 20 LinesBOOST_AUTO_TEST_CASE(cuckoocache_hit_rate_ok) {
/** /**
* Arbitrarily selected Hit Rate threshold that happens to work for this * Arbitrarily selected Hit Rate threshold that happens to work for this
* test as a lower bound on performance. * test as a lower bound on performance.
*/ */
double HitRateThresh = 0.98; double HitRateThresh = 0.98;
size_t megabytes = 4; size_t megabytes = 4;
for (double load = 0.1; load < 2; load *= 2) { for (double load = 0.1; load < 2; load *= 2) {
double hits = double hits =
test_cache<CuckooCache::cache<uint256, SignatureCacheHasher>>( test_cache<CuckooCache::cache<CuckooCache::KeyOnly<uint256>,
megabytes, load); SignatureCacheHasher>>(megabytes,
load);
BOOST_CHECK(normalize_hit_rate(hits, load) > HitRateThresh); BOOST_CHECK(normalize_hit_rate(hits, load) > HitRateThresh);
} }
} }
/** /**
* This helper checks that erased elements are preferentially inserted onto and * This helper checks that erased elements are preferentially inserted onto and
* that the hit rate of "fresher" keys is reasonable. * that the hit rate of "fresher" keys is reasonable.
*/ */
▲ Show 20 Lines • Show All 58 Lines • ▼ Show 20 Linestemplate <typename Cache> static void test_cache_erase(size_t megabytes) {
BOOST_CHECK_EQUAL(hit_rate_fresh, 1.0); BOOST_CHECK_EQUAL(hit_rate_fresh, 1.0);
// Check that we have a more than 2x better hit rate on stale elements than // Check that we have a more than 2x better hit rate on stale elements than
// erased elements. // erased elements.
BOOST_CHECK(hit_rate_stale > 2 * hit_rate_erased_but_contained); BOOST_CHECK(hit_rate_stale > 2 * hit_rate_erased_but_contained);
} }
BOOST_AUTO_TEST_CASE(cuckoocache_erase_ok) { BOOST_AUTO_TEST_CASE(cuckoocache_erase_ok) {
size_t megabytes = 4; size_t megabytes = 4;
test_cache_erase<CuckooCache::cache<uint256, SignatureCacheHasher>>( test_cache_erase<CuckooCache::cache<CuckooCache::KeyOnly<uint256>,
megabytes); SignatureCacheHasher>>(megabytes);
} }
template <typename Cache> template <typename Cache>
static void test_cache_erase_parallel(size_t megabytes) { static void test_cache_erase_parallel(size_t megabytes) {
double load = 1; double load = 1;
SeedInsecureRand(true); SeedInsecureRand(true);
std::vector<uint256> hashes; std::vector<uint256> hashes;
Cache set{}; Cache set{};
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Linesstatic void test_cache_erase_parallel(size_t megabytes) {
BOOST_CHECK_EQUAL(hit_rate_fresh, 1.0); BOOST_CHECK_EQUAL(hit_rate_fresh, 1.0);
// Check that we have a more than 2x better hit rate on stale elements than // Check that we have a more than 2x better hit rate on stale elements than
// erased elements. // erased elements.
BOOST_CHECK(hit_rate_stale > 2 * hit_rate_erased_but_contained); BOOST_CHECK(hit_rate_stale > 2 * hit_rate_erased_but_contained);
} }
BOOST_AUTO_TEST_CASE(cuckoocache_erase_parallel_ok) { BOOST_AUTO_TEST_CASE(cuckoocache_erase_parallel_ok) {
size_t megabytes = 4; size_t megabytes = 4;
test_cache_erase_parallel< test_cache_erase_parallel<CuckooCache::cache<CuckooCache::KeyOnly<uint256>,
CuckooCache::cache<uint256, SignatureCacheHasher>>(megabytes); SignatureCacheHasher>>(
megabytes);
} }
template <typename Cache> static void test_cache_generations() { template <typename Cache> static void test_cache_generations() {
// This test checks that for a simulation of network activity, the fresh hit // This test checks that for a simulation of network activity, the fresh hit
// rate is never below 99%, and the number of times that it is worse than // rate is never below 99%, and the number of times that it is worse than
// 99.9% are less than 1% of the time. // 99.9% are less than 1% of the time.
double min_hit_rate = 0.99; double min_hit_rate = 0.99;
double tight_hit_rate = 0.999; double tight_hit_rate = 0.999;
▲ Show 20 Lines • Show All 84 Lines • ▼ Show 20 Lines for (uint32_t i = 0; i < total; ++i) {
out_of_tight_tolerance += hit < tight_hit_rate; out_of_tight_tolerance += hit < tight_hit_rate;
} }
// Check that being out of tolerance happens less than // Check that being out of tolerance happens less than
// max_rate_less_than_tight_hit_rate of the time // max_rate_less_than_tight_hit_rate of the time
BOOST_CHECK(double(out_of_tight_tolerance) / double(total) < BOOST_CHECK(double(out_of_tight_tolerance) / double(total) <
max_rate_less_than_tight_hit_rate); max_rate_less_than_tight_hit_rate);
} }
BOOST_AUTO_TEST_CASE(cuckoocache_generations) { BOOST_AUTO_TEST_CASE(cuckoocache_generations) {
test_cache_generations<CuckooCache::cache<uint256, SignatureCacheHasher>>(); test_cache_generations<CuckooCache::cache<CuckooCache::KeyOnly<uint256>,
SignatureCacheHasher>>();
} }
BOOST_AUTO_TEST_SUITE_END(); BOOST_AUTO_TEST_SUITE_END();