MB-67342: Use byte_literals.h

Change-Id: Ibdb9e4d69cb2c183c97d2a00e8e2f92fb607c796
Reviewed-on: https://review.couchbase.org/c/kv_engine/+/229826
Reviewed-by: Trond Norbye <[email protected]>
Tested-by: Vesko Karaganev <[email protected]>

Author: veselink1

auditd/src/auditconfig.h

@@ -10,6 +10,7 @@
 #pragma once
 
 #include <nlohmann/json_fwd.hpp>
+#include <platform/byte_literals.h>
 #include <atomic>
 #include <chrono>
 #include <cinttypes>
@@ -91,7 +92,7 @@ class AuditConfig {
 
     bool auditd_enabled{false};
     uint32_t rotate_interval{900};
-    size_t rotate_size{20 * 1024 * 1024};
+    size_t rotate_size{20_MiB};
     std::optional<std::chrono::seconds> prune_age;
     bool buffered{true};
     bool filtering_enabled{false};

auditd/src/auditfile.cc

@@ -206,7 +206,7 @@ bool AuditFile::open() {
 
     try {
         file = cb::crypto::FileWriter::create(
-                key, open_file_name, 8192, cb::crypto::Compression::None);
+                key, open_file_name, 8_KiB, cb::crypto::Compression::None);
         LOG_INFO_CTX(
                 "Audit file",
                 {"encrypted", file->is_encrypted() ? "encrypted" : "plain"});

auditd/src/auditfile.h

@@ -127,7 +127,7 @@ class AuditFile {
     std::filesystem::path open_file_name;
     std::filesystem::path log_directory;
     time_t open_time = 0;
-    size_t max_log_size = 20 * 1024 * 1024;
+    size_t max_log_size = 20_MiB;
     uint32_t rotate_interval = 900;
     std::optional<std::chrono::seconds> prune_age;
     /// Iterating over all files in the directory and fetch their

auditd/tests/auditconfig_test.cc

@@ -39,7 +39,7 @@ class AuditConfigTest : public ::testing::Test {
     nlohmann::json createDefaultConfig() {
         nlohmann::json root;
         root["version"] = 2;
-        root["rotate_size"] = 20 * 1024 * 1024;
+        root["rotate_size"] = 20_MiB;
         root["rotate_interval"] = 900;
         root["auditd_enabled"] = true;
         root["buffered"] = true;

daemon/cmdline.cc

@@ -32,7 +32,7 @@ static void usage() {
 }
 
 static std::string read_command() {
-    std::vector<char> buffer(1 * 1024 * 1024);
+    std::vector<char> buffer(1_MiB);
 #ifdef WIN32
     // Windows call a blocking call to fgets() in stdin_check so we
     // can might as well use the portable fgets() and not have to

daemon/connection_libevent.cc

@@ -31,7 +31,7 @@
 /// consume memory on the server (for instance send everything except
 /// the last byte of a request and let the server be stuck waiting
 /// for the last byte of a 20MB command)
-static constexpr size_t MaxUnauthenticatedFrameSize = 16 * 1024;
+static constexpr size_t MaxUnauthenticatedFrameSize = 16_KiB;
 
 LibeventConnection::LibeventConnection(SOCKET sfd,
                                        FrontEndThread& thr,
@@ -161,7 +161,7 @@ void LibeventConnection::rw_callback() {
         // transferred at least 64k to getting notified *too* often.
         const auto length = getSendQueueSize();
         if (length) {
-            const size_t chunk = 64 * 1024;
+            const size_t chunk = 64_KiB;
             if (length > chunk) {
                 const auto watermark =
                         std::min(length - chunk, max_send_watermark_size);

daemon/protocol/mcbp/get_file_fragment_context.cc

@@ -25,7 +25,7 @@
 #include <platform/crc32c.h>
 #include <platform/strerror.h>
 
-constexpr std::size_t MaxReadSize = 2 * 1024 * 1024 * 1024ULL;
+constexpr std::size_t MaxReadSize = 2_GiB;
 
 GetFileFragmentContext::GetFileFragmentContext(Cookie& cookie)
     : SteppableCommandContext(cookie),
@@ -195,7 +195,7 @@ cb::engine_errc GetFileFragmentContext::read_file_chunk() {
                 "Read file fragment",
                 [this]() {
                     try {
-                        constexpr std::size_t ChunkSize = 20 * 1024 * 1024;
+                        constexpr std::size_t ChunkSize = 20_MiB;
                         const auto to_read = std::min(length, ChunkSize);
 
                         auto iob = folly::IOBuf::createCombined(to_read);

daemon/settings.cc

@@ -216,7 +216,7 @@ void Settings::reconfigure(const nlohmann::json& json) {
             setMaxPacketSize(value.get<uint32_t>() * uint32_t(1024) *
                              uint32_t(1024));
         } else if (key == "max_send_queue_size"sv) {
-            setMaxSendQueueSize(value.get<size_t>() * 1024 * 1024);
+            setMaxSendQueueSize(value.get<size_t>() * 1_MiB);
         } else if (key == "max_so_sndbuf_size"sv) {
             setMaxSoSndbufSize(value.get<uint32_t>());
         } else if (key == "max_connections"sv) {
@@ -705,8 +705,8 @@ void Settings::updateSettings(const Settings& other, bool apply) {
     if (other.has.max_send_queue_size) {
         if (other.max_send_queue_size != max_send_queue_size) {
             LOG_INFO_CTX("Change max packet size",
-                         {"from", max_send_queue_size / (1024 * 1024)},
-                         {"to", other.max_send_queue_size / (1024 * 1024)});
+                         {"from", max_send_queue_size / (1_MiB)},
+                         {"to", other.max_send_queue_size / (1_MiB)});
             setMaxSendQueueSize(other.max_send_queue_size);
         }
     }

daemon/settings.h

@@ -1019,7 +1019,7 @@ class Settings {
     /// body of the document. With a 1MB output queue you can fit 50 ~20k
     /// documents (50 is the (default) max number of operations a client
     /// may perform before backing off.
-    std::atomic<size_t> max_send_queue_size{1024 * 1024};
+    std::atomic<size_t> max_send_queue_size{1_MiB};
 
     /// The maximum size we want to try to set SO_SNDBUF to. For windows
     /// the default is 1MB as there is no operating system tunable which
@@ -1028,9 +1028,9 @@ class Settings {
     /// insane large number and use the operating systems max value.
     std::atomic<uint32_t> max_so_sndbuf_size{
 #ifdef WIN32
-            1024 * 1024
+            1_MiB
 #else
-            256 * 1024 * 1024
+            256_MiB
 #endif
     };
 
@@ -1099,7 +1099,7 @@ class Settings {
     std::atomic<std::size_t> max_concurrent_commands_per_connection{32};
 
     // The rate limit for Fusion extent migration, in bytes per second
-    std::atomic<size_t> fusion_migration_rate_limit{1024 * 1024 * 75};
+    std::atomic<size_t> fusion_migration_rate_limit{75_MiB};
 
     /**
      * Note that it is not safe to add new listeners after we've spun up
@@ -1138,7 +1138,7 @@ class Settings {
     /// Max document size is 20MB so by using 30MB we'll get the correct
     /// E2BIG error message for connections going a bit bigger (and not
     /// a quiet disconnect)
-    uint32_t max_packet_size{30 * 1024 * 1024};
+    uint32_t max_packet_size{30_MiB};
 
     std::atomic<int> num_reader_threads{0};
     std::atomic<int> num_writer_threads{0};

daemon/settings_test.cc

@@ -630,7 +630,7 @@ TEST_F(SettingsTest, max_packet_size) {
     obj["max_packet_size"] = maxPacketSize;
     try {
         Settings settings(obj);
-        EXPECT_EQ(30 * 1024 * 1024, settings.getMaxPacketSize());
+        EXPECT_EQ(30_MiB, settings.getMaxPacketSize());
         EXPECT_TRUE(settings.has.max_packet_size);
     } catch (std::exception& exception) {
         FAIL() << exception.what();
@@ -909,7 +909,7 @@ TEST(SettingsUpdateTest, UpdatingLoggerSettingsShouldFail) {
     cb::logger::Config config;
     config.filename.assign("logger_test");
     config.buffersize = 1024;
-    config.cyclesize = 1024 * 1024;
+    config.cyclesize = 1_MiB;
 
     EXPECT_NO_THROW(settings.updateSettings(updated, false));