Convert cacheDigestCalcMaskSize and cacheDigestTest to methods

diff --git a/src/CacheDigest.cc b/src/CacheDigest.cc
index 84cd5a0098f1dbbc1fc787b999318ce2a59d1aa0..6811359d009bec5d363f78e9270c6b2273fe8c88 100644 (file)
--- a/src/CacheDigest.cc
+++ b/src/CacheDigest.cc
@@ -37,7 +37,7 @@ static uint32_t hashed_keys[4];
 static void
 cacheDigestInit(CacheDigest * cd, int capacity)
 {
-    const size_t mask_size = cacheDigestCalcMaskSize(capacity, cd->bits_per_entry);
+    const size_t mask_size = CacheDigest::CalcMaskSize(capacity, cd->bits_per_entry);
     assert(cd);
     assert(capacity > 0 && cd->bits_per_entry > 0);
     assert(mask_size > 0);
@@ -91,19 +91,18 @@ CacheDigest::updateCapacity(int newCapacity)
     cacheDigestInit(this, newCapacity); // will re-init mask and mask_size
 }
 
-/* returns true if the key belongs to the digest */
-int
-cacheDigestTest(const CacheDigest * cd, const cache_key * key)
+bool
+CacheDigest::test(const cache_key * key) const
 {
-    assert(cd && key);
+    assert(key);
     /* hash */
-    cacheDigestHashKey(cd, key);
+    cacheDigestHashKey(this, key);
     /* test corresponding bits */
     return
-        CBIT_TEST(cd->mask, hashed_keys[0]) &&
-        CBIT_TEST(cd->mask, hashed_keys[1]) &&
-        CBIT_TEST(cd->mask, hashed_keys[2]) &&
-        CBIT_TEST(cd->mask, hashed_keys[3]);
+        CBIT_TEST(mask, hashed_keys[0]) &&
+        CBIT_TEST(mask, hashed_keys[1]) &&
+        CBIT_TEST(mask, hashed_keys[2]) &&
+        CBIT_TEST(mask, hashed_keys[3]);
 }
 
 void
@@ -285,8 +284,9 @@ cacheDigestReport(CacheDigest * cd, const char *label, StoreEntry * e)
 }
 
 size_t
-cacheDigestCalcMaskSize(int cap, int bpe)
+CacheDigest::CalcMaskSize(int cap, int bpe)
 {
+    // XXX: might 32-bit overflow during multiply
     return (size_t) (cap * bpe + 7) / 8;
 }
 

diff --git a/src/CacheDigest.h b/src/CacheDigest.h
index 2e3ad3197cfe60436e88f6453f3616f12edbb53d..46798a17428a67bb396abba596a6f62666837501 100644 (file)
--- a/src/CacheDigest.h
+++ b/src/CacheDigest.h
@@ -34,6 +34,13 @@ public:
     /// changes mask size to fit newCapacity, resets bits to 0
     void updateCapacity(int newCapacity);
 
+    /// \returns true if the key belongs to the digest
+    bool test(const cache_key * key) const;
+
+    /// calculate the size of mask required to digest up to
+    /// a specified capacity and bitsize.
+    static size_t CalcMaskSize(int cap, int bpe);
+
 public:
     /* public, read-only */
     char *mask;         /* bit mask */
@@ -44,10 +51,8 @@ public:
     int del_count;      /* number of deletions performed so far */
 };
 
-int cacheDigestTest(const CacheDigest * cd, const cache_key * key);
 void cacheDigestAdd(CacheDigest * cd, const cache_key * key);
 void cacheDigestDel(CacheDigest * cd, const cache_key * key);
-size_t cacheDigestCalcMaskSize(int cap, int bpe);
 int cacheDigestBitUtil(const CacheDigest * cd);
 void cacheDigestGuessStatsUpdate(CacheDigestGuessStats * stats, int real_hit, int guess_hit);
 void cacheDigestGuessStatsReport(const CacheDigestGuessStats * stats, StoreEntry * sentry, const char *label);

diff --git a/src/neighbors.cc b/src/neighbors.cc
index 627dc5c5afd00449446845081b1ca4e65aaa9ccc..31ab13fcdd4ed91442fb9931213cb7f2d5f822cb 100644 (file)
--- a/src/neighbors.cc
+++ b/src/neighbors.cc
@@ -762,7 +762,7 @@ peerDigestLookup(CachePeer * p, HttpRequest * request)
     assert(p->digest->cd);
     /* does digest predict a hit? */
 
-    if (!cacheDigestTest(p->digest->cd, key))
+    if (!p->digest->cd->test(key))
         return LOOKUP_MISS;
 
     debugs(15, 5, "peerDigestLookup: peer " << p->host << " says HIT!");

diff --git a/src/peer_digest.cc b/src/peer_digest.cc
index 85df88c6afd351ea726bb73e278d05dd4f9908bc..8b235335c86740d9880c8a0d58d0403380e0b7f2 100644 (file)
--- a/src/peer_digest.cc
+++ b/src/peer_digest.cc
@@ -977,10 +977,10 @@ peerDigestSetCBlock(PeerDigest * pd, const char *buf)
     }
 
     /* check consistency further */
-    if ((size_t)cblock.mask_size != cacheDigestCalcMaskSize(cblock.capacity, cblock.bits_per_entry)) {
+    if ((size_t)cblock.mask_size != CacheDigest::CalcMaskSize(cblock.capacity, cblock.bits_per_entry)) {
         debugs(72, DBG_CRITICAL, host << " digest cblock is corrupted " <<
                "(mask size mismatch: " << cblock.mask_size << " ? " <<
-               cacheDigestCalcMaskSize(cblock.capacity, cblock.bits_per_entry)
+               CacheDigest::CalcMaskSize(cblock.capacity, cblock.bits_per_entry)
                << ").");
         return 0;
     }

diff --git a/src/store_digest.cc b/src/store_digest.cc
index fe048e192af434a242486f13e72f489c3ec3d9f8..c6b95a2ed01fb3c540f31ef9a0fdf758a223207e 100644 (file)
--- a/src/store_digest.cc
+++ b/src/store_digest.cc
@@ -147,7 +147,7 @@ storeDigestDel(const StoreEntry * entry)
     debugs(71, 6, "storeDigestDel: checking entry, key: " << entry->getMD5Text());
 
     if (!EBIT_TEST(entry->flags, KEY_PRIVATE)) {
-        if (!cacheDigestTest(store_digest,  (const cache_key *)entry->key)) {
+        if (!store_digest->test(static_cast<const cache_key *>(entry->key))) {
             ++sd_stats.del_lost_count;
             debugs(71, 6, "storeDigestDel: lost entry, key: " << entry->getMD5Text() << " url: " << entry->url()  );
         } else {
@@ -254,7 +254,7 @@ storeDigestAdd(const StoreEntry * entry)
     if (storeDigestAddable(entry)) {
         ++sd_stats.add_count;
 
-        if (cacheDigestTest(store_digest, (const cache_key *)entry->key))
+        if (store_digest->test(static_cast<const cache_key *>(entry->key)))
             ++sd_stats.add_coll_count;
 
         cacheDigestAdd(store_digest,  (const cache_key *)entry->key);
@@ -263,7 +263,7 @@ storeDigestAdd(const StoreEntry * entry)
     } else {
         ++sd_stats.rej_count;
 
-        if (cacheDigestTest(store_digest,  (const cache_key *)entry->key))
+        if (store_digest->test(static_cast<const cache_key *>(entry->key)))
             ++sd_stats.rej_coll_count;
     }
 }

diff --git a/src/test_cache_digest.cc b/src/test_cache_digest.cc
index cedcf575ff4540281516c7b6f52152f951a8d8be..1972b777d3efc4cb9d02dc5ce3921d29a4deb0e7 100644 (file)
--- a/src/test_cache_digest.cc
+++ b/src/test_cache_digest.cc
@@ -290,7 +290,7 @@ static void
 cacheQueryPeer(Cache * cache, const cache_key * key)
 {
     const int peer_has_it = hash_lookup(cache->peer->hash, key) != NULL;
-    const int we_think_we_have_it = cacheDigestTest(cache->digest, key);
+    const int we_think_we_have_it = cache->digest->test(key);
 
     ++ cache->qstats.query_count;
 

diff --git a/src/tests/stub_CacheDigest.cc b/src/tests/stub_CacheDigest.cc
index f305e22c5c1aa3f553cf40206596b29df44ce402..f41a85ce6bb6527d62370eb56d6aaaf1ee8cffda 100644 (file)
--- a/src/tests/stub_CacheDigest.cc
+++ b/src/tests/stub_CacheDigest.cc
@@ -22,12 +22,12 @@ CacheDigest::~CacheDigest() {STUB}
 CacheDigest *CacheDigest::clone() const STUB_RETVAL(nullptr)
 void CacheDigest::clear() STUB
 void CacheDigest::updateCapacity(int) STUB
-int cacheDigestTest(const CacheDigest *, const cache_key *) STUB_RETVAL(1)
+bool CacheDigest::test(const cache_key *) const STUB_RETVAL(false)
 void cacheDigestAdd(CacheDigest *, const cache_key *) STUB
 void cacheDigestDel(CacheDigest *, const cache_key *) STUB
 int cacheDigestBitUtil(const CacheDigest *) STUB_RETVAL(0)
 void cacheDigestGuessStatsUpdate(CacheDigestGuessStats *, int, int) STUB
 void cacheDigestGuessStatsReport(const CacheDigestGuessStats *, StoreEntry *, const char *) STUB
 void cacheDigestReport(CacheDigest *, const char *, StoreEntry *) STUB
-size_t cacheDigestCalcMaskSize(int, int) STUB_RETVAL(1)
+size_t CacheDigest::CalcMaskSize(int, int) STUB_RETVAL(1)