MB-58555: Use fractionOf for calculation of mutation_mem_ratio threshold

...and refactor out the existing percentOf from a couple of places.

By casting the integer to a double, we avoid performing the operation
with float, which has insufficient precision.

We do the same for memory watermarks already.

Change-Id: Ia3aab14f24b6d85b3d298c31ca25095e44831452
Reviewed-on: https://review.couchbase.org/c/kv_engine/+/196802
Tested-by: Vesko Karaganev <vesko.karaganev@couchbase.com>
Reviewed-by: Pavlos Georgiou <pavlos.georgiou@couchbase.com>

Author: veselink1

engines/ep/src/ep_engine.cc

@@ -80,6 +80,7 @@
 #include <statistics/prometheus.h>
 #include <utilities/engine_errc_2_mcbp.h>
 #include <utilities/logtags.h>
+#include <utilities/math_utilities.h>
 #include <xattr/utils.h>
 #include <functional>
 
@@ -98,10 +99,6 @@
 using cb::tracing::Code;
 using namespace std::string_view_literals;
 
-static size_t percentOf(size_t val, double percent) {
-    return static_cast<size_t>(static_cast<double>(val) * percent);
-}
-
 struct EPHandleReleaser {
     void operator()(const EventuallyPersistentEngine*) {
         ObjectRegistry::onSwitchThread(nullptr);
@@ -6947,8 +6944,10 @@ void EventuallyPersistentEngine::setMaxDataSize(size_t size) {
 }
 
 void EventuallyPersistentEngine::configureMemWatermarksForQuota(size_t quota) {
-    configuration.setMemLowWat(percentOf(quota, stats.mem_low_wat_percent));
-    configuration.setMemHighWat(percentOf(quota, stats.mem_high_wat_percent));
+    configuration.setMemLowWat(
+            cb::fractionOf(quota, stats.mem_low_wat_percent));
+    configuration.setMemHighWat(
+            cb::fractionOf(quota, stats.mem_high_wat_percent));
 }
 
 void EventuallyPersistentEngine::configureStorageMemoryForQuota(size_t quota) {

engines/ep/src/memory_tracker.cc

@@ -13,12 +13,13 @@
 #include "ep_engine.h"
 #include "ep_engine_group.h"
 #include "kv_bucket.h"
+#include <utilities/math_utilities.h>
 
 bool StrictQuotaMemoryTracker::isBelowMutationMemoryQuota(
         size_t pendingBytes) const {
     return engine.getEpStats().getEstimatedTotalMemoryUsed() + pendingBytes <
-           engine.getEpStats().getMaxDataSize() *
-                   engine.getKVBucket()->getMutationMemRatio();
+           cb::fractionOf(engine.getEpStats().getMaxDataSize(),
+                          engine.getKVBucket()->getMutationMemRatio());
 }
 
 bool StrictQuotaMemoryTracker::isBelowMemoryQuota(size_t pendingBytes) const {
@@ -28,8 +29,8 @@ bool StrictQuotaMemoryTracker::isBelowMemoryQuota(size_t pendingBytes) const {
 
 bool StrictQuotaMemoryTracker::isBelowBackfillThreshold() const {
     return engine.getEpStats().getEstimatedTotalMemoryUsed() <
-           engine.getEpStats().getMaxDataSize() *
-                   engine.getKVBucket()->getBackfillMemoryThreshold();
+           cb::fractionOf(engine.getEpStats().getMaxDataSize(),
+                          engine.getKVBucket()->getBackfillMemoryThreshold());
 }
 
 bool StrictQuotaMemoryTracker::needsToFreeMemory() const {

engines/ep/src/replicationthrottle.cc

@@ -14,6 +14,7 @@
 #include "ep_engine.h"
 #include "kv_bucket.h"
 #include "stats.h"
+#include <utilities/math_utilities.h>
 
 ReplicationThrottleEP::ReplicationThrottleEP(
         const EventuallyPersistentEngine& engine)
@@ -29,7 +30,7 @@ bool ReplicationThrottleEP::hasSomeMemory() const {
     const auto* bucket = engine.getKVBucket();
     Expects(bucket);
 
-    return memoryUsed <= maxSize * bucket->getMutationMemRatio();
+    return memoryUsed <= cb::fractionOf(maxSize, bucket->getMutationMemRatio());
 }
 
 ReplicationThrottleEP::Status ReplicationThrottleEP::getStatus() const {

engines/ep/tests/module_tests/bucket_quota_change_test.cc

@@ -19,17 +19,14 @@
 #include "kvstore/kvstore_iface.h"
 #include "test_helpers.h"
 #include "vbucket.h"
+#include <utilities/math_utilities.h>
 
 #include "../mock/mock_synchronous_ep_engine.h"
 
 #ifdef EP_USE_MAGMA
 #include "kvstore/magma-kvstore/magma-kvstore_config.h"
 #endif
 
-auto percentOf(size_t val, double percent) {
-    return static_cast<size_t>(static_cast<double>(val) * percent);
-}
-
 class BucketQuotaChangeTest : public STParameterizedBucketTest {
 public:
     void SetUp() override {
@@ -114,14 +111,14 @@ class BucketQuotaChangeTest : public STParameterizedBucketTest {
     }
 
     void setLowWatermark(double percentage) {
-        auto newValue = percentOf(getCurrentBucketQuota(), percentage);
+        auto newValue = cb::fractionOf(getCurrentBucketQuota(), percentage);
         std::string msg;
         engine->setFlushParam("mem_low_wat", std::to_string(newValue), msg);
         initialMemLowWatPercent = percentage;
     }
 
     void setHighWatermark(double percentage) {
-        auto newValue = percentOf(getCurrentBucketQuota(), percentage);
+        auto newValue = cb::fractionOf(getCurrentBucketQuota(), percentage);
         std::string msg;
         engine->setFlushParam("mem_high_wat", std::to_string(newValue), msg);
         initialMemHighWatPercent = percentage;
@@ -135,11 +132,11 @@ class BucketQuotaChangeTest : public STParameterizedBucketTest {
     void checkWatermarkValues(size_t quotaValue) {
         EXPECT_EQ(initialMemLowWatPercent,
                   engine->getEpStats().mem_low_wat_percent);
-        EXPECT_EQ(percentOf(quotaValue, initialMemLowWatPercent),
+        EXPECT_EQ(cb::fractionOf(quotaValue, initialMemLowWatPercent),
                   engine->getConfiguration().getMemLowWat());
         EXPECT_EQ(initialMemHighWatPercent,
                   engine->getEpStats().mem_high_wat_percent);
-        EXPECT_EQ(percentOf(quotaValue, initialMemHighWatPercent),
+        EXPECT_EQ(cb::fractionOf(quotaValue, initialMemHighWatPercent),
                   engine->getConfiguration().getMemHighWat());
     }
 
@@ -162,8 +159,8 @@ class BucketQuotaChangeTest : public STParameterizedBucketTest {
             engine->getKVBucket()->getOneRWUnderlying()->getStat("memory_quota",
                                                                  magmaQuota);
             EXPECT_EQ(
-                    percentOf(quotaValue,
-                              magmaKVStoreConfig.getMagmaMemQuotaRatio()),
+                    cb::fractionOf(quotaValue,
+                                   magmaKVStoreConfig.getMagmaMemQuotaRatio()),
                     magmaQuota * engine->getConfiguration().getMaxNumShards());
         }
 #endif
@@ -291,10 +288,10 @@ class BucketQuotaChangeTest : public STParameterizedBucketTest {
         // backfills, and storage engine quota, before it changes the actual
         // quota, check that those values have been updated now (and that quota
         // is still the same).
-        EXPECT_EQ(percentOf(newQuota, initialMemLowWatPercent),
+        EXPECT_EQ(cb::fractionOf(newQuota, initialMemLowWatPercent),
                   engine->getConfiguration().getMemLowWat());
 
-        EXPECT_EQ(percentOf(newQuota, initialMemHighWatPercent),
+        EXPECT_EQ(cb::fractionOf(newQuota, initialMemHighWatPercent),
                   engine->getConfiguration().getMemHighWat());
 
         checkMaxRunningBackfills(newQuota);

utilities/math_utilities.h

@@ -0,0 +1,26 @@
+/*
+ *     Copyright 2023-Present Couchbase, Inc.
+ *
+ *   Use of this software is governed by the Business Source License included
+ *   in the file licenses/BSL-Couchbase.txt.  As of the Change Date specified
+ *   in that file, in accordance with the Business Source License, use of this
+ *   software will be governed by the Apache License, Version 2.0, included in
+ *   the file licenses/APL2.txt.
+ */
+#pragma once
+
+namespace cb {
+
+/**
+ * Calculate a fraction of an integer, using sufficient precision to represent
+ * the addressable virtual memory.
+ *
+ * @param val An integer value
+ * @param frac The fraction of the value to calculate [0.-1.]
+ */
+template <typename T>
+auto fractionOf(T val, double frac) {
+    return static_cast<T>(static_cast<double>(val) * frac);
+}
+
+} // namespace cb