From bc9380d5e29876ddba62de9f63af1b32bf1fd6ba Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Wed, 2 Mar 2022 15:04:30 +0100
Subject: [PATCH 01/84] Change Mako file extensions to cpp

---
 bindings/c/CMakeLists.txt                   | 8 ++++----
 bindings/c/test/mako/{mako.c => mako.cpp}   | 0
 bindings/c/test/mako/{mako.h => mako.hpp}   | 0
 bindings/c/test/mako/{utils.c => utils.cpp} | 0
 bindings/c/test/mako/{utils.h => utils.hpp} | 0
 5 files changed, 4 insertions(+), 4 deletions(-)
 rename bindings/c/test/mako/{mako.c => mako.cpp} (100%)
 rename bindings/c/test/mako/{mako.h => mako.hpp} (100%)
 rename bindings/c/test/mako/{utils.c => utils.cpp} (100%)
 rename bindings/c/test/mako/{utils.h => utils.hpp} (100%)

diff --git a/bindings/c/CMakeLists.txt b/bindings/c/CMakeLists.txt
index 78dce4cdc9..31b65d83d1 100644
--- a/bindings/c/CMakeLists.txt
+++ b/bindings/c/CMakeLists.txt
@@ -81,10 +81,10 @@ endif()
 # check later whether this works
 if(NOT WIN32 AND NOT IS_ARM_MAC)
   set(MAKO_SRCS
-    test/mako/mako.c
-    test/mako/mako.h
-    test/mako/utils.c
-    test/mako/utils.h)
+    test/mako/mako.cpp
+    test/mako/mako.hpp
+    test/mako/utils.cpp
+    test/mako/utils.hpp)
   add_subdirectory(test/unit/third_party)
   find_package(Threads REQUIRED)
   set(UNIT_TEST_SRCS
diff --git a/bindings/c/test/mako/mako.c b/bindings/c/test/mako/mako.cpp
similarity index 100%
rename from bindings/c/test/mako/mako.c
rename to bindings/c/test/mako/mako.cpp
diff --git a/bindings/c/test/mako/mako.h b/bindings/c/test/mako/mako.hpp
similarity index 100%
rename from bindings/c/test/mako/mako.h
rename to bindings/c/test/mako/mako.hpp
diff --git a/bindings/c/test/mako/utils.c b/bindings/c/test/mako/utils.cpp
similarity index 100%
rename from bindings/c/test/mako/utils.c
rename to bindings/c/test/mako/utils.cpp
diff --git a/bindings/c/test/mako/utils.h b/bindings/c/test/mako/utils.hpp
similarity index 100%
rename from bindings/c/test/mako/utils.h
rename to bindings/c/test/mako/utils.hpp

From b23c51ffccc2a25a12656d0ac3214a0f5d6fb90e Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Wed, 2 Mar 2022 15:12:36 +0100
Subject: [PATCH 02/84] C++ wrapper for fdb_c API

* Header-only
* C objects wrapped in refcounting C++ objects
* Accept lambdas as future callback
* Type-safe access to Future values
* throw/nothrow member functions
---
 bindings/c/CMakeLists.txt |   6 +-
 bindings/c/test/fdb.hpp   | 552 ++++++++++++++++++++++++++++++++++++++
 2 files changed, 557 insertions(+), 1 deletion(-)
 create mode 100644 bindings/c/test/fdb.hpp

diff --git a/bindings/c/CMakeLists.txt b/bindings/c/CMakeLists.txt
index 31b65d83d1..0058fd5354 100644
--- a/bindings/c/CMakeLists.txt
+++ b/bindings/c/CMakeLists.txt
@@ -99,6 +99,10 @@ if(NOT WIN32 AND NOT IS_ARM_MAC)
     test/unit/fdb_api.cpp
     test/unit/fdb_api.hpp)
 
+  add_library(fdb_cpp INTERFACE)
+  target_sources(fdb_cpp INTERFACE test/fdb.hpp)
+  target_include_directories(fdb_cpp INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/test)
+  target_link_libraries(fdb_cpp INTERFACE fmt::fmt)
   if(OPEN_FOR_IDE)
     add_library(fdb_c_performance_test OBJECT test/performance_test.c test/test.h)
     add_library(fdb_c_ryw_benchmark OBJECT test/ryw_benchmark.c test/test.h)
@@ -143,7 +147,7 @@ if(NOT WIN32 AND NOT IS_ARM_MAC)
 
   # do not set RPATH for mako
   set_property(TARGET mako PROPERTY SKIP_BUILD_RPATH TRUE)
-  target_link_libraries(mako PRIVATE fdb_c fdbclient)
+  target_link_libraries(mako PRIVATE fdb_c fdbclient fmt::fmt Threads::Threads fdb_cpp)
 
   if(NOT OPEN_FOR_IDE)
     # Make sure that fdb_c.h is compatible with c90
diff --git a/bindings/c/test/fdb.hpp b/bindings/c/test/fdb.hpp
new file mode 100644
index 0000000000..f0538ebcc0
--- /dev/null
+++ b/bindings/c/test/fdb.hpp
@@ -0,0 +1,552 @@
+#pragma once
+
+#ifndef FDB_API_VERSION
+#define FDB_API_VERSION 710
+#endif
+
+#include <cstdint>
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <fmt/format.h>
+
+// introduce the option enums
+#include <fdb_c_options.g.h>
+
+namespace fdb {
+
+// hide C API to discourage mixing C/C++ API
+namespace native {
+#include <foundationdb/fdb_c.h>
+}
+
+using ByteString = std::basic_string<uint8_t>;
+using BytesRef = std::basic_string_view<uint8_t>;
+using CharsRef = std::string_view;
+using KeyRef = BytesRef;
+using ValueRef = BytesRef;
+
+inline uint8_t const* to_byte_ptr(char const* ptr) noexcept {
+    return reinterpret_cast<uint8_t const*>(ptr);
+}
+
+// get bytestring view from charstring: e.g. std::basic_string{_view}<char>
+template <template <class...> class StringLike, class Char>
+BytesRef to_bytes_ref(const StringLike<Char>& s) noexcept {
+    static_assert(sizeof(Char) == 1);
+    return BytesRef(reinterpret_cast<uint8_t const*>(s.data()),
+                    s.size());
+}
+
+// get charstring view from bytestring: e.g. std::basic_string{_view}<uint8_t>
+template <template <class...> class StringLike, class Char>
+CharsRef to_chars_ref(const StringLike<Char>& s) noexcept {
+    static_assert(sizeof(Char) == 1);
+    return CharsRef(reinterpret_cast<char const*>(s.data()),
+                    s.size());
+}
+
+[[maybe_unused]] constexpr const bool overflow_check = false;
+
+inline int intsize(BytesRef b) {
+    if constexpr (overflow_check) {
+        if (b.size() > static_cast<size_t>(std::numeric_limits<int>::max()))
+            throw std::overflow_error("byte strlen goes beyond int bounds");
+    }
+    return static_cast<int>(b.size());
+}
+
+class Error {
+public:
+    using code_type = native::fdb_error_t;
+
+    Error() noexcept : err(0) {}
+
+    explicit Error(code_type err) noexcept : err(err) {}
+
+    char const* what() noexcept { return native::fdb_get_error(err); }
+
+    explicit operator bool() const noexcept { return err != 0; }
+
+    bool is(code_type other) const noexcept { return err != other; }
+
+    code_type code() const noexcept { return err; }
+
+    bool retryable() const noexcept {
+        return native::fdb_error_predicate(FDB_ERROR_PREDICATE_RETRYABLE, err) != 0;
+    }
+private:
+    code_type err;
+};
+
+/* Traits of value types held by ready futures.
+   Holds type and value extraction function. */
+namespace future_var {
+    struct None {
+        struct type {};
+        static Error extract(native::FDBFuture*, type&) noexcept {
+            return Error(0);
+        }
+    };
+    struct Int64 {
+        using type = int64_t;
+        static Error extract(native::FDBFuture* f, type& out) noexcept {
+            return Error(native::fdb_future_get_int64(f, &out));
+        }
+    };
+    struct Key {
+        using type = std::pair<uint8_t const*, int>;
+        static Error extract(native::FDBFuture* f, type& out) noexcept {
+            auto& [out_key, out_key_length] = out;
+            return Error(native::fdb_future_get_key(f, &out_key, &out_key_length));
+        }
+    };
+    struct Value {
+        using type = std::tuple<bool, uint8_t const*, int>;
+        static Error extract(native::FDBFuture* f, type& out) noexcept {
+            auto& [out_present, out_value, out_value_length] = out;
+            auto out_present_native = native::fdb_bool_t{};
+            auto err = native::fdb_future_get_value(f, &out_present_native,
+                                            &out_value, &out_value_length);
+            out_present = (out_present_native != 0);
+            return Error(err);
+        }
+    };
+    struct StringArray {
+        using type = std::pair<const char**, int>;
+        static Error extract(native::FDBFuture* f, type& out) noexcept {
+            auto& [out_strings, out_count] = out;
+            return Error(native::fdb_future_get_string_array(f, &out_strings, &out_count));
+        }
+    };
+    struct KeyValueArray {
+        using type = std::tuple<native::FDBKeyValue const *, int, bool>;
+        static Error extract(native::FDBFuture* f, type& out) noexcept {
+            auto& [out_kv, out_count, out_more] = out;
+            auto out_more_native = native::fdb_bool_t{};
+            auto err = native::fdb_future_get_keyvalue_array(f, &out_kv, &out_count, &out_more_native);
+            out_more = (out_more_native != 0);
+            return Error(err);
+        }
+    };
+} // namespace future_var
+
+[[noreturn]] inline void throw_error(std::string_view preamble, Error err) {
+    auto msg = std::string(preamble);
+    msg.append(err.what());
+    throw std::runtime_error(msg);
+}
+
+inline int max_api_version() {
+    return native::fdb_get_max_api_version();
+}
+
+inline Error select_api_version_nothrow(int version) {
+    return Error(native::fdb_select_api_version(version));
+}
+
+inline void select_api_version(int version) {
+    if (auto err = select_api_version_nothrow(version)) {
+        throw_error(fmt::format("ERROR: fdb_select_api_version({}): ", version), err);
+    }
+}
+
+namespace network {
+
+    inline Error set_option_nothrow(FDBNetworkOption option, BytesRef str) noexcept {
+        return Error(native::fdb_network_set_option(option, str.data(), intsize(str)));
+    }
+
+    inline Error set_option_nothrow(FDBNetworkOption option, int64_t value) noexcept {
+        return Error(native::fdb_network_set_option(
+                    option,
+                    reinterpret_cast<const uint8_t*>(&value),
+                    static_cast<int>(sizeof(value))));
+    }
+
+    inline void set_option(FDBNetworkOption option, BytesRef str) {
+        if (auto err = set_option_nothrow(option, str)) {
+            throw_error(
+                    fmt::format("ERROR: fdb_network_set_option({}): ",
+                                static_cast<std::underlying_type_t<FDBNetworkOption>>(option)),
+                    err);
+        }
+    }
+
+    inline void set_option(FDBNetworkOption option, int64_t value) {
+        if (auto err = set_option_nothrow(option, value)) {
+            throw_error(
+                    fmt::format("ERROR: fdb_network_set_option({}, {}): ",
+                                static_cast<std::underlying_type_t<FDBNetworkOption>>(option),
+                                value),
+                    err);
+        }
+    }
+
+    inline Error setup_nothrow() noexcept {
+        return Error(native::fdb_setup_network());
+    }
+
+    inline void setup() {
+        if (auto err = setup_nothrow())
+            throw_error("ERROR: fdb_network_setup(): ", err);
+    }
+
+    inline Error run() {
+        return Error(native::fdb_run_network());
+    }
+
+    inline Error stop() {
+        return Error(native::fdb_stop_network());
+    }
+
+} // namespace network
+
+class TX;
+class Database;
+
+class Result {
+    friend class TX;
+    std::shared_ptr<native::FDBResult> r;
+
+    Result(native::FDBResult* result) {
+        if (result) r = std::shared_ptr<native::FDBResult>(result, &native::fdb_result_destroy);
+    }
+public:
+
+    using KeyValueArray = future_var::KeyValueArray::type;
+
+    Error get_keyvalue_array_nothrow(KeyValueArray& out) const noexcept {
+        auto out_more_native = native::fdb_bool_t{};
+        auto& [out_kv, out_count, out_more] = out;
+        auto err_raw = native::fdb_result_get_keyvalue_array(r.get(), &out_kv,
+                                                     &out_count, &out_more_native);
+        out_more = out_more_native != 0;
+        return Error(err_raw);
+    }
+
+    KeyValueArray get_keyvalue_array() const {
+        auto ret = KeyValueArray{};
+        if (auto err = get_keyvalue_array_nothrow(ret))
+            throw_error("ERROR: result_get_keyvalue_array(): ", err);
+        return ret;
+    }
+
+};
+
+class Future {
+protected:
+    friend class TX;
+    std::shared_ptr<native::FDBFuture> f;
+
+    Future(native::FDBFuture* future)
+    {
+        if (future) f = std::shared_ptr<native::FDBFuture>(future, &native::fdb_future_destroy);
+    }
+
+    // wrap any capturing lambda as callback passable to fdb_future_set_callback().
+    // destroy after invocation.
+    template <class Fn>
+    static void callback(native::FDBFuture*, void* param) {
+        auto fp = static_cast<Fn*>(param);
+        try {
+            (*fp)();
+        } catch (const std::exception& e) {
+            fmt::print(stderr, "ERROR: Exception thrown in user callback: {}", e.what());
+        }
+        delete fp;
+    }
+
+    // set as callback user-defined completion handler of signature void(Future)
+    template <class FutureType, class UserFunc>
+    void then(UserFunc&& fn) {
+        auto cb = [fut=FutureType(*this), fn=std::forward<UserFunc>(fn)]() {
+            fn(fut);
+        };
+        using cb_type = std::decay_t<decltype(cb)>;
+        auto fp = new cb_type(std::move(cb));
+        native::fdb_future_set_callback(f.get(), &callback<cb_type>, fp);
+    }
+
+public:
+    Future() noexcept : Future(nullptr) {}
+    Future(const Future&) noexcept = default;
+    Future& operator=(const Future&) noexcept = default;
+
+    bool valid() const noexcept { return f != nullptr; }
+
+    explicit operator bool() const noexcept { return valid(); }
+
+    bool ready() const noexcept {
+        assert(valid());
+        return native::fdb_future_is_ready(f.get()) != 0;
+    }
+
+    Error block_until_ready() const noexcept {
+        assert(valid());
+        return Error(native::fdb_future_block_until_ready(f.get()));
+    }
+
+    Error error() const noexcept {
+        assert(valid());
+        return Error(native::fdb_future_get_error(f.get()));
+    }
+
+    void cancel() noexcept {
+        native::fdb_future_cancel(f.get());
+    }
+
+    template <class VarTraits>
+    typename VarTraits::type get() const {
+        assert(valid());
+        assert(!error());
+        auto out = typename VarTraits::Type{};
+        if (auto err = VarTraits::extract(f.get(), out)) {
+            throw_error("future_get: ", err);
+        }
+        return out;
+    }
+
+    template <class VarTraits>
+    Error get_nothrow(typename VarTraits::type& var) const noexcept {
+        assert(valid());
+        assert(!error());
+        auto out = typename VarTraits::Type{};
+        return VarTraits::extract(f.get(), out);
+    }
+
+    template <class UserFunc>
+    void then(UserFunc&& fn) {
+        then<Future>(std::forward<UserFunc>(fn));
+    }
+};
+
+template <typename VarTraits>
+class TypedFuture : public Future {
+    friend class TX;
+    using self_type = TypedFuture<VarTraits>;
+    using Future::Future;
+    // hide type-unsafe inherited functions
+    using Future::get;
+    using Future::get_nothrow;
+    using Future::then;
+    TypedFuture(const Future& f) noexcept : Future(f) {}
+public:
+    using contained_type = typename VarTraits::type;
+
+    Future erase_type() const noexcept {
+        return static_cast<Future const&>(*this);
+    }
+
+    contained_type get() const {
+        return get<VarTraits>();
+    }
+
+    Error get_nothrow(contained_type& out) const noexcept {
+        return get_nothrow<VarTraits>(out);
+    }
+
+    template <class UserFunc>
+    void then(UserFunc&& fn) {
+        Future::then<self_type>(std::forward<UserFunc>(fn));
+    }
+};
+
+namespace key_select {
+
+    struct inclusive { static constexpr const bool value = true; };
+
+    struct exclusive { static constexpr const bool value = false; };
+}
+
+class TX {
+    friend class Database;
+    std::shared_ptr<native::FDBTransaction> tr;
+
+    explicit TX(native::FDBTransaction* tr_raw) {
+        if (tr_raw) tr = std::shared_ptr<native::FDBTransaction>(tr_raw, &native::fdb_transaction_destroy);
+    }
+public:
+    TX() noexcept : TX(nullptr) {}
+    TX(const TX&) noexcept = default;
+    TX& operator=(const TX&) noexcept = default;
+
+    bool valid() const noexcept { return tr != nullptr; }
+
+    explicit operator bool() const noexcept { return valid(); }
+
+    Error set_option_nothrow(FDBTransactionOption option, int64_t value) noexcept {
+        return Error(native::fdb_transaction_set_option(
+                        tr.get(), option,
+                        reinterpret_cast<const uint8_t*>(&value),
+                        static_cast<int>(sizeof(value))));
+    }
+
+    Error set_option_nothrow(FDBTransactionOption option, BytesRef str) noexcept {
+        return Error(native::fdb_transaction_set_option(
+                        tr.get(), option, str.data(), intsize(str)));
+    }
+
+    void set_option(FDBTransactionOption option, int64_t value) {
+        if (auto err = set_option_nothrow(option, value)) {
+            throw_error(fmt::format("transaction_set_option({}, {}) returned error: ",
+                        static_cast<std::underlying_type_t<FDBTransactionOption>>(option),
+                        value),
+                        err);
+        }
+    }
+
+    void set_option(FDBTransactionOption option, BytesRef str) {
+        if (auto err = set_option_nothrow(option, str)) {
+            throw_error(
+                    fmt::format("transaction_set_option({}) returned error: ",
+                        static_cast<std::underlying_type_t<FDBTransactionOption>>(option)),
+                    err);
+        }
+    }
+
+    TypedFuture<future_var::Int64> get_read_version() {
+        return native::fdb_transaction_get_read_version(tr.get());
+    }
+
+    Error get_committed_version_nothrow(int64_t& out) {
+        return Error(native::fdb_transaction_get_committed_version(tr.get(), &out));
+    }
+
+    int64_t get_committed_version() {
+        auto out = int64_t{};
+        if (auto err = get_committed_version_nothrow(out)) {
+            throw_error("get_committed_version: ", err);
+        }
+        return out;
+    }
+
+    // Func should have signature void(Future f, bool need_retry)
+    // Func should first check that retry == false and f.error() == 0
+    // before attempting to extract value from f
+    TypedFuture<future_var::Value> get(KeyRef key, bool snapshot) {
+        return native::fdb_transaction_get(tr.get(), key.data(), intsize(key), snapshot);
+    }
+
+    // Usage: tx.get_range<key_select::inclusive, key_select::exclusive>(begin, end, ...);
+    // gets key-value pairs in key range [begin, end)
+    template <class FirstInclusive, class LastInclusive>
+    TypedFuture<future_var::KeyValueArray> get_range(KeyRef begin, KeyRef end,
+                   int limit, int target_bytes, FDBStreamingMode mode,
+                   int iteration, bool snapshot, bool reverse) {
+        if constexpr (FirstInclusive::value && LastInclusive::value) {
+            return native::fdb_transaction_get_range(tr.get(),
+                    FDB_KEYSEL_FIRST_GREATER_OR_EQUAL(begin.data(), intsize(begin)),
+                    FDB_KEYSEL_LAST_LESS_OR_EQUAL(end.data(), intsize(end)),
+                    limit, target_bytes, mode, iteration, snapshot, reverse);
+        } else if constexpr (FirstInclusive::value && !LastInclusive::value) {
+            return native::fdb_transaction_get_range(tr.get(),
+                    FDB_KEYSEL_FIRST_GREATER_OR_EQUAL(begin.data(), intsize(begin)),
+                    FDB_KEYSEL_LAST_LESS_THAN(end.data(), intsize(end)),
+                    limit, target_bytes, mode, iteration, snapshot, reverse);
+        } else if constexpr (!FirstInclusive::value && LastInclusive::value) {
+            return native::fdb_transaction_get_range(tr.get(),
+                    FDB_KEYSEL_FIRST_GREATER_THAN(begin.data(), intsize(begin)),
+                    FDB_KEYSEL_LAST_LESS_OR_EQUAL(end.data(), intsize(end)),
+                    limit, target_bytes, mode, iteration, snapshot, reverse);
+        } else {
+            return native::fdb_transaction_get_range(tr.get(),
+                    FDB_KEYSEL_FIRST_GREATER_THAN(begin.data(), intsize(begin)),
+                    FDB_KEYSEL_LAST_LESS_THAN(end.data(), intsize(end)),
+                    limit, target_bytes, mode, iteration, snapshot, reverse);
+        }
+    }
+
+    Result read_blob_granules(KeyRef begin, KeyRef end,
+                              int64_t begin_version, int64_t read_version,
+                              native::FDBReadBlobGranuleContext context) {
+        return Result(native::fdb_transaction_read_blob_granules(tr.get(),
+                    begin.data(), intsize(begin),
+                    end.data(), intsize(end),
+                    begin_version, read_version, context));
+    }
+
+    TypedFuture<future_var::None> commit() {
+        return native::fdb_transaction_commit(tr.get());
+    }
+
+    TypedFuture<future_var::None> on_error(Error err) {
+        return native::fdb_transaction_on_error(tr.get(), err.code());
+    }
+
+    void reset() {
+        return native::fdb_transaction_reset(tr.get());
+    }
+
+    void set(KeyRef key, ValueRef value) {
+        native::fdb_transaction_set(tr.get(), key.data(), intsize(key), value.data(), intsize(value));
+    }
+
+    void clear(KeyRef key) {
+        native::fdb_transaction_clear(tr.get(), key.data(), intsize(key));
+    }
+
+    void clear_range(KeyRef begin, KeyRef end) {
+        native::fdb_transaction_clear_range(tr.get(), begin.data(), intsize(begin),
+                                    end.data(), intsize(end));
+    }
+
+};
+
+class Database {
+    std::shared_ptr<native::FDBDatabase> db;
+public:
+    Database(const Database&) noexcept = default;
+    Database& operator=(const Database&) noexcept = default;
+    Database(const std::string& cluster_file_path) : db(nullptr) {
+        auto db_raw = static_cast<native::FDBDatabase*>(nullptr);
+        if (auto err = Error(native::fdb_create_database(cluster_file_path.c_str(), &db_raw)))
+            throw_error(
+                    fmt::format("Failed to create database with '{}': ", cluster_file_path),
+                    err);
+        db = std::shared_ptr<native::FDBDatabase>(db_raw, &native::fdb_database_destroy);
+    }
+    Database() noexcept : db(nullptr) {}
+
+    Error set_option_nothrow(FDBDatabaseOption option, int64_t value) noexcept {
+        return Error(native::fdb_database_set_option(
+                        db.get(), option,
+                        reinterpret_cast<const uint8_t*>(&value),
+                        static_cast<int>(sizeof(value))));
+    }
+
+    Error set_option_nothrow(FDBDatabaseOption option, BytesRef str) noexcept {
+        return Error(native::fdb_database_set_option(
+                        db.get(), option, str.data(), intsize(str)));
+    }
+
+    void set_option(FDBDatabaseOption option, int64_t value) {
+        if (auto err = set_option_nothrow(option, value)) {
+            throw_error(
+                fmt::format("database_set_option({}, {}) returned error: ",
+                static_cast<std::underlying_type_t<FDBDatabaseOption>>(option),
+                value),
+                err);
+        }
+    }
+
+    void set_option(FDBDatabaseOption option, BytesRef str) {
+        if (auto err = set_option_nothrow(option, str)) {
+            throw_error(
+                fmt::format("database_set_option({}) returned error: ",
+                    static_cast<std::underlying_type_t<FDBDatabaseOption>>(option)),
+                err);
+        }
+    }
+
+    TX create_tx() {
+        if (!db) throw std::runtime_error("create_transaction from null database");
+        auto tx_native = static_cast<native::FDBTransaction*>(nullptr);
+        auto err = Error(native::fdb_database_create_transaction(db.get(), &tx_native));
+        if (err) throw_error("Failed to create transaction: ", err);
+        return TX(tx_native);
+    }
+};
+
+} // namespace fdb

From 0c6578a1e5745befebf1e83230b116427c978a4f Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Wed, 2 Mar 2022 15:28:05 +0100
Subject: [PATCH 03/84] Refactor Mako to C++

* Refine each op into non-blocking sub-op steps returning valid or null futures
  (for asynchrony to come)
* Restructure op switch-case block to (op, step)-function mapping
* Simplify statistics update
* Simplify console output formatting
* Simplify memory management
---
 bindings/c/test/mako/mako.cpp  | 5051 ++++++++++++++------------------
 bindings/c/test/mako/mako.hpp  |  452 ++-
 bindings/c/test/mako/utils.cpp |  101 +-
 bindings/c/test/mako/utils.hpp |  163 +-
 4 files changed, 2650 insertions(+), 3117 deletions(-)

diff --git a/bindings/c/test/mako/mako.cpp b/bindings/c/test/mako/mako.cpp
index b08a3b2366..977e0f9458 100644
--- a/bindings/c/test/mako/mako.cpp
+++ b/bindings/c/test/mako/mako.cpp
@@ -1,584 +1,262 @@
-#include <assert.h>
-#include <errno.h>
+#include <cmath>
+#include <cassert>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <map>
+#include <new>
+#include <string>
+#include <string_view>
+#include <thread>
+
 #include <fcntl.h>
 #include <getopt.h>
-#include <inttypes.h>
-#include <math.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/wait.h>
-#include <time.h>
 #include <unistd.h>
-
+#include <sys/types.h>
+#include <sys/stat.h>
 #if defined(__linux__)
 #include <linux/limits.h>
 #elif defined(__FreeBSD__)
 #include <sys/stat.h>
-#define CLOCK_MONOTONIC_COARSE CLOCK_MONOTONIC_FAST
 #elif defined(__APPLE__)
 #include <sys/syslimits.h>
-#define CLOCK_MONOTONIC_COARSE CLOCK_MONOTONIC
 #else
 #include <limits.h>
 #endif
 
+#include <fmt/format.h>
+#include <fmt/printf.h>
+#include <fdb.hpp>
 #include "fdbclient/zipf.h"
-#include "mako.h"
-#include "utils.h"
+#include "mako.hpp"
+#include "utils.hpp"
+
+using namespace fdb;
+
+const std::string KEY_PREFIX{"mako"};
+const std::string TEMP_DATA_STORE{"/tmp/makoTemp"};
 
 /* global variables */
 FILE* printme; /* descriptor used for default messages */
 FILE* annoyme; /* descriptor used for annoying messages */
 FILE* debugme; /* descriptor used for debug messages */
 
-#define check_fdb_error(_e)                                                                                            \
-	do {                                                                                                               \
-		if (_e) {                                                                                                      \
-			fprintf(stderr, "ERROR: Failed at %s:%d (%s)\n", __FILE__, __LINE__, fdb_get_error(_e));                   \
-			goto failExit;                                                                                             \
-		}                                                                                                              \
-	} while (0)
+enum class FutureRC {
+    OK,
+    RETRY,
+    CONFLICT,
+    ABORT
+};
 
-#define fdb_block_wait(_f)                                                                                             \
-	do {                                                                                                               \
-		if ((fdb_future_block_until_ready(_f)) != 0) {                                                                 \
-			fprintf(stderr, "ERROR: fdb_future_block_until_ready failed at %s:%d\n", __FILE__, __LINE__);              \
-			goto failExit;                                                                                             \
-		}                                                                                                              \
-	} while (0)
-
-#define fdb_wait_and_handle_error(_func, _f, _t)                                                                       \
-	do {                                                                                                               \
-		int err = wait_future(_f);                                                                                     \
-		if (err) {                                                                                                     \
-			int err2;                                                                                                  \
-			if ((err != 1020 /* not_committed */) && (err != 1021 /* commit_unknown_result */) &&                      \
-			    (err != 1213 /* tag_throttled */)) {                                                                   \
-				fprintf(stderr, "ERROR: Error %s (%d) occured at %s\n", #_func, err, fdb_get_error(err));              \
-			} else {                                                                                                   \
-				fprintf(annoyme, "ERROR: Error %s (%d) occured at %s\n", #_func, err, fdb_get_error(err));             \
-			}                                                                                                          \
-			fdb_future_destroy(_f);                                                                                    \
-			_f = fdb_transaction_on_error(_t, err);                                                                    \
-			/* this will return the original error for non-retryable errors */                                         \
-			err2 = wait_future(_f);                                                                                    \
-			fdb_future_destroy(_f);                                                                                    \
-			if (err2) {                                                                                                \
-				/* unretryable error */                                                                                \
-				fprintf(stderr, "ERROR: fdb_transaction_on_error returned %d at %s:%d\n", err2, __FILE__, __LINE__);   \
-				fdb_transaction_reset(_t);                                                                             \
-				/* TODO: if we add a retry limit in the future,                                                        \
-				 *       handle the conflict stats properly.                                                           \
-				 */                                                                                                    \
-				return FDB_ERROR_ABORT;                                                                                \
-			}                                                                                                          \
-			if (err == 1020 /* not_committed */) {                                                                     \
-				return FDB_ERROR_CONFLICT;                                                                             \
-			}                                                                                                          \
-			return FDB_ERROR_RETRY;                                                                                    \
-		}                                                                                                              \
-	} while (0)
-
-#define fdb_handle_result_error(_func, err, _t)                                                                        \
-	do {                                                                                                               \
-		if (err) {                                                                                                     \
-			int err2;                                                                                                  \
-			FDBFuture* fErr;                                                                                           \
-			if ((err != 1020 /* not_committed */) && (err != 1021 /* commit_unknown_result */) &&                      \
-			    (err != 1213 /* tag_throttled */)) {                                                                   \
-				fprintf(stderr, "ERROR: Error %s (%d) occured at %s\n", #_func, err, fdb_get_error(err));              \
-			} else {                                                                                                   \
-				fprintf(annoyme, "ERROR: Error %s (%d) occured at %s\n", #_func, err, fdb_get_error(err));             \
-			}                                                                                                          \
-			fErr = fdb_transaction_on_error(_t, err);                                                                  \
-			/* this will return the original error for non-retryable errors */                                         \
-			err2 = wait_future(fErr);                                                                                  \
-			fdb_future_destroy(fErr);                                                                                  \
-			if (err2) {                                                                                                \
-				/* unretryable error */                                                                                \
-				fprintf(stderr, "ERROR: fdb_transaction_on_error returned %d at %s:%d\n", err2, __FILE__, __LINE__);   \
-				fdb_transaction_reset(_t);                                                                             \
-				/* TODO: if we add a retry limit in the future,                                                        \
-				 *       handle the conflict stats properly.                                                           \
-				 */                                                                                                    \
-				return FDB_ERROR_ABORT;                                                                                \
-			}                                                                                                          \
-			if (err == 1020 /* not_committed */) {                                                                     \
-				return FDB_ERROR_CONFLICT;                                                                             \
-			}                                                                                                          \
-			return FDB_ERROR_RETRY;                                                                                    \
-		}                                                                                                              \
-	} while (0)
-
-fdb_error_t wait_future(FDBFuture* f) {
-	fdb_error_t err;
-
-	err = fdb_future_block_until_ready(f);
-	if (err) {
-		return err; /* error from fdb_future_block_until_ready() */
-	}
-	return fdb_future_get_error(f);
+template <class FutureType>
+FutureRC wait_and_handle_for_on_error(TX tx, FutureType f, std::string_view operation) {
+    assert(f);
+    auto err = Error{};
+    if ((err = f.block_until_ready())) {
+        fmt::print(stderr, "ERROR: Error while on_error() blocking for {}: {}\n",
+                   operation, err.what());
+        return FutureRC::ABORT;
+    }
+    if ((err = f.error())) {
+        fmt::print(stderr, "ERROR: Unretryable on_error() error from {}: {}\n",
+                   operation, err.what());
+        return FutureRC::ABORT;
+    } else {
+        return FutureRC::OK;
+    }
 }
 
-int commit_transaction(FDBTransaction* transaction) {
-	FDBFuture* f;
-
-	f = fdb_transaction_commit(transaction);
-	fdb_wait_and_handle_error(commit_transaction, f, transaction);
-	fdb_future_destroy(f);
-
-	return FDB_SUCCESS;
-}
-
-void update_op_lat_stats(struct timespec* start,
-                         struct timespec* end,
-                         int op,
-                         mako_stats_t* stats,
-                         lat_block_t* block[],
-                         int* elem_size,
-                         bool* is_memory_allocated) {
-	uint64_t latencyus;
-
-	latencyus = (((uint64_t)end->tv_sec * 1000000000 + end->tv_nsec) -
-	             ((uint64_t)start->tv_sec * 1000000000 + start->tv_nsec)) /
-	            1000;
-	stats->latency_samples[op]++;
-	stats->latency_us_total[op] += latencyus;
-	if (latencyus < stats->latency_us_min[op]) {
-		stats->latency_us_min[op] = latencyus;
-	}
-	if (latencyus > stats->latency_us_max[op]) {
-		stats->latency_us_max[op] = latencyus;
-	}
-	if (!is_memory_allocated[op])
-		return;
-	if (elem_size[op] < stats->latency_samples[op]) {
-		elem_size[op] = elem_size[op] + LAT_BLOCK_SIZE;
-		lat_block_t* temp_block = (lat_block_t*)malloc(sizeof(lat_block_t));
-		if (temp_block == NULL) {
-			is_memory_allocated[op] = false;
-			return;
-		}
-		temp_block->next_block = NULL;
-		block[op]->next_block = (lat_block_t*)temp_block;
-		block[op] = temp_block;
-	}
-	block[op]->data[(stats->latency_samples[op] - 1) % LAT_BLOCK_SIZE] = latencyus;
-}
-
-/* FDB network thread */
-void* fdb_network_thread(void* args) {
-	fdb_error_t err;
-
-	fprintf(debugme, "DEBUG: fdb_network_thread started\n");
-
-	err = fdb_run_network();
-	if (err) {
-		fprintf(stderr, "ERROR: fdb_run_network: %s\n", fdb_get_error(err));
-	}
-
-	return 0;
-}
-
-int genprefix(char* str, char* prefix, int prefixlen, int prefixpadding, int rows, int len) {
-	const int rowdigit = digits(rows);
-	const int paddinglen = len - (prefixlen + rowdigit) - 1;
-	int offset = 0;
-	if (prefixpadding) {
-		memset(str, 'x', paddinglen);
-		offset += paddinglen;
-	}
-	memcpy(str + offset, prefix, prefixlen);
-	str[len - 1] = '\0';
-	return offset + prefixlen;
+// wait on any non-immediate tx-related operation to complete. Follow up with on_error().
+template <class FutureType>
+FutureRC wait_and_handle_error(TX tx, FutureType f, std::string_view operation) {
+    assert(f);
+    auto err = Error{};
+    if ((err = f.block_until_ready())) {
+        const auto retry = err.retryable();
+        auto fp = retry ? annoyme : stderr;
+        fmt::print(fp, "ERROR: {} error in {}: {}\n",
+                   (retry ? "Retryable" : "Unretryable"),
+                   operation, err.what());
+        return retry ? FutureRC::RETRY : FutureRC::ABORT;
+    }
+    err = f.error();
+    if (!err) return FutureRC::OK;
+    auto fp = err.retryable() ? annoyme : stderr;
+    fmt::print(fp, "ERROR: Error in {}: {}\n", operation, err.what());
+    // implicit backoff
+    auto follow_up = tx.on_error(err);
+    auto rc = wait_and_handle_for_on_error(tx, f, operation);
+    if (rc == FutureRC::OK) {
+        if (err.is(1020/*not_committed*/))
+            return FutureRC::CONFLICT;
+        else
+            return FutureRC::RETRY;
+    } else {
+        tx.reset();
+        return rc;
+    }
 }
 
 /* cleanup database */
-int cleanup(FDBTransaction* transaction, mako_args_t* args) {
-	struct timespec timer_start, timer_end;
-	char* prefixstr = (char*)malloc(sizeof(char) * args->key_length + 1);
-	if (!prefixstr)
-		return -1;
-	char* beginstr = (char*)malloc(sizeof(char) * args->key_length + 1);
-	if (!beginstr) {
-		free(prefixstr);
-		return -1;
-	}
-	char* endstr = (char*)malloc(sizeof(char) * args->key_length + 1);
-	if (!endstr) {
-		free(prefixstr);
-		free(beginstr);
-		return -1;
-	}
+int cleanup(TX tx, mako_args_t const& args) {
+    auto beginstr = ByteString{};
+    beginstr.reserve(args.key_length);
+    genkeyprefix(beginstr, KEY_PREFIX, args);
+    beginstr.push_back(0);
 
-	int len = genprefix(prefixstr, KEYPREFIX, KEYPREFIXLEN, args->prefixpadding, args->rows, args->key_length + 1);
-	snprintf(beginstr, len + 2, "%s%c", prefixstr, 0x00);
-	snprintf(endstr, len + 2, "%s%c", prefixstr, 0xff);
-	free(prefixstr);
-	len += 1;
+    auto endstr = ByteString{};
+    endstr.reserve(args.key_length);
+    genkeyprefix(endstr, KEY_PREFIX, args);
+    endstr.push_back(0xff);
 
-retryTxn:
-	clock_gettime(CLOCK_MONOTONIC_COARSE, &timer_start);
+    const auto time_start = steady_clock::now();
 
-	fdb_transaction_clear_range(transaction, (uint8_t*)beginstr, len + 1, (uint8_t*)endstr, len + 1);
-	switch (commit_transaction(transaction)) {
-	case (FDB_SUCCESS):
-		break;
-	case (FDB_ERROR_RETRY):
-		fdb_transaction_reset(transaction);
-		goto retryTxn;
-	default:
-		goto failExit;
-	}
+    while (true) {
+        tx.clear_range(beginstr, endstr);
+        auto future_commit = tx.commit();
+        const auto rc = wait_and_handle_error(tx, future_commit, "COMMIT_CLEANUP");
+        if (rc == FutureRC::OK) {
+            break;
+        } else if (rc == FutureRC::RETRY || rc == FutureRC::CONFLICT) {
+            // tx already reset
+            continue;
+        } else {
+            return -1;
+        }
+    }
 
-	fdb_transaction_reset(transaction);
-	clock_gettime(CLOCK_MONOTONIC_COARSE, &timer_end);
-	fprintf(printme,
-	        "INFO: Clear range: %6.3f sec\n",
-	        ((timer_end.tv_sec - timer_start.tv_sec) * 1000000000.0 + timer_end.tv_nsec - timer_start.tv_nsec) /
-	            1000000000);
-
-	free(beginstr);
-	free(endstr);
-
-	return 0;
-
-failExit:
-	free(beginstr);
-	free(endstr);
-
-	fprintf(stderr, "ERROR: FDB failure in cleanup()\n");
-	return -1;
+    tx.reset();
+    const auto time_end = steady_clock::now();
+    fmt::print(printme, "INFO: Clear range: {:6.3f} sec\n",
+               to_double_seconds(time_end - time_start));
+    return 0;
 }
 
 /* populate database */
-int populate(FDBTransaction* transaction,
-             mako_args_t* args,
+int populate(TX tx,
+             mako_args_t const& args,
              int worker_id,
              int thread_id,
              int thread_tps,
-             mako_stats_t* stats,
-             lat_block_t* block[],
-             int* elem_size,
-             bool* is_memory_allocated) {
-	int i;
-	struct timespec timer_start, timer_end;
-	struct timespec timer_prev, timer_now; /* for throttling */
-	struct timespec timer_per_xact_start, timer_per_xact_end;
-	struct timespec timer_start_commit;
-	char* keystr;
-	char* valstr;
+             mako_stats_t& stats,
+             sample_bin_array_t& sample_bins) {
+    const auto key_begin = insert_begin(args.rows, worker_id, thread_id,
+                                        args.num_processes, args.num_threads);
+    const auto key_end = insert_end(args.rows, worker_id, thread_id,
+                                    args.num_processes, args.num_threads);
+    auto xacts = 0;
 
-	int begin = insert_begin(args->rows, worker_id, thread_id, args->num_processes, args->num_threads);
-	int end = insert_end(args->rows, worker_id, thread_id, args->num_processes, args->num_threads);
-	int xacts = 0;
-	int tracetimer = 0;
+    auto keystr = ByteString{};
+    auto valstr = ByteString{};
+    keystr.reserve(args.key_length);
+    valstr.reserve(args.value_length);
+    const auto time_start = steady_clock::now();
+    const auto num_commit_every = args.txnspec.ops[OP_INSERT][OP_COUNT];
+    auto time_prev = time_start; // for throttling
+    auto time_tx_start = time_start;
+    auto time_last_traced = time_start;
+    auto key_checkpoint = key_begin; // in case of commit failure, restart from this key
 
-	keystr = (char*)malloc(sizeof(char) * args->key_length + 1);
-	if (!keystr)
-		return -1;
-	valstr = (char*)malloc(sizeof(char) * args->value_length + 1);
-	if (!valstr) {
-		free(keystr);
-		return -1;
-	}
+    for (auto i = key_begin; i <= key_end; i++) {
+        /* sequential keys */
+        genkey(keystr, KEY_PREFIX, args, i);
+        /* random values */
+        randstr(valstr, args.value_length);
 
-	clock_gettime(CLOCK_MONOTONIC, &timer_start);
-	timer_prev.tv_sec = timer_start.tv_sec;
-	timer_prev.tv_nsec = timer_start.tv_nsec;
-	timer_per_xact_start.tv_sec = timer_start.tv_sec;
-	timer_per_xact_start.tv_nsec = timer_start.tv_nsec;
+        while (thread_tps > 0 && xacts >= thread_tps /* throttle */) {
+            const auto time_now = steady_clock::now();
+            if (to_integer_seconds(time_now - time_prev) >= 1) {
+                xacts = 0;
+                time_prev = time_now;
+            } else {
+                usleep(1000);
+            }
+        }
+        if (args.txntrace) {
+            const auto time_now = steady_clock::now();
+            if (to_integer_seconds(time_now - time_last_traced) >= args.txntrace) {
+                time_last_traced = time_now;
+                fmt::print(debugme, "DEBUG: txn tracing {}\n", to_chars_ref(keystr));
+                auto err = Error{};
+                err = tx.set_option_nothrow(
+                    FDB_TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER, keystr);
+                if (err) {
+                    fmt::print(stderr,
+                               "ERROR: set_option(TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER): {}\n",
+                                err.what());
+                }
+                err = tx.set_option_nothrow(FDB_TR_OPTION_LOG_TRANSACTION, BytesRef());
+                if (err) {
+                    fmt::print(stderr,
+                               "ERROR: set_option(TR_OPTION_LOG_TRANSACTION): {}\n",
+                               err.what());
+                }
+            }
+        }
 
-	for (i = begin; i <= end; i++) {
+        /* insert (SET) */
+        tx.set(keystr, valstr);
+        stats.incr_count_immediate(OP_INSERT);
 
-		/* sequential keys */
-		genkey(keystr, KEYPREFIX, KEYPREFIXLEN, args->prefixpadding, i, args->rows, args->key_length + 1);
-		/* random values */
-		randstr(valstr, args->value_length + 1);
+        /* commit every 100 inserts (default) or if this is the last key */
+        if (i == key_end || (i - key_begin + 1) % num_commit_every == 0) {
+            auto time_commit_start = timepoint_t{};
+            const auto is_sample_target = (stats.get_tx_count() % args.sampling) == 0;
+            if (is_sample_target) time_commit_start = steady_clock::now();
+            auto future_commit = tx.commit();
+            const auto rc = wait_and_handle_error(tx, future_commit,
+                                                  "COMMIT_POPULATE_INSERT");
+            if (rc == FutureRC::OK) {
+                key_checkpoint = i + 1; // restart on failures from next key
+            } else if (rc == FutureRC::ABORT) {
+                return -1;
+            } else {
+                i = key_checkpoint - 1; // restart from last committed
+                time_tx_start = steady_clock::now(); // tx shall restart
+                continue;
+            }
 
-		if (((thread_tps > 0) && (xacts >= thread_tps)) /* throttle */ || (args->txntrace) /* txn tracing */) {
+            /* xact latency stats */
+            if (is_sample_target) {
+                const auto time_commit_end = steady_clock::now();
+                const auto commit_latency_us =
+                    to_integer_microseconds(time_commit_end - time_commit_start);
+                const auto tx_duration_us =
+                    to_integer_microseconds(time_commit_end - time_tx_start);
+                sample_bins[OP_COMMIT].put(commit_latency_us);
+                sample_bins[OP_TRANSACTION].put(tx_duration_us);
+                stats.add_latency(OP_COMMIT, commit_latency_us);
+                stats.add_latency(OP_TRANSACTION, tx_duration_us);
+            }
 
-		throttle:
-			clock_gettime(CLOCK_MONOTONIC_COARSE, &timer_now);
-			if ((timer_now.tv_sec > timer_prev.tv_sec + 1) ||
-			    ((timer_now.tv_sec == timer_prev.tv_sec + 1) && (timer_now.tv_nsec > timer_prev.tv_nsec))) {
-				/* more than 1 second passed, no need to throttle */
-				xacts = 0;
-				timer_prev.tv_sec = timer_now.tv_sec;
-				timer_prev.tv_nsec = timer_now.tv_nsec;
+            time_tx_start = steady_clock::now();
 
-				/* enable transaction tracing */
-				if (args->txntrace) {
-					tracetimer++;
-					if (tracetimer == args->txntrace) {
-						fdb_error_t err;
-						tracetimer = 0;
-						fprintf(debugme, "DEBUG: txn tracing %s\n", keystr);
-						err = fdb_transaction_set_option(
-						    transaction, FDB_TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER, (uint8_t*)keystr, strlen(keystr));
-						if (err) {
-							fprintf(
-							    stderr,
-							    "ERROR: fdb_transaction_set_option(FDB_TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER): %s\n",
-							    fdb_get_error(err));
-						}
-						err = fdb_transaction_set_option(transaction, FDB_TR_OPTION_LOG_TRANSACTION, (uint8_t*)NULL, 0);
-						if (err) {
-							fprintf(stderr,
-							        "ERROR: fdb_transaction_set_option(FDB_TR_OPTION_LOG_TRANSACTION): %s\n",
-							        fdb_get_error(err));
-						}
-					}
-				}
-			} else {
-				if (thread_tps > 0) {
-					/* 1 second not passed, throttle */
-					usleep(1000); /* sleep for 1ms */
-					goto throttle;
-				}
-			}
-		} /* throttle or txntrace */
+            tx.reset();
+            stats.incr_tx_count();
+            xacts++; /* for throttling */
+        }
+    }
+    const auto time_end = steady_clock::now();
 
-		/* insert (SET) */
-		fdb_transaction_set(transaction, (uint8_t*)keystr, strlen(keystr), (uint8_t*)valstr, strlen(valstr));
-		stats->ops[OP_INSERT]++;
+    fmt::print(debugme,
+            "DEBUG: Populated {} rows [{}, {}]: {:6.3f} sec\n",
+            key_end - key_begin + 1, key_begin, key_end,
+            to_double_seconds(time_end - time_start));
 
-		/* commit every 100 inserts (default) */
-		if (i % args->txnspec.ops[OP_INSERT][OP_COUNT] == 0) {
-		retryTxn:
-			if (stats->xacts % args->sampling == 0) {
-				clock_gettime(CLOCK_MONOTONIC, &timer_start_commit);
-			}
-
-			switch (commit_transaction(transaction)) {
-			case (FDB_SUCCESS):
-				break;
-			case (FDB_ERROR_RETRY):
-				goto retryTxn;
-			default:
-				goto failExit;
-			}
-
-			/* xact latency stats */
-			if (stats->xacts % args->sampling == 0) {
-				clock_gettime(CLOCK_MONOTONIC, &timer_per_xact_end);
-				update_op_lat_stats(
-				    &timer_start_commit, &timer_per_xact_end, OP_COMMIT, stats, block, elem_size, is_memory_allocated);
-				update_op_lat_stats(&timer_per_xact_start,
-				                    &timer_per_xact_end,
-				                    OP_TRANSACTION,
-				                    stats,
-				                    block,
-				                    elem_size,
-				                    is_memory_allocated);
-			}
-
-			stats->ops[OP_COMMIT]++;
-			stats->ops[OP_TRANSACTION]++;
-			clock_gettime(CLOCK_MONOTONIC, &timer_per_xact_start);
-
-			fdb_transaction_reset(transaction);
-			stats->xacts++;
-			xacts++; /* for throttling */
-		}
-	}
-	time_t start_time_sec, current_time_sec;
-	time(&start_time_sec);
-	int is_committed = false;
-	// will hit FDB_ERROR_RETRY if running mako with multi-version client
-	while (!is_committed) {
-		if (stats->xacts % args->sampling == 0) {
-			clock_gettime(CLOCK_MONOTONIC, &timer_start_commit);
-		}
-		int rc;
-		if ((rc = commit_transaction(transaction) != FDB_SUCCESS)) {
-			if (rc == FDB_ERROR_RETRY) {
-				time(&current_time_sec);
-				if (difftime(current_time_sec, start_time_sec) > 5) {
-					goto failExit;
-				} else {
-					continue;
-				}
-			} else {
-				goto failExit;
-			}
-		}
-		is_committed = true;
-		/* xact latency stats */
-		if (stats->xacts % args->sampling == 0) {
-			clock_gettime(CLOCK_MONOTONIC, &timer_per_xact_end);
-			update_op_lat_stats(
-			    &timer_start_commit, &timer_per_xact_end, OP_COMMIT, stats, block, elem_size, is_memory_allocated);
-			update_op_lat_stats(&timer_per_xact_start,
-			                    &timer_per_xact_end,
-			                    OP_TRANSACTION,
-			                    stats,
-			                    block,
-			                    elem_size,
-			                    is_memory_allocated);
-		}
-	}
-
-	clock_gettime(CLOCK_MONOTONIC, &timer_end);
-	stats->xacts++;
-
-	fprintf(debugme,
-	        "DEBUG: Populated %d rows (%d-%d): %6.3f sec\n",
-	        end - begin,
-	        begin,
-	        end,
-	        ((timer_end.tv_sec - timer_start.tv_sec) * 1000000000.0 + timer_end.tv_nsec - timer_start.tv_nsec) /
-	            1000000000);
-
-	free(keystr);
-	free(valstr);
-	return 0;
-
-failExit:
-	if (keystr)
-		free(keystr);
-	if (valstr)
-		free(valstr);
-	fprintf(stderr, "ERROR: FDB failure in populate()\n");
-	return -1;
-}
-
-int64_t run_op_getreadversion(FDBTransaction* transaction, int64_t* rv) {
-	FDBFuture* f;
-	fdb_error_t err;
-
-	*rv = 0;
-
-	f = fdb_transaction_get_read_version(transaction);
-	fdb_wait_and_handle_error(fdb_transaction_get_read_version, f, transaction);
-
-#if FDB_API_VERSION < 620
-	err = fdb_future_get_version(f, rv);
-#else
-	err = fdb_future_get_int64(f, rv);
-#endif
-
-	fdb_future_destroy(f);
-	if (err) {
-#if FDB_API_VERSION < 620
-		fprintf(stderr, "ERROR: fdb_future_get_version: %s\n", fdb_get_error(err));
-#else
-		fprintf(stderr, "ERROR: fdb_future_get_int64: %s\n", fdb_get_error(err));
-#endif
-		return FDB_ERROR_RETRY;
-	}
-
-	/* fail if rv not properly set */
-	if (!*rv) {
-		return FDB_ERROR_RETRY;
-	}
-	return FDB_SUCCESS;
-}
-
-int run_op_get(FDBTransaction* transaction, char* keystr, char* valstr, int snapshot) {
-	FDBFuture* f;
-	int out_present;
-	char* val;
-	int vallen;
-	fdb_error_t err;
-
-	f = fdb_transaction_get(transaction, (uint8_t*)keystr, strlen(keystr), snapshot);
-	fdb_wait_and_handle_error(fdb_transaction_get, f, transaction);
-
-	err = fdb_future_get_value(f, &out_present, (const uint8_t**)&val, &vallen);
-	fdb_future_destroy(f);
-	if (err || !out_present) {
-		/* error or value not present */
-		return FDB_ERROR_RETRY;
-	}
-	strncpy(valstr, val, vallen);
-	valstr[vallen] = '\0';
-	return FDB_SUCCESS;
-}
-
-int run_op_getrange(FDBTransaction* transaction,
-                    char* keystr,
-                    char* keystr2,
-                    char* valstr,
-                    int snapshot,
-                    int reverse,
-                    FDBStreamingMode streaming_mode) {
-	FDBFuture* f;
-	fdb_error_t err;
-	FDBKeyValue const* out_kv;
-	int out_count;
-	int out_more;
-
-	f = fdb_transaction_get_range(transaction,
-	                              FDB_KEYSEL_FIRST_GREATER_OR_EQUAL((uint8_t*)keystr, strlen(keystr)),
-	                              FDB_KEYSEL_LAST_LESS_OR_EQUAL((uint8_t*)keystr2, strlen(keystr2)) + 1,
-	                              0 /* limit */,
-	                              0 /* target_bytes */,
-	                              streaming_mode /* FDBStreamingMode */,
-	                              0 /* iteration */,
-	                              snapshot,
-	                              reverse /* reverse */);
-	fdb_wait_and_handle_error(fdb_transaction_get_range, f, transaction);
-
-	err = fdb_future_get_keyvalue_array(f, &out_kv, &out_count, &out_more);
-	if (err) {
-		fprintf(stderr, "ERROR: fdb_future_get_keyvalue_array: %s\n", fdb_get_error(err));
-		fdb_future_destroy(f);
-		return FDB_ERROR_RETRY;
-	}
-	fdb_future_destroy(f);
-	return FDB_SUCCESS;
-}
-
-/* Update -- GET and SET the same key */
-int run_op_update(FDBTransaction* transaction, char* keystr, char* valstr) {
-	FDBFuture* f;
-	int out_present;
-	char* val;
-	int vallen;
-	fdb_error_t err;
-
-	/* GET first */
-	f = fdb_transaction_get(transaction, (uint8_t*)keystr, strlen(keystr), 0);
-	fdb_wait_and_handle_error(fdb_transaction_get, f, transaction);
-
-	err = fdb_future_get_value(f, &out_present, (const uint8_t**)&val, &vallen);
-	fdb_future_destroy(f);
-	if (err || !out_present) {
-		/* error or value not present */
-		return FDB_ERROR_RETRY;
-	}
-
-	/* Update Value (SET) */
-	fdb_transaction_set(transaction, (uint8_t*)keystr, strlen(keystr), (uint8_t*)valstr, strlen(valstr));
-	return FDB_SUCCESS;
-}
-
-int run_op_insert(FDBTransaction* transaction, char* keystr, char* valstr) {
-	fdb_transaction_set(transaction, (uint8_t*)keystr, strlen(keystr), (uint8_t*)valstr, strlen(valstr));
-	return FDB_SUCCESS;
-}
-
-int run_op_clear(FDBTransaction* transaction, char* keystr) {
-	fdb_transaction_clear(transaction, (uint8_t*)keystr, strlen(keystr));
-	return FDB_SUCCESS;
-}
-
-int run_op_clearrange(FDBTransaction* transaction, char* keystr, char* keystr2) {
-	fdb_transaction_clear_range(transaction, (uint8_t*)keystr, strlen(keystr), (uint8_t*)keystr2, strlen(keystr2));
-	return FDB_SUCCESS;
+    return 0;
 }
 
 // TODO: could always abstract this into something more generically usable by something other than mako.
 // But outside of testing there are likely few use cases for local granules
 typedef struct {
-	char* bgFilePath;
-	int nextId;
-	uint8_t** data_by_id;
+    char const* bgFilePath;
+    int nextId;
+    uint8_t** data_by_id;
 } BGLocalFileContext;
 
 int64_t granule_start_load(const char* filename,
@@ -586,2526 +264,2199 @@ int64_t granule_start_load(const char* filename,
                            int64_t offset,
                            int64_t length,
                            void* userContext) {
-	FILE* fp;
-	char full_fname[PATH_MAX];
-	int loadId;
-	uint8_t* data;
-	size_t readSize;
+    FILE* fp;
+    char full_fname[PATH_MAX]{0,};
+    int loadId;
+    uint8_t* data;
+    size_t readSize;
 
-	BGLocalFileContext* context = (BGLocalFileContext*)userContext;
+    BGLocalFileContext* context = (BGLocalFileContext*)userContext;
 
-	loadId = context->nextId;
-	if (context->data_by_id[loadId] != 0) {
-		fprintf(stderr, "ERROR: too many granule file loads at once: %d\n", MAX_BG_IDS);
-		return -1;
-	}
-	context->nextId = (context->nextId + 1) % MAX_BG_IDS;
+    loadId = context->nextId;
+    if (context->data_by_id[loadId] != 0) {
+        fmt::print(stderr, "ERROR: too many granule file loads at once: {}\n", MAX_BG_IDS);
+        return -1;
+    }
+    context->nextId = (context->nextId + 1) % MAX_BG_IDS;
 
-	int ret = snprintf(full_fname, PATH_MAX, "%s%s", context->bgFilePath, filename);
-	if (ret < 0 || ret >= PATH_MAX) {
-		fprintf(stderr, "ERROR: BG filename too long: %s%s\n", context->bgFilePath, filename);
-		return -1;
-	}
+    int ret = snprintf(full_fname, PATH_MAX, "%s%s", context->bgFilePath, filename);
+    if (ret < 0 || ret >= PATH_MAX) {
+        fmt::print(stderr, "ERROR: BG filename too long: {}{}\n", context->bgFilePath, filename);
+        return -1;
+    }
 
-	fp = fopen(full_fname, "r");
-	if (!fp) {
-		fprintf(stderr, "ERROR: BG could not open file: %s\n", full_fname);
-		return -1;
-	}
+    fp = fopen(full_fname, "r");
+    if (!fp) {
+        fmt::print(stderr, "ERROR: BG could not open file: {}\n", full_fname);
+        return -1;
+    }
 
-	// don't seek if offset == 0
-	if (offset && fseek(fp, offset, SEEK_SET)) {
-		// if fseek was non-zero, it failed
-		fprintf(stderr, "ERROR: BG could not seek to %" PRId64 " in file %s\n", offset, full_fname);
-		fclose(fp);
-		return -1;
-	}
+    // don't seek if offset == 0
+    if (offset && fseek(fp, offset, SEEK_SET)) {
+        // if fseek was non-zero, it failed
+        fmt::print(stderr, "ERROR: BG could not seek to %{} in file {}\n", offset, full_fname);
+        fclose(fp);
+        return -1;
+    }
 
-	data = (uint8_t*)malloc(length);
-	readSize = fread(data, sizeof(uint8_t), length, fp);
-	fclose(fp);
+    data = new uint8_t[length];
+    readSize = fread(data, sizeof(uint8_t), length, fp);
+    fclose(fp);
 
-	if (readSize != length) {
-		fprintf(stderr, "ERROR: BG could not read %" PRId64 " bytes from file: %s\n", length, full_fname);
-		return -1;
-	}
+    if (readSize != length) {
+        fmt::print(stderr, "ERROR: BG could not read {} bytes from file: {}\n", length, full_fname);
+        return -1;
+    }
 
-	context->data_by_id[loadId] = data;
-	return loadId;
+    context->data_by_id[loadId] = data;
+    return loadId;
 }
 
 uint8_t* granule_get_load(int64_t loadId, void* userContext) {
-	BGLocalFileContext* context = (BGLocalFileContext*)userContext;
-	if (context->data_by_id[loadId] == 0) {
-		fprintf(stderr, "ERROR: BG loadId invalid for get_load: %" PRId64 "\n", loadId);
-		return 0;
-	}
-	return context->data_by_id[loadId];
+    BGLocalFileContext* context = (BGLocalFileContext*)userContext;
+    if (context->data_by_id[loadId] == 0) {
+        fmt::print(stderr, "ERROR: BG loadId invalid for get_load: {}\n", loadId);
+        return 0;
+    }
+    return context->data_by_id[loadId];
 }
 
 void granule_free_load(int64_t loadId, void* userContext) {
-	BGLocalFileContext* context = (BGLocalFileContext*)userContext;
-	if (context->data_by_id[loadId] == 0) {
-		fprintf(stderr, "ERROR: BG loadId invalid for free_load: %" PRId64 "\n", loadId);
-	}
-	free(context->data_by_id[loadId]);
-	context->data_by_id[loadId] = 0;
+    BGLocalFileContext* context = (BGLocalFileContext*)userContext;
+    if (context->data_by_id[loadId] == 0) {
+        fmt::print(stderr, "ERROR: BG loadId invalid for free_load: {}\n", loadId);
+    }
+    delete[] context->data_by_id[loadId];
+    context->data_by_id[loadId] = 0;
 }
 
-int run_op_read_blob_granules(FDBTransaction* transaction,
-                              char* keystr,
-                              char* keystr2,
-                              bool doMaterialize,
-                              char* bgFilePath) {
-	FDBResult* r;
-	fdb_error_t err;
-	FDBKeyValue const* out_kv;
-	int out_count;
-	int out_more;
+inline int next_key(mako_args_t const& args) {
+    if (args.zipf) return zipfian_next();
+    return urand(0, args.rows - 1);
+}
 
-	err = fdb_transaction_set_option(transaction, FDB_TR_OPTION_READ_YOUR_WRITES_DISABLE, (uint8_t*)NULL, 0);
-	if (err) {
-		fprintf(stderr, "ERROR: FDB_TR_OPTION_READ_YOUR_WRITES_DISABLE: %s\n", fdb_get_error(err));
-		return FDB_ERROR_RETRY;
-	}
+const std::array<OpDesc, MAX_OP> op_desc{{
+    {"GRV",             {StepKind::READ},                  false },
+    {"GET",             {StepKind::READ},                  false },
+    {"GETRANGE",        {StepKind::READ},                  false },
+    {"SGET",            {StepKind::READ},                  false },
+    {"SGETRANGE",       {StepKind::READ},                  false },
+    {"UPDATE",          {StepKind::COMMIT, StepKind::IMM}, true  },
+    {"INSERT",          {StepKind::IMM},                   true  },
+    {"INSERTRANGE",     {StepKind::IMM},                   true  },
+    {"OVERWRITE",       {StepKind::IMM},                   true  },
+    {"CLEAR",           {StepKind::IMM},                   true  },
+    {"SETCLEAR",        {StepKind::COMMIT, StepKind::IMM}, true  },
+    {"CLEARRANGE",      {StepKind::IMM},                   true  },
+    {"SETCLEARRANGE",   {StepKind::COMMIT, StepKind::IMM}, true  },
+    {"COMMIT",          {StepKind::NONE},                  false },
+    {"TRANSACTION",     {StepKind::NONE},                  false },
+    {"READBLOBGRANULE", {StepKind::ON_ERROR},              false }
+}};
 
-	// Allocate a separate context per call to avoid multiple threads accessing
-	BGLocalFileContext fileContext;
-	fileContext.bgFilePath = bgFilePath;
-	fileContext.nextId = 0;
-	fileContext.data_by_id = (uint8_t**)malloc(MAX_BG_IDS * sizeof(uint8_t*));
-	memset(fileContext.data_by_id, 0, MAX_BG_IDS * sizeof(uint8_t*));
+const std::map<std::pair<int/*op*/, int/*sub-op step*/>,
+               Future(*)(TX,
+                         mako_args_t const&,
+                         ByteString&/*key1*/,
+                         ByteString&/*key2*/,
+                         ByteString&/*value*/)> operation_fn_table{
+    {
+        {OP_GETREADVERSION, 0},
+        [](TX tx, mako_args_t const&, ByteString&, ByteString&, ByteString&) {
+            return tx.get_read_version().erase_type();
+        }
+    },
+    {
+        {OP_GET, 0},
+        [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString&) {
+            const auto num = next_key(args);
+            genkey(key, KEY_PREFIX, args, num);
+            return tx.get(key, false/*snapshot*/).erase_type();
+        }
+    },
+    {
+        {OP_GETRANGE, 0},
+        [](TX tx, mako_args_t const& args, ByteString& begin, ByteString& end, ByteString&) {
+            const auto num_begin = next_key(args);
+            genkey(begin, KEY_PREFIX, args, num_begin);
+            auto num_end = num_begin + args.txnspec.ops[OP_GETRANGE][OP_RANGE] - 1;
+            if (num_end > args.rows - 1)
+                num_end = args.rows - 1;
+            genkey(end, KEY_PREFIX, args, num_end);
+            return tx.get_range<key_select::inclusive, key_select::inclusive>(
+                    begin, end, 0/*limit*/, 0/*target_bytes*/, args.streaming_mode,
+                    0/*iteration*/, false/*snapshot*/,
+                    args.txnspec.ops[OP_GETRANGE][OP_REVERSE]).erase_type();
+        }
+    },
+    {
+        {OP_SGET, 0},
+        [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString&) {
+            const auto num = next_key(args);
+            genkey(key, KEY_PREFIX, args, num);
+            return tx.get(key, true/*snapshot*/).erase_type();
+        }
+    },
+    {
+        {OP_SGETRANGE, 0},
+        [](TX tx, mako_args_t const& args, ByteString& begin, ByteString& end, ByteString&) {
+            const auto num_begin = next_key(args);
+            genkey(begin, KEY_PREFIX, args, num_begin);
+            auto num_end = num_begin + args.txnspec.ops[OP_SGETRANGE][OP_RANGE] - 1;
+            if (num_end > args.rows - 1)
+                num_end = args.rows - 1;
+            genkey(end, KEY_PREFIX, args, num_end);
+            return tx.get_range<key_select::inclusive, key_select::inclusive>(
+                    begin, end, 0/*limit*/, 0/*target_bytes*/, args.streaming_mode,
+                    0/*iteration*/, true/*snapshot*/,
+                    args.txnspec.ops[OP_SGETRANGE][OP_REVERSE]).erase_type();
+        }
+    },
+    {
+        {OP_UPDATE, 0},
+        [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString&) {
+            const auto num = next_key(args);
+            genkey(key, KEY_PREFIX, args, num);
+            return tx.get(key, false/*snapshot*/).erase_type();
+        }
+    },
+    {
+        {OP_UPDATE, 1},
+        [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString& value) {
+            randstr(value, args.value_length);
+            tx.set(key, value);
+            return Future();
+        }
+    },
+    {
+        {OP_INSERT, 0},
+        [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString& value) {
+            genkeyprefix(key, KEY_PREFIX, args);
+            // concat([padding], key_prefix, random_string): reasonably unique
+            randstr<false/*clear-before-append*/>(
+                    key, args.key_length - static_cast<int>(key.size()));
+            randstr(value, args.value_length);
+            tx.set(key, value);
+            return Future();
+        }
+    },
+    {
+        {OP_INSERTRANGE, 0},
+        [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString& value) {
+            genkeyprefix(key, KEY_PREFIX, args);
+            const auto prefix_len = static_cast<int>(key.size());
+            const auto range = args.txnspec.ops[OP_INSERTRANGE][OP_RANGE];
+            assert(range > 0);
+            const auto range_digits = digits(range);
+            assert(args.key_length - prefix_len >= range_digits);
+            const auto rand_len = args.key_length - prefix_len - range_digits;
+            // concat([padding], prefix, random_string, range_digits)
+            randstr<false/*clear-before-append*/>(key, rand_len);
+            randstr(value, args.value_length);
+            for (auto i = 0; i < range; i++) {
+                fmt::format_to(std::back_inserter(key), "{0:0{1}d}", i, range_digits);
+                tx.set(key, value);
+                key.resize(key.size() - static_cast<size_t>(range_digits));
+            }
+            return Future();
+        }
+    },
+    {
+        {OP_OVERWRITE, 0},
+        [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString& value) {
+            genkey(key, KEY_PREFIX, args, next_key(args));
+            randstr(value, args.value_length);
+            return Future();
+        }
+    },
+    {
+        {OP_CLEAR, 0},
+        [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString&) {
+            genkey(key, KEY_PREFIX, args, next_key(args));
+            tx.clear(key);
+            return Future();
+        }
+    },
+    {
+        {OP_SETCLEAR, 0},
+        [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString& value) {
+            genkeyprefix(key, KEY_PREFIX, args);
+            const auto prefix_len = static_cast<int>(key.size());
+            randstr<false/*append-after-clear*/>(key, args.key_length - prefix_len);
+            randstr(value, args.value_length);
+            tx.set(key, value);
+            return tx.commit().erase_type();
+        }
+    },
+    {
+        {OP_SETCLEAR, 1},
+        [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString&) {
+            tx.reset(); // assuming commit from step 0 worked.
+            tx.clear(key); // key should forward unchanged from step 0
+            return Future();
+        }
+    },
+    {
+        {OP_CLEARRANGE, 0},
+        [](TX tx, mako_args_t const& args, ByteString& begin, ByteString& end, ByteString&) {
+            const auto num_begin = next_key(args);
+            genkey(begin, KEY_PREFIX, args, num_begin);
+            const auto range = args.txnspec.ops[OP_CLEARRANGE][OP_RANGE];
+            assert(range > 0);
+            genkey(end, KEY_PREFIX, args, std::min(args.rows - 1, num_begin + range - 1));
+            tx.clear_range(begin, end);
+            return Future();
+        }
+    },
+    {
+        {OP_SETCLEARRANGE, 0},
+        [](TX tx, mako_args_t const& args, ByteString& key_begin, ByteString& key, ByteString& value) {
+            genkeyprefix(key, KEY_PREFIX, args);
+            const auto prefix_len = static_cast<int>(key.size());
+            const auto range = args.txnspec.ops[OP_SETCLEARRANGE][OP_RANGE];
+            assert(range > 0);
+            const auto range_digits = digits(range);
+            assert(args.key_length - prefix_len >= range_digits);
+            const auto rand_len = args.key_length - prefix_len - range_digits;
+            // concat([padding], prefix, random_string, range_digits)
+            randstr<false/*clear-before-append*/>(key, rand_len);
+            randstr(value, args.value_length);
+            for (auto i = 0; i <= range; i++) {
+                fmt::format_to(std::back_inserter(key), "{0:0{1}d}", i, range_digits);
+                if (i == range) break; // preserve "exclusive last"
+                // preserve first key for step 1
+                if (i == 0) key_begin = key;
+                tx.set(key, value);
+                // preserve last key for step 1
+                key.resize(key.size() - static_cast<size_t>(range_digits));
+            }
+            return tx.commit().erase_type();
+        }
+    },
+    {
+        {OP_SETCLEARRANGE, 1},
+        [](TX tx, mako_args_t const& args, ByteString& begin, ByteString& end, ByteString&) {
+            tx.reset();
+            tx.clear_range(begin, end);
+            return Future();
+        }
+    },
+    {
+        {OP_READ_BG, 0},
+        [](TX tx, mako_args_t const& args, ByteString& begin, ByteString& end, ByteString&) {
+            const auto num_begin = next_key(args);
+            genkey(begin, KEY_PREFIX, args, num_begin);
+            const auto range = args.txnspec.ops[OP_READ_BG][OP_RANGE];
+            assert(range > 0);
+            genkey(end, KEY_PREFIX, args, std::min(args.rows - 1, num_begin + range - 1));
+            auto err = Error{};
 
-	FDBReadBlobGranuleContext granuleContext;
-	granuleContext.userContext = &fileContext;
-	granuleContext.start_load_f = &granule_start_load;
-	granuleContext.get_load_f = &granule_get_load;
-	granuleContext.free_load_f = &granule_free_load;
-	granuleContext.debugNoMaterialize = !doMaterialize;
+            err = tx.set_option_nothrow(FDB_TR_OPTION_READ_YOUR_WRITES_DISABLE, BytesRef());
+            if (err) {
+                // Issuing read/writes before disabling RYW results in error.
+                // Possible malformed workload?
+                // As workloads execute in sequence, retrying would likely repeat this error.
+                fmt::print(stderr, "ERROR: TR_OPTION_READ_YOUR_WRITES_DISABLE: {}", err.what());
+                return Future();
+            }
 
-	r = fdb_transaction_read_blob_granules(transaction,
-	                                       (uint8_t*)keystr,
-	                                       strlen(keystr),
-	                                       (uint8_t*)keystr2,
-	                                       strlen(keystr2),
-	                                       0 /* beginVersion*/,
-	                                       -1, /* endVersion. -1 is use txn read version */
-	                                       granuleContext);
+            auto mem = std::unique_ptr<uint8_t*[]>(new uint8_t*[MAX_BG_IDS]);
+            // Allocate a separate context per call to avoid multiple threads accessing
+            BGLocalFileContext fileContext;
+            fileContext.bgFilePath = args.bg_file_path;
+            fileContext.nextId = 0;
+            fileContext.data_by_id = mem.get();
+            memset(fileContext.data_by_id, 0, MAX_BG_IDS * sizeof(uint8_t*));
 
-	free(fileContext.data_by_id);
+            native::FDBReadBlobGranuleContext granuleContext;
+            granuleContext.userContext = &fileContext;
+            granuleContext.start_load_f = &granule_start_load;
+            granuleContext.get_load_f = &granule_get_load;
+            granuleContext.free_load_f = &granule_free_load;
+            granuleContext.debugNoMaterialize = !args.bg_materialize_files;
 
-	err = fdb_result_get_keyvalue_array(r, &out_kv, &out_count, &out_more);
+            auto r = tx.read_blob_granules(
+                    begin, end, 0/*begin_version*/, -1/*end_version, use txn's*/, granuleContext);
 
-	if (err) {
-		if (err != 2037 /* blob_granule_not_materialized */) {
-			fdb_handle_result_error(fdb_transaction_read_blob_granules, err, transaction);
-		} else {
-			fdb_result_destroy(r);
-			return FDB_SUCCESS;
-		}
-	}
+            mem.reset();
 
-	fdb_result_destroy(r);
+            auto out = Result::KeyValueArray{};
+            err = r.get_keyvalue_array_nothrow(out);
+            if (!err || err.is(2037/*blob_granule_not_materialized*/))
+                return Future();
+            const auto fp = (err.is(1020/*not_committed*/) ||
+                             err.is(1021/*commit_unknown_result*/) ||
+                             err.is(1213/*tag_throttled*/)) ? annoyme : stderr;
+            fmt::print(fp, "ERROR: get_keyvalue_array() after read_blob_granules(): {}\n",
+                       err.what());
+            return tx.on_error(err).erase_type();
+        }
+    }
+};
 
-	return FDB_SUCCESS;
+using OpIterator = std::tuple<int/*op*/, int/*count*/, int/*step*/>;
+
+constexpr const OpIterator OpEnd = OpIterator(MAX_OP, -1, -1);
+
+OpIterator get_op_begin(mako_args_t const& args) noexcept {
+    for (auto op = 0; op < MAX_OP; op++) {
+        if (op == OP_COMMIT || op == OP_TRANSACTION ||
+            args.txnspec.ops[op][OP_COUNT] == 0)
+            continue;
+        return OpIterator(op, 0, 0);
+    }
+    return OpEnd;
+}
+
+OpIterator get_op_next(mako_args_t const& args, OpIterator current) noexcept {
+    if (OpEnd == current) return OpEnd;
+    auto [op, count, step] = current;
+    assert(op < MAX_OP && op != OP_TRANSACTION && op != OP_COMMIT);
+    if (op_desc[op].steps() > step + 1)
+        return OpIterator(op, count, step + 1);
+    count++;
+    for ( ; op < MAX_OP; op++, count=0) {
+        if (op == OP_COMMIT || op == OP_TRANSACTION ||
+            args.txnspec.ops[op][OP_COUNT] <= count)
+            continue;
+        return OpIterator(op, count, 0);
+    }
+    return OpEnd;
 }
 
 /* run one transaction */
-int run_one_transaction(FDBTransaction* transaction,
-                        mako_args_t* args,
-                        mako_stats_t* stats,
-                        char* keystr,
-                        char* keystr2,
-                        char* valstr,
-                        lat_block_t* block[],
-                        int* elem_size,
-                        bool* is_memory_allocated) {
-	int i;
-	int count;
-	int rc;
-	struct timespec timer_start, timer_end;
-	struct timespec timer_per_xact_start, timer_per_xact_end;
-	struct timespec timer_start_commit;
-	int docommit = 0;
-	int keynum;
-	int keyend;
-	int64_t readversion;
-	int randstrlen;
-	int rangei;
+int run_one_transaction(TX tx,
+                        mako_args_t const& args,
+                        mako_stats_t& stats,
+                        sample_bin_array_t& sample_bins) {
+    // reuse memory for keys to avoid realloc overhead
+    auto key1 = ByteString{};
+    key1.reserve(args.key_length);
+    auto key2 = ByteString{};
+    key2.reserve(args.key_length);
+    auto val = ByteString{};
+    key2.reserve(args.value_length);
 
-#if 0 /* this call conflicts with debug transaction */
-  /* make sure that the transaction object is clean */
-  fdb_transaction_reset(transaction);
-#endif
+    auto time_tx_start = steady_clock::now();
 
-	clock_gettime(CLOCK_MONOTONIC, &timer_per_xact_start);
+    auto op_iter = get_op_begin(args);
+    auto needs_commit = false;
+    auto time_per_op_start = std::array<timepoint_t, MAX_OP>{};
+    const auto do_sample = (stats.get_tx_count() % args.sampling) == 0;
+    while (op_iter != OpEnd) {
+        const auto [op, count, step] = op_iter;
+        const auto step_kind = op_desc[op].step_kind(step);
+        const auto op_key = std::make_pair(op, step);
+        const auto time_step_start = steady_clock::now();
+        if (step == 0 /* first step */) {
+            time_per_op_start[op] = time_step_start;
+        }
+        auto f = operation_fn_table.at(op_key)(tx, args, key1, key2, val);
+        auto future_rc = FutureRC::OK;
+        if (f) {
+            if (step_kind != StepKind::ON_ERROR) {
+                future_rc = wait_and_handle_error(tx, f, op_desc[op].name());
+            } else {
+                auto followup_rc = wait_and_handle_for_on_error(tx, f, op_desc[op].name());
+                if (followup_rc == FutureRC::OK) {
+                    future_rc = FutureRC::RETRY;
+                }
+            }
+        }
+        const auto time_step_end = steady_clock::now();
+        const auto step_usec = to_integer_microseconds(time_step_end - time_step_start);
+        if (future_rc != FutureRC::OK) {
+            if (future_rc == FutureRC::CONFLICT) {
+                stats.incr_conflict_count();
+            } else if (future_rc == FutureRC::RETRY) {
+                stats.incr_error_count(op);
+            } else {
+                // abort
+                tx.reset();
+                return -1;
+            }
+            // retry from first op
+            op_iter = get_op_begin(args);
+            needs_commit = false;
+            continue;
+        }
+        // step successful
+        if (step_kind == StepKind::COMMIT) {
+            const auto tx_usec = to_integer_microseconds(time_step_end - time_tx_start);
+            stats.add_latency(OP_COMMIT, step_usec);
+            stats.add_latency(OP_TRANSACTION, tx_usec);
+            if (do_sample) {
+                sample_bins[OP_COMMIT].put(step_usec);
+                sample_bins[OP_TRANSACTION].put(tx_usec);
+            }
+            time_tx_start = time_step_end; // new tx begins
+        }
 
-retryTxn:
-	for (i = 0; i < MAX_OP; i++) {
+        // op completed successfully
+        if (step + 1 == op_desc[op].steps() /* last step */) {
+            if (op_desc[op].needs_commit())
+                needs_commit = true;
+            const auto op_usec =
+                to_integer_microseconds(time_step_end - time_per_op_start[op]);
+            stats.add_latency(op, op_usec);
+            if (do_sample) sample_bins[op].put(op_usec);
+        }
+        // move to next op
+        op_iter = get_op_next(args, op_iter);
 
-		if ((args->txnspec.ops[i][OP_COUNT] > 0) && (i != OP_TRANSACTION) && (i != OP_COMMIT)) {
-			for (count = 0; count < args->txnspec.ops[i][OP_COUNT]; count++) {
-
-				/* note: for simplicity, always generate a new key(s) even when retrying */
-
-				/* pick a random key(s) */
-				if (args->zipf) {
-					keynum = zipfian_next();
-				} else {
-					keynum = urand(0, args->rows - 1);
-				}
-				genkey(keystr, KEYPREFIX, KEYPREFIXLEN, args->prefixpadding, keynum, args->rows, args->key_length + 1);
-
-				/* range */
-				if (args->txnspec.ops[i][OP_RANGE] > 0) {
-					keyend = keynum + args->txnspec.ops[i][OP_RANGE] - 1; /* inclusive */
-					if (keyend > args->rows - 1) {
-						keyend = args->rows - 1;
-					}
-					genkey(keystr2,
-					       KEYPREFIX,
-					       KEYPREFIXLEN,
-					       args->prefixpadding,
-					       keyend,
-					       args->rows,
-					       args->key_length + 1);
-				}
-
-				if (stats->xacts % args->sampling == 0) {
-					/* per op latency */
-					clock_gettime(CLOCK_MONOTONIC, &timer_start);
-				}
-
-				switch (i) {
-				case OP_GETREADVERSION:
-					rc = run_op_getreadversion(transaction, &readversion);
-					break;
-				case OP_GET:
-					rc = run_op_get(transaction, keystr, valstr, 0);
-					break;
-				case OP_GETRANGE:
-					rc = run_op_getrange(transaction,
-					                     keystr,
-					                     keystr2,
-					                     valstr,
-					                     0,
-					                     args->txnspec.ops[i][OP_REVERSE],
-					                     args->streaming_mode);
-					break;
-				case OP_SGET:
-					rc = run_op_get(transaction, keystr, valstr, 1);
-					break;
-				case OP_SGETRANGE:
-					rc = run_op_getrange(transaction,
-					                     keystr,
-					                     keystr2,
-					                     valstr,
-					                     1,
-					                     args->txnspec.ops[i][OP_REVERSE],
-					                     args->streaming_mode);
-					break;
-				case OP_UPDATE:
-					randstr(valstr, args->value_length + 1);
-					rc = run_op_update(transaction, keystr, valstr);
-					docommit = 1;
-					break;
-				case OP_INSERT:
-					randstr(keystr + KEYPREFIXLEN, args->key_length - KEYPREFIXLEN + 1); /* make it (almost) unique */
-					randstr(valstr, args->value_length + 1);
-					rc = run_op_insert(transaction, keystr, valstr);
-					docommit = 1;
-					break;
-				case OP_INSERTRANGE:
-					randstrlen = args->key_length - KEYPREFIXLEN - digits(args->txnspec.ops[i][OP_RANGE]);
-					randstr(keystr + KEYPREFIXLEN, randstrlen + 1); /* make it (almost) unique */
-					randstr(valstr, args->value_length + 1);
-					for (rangei = 0; rangei < args->txnspec.ops[i][OP_RANGE]; rangei++) {
-						sprintf(keystr + KEYPREFIXLEN + randstrlen,
-						        "%0.*d",
-						        digits(args->txnspec.ops[i][OP_RANGE]),
-						        rangei);
-						rc = run_op_insert(transaction, keystr, valstr);
-						if (rc != FDB_SUCCESS)
-							break;
-					}
-					docommit = 1;
-					break;
-				case OP_OVERWRITE:
-					rc = run_op_insert(transaction, keystr, valstr);
-					docommit = 1;
-					break;
-				case OP_CLEAR:
-					rc = run_op_clear(transaction, keystr);
-					docommit = 1;
-					break;
-				case OP_SETCLEAR:
-					randstr(keystr + KEYPREFIXLEN, args->key_length - KEYPREFIXLEN + 1); /* make it (almost) unique */
-					randstr(valstr, args->value_length + 1);
-					rc = run_op_insert(transaction, keystr, valstr);
-					if (rc == FDB_SUCCESS) {
-						/* commit insert so mutation goes to storage */
-						/* to measure commit latency */
-						if (stats->xacts % args->sampling == 0) {
-							clock_gettime(CLOCK_MONOTONIC, &timer_start_commit);
-						}
-						rc = commit_transaction(transaction);
-						if (rc == FDB_SUCCESS) {
-							stats->ops[OP_COMMIT]++;
-							stats->ops[OP_TRANSACTION]++;
-							if (stats->xacts % args->sampling == 0) {
-								clock_gettime(CLOCK_MONOTONIC, &timer_per_xact_end);
-								update_op_lat_stats(&timer_start_commit,
-								                    &timer_per_xact_end,
-								                    OP_COMMIT,
-								                    stats,
-								                    block,
-								                    elem_size,
-								                    is_memory_allocated);
-								update_op_lat_stats(&timer_per_xact_start,
-								                    &timer_per_xact_end,
-								                    OP_TRANSACTION,
-								                    stats,
-								                    block,
-								                    elem_size,
-								                    is_memory_allocated);
-							}
-						} else {
-							/* error */
-							if (rc == FDB_ERROR_CONFLICT) {
-								stats->conflicts++;
-							} else {
-								stats->errors[OP_COMMIT]++;
-							}
-							if (rc == FDB_ERROR_ABORT) {
-								/* make sure to reset transaction */
-								fdb_transaction_reset(transaction);
-								return rc; /* abort */
-							}
-							goto retryTxn;
-						}
-						fdb_transaction_reset(transaction);
-						rc = run_op_clear(transaction, keystr);
-					}
-					docommit = 1;
-					break;
-				case OP_CLEARRANGE:
-					rc = run_op_clearrange(transaction, keystr, keystr2);
-					docommit = 1;
-					break;
-				case OP_SETCLEARRANGE:
-					randstrlen = args->key_length - KEYPREFIXLEN - digits(args->txnspec.ops[i][OP_RANGE]);
-					randstr(keystr + KEYPREFIXLEN, randstrlen + 1); /* make it (almost) unique */
-					randstr(valstr, args->value_length + 1);
-					for (rangei = 0; rangei < args->txnspec.ops[i][OP_RANGE]; rangei++) {
-						sprintf(keystr + KEYPREFIXLEN + randstrlen,
-						        "%0.*d",
-						        digits(args->txnspec.ops[i][OP_RANGE]),
-						        rangei);
-						if (rangei == 0) {
-							strcpy(keystr2, keystr);
-							keystr2[strlen(keystr)] = '\0';
-						}
-						rc = run_op_insert(transaction, keystr, valstr);
-						/* rollback not necessary, move on */
-						if (rc == FDB_ERROR_RETRY) {
-							goto retryTxn;
-						} else if (rc == FDB_ERROR_ABORT) {
-							/* make sure to reset transaction */
-							fdb_transaction_reset(transaction);
-							return rc; /* abort */
-						}
-					}
-					/* commit insert so mutation goes to storage */
-					if (stats->xacts % args->sampling == 0) {
-						clock_gettime(CLOCK_MONOTONIC, &timer_start_commit);
-					}
-					rc = commit_transaction(transaction);
-					if (rc == FDB_SUCCESS) {
-						stats->ops[OP_COMMIT]++;
-						stats->ops[OP_TRANSACTION]++;
-						if (stats->xacts % args->sampling == 0) {
-							clock_gettime(CLOCK_MONOTONIC, &timer_per_xact_end);
-							update_op_lat_stats(&timer_start_commit,
-							                    &timer_per_xact_end,
-							                    OP_COMMIT,
-							                    stats,
-							                    block,
-							                    elem_size,
-							                    is_memory_allocated);
-							update_op_lat_stats(&timer_per_xact_start,
-							                    &timer_per_xact_end,
-							                    OP_TRANSACTION,
-							                    stats,
-							                    block,
-							                    elem_size,
-							                    is_memory_allocated);
-						}
-					} else {
-						/* error */
-						if (rc == FDB_ERROR_CONFLICT) {
-							stats->conflicts++;
-						} else {
-							stats->errors[OP_TRANSACTION]++;
-						}
-						if (rc == FDB_ERROR_ABORT) {
-							/* make sure to reset transaction */
-							fdb_transaction_reset(transaction);
-							return rc; /* abort */
-						}
-						goto retryTxn;
-					}
-					fdb_transaction_reset(transaction);
-					rc = run_op_clearrange(transaction, keystr2, keystr);
-					docommit = 1;
-					break;
-				case OP_READ_BG:
-					rc = run_op_read_blob_granules(
-					    transaction, keystr, keystr2, args->bg_materialize_files, args->bg_file_path);
-					break;
-				default:
-					fprintf(stderr, "ERROR: Unknown Operation %d\n", i);
-					break;
-				}
-
-				if (stats->xacts % args->sampling == 0) {
-					clock_gettime(CLOCK_MONOTONIC, &timer_end);
-					if (rc == FDB_SUCCESS) {
-						/* per op latency, record successful transactions */
-						update_op_lat_stats(&timer_start, &timer_end, i, stats, block, elem_size, is_memory_allocated);
-					}
-				}
-
-				/* check rc and update stats */
-				if (rc == FDB_SUCCESS) {
-					stats->ops[i]++;
-				} else {
-					/* error */
-					if (rc == FDB_ERROR_CONFLICT) {
-						stats->conflicts++;
-					} else {
-						stats->errors[OP_TRANSACTION]++;
-					}
-					if (rc == FDB_ERROR_ABORT) {
-						/* make sure to reset transaction */
-						fdb_transaction_reset(transaction);
-						return rc; /* abort */
-					}
-					goto retryTxn;
-				}
-			}
-		}
-	}
-
-	/* commit only successful transaction */
-	if (docommit | args->commit_get) {
-		if (stats->xacts % args->sampling == 0) {
-			clock_gettime(CLOCK_MONOTONIC, &timer_start_commit);
-		}
-		rc = commit_transaction(transaction);
-		if (rc == FDB_SUCCESS) {
-			/* success */
-			stats->ops[OP_COMMIT]++;
-			if (stats->xacts % args->sampling == 0) {
-				clock_gettime(CLOCK_MONOTONIC, &timer_per_xact_end);
-				update_op_lat_stats(
-				    &timer_start_commit, &timer_per_xact_end, OP_COMMIT, stats, block, elem_size, is_memory_allocated);
-			}
-		} else {
-			/* error */
-			if (rc == FDB_ERROR_CONFLICT) {
-				stats->conflicts++;
-			} else {
-				stats->errors[OP_TRANSACTION]++;
-			}
-			if (rc == FDB_ERROR_ABORT) {
-				/* make sure to reset transaction */
-				fdb_transaction_reset(transaction);
-				return rc; /* abort */
-			}
-			goto retryTxn;
-		}
-	}
-
-	stats->ops[OP_TRANSACTION]++;
-	if (stats->xacts % args->sampling == 0) {
-		clock_gettime(CLOCK_MONOTONIC, &timer_per_xact_end);
-		update_op_lat_stats(
-		    &timer_per_xact_start, &timer_per_xact_end, OP_TRANSACTION, stats, block, elem_size, is_memory_allocated);
-	}
-
-	stats->xacts++;
-
-	/* make sure to reset transaction */
-	fdb_transaction_reset(transaction);
-	return 0;
+        // reached the end?
+        if (op_iter == OpEnd && (needs_commit || args.commit_get)) {
+            const auto time_commit_start = steady_clock::now();
+            auto f = tx.commit();
+            const auto rc = wait_and_handle_error(tx, f, "COMMIT_AT_TX_END");
+            const auto time_commit_end = steady_clock::now();
+            const auto commit_usec =
+                to_integer_microseconds(time_commit_end - time_commit_start);
+            const auto tx_usec =
+                to_integer_microseconds(time_commit_end - time_tx_start);
+            if (rc == FutureRC::OK) {
+                stats.add_latency(OP_COMMIT, commit_usec);
+                stats.add_latency(OP_TRANSACTION, tx_usec);
+                if (do_sample) {
+                    sample_bins[OP_COMMIT].put(commit_usec);
+                    sample_bins[OP_TRANSACTION].put(tx_usec);
+                }
+            } else {
+                if (rc == FutureRC::CONFLICT)
+                    stats.incr_conflict_count();
+                else
+                    stats.incr_error_count(OP_COMMIT);
+                if (rc == FutureRC::ABORT) {
+                    tx.reset();
+                    return -1;
+                }
+                // restart from beginning
+                op_iter = get_op_begin(args);
+            }
+        }
+    }
+    stats.incr_tx_count();
+    /* make sure to reset transaction */
+    tx.reset();
+    return 0;
 }
 
-int run_workload(FDBTransaction* transaction,
-                 mako_args_t* args,
-                 int thread_tps,
-                 volatile double* throttle_factor,
-                 int thread_iters,
-                 volatile int* signal,
-                 mako_stats_t* stats,
-                 int dotrace,
-                 int dotagging,
-                 lat_block_t* block[],
-                 int* elem_size,
-                 bool* is_memory_allocated) {
-	int xacts = 0;
-	int64_t total_xacts = 0;
-	int rc = 0;
-	struct timespec timer_prev, timer_now;
-	char* keystr;
-	char* keystr2;
-	char* valstr;
-	int current_tps;
-	char* traceid;
-	int tracetimer = 0;
-	char* tagstr;
+int run_workload(TX tx,
+                 mako_args_t const& args,
+                 int const thread_tps,
+                 std::atomic<double> const& throttle_factor,
+                 int const thread_iters,
+                 std::atomic<int> const& signal,
+                 mako_stats_t& stats,
+                 sample_bin_array_t& sample_bins,
+                 int const dotrace,
+                 int const dotagging) {
+    auto traceid = std::string{};
+    auto tagstr = std::string{};
 
-	if (thread_tps < 0)
-		return 0;
+    if (thread_tps < 0) return 0;
 
-	if (dotrace) {
-		traceid = (char*)malloc(32);
-	}
+    if (dotrace) traceid.reserve(32);
 
-	if (dotagging) {
-		tagstr = (char*)calloc(16, 1);
-		memcpy(tagstr, KEYPREFIX, KEYPREFIXLEN);
-		memcpy(tagstr + KEYPREFIXLEN, args->txntagging_prefix, TAGPREFIXLENGTH_MAX);
-	}
+    if (dotagging) tagstr.reserve(16);
 
-	current_tps = (int)((double)thread_tps * *throttle_factor);
+    auto current_tps = static_cast<int>(thread_tps * throttle_factor.load());
 
-	keystr = (char*)malloc(sizeof(char) * args->key_length + 1);
-	if (!keystr)
-		return -1;
-	keystr2 = (char*)malloc(sizeof(char) * args->key_length + 1);
-	if (!keystr2) {
-		free(keystr);
-		return -1;
-	}
-	valstr = (char*)malloc(sizeof(char) * args->value_length + 1);
-	if (!valstr) {
-		free(keystr);
-		free(keystr2);
-		return -1;
-	}
+    auto time_prev = steady_clock::now();
+    auto time_last_trace = time_prev;
 
-	clock_gettime(CLOCK_MONOTONIC_COARSE, &timer_prev);
+    auto rc = 0;
+    auto xacts = 0;
+    auto total_xacts = int64_t{};
+    /* main transaction loop */
+    while (1) {
+        while ((thread_tps > 0) && (xacts >= current_tps)) {
+            /* throttle on */
+            const auto time_now = steady_clock::now();
+            if (to_double_seconds(time_now - time_prev) >= 1.0) {
+                /* more than 1 second passed, no need to throttle */
+                xacts = 0;
+                time_prev = time_now;
 
-	/* main transaction loop */
-	while (1) {
+                /* update throttle rate */
+                current_tps = static_cast<int>(thread_tps * throttle_factor.load());
+            } else {
+                usleep(1000);
+            }
+        }
+        /* enable transaction trace */
+        if (dotrace) {
+            const auto time_now = steady_clock::now();
+            if (to_integer_seconds(time_now - time_last_trace) >= 1) {
+                time_last_trace = time_now;
+                traceid.clear();
+                fmt::format_to(std::back_inserter(traceid),
+                               "makotrace{:0>19d}", total_xacts);
+                fmt::print(debugme, "DEBUG: txn tracing {}\n", traceid);
+                auto err = Error{};
+                err = tx.set_option_nothrow(
+                                    FDB_TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER,
+                                    to_bytes_ref(traceid));
+                if (err) {
+                    fmt::print(
+                        stderr, "ERROR: TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER: {}\n", err.what());
+                }
+                err = tx.set_option_nothrow(FDB_TR_OPTION_LOG_TRANSACTION,
+                                            BytesRef());
+                if (err) {
+                    fmt::print(stderr, "ERROR: TR_OPTION_LOG_TRANSACTION: {}\n", err.what());
+                }
+            }
+        }
 
-		if (((thread_tps > 0) && (xacts >= current_tps)) /* throttle on */ || dotrace /* transaction tracing on */) {
+        /* enable transaction tagging */
+        if (dotagging > 0) {
+            tagstr.clear();
+            fmt::format_to(std::back_inserter(tagstr), "{}{}{:0>3d}",
+                           KEY_PREFIX,
+                           args.txntagging_prefix,
+                           urand(0, args.txntagging - 1));
+            auto err = tx.set_option_nothrow(FDB_TR_OPTION_AUTO_THROTTLE_TAG,
+                                                      to_bytes_ref(tagstr));
+            if (err) {
+                fmt::print(stderr, "ERROR: TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER: {}\n",
+                           err.what());
+            }
+        }
 
-			clock_gettime(CLOCK_MONOTONIC_COARSE, &timer_now);
-			if ((timer_now.tv_sec > timer_prev.tv_sec + 1) ||
-			    ((timer_now.tv_sec == timer_prev.tv_sec + 1) && (timer_now.tv_nsec > timer_prev.tv_nsec))) {
-				/* more than 1 second passed, no need to throttle */
-				xacts = 0;
-				timer_prev.tv_sec = timer_now.tv_sec;
-				timer_prev.tv_nsec = timer_now.tv_nsec;
+        rc = run_one_transaction(tx, args, stats, sample_bins);
+        if (rc) {
+            fmt::print(annoyme, "ERROR: run_one_transaction failed ({})\n", rc);
+        }
 
-				/* update throttle rate */
-				if (thread_tps > 0) {
-					current_tps = (int)((double)thread_tps * *throttle_factor);
-				}
-
-				/* enable transaction trace */
-				if (dotrace) {
-					tracetimer++;
-					if (tracetimer == dotrace) {
-						fdb_error_t err;
-						tracetimer = 0;
-						snprintf(traceid, 32, "makotrace%019" PRId64, total_xacts);
-						fprintf(debugme, "DEBUG: txn tracing %s\n", traceid);
-						err = fdb_transaction_set_option(transaction,
-						                                 FDB_TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER,
-						                                 (uint8_t*)traceid,
-						                                 strlen(traceid));
-						if (err) {
-							fprintf(
-							    stderr, "ERROR: FDB_TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER: %s\n", fdb_get_error(err));
-						}
-						err = fdb_transaction_set_option(transaction, FDB_TR_OPTION_LOG_TRANSACTION, (uint8_t*)NULL, 0);
-						if (err) {
-							fprintf(stderr, "ERROR: FDB_TR_OPTION_LOG_TRANSACTION: %s\n", fdb_get_error(err));
-						}
-					}
-				}
-
-			} else {
-				if (thread_tps > 0) {
-					/* 1 second not passed, throttle */
-					usleep(1000);
-					continue;
-				}
-			}
-		} /* throttle or txntrace */
-
-		/* enable transaction tagging */
-		if (dotagging > 0) {
-			sprintf(tagstr + KEYPREFIXLEN + TAGPREFIXLENGTH_MAX, "%03d", urand(0, args->txntagging - 1));
-			fdb_error_t err =
-			    fdb_transaction_set_option(transaction, FDB_TR_OPTION_AUTO_THROTTLE_TAG, (uint8_t*)tagstr, 16);
-			if (err) {
-				fprintf(stderr, "ERROR: FDB_TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER: %s\n", fdb_get_error(err));
-			}
-		}
-
-		rc = run_one_transaction(
-		    transaction, args, stats, keystr, keystr2, valstr, block, elem_size, is_memory_allocated);
-		if (rc) {
-			/* FIXME: run_one_transaction should return something meaningful */
-			fprintf(annoyme, "ERROR: run_one_transaction failed (%d)\n", rc);
-		}
-
-		if (thread_iters > 0) {
-			if (thread_iters == xacts) {
-				/* xact limit reached */
-				break;
-			}
-		} else if (*signal == SIGNAL_RED) {
-			/* signal turned red, target duration reached */
-			break;
-		}
-		xacts++;
-		total_xacts++;
-	}
-	free(keystr);
-	free(keystr2);
-	free(valstr);
-	if (dotrace) {
-		free(traceid);
-	}
-	if (dotagging) {
-		free(tagstr);
-	}
-
-	return rc;
+        if (thread_iters > 0) {
+            if (thread_iters == xacts) {
+                /* xact limit reached */
+                break;
+            }
+        } else if (signal.load() == SIGNAL_RED) {
+            /* signal turned red, target duration reached */
+            break;
+        }
+        xacts++;
+        total_xacts++;
+    }
+    return rc;
 }
 
-void get_stats_file_name(char filename[], int worker_id, int thread_id, int op) {
-	char str1[256];
-	sprintf(str1, "/%d_%d_", worker_id + 1, thread_id + 1);
-	strcat(filename, str1);
-	switch (op) {
-	case OP_GETREADVERSION:
-		strcat(filename, "GRV");
-		break;
-	case OP_GET:
-		strcat(filename, "GET");
-		break;
-	case OP_GETRANGE:
-		strcat(filename, "GETRANGE");
-		break;
-	case OP_SGET:
-		strcat(filename, "SGET");
-		break;
-	case OP_SGETRANGE:
-		strcat(filename, "SGETRANGE");
-		break;
-	case OP_UPDATE:
-		strcat(filename, "UPDATE");
-		break;
-	case OP_INSERT:
-		strcat(filename, "INSERT");
-		break;
-	case OP_INSERTRANGE:
-		strcat(filename, "INSERTRANGE");
-		break;
-	case OP_OVERWRITE:
-		strcat(filename, "OVERWRITE");
-		break;
-	case OP_CLEAR:
-		strcat(filename, "CLEAR");
-		break;
-	case OP_SETCLEAR:
-		strcat(filename, "SETCLEAR");
-		break;
-	case OP_CLEARRANGE:
-		strcat(filename, "CLEARRANGE");
-		break;
-	case OP_SETCLEARRANGE:
-		strcat(filename, "SETCLRRANGE");
-		break;
-	case OP_COMMIT:
-		strcat(filename, "COMMIT");
-		break;
-	case OP_TRANSACTION:
-		strcat(filename, "TRANSACTION");
-		break;
-	case OP_READ_BG:
-		strcat(filename, "READBLOBGRANULES");
-		break;
-	}
+std::string get_stats_file_name(std::string_view dirname,
+                                int worker_id, int thread_id, int op) {
+
+    return fmt::format("{}/{}_{}_{}",
+                       dirname, worker_id + 1, thread_id + 1, op_desc[op].name());
 }
 
 /* mako worker thread */
-void* worker_thread(void* thread_args) {
-	int worker_id = ((thread_args_t*)thread_args)->process->worker_id;
-	int thread_id = ((thread_args_t*)thread_args)->thread_id;
-	mako_args_t* args = ((thread_args_t*)thread_args)->process->args;
-	size_t database_index = ((thread_args_t*)thread_args)->database_index;
-	FDBDatabase* database = ((thread_args_t*)thread_args)->process->databases[database_index];
-	fdb_error_t err;
-	int rc;
-	FDBTransaction* transaction;
-	int thread_tps = 0;
-	int thread_iters = 0;
-	int op;
-	int i, size;
-	int dotrace = (worker_id == 0 && thread_id == 0 && args->txntrace) ? args->txntrace : 0;
-	int dotagging = args->txntagging;
-	volatile int* signal = &((thread_args_t*)thread_args)->process->shm->signal;
-	volatile double* throttle_factor = &((thread_args_t*)thread_args)->process->shm->throttle_factor;
-	volatile int* readycount = &((thread_args_t*)thread_args)->process->shm->readycount;
-	volatile int* stopcount = &((thread_args_t*)thread_args)->process->shm->stopcount;
-	mako_stats_t* stats = (void*)((thread_args_t*)thread_args)->process->shm + sizeof(mako_shmhdr_t) /* skip header */
-	                      + (sizeof(mako_stats_t) * (worker_id * args->num_threads + thread_id));
+void worker_thread(thread_args_t& thread_args) {
+    const auto& args = *thread_args.process->args;
+    const auto parent_id = thread_args.process->parent_id;
+    const auto worker_id = thread_args.process->worker_id;
+    const auto thread_id = thread_args.thread_id;
+    const auto dotrace = (worker_id == 0 && thread_id == 0 && args.txntrace) ? args.txntrace : 0;
+    const auto dotagging = args.txntagging;
+    const auto database_index = thread_args.database_index;
+    const auto& signal = thread_args.process->shm->signal;
+    const auto& throttle_factor = thread_args.process->shm->throttle_factor;
+    auto& readycount = thread_args.process->shm->readycount;
+    auto& stopcount = thread_args.process->shm->stopcount;
+    static_assert(std::is_same_v<
+            decltype(std::decay_t<decltype(*thread_args.process)>::shm), mako_shmhdr_t*>);
+    auto& stats = *(reinterpret_cast<mako_stats_t*>(thread_args.process->shm + 1)/* skip header */ +
+                    (worker_id * args.num_threads + thread_id));
 
-	lat_block_t* block[MAX_OP];
-	for (int i = 0; i < MAX_OP; i++) {
-		block[i] = ((thread_args_t*)thread_args)->block[i];
-	}
-	int* elem_size = &((thread_args_t*)thread_args)->elem_size[0];
-	pid_t* parent_id = &((thread_args_t*)thread_args)->process->parent_id;
-	bool* is_memory_allocated = &((thread_args_t*)thread_args)->is_memory_allocated[0];
+    /* init per-thread latency statistics */
+    new (&stats) mako_stats_t();
 
-	/* init latency */
-	for (op = 0; op < MAX_OP; op++) {
-		stats->latency_us_min[op] = 0xFFFFFFFFFFFFFFFF; /* uint64_t */
-		stats->latency_us_max[op] = 0;
-		stats->latency_us_total[op] = 0;
-		stats->latency_samples[op] = 0;
-	}
+    fmt::print(debugme,
+            "DEBUG: worker_id:{} ({}) thread_id:{} ({}) database_index:{} (tid:{})\n",
+            worker_id, args.num_processes, thread_id, args.num_threads,
+            database_index, fmt::ptr(pthread_self()));
 
-	fprintf(debugme,
-	        "DEBUG: worker_id:%d (%d) thread_id:%d (%d) database_index:%lu (tid:%" PRIu64 ")\n",
-	        worker_id,
-	        args->num_processes,
-	        thread_id,
-	        args->num_threads,
-	        database_index,
-	        (uint64_t)pthread_self());
+    const auto thread_tps =
+        args.tpsmax == 0 ? 0 :
+                           compute_thread_tps(args.tpsmax, worker_id, thread_id,
+                                              args.num_processes, args.num_threads);
 
-	if (args->tpsmax) {
-		thread_tps = compute_thread_tps(args->tpsmax, worker_id, thread_id, args->num_processes, args->num_threads);
-	}
+    const auto thread_iters =
+        args.iteration == 0 ? 0 :
+                              compute_thread_iters(args.iteration, worker_id, thread_id,
+                                                   args.num_processes, args.num_threads);
 
-	if (args->iteration) {
-		thread_iters =
-		    compute_thread_iters(args->iteration, worker_id, thread_id, args->num_processes, args->num_threads);
-	}
+    auto database = thread_args.process->databases[database_index];
+    /* create my own transaction object */
+    auto tx = database.create_tx();
 
-	/* create my own transaction object */
-	err = fdb_database_create_transaction(database, &transaction);
-	check_fdb_error(err);
+    /* i'm ready */
+    readycount.fetch_add(1);
+    auto stopcount_guard = exit_guard([&stopcount]() { stopcount.fetch_add(1); });
+    while (signal.load() == SIGNAL_OFF) {
+        usleep(10000); /* 10ms */
+    }
 
-	/* i'm ready */
-	__sync_fetch_and_add(readycount, 1);
-	while (*signal == SIGNAL_OFF) {
-		usleep(10000); /* 10ms */
-	}
+    auto& sample_bins = thread_args.sample_bins;
 
-	/* clean */
-	if (args->mode == MODE_CLEAN) {
-		rc = cleanup(transaction, args);
-		if (rc < 0) {
-			fprintf(stderr, "ERROR: cleanup failed\n");
-		}
-	}
+    if (args.mode == MODE_CLEAN) {
+        auto rc = cleanup(tx, args);
+        if (rc < 0) {
+            fmt::print(stderr, "ERROR: cleanup failed\n");
+        }
+    } else if (args.mode == MODE_BUILD) {
+        auto rc =
+            populate(tx, args, worker_id, thread_id, thread_tps, stats, sample_bins);
+        if (rc < 0) {
+            fmt::print(stderr, "ERROR: populate failed\n");
+        }
+    } else if (args.mode == MODE_RUN) {
+        auto rc = run_workload(tx,
+                               args,
+                               thread_tps,
+                               throttle_factor,
+                               thread_iters,
+                               signal,
+                               stats,
+                               sample_bins,
+                               dotrace,
+                               dotagging);
+        if (rc < 0) {
+            fmt::print(stderr, "ERROR: run_workload failed\n");
+        }
+    }
 
-	/* build/popualte */
-	else if (args->mode == MODE_BUILD) {
-		rc =
-		    populate(transaction, args, worker_id, thread_id, thread_tps, stats, block, elem_size, is_memory_allocated);
-		if (rc < 0) {
-			fprintf(stderr, "ERROR: populate failed\n");
-		}
-	}
-
-	/* run the workload */
-	else if (args->mode == MODE_RUN) {
-		rc = run_workload(transaction,
-		                  args,
-		                  thread_tps,
-		                  throttle_factor,
-		                  thread_iters,
-		                  signal,
-		                  stats,
-		                  dotrace,
-		                  dotagging,
-		                  block,
-		                  elem_size,
-		                  is_memory_allocated);
-		if (rc < 0) {
-			fprintf(stderr, "ERROR: run_workload failed\n");
-		}
-	}
-
-	if (args->mode == MODE_BUILD || args->mode == MODE_RUN) {
-		char str2[1000];
-		sprintf(str2, "%s%d", TEMP_DATA_STORE, *parent_id);
-		rc = mkdir(str2, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
-		if (rc < 0) {
-			int ec = errno;
-			fprintf(stderr, "Failed to make directory: %s because %s\n", str2, strerror(ec));
-			goto failExit;
-		}
-		for (op = 0; op < MAX_OP; op++) {
-			if (args->txnspec.ops[op][OP_COUNT] > 0 || op == OP_COMMIT || op == OP_TRANSACTION) {
-				FILE* fp;
-				char file_name[NAME_MAX] = { '\0' };
-				strcat(file_name, str2);
-				get_stats_file_name(file_name, worker_id, thread_id, op);
-				fp = fopen(file_name, "w");
-				if (!fp) {
-					int ec = errno;
-					fprintf(stderr, "Failed to open file: %s because %s\n", file_name, strerror(ec));
-					goto failExit;
-				}
-				lat_block_t* temp_block = ((thread_args_t*)thread_args)->block[op];
-				if (is_memory_allocated[op]) {
-					size = stats->latency_samples[op] / LAT_BLOCK_SIZE;
-					for (i = 0; i < size && temp_block != NULL; i++) {
-						fwrite(&temp_block->data, sizeof(uint64_t) * LAT_BLOCK_SIZE, 1, fp);
-						temp_block = temp_block->next_block;
-					}
-					size = stats->latency_samples[op] % LAT_BLOCK_SIZE;
-					if (size != 0)
-						fwrite(&temp_block->data, sizeof(uint64_t) * size, 1, fp);
-				} else {
-					while (temp_block) {
-						fwrite(&temp_block->data, sizeof(uint64_t) * LAT_BLOCK_SIZE, 1, fp);
-						temp_block = temp_block->next_block;
-					}
-				}
-				fclose(fp);
-			}
-		}
-	}
-
-	/* fall through */
-failExit:
-	__sync_fetch_and_add(stopcount, 1);
-	for (op = 0; op < MAX_OP; op++) {
-		lat_block_t* curr = ((thread_args_t*)thread_args)->block[op];
-		lat_block_t* prev = NULL;
-		size = elem_size[op] / LAT_BLOCK_SIZE;
-		while (size--) {
-			prev = curr;
-			curr = curr->next_block;
-			free(prev);
-		}
-	}
-	fdb_transaction_destroy(transaction);
-	pthread_exit(0);
+    if (args.mode == MODE_BUILD || args.mode == MODE_RUN) {
+        const auto dirname = fmt::format("{}{}", TEMP_DATA_STORE, parent_id);
+        const auto rc = mkdir(dirname.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
+        if (rc < 0) {
+            fmt::print(stderr, "ERROR: mkdir {}: {}\n", dirname, strerror(errno));
+            return;
+        }
+        for (auto op = 0; op < MAX_OP; op++) {
+            if (args.txnspec.ops[op][OP_COUNT] > 0 ||
+                op == OP_COMMIT || op == OP_TRANSACTION) {
+                const auto filename = get_stats_file_name(dirname, worker_id,
+                                                          thread_id, op);
+                auto fp = fopen(filename.c_str(), "w");
+                if (!fp) {
+                    fmt::print(stderr, "ERROR: fopen({}): {}\n", filename, strerror(errno));
+                    continue;
+                }
+                auto fclose_guard = exit_guard([fp]() { fclose(fp); });
+                thread_args.sample_bins[op].for_each_block(
+                        [fp](auto ptr, auto count) {
+                            fwrite(ptr, sizeof(*ptr) * count, 1, fp);
+                        });
+            }
+        }
+    }
 }
 
 /* mako worker process */
-int worker_process_main(mako_args_t* args, int worker_id, mako_shmhdr_t* shm, pid_t* pid_main) {
-	int i;
-	pthread_t network_thread; /* handle for thread which invoked fdb_run_network() */
-	pthread_t* worker_threads = NULL;
-#if FDB_API_VERSION < 610
-	FDBCluster* cluster;
-#endif
-	process_info_t process;
-	thread_args_t* thread_args = NULL;
-	int rc;
-	fdb_error_t err;
+int worker_process_main(mako_args_t& args, int worker_id, mako_shmhdr_t* shm, pid_t pid_main) {
+    process_info_t process;
 
-	process.worker_id = worker_id;
-	process.parent_id = *pid_main;
-	process.args = args;
-	process.shm = (mako_shmhdr_t*)shm;
+    process.worker_id = worker_id;
+    process.parent_id = pid_main;
+    process.args = &args;
+    process.shm = shm;
 
-	fprintf(debugme, "DEBUG: worker %d started\n", worker_id);
+    fmt::print(debugme, "DEBUG: worker {} started\n", worker_id);
 
-	/* Everything starts from here */
+    Error err;
+    /* Everything starts from here */
 
-	err = fdb_select_api_version(args->api_version);
-	if (err) {
-		fprintf(stderr, "ERROR: Failed at %s:%d (%s)\n", __FILE__, __LINE__, fdb_get_error(err));
-		return -1;
-	}
+    select_api_version(args.api_version);
 
-	/* enable flatbuffers if specified */
-	if (args->flatbuffers) {
+    /* enable flatbuffers if specified */
+    if (args.flatbuffers) {
 #ifdef FDB_NET_OPTION_USE_FLATBUFFERS
-		fprintf(debugme, "DEBUG: Using flatbuffers\n");
-		err = fdb_network_set_option(FDB_NET_OPTION_USE_FLATBUFFERS, (uint8_t*)&args->flatbuffers, sizeof(uint8_t));
-		if (err) {
-			fprintf(stderr, "ERROR: fdb_network_set_option(FDB_NET_OPTION_USE_FLATBUFFERS): %s\n", fdb_get_error(err));
-		}
+        fprintf(debugme, "DEBUG: Using flatbuffers\n");
+        err = network::set_option_nothrow(
+                    FDB_NET_OPTION_USE_FLATBUFFERS,
+                    BytesRef(&args.flatbuffers, sizeof(args.flatbuffers)));
+        if (err) {
+            fmt::print(stderr, "ERROR: network_set_option(USE_FLATBUFFERS): {}\n",
+                                err.what());
+        }
 #else
-		fprintf(printme, "INFO: flatbuffers is not supported in FDB API version %d\n", FDB_API_VERSION);
+        fmt::print(printme, "INFO: flatbuffers is not supported in FDB API version {}\n", FDB_API_VERSION);
 #endif
-	}
+    }
 
-	/* Set client Log group */
-	if (strlen(args->log_group) != 0) {
-		err =
-		    fdb_network_set_option(FDB_NET_OPTION_TRACE_LOG_GROUP, (uint8_t*)args->log_group, strlen(args->log_group));
-		if (err) {
-			fprintf(stderr, "ERROR: fdb_network_set_option(FDB_NET_OPTION_TRACE_LOG_GROUP): %s\n", fdb_get_error(err));
-		}
-	}
+    /* Set client Log group */
+    if (args.log_group[0] != '\0') {
+        err = network::set_option_nothrow(FDB_NET_OPTION_TRACE_LOG_GROUP,
+                                          BytesRef(to_byte_ptr(args.log_group)));
+        if (err) {
+            fmt::print(stderr, "ERROR: fdb_network_set_option(FDB_NET_OPTION_TRACE_LOG_GROUP): {}\n", err.what());
+        }
+    }
 
-	/* enable tracing if specified */
-	if (args->trace) {
-		fprintf(debugme,
-		        "DEBUG: Enable Tracing in %s (%s)\n",
-		        (args->traceformat == 0) ? "XML" : "JSON",
-		        (args->tracepath[0] == '\0') ? "current directory" : args->tracepath);
-		err = fdb_network_set_option(FDB_NET_OPTION_TRACE_ENABLE, (uint8_t*)args->tracepath, strlen(args->tracepath));
-		if (err) {
-			fprintf(stderr, "ERROR: fdb_network_set_option(FDB_NET_OPTION_TRACE_ENABLE): %s\n", fdb_get_error(err));
-		}
-		if (args->traceformat == 1) {
-			err = fdb_network_set_option(FDB_NET_OPTION_TRACE_FORMAT, (uint8_t*)"json", 4);
-			if (err) {
-				fprintf(stderr, "ERROR: fdb_network_set_option(FDB_NET_OPTION_TRACE_FORMAT): %s\n", fdb_get_error(err));
-			}
-		}
-	}
+    /* enable tracing if specified */
+    if (args.trace) {
+        fmt::print(debugme,
+                   "DEBUG: Enable Tracing in {} ({})\n",
+                   (args.traceformat == 0) ? "XML" : "JSON",
+                   (args.tracepath[0] == '\0') ? "current directory" : args.tracepath);
+        err = network::set_option_nothrow(FDB_NET_OPTION_TRACE_ENABLE,
+                                          BytesRef(to_byte_ptr(args.tracepath)));
+        if (err) {
+            fmt::print(stderr, "ERROR: network_set_option(TRACE_ENABLE): {}\n", err.what());
+        }
+        if (args.traceformat == 1) {
+            err = network::set_option_nothrow(FDB_NET_OPTION_TRACE_FORMAT,
+                                              BytesRef(to_byte_ptr("json")));
+            if (err) {
+                fmt::print(stderr,
+                           "ERROR: fdb_network_set_option(FDB_NET_OPTION_TRACE_FORMAT): {}\n", err.what());
+            }
+        }
+    }
 
-	/* enable knobs if specified */
-	if (args->knobs[0] != '\0') {
-		char delim[] = ", ";
-		char* knob = strtok(args->knobs, delim);
-		while (knob != NULL) {
-			fprintf(debugme, "DEBUG: Setting client knobs: %s\n", knob);
-			err = fdb_network_set_option(FDB_NET_OPTION_KNOB, (uint8_t*)knob, strlen(knob));
-			if (err) {
-				fprintf(stderr, "ERROR: fdb_network_set_option: %s\n", fdb_get_error(err));
-			}
-			knob = strtok(NULL, delim);
-		}
-	}
+    /* enable knobs if specified */
+    if (args.knobs[0] != '\0') {
+        char delim[] = ", ";
+        auto knob = strtok(args.knobs, delim);
+        while (knob != NULL) {
+            fmt::print(debugme, "DEBUG: Setting client knobs: {}\n", knob);
+            err = network::set_option_nothrow(FDB_NET_OPTION_KNOB,
+                                              BytesRef(to_byte_ptr(knob)));
+            if (err) {
+                fmt::print(stderr, "ERROR: fdb_network_set_option: {}\n", err.what());
+            }
+            knob = strtok(NULL, delim);
+        }
+    }
 
-	if (args->client_threads_per_version > 0) {
-		err = fdb_network_set_option(
-		    FDB_NET_OPTION_CLIENT_THREADS_PER_VERSION, (uint8_t*)&args->client_threads_per_version, sizeof(int64_t));
-		if (err) {
-			fprintf(stderr,
-			        "ERROR: fdb_network_set_option (FDB_NET_OPTION_CLIENT_THREADS_PER_VERSION) (%d): %s\n",
-			        args->client_threads_per_version,
-			        fdb_get_error(err));
-			// let's exit here since we do not want to confuse users
-			// that mako is running with multi-threaded client enabled
-			return -1;
-		}
-	}
+    if (args.client_threads_per_version > 0) {
+        err = network::set_option_nothrow(
+            FDB_NET_OPTION_CLIENT_THREADS_PER_VERSION,
+            args.client_threads_per_version);
+        if (err) {
+            fmt::print(stderr,
+                       "ERROR: fdb_network_set_option (FDB_NET_OPTION_CLIENT_THREADS_PER_VERSION) ({}): {}\n",
+                       args.client_threads_per_version,
+                       err.what());
+            // let's exit here since we do not want to confuse users
+            // that mako is running with multi-threaded client enabled
+            return -1;
+        }
+    }
 
-	/* Network thread must be setup before doing anything */
-	fprintf(debugme, "DEBUG: fdb_setup_network\n");
-	err = fdb_setup_network();
-	if (err) {
-		fprintf(stderr, "ERROR: Failed at %s:%d (%s)\n", __FILE__, __LINE__, fdb_get_error(err));
-		return -1;
-	}
+    /* Network thread must be setup before doing anything */
+    fprintf(debugme, "DEBUG: fdb_setup_network\n");
+    network::setup();
 
-	/* Each worker process will have its own network thread */
-	fprintf(debugme, "DEBUG: creating network thread\n");
-	rc = pthread_create(&network_thread, NULL, fdb_network_thread, (void*)args);
-	if (rc != 0) {
-		fprintf(stderr, "ERROR: Cannot create a network thread\n");
-		return -1;
-	}
+    /* Each worker process will have its own network thread */
+    fprintf(debugme, "DEBUG: creating network thread\n");
+    auto network_thread = std::thread([]() {
+            fmt::print(debugme, "DEBUG: network thread started\n");
+            if (auto err = network::run()) {
+                fmt::print(stderr, "ERROR: fdb_run_network: {}\n", err.what());
+            }
+        });
 
-	/*** let's party! ***/
+    /*** let's party! ***/
 
-	/* set up cluster and datbase for worker threads */
+    /* set up database for worker threads */
+    for (auto i = 0; i < args.num_databases; i++) {
+        size_t cluster_index = args.num_fdb_clusters <= 1 ? 0 : i % args.num_fdb_clusters;
+        process.databases.emplace_back(Database(args.cluster_files[cluster_index]));
+        fmt::print(debugme, "DEBUG: creating database at cluster {}\n", args.cluster_files[cluster_index]);
+        if (args.disable_ryw) {
+            process.databases.back().set_option(FDB_DB_OPTION_SNAPSHOT_RYW_DISABLE, BytesRef{});
+        }
+    }
 
-#if FDB_API_VERSION < 610
-	/* cluster */
-	f = fdb_create_cluster(args->cluster_file);
-	fdb_block_wait(f);
-	err = fdb_future_get_cluster(f, &cluster);
-	check_fdb_error(err);
-	fdb_future_destroy(f);
+    fmt::print(debugme, "DEBUG: creating {} worker threads\n", args.num_threads);
+    auto worker_threads = std::vector<std::thread>(args.num_threads);
 
-	/* database */
-	/* big mystery -- do we ever have a database named other than "DB"? */
-	f = fdb_cluster_create_database(cluster, (uint8_t*)"DB", 2);
-	fdb_block_wait(f);
-	err = fdb_future_get_database(f, &process.database);
-	check_fdb_error(err);
-	fdb_future_destroy(f);
+    /* spawn worker threads */
+    auto thread_args = std::vector<thread_args_t>(args.num_threads);
 
-#else /* >= 610 */
-	for (size_t i = 0; i < args->num_databases; i++) {
-		size_t cluster_index = args->num_fdb_clusters <= 1 ? 0 : i % args->num_fdb_clusters;
-		fdb_create_database(args->cluster_files[cluster_index], &process.databases[i]);
-		fprintf(debugme, "DEBUG: creating database at cluster %s\n", args->cluster_files[cluster_index]);
-		if (args->disable_ryw) {
-			fdb_database_set_option(process.databases[i], FDB_DB_OPTION_SNAPSHOT_RYW_DISABLE, (uint8_t*)NULL, 0);
-		}
-	}
-#endif
+    for (auto i = 0; i < args.num_threads; i++) {
+        auto& this_args = thread_args[i];
+        this_args.thread_id = i;
+        this_args.database_index = i % args.num_databases;
 
-	fprintf(debugme, "DEBUG: creating %d worker threads\n", args->num_threads);
-	worker_threads = (pthread_t*)calloc(sizeof(pthread_t), args->num_threads);
-	if (!worker_threads) {
-		fprintf(stderr, "ERROR: cannot allocate worker_threads\n");
-		goto failExit;
-	}
+        /* for ops to run, pre-allocate one latency sample block */
+        for (int op = 0; op < MAX_OP; op++) {
+            if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
+                this_args.sample_bins[op].reserve_one();
+            }
+        }
+        this_args.process = &process;
+        worker_threads[i] = std::thread(worker_thread, std::ref(this_args));
+    }
 
-	/* spawn worker threads */
-	thread_args = (thread_args_t*)calloc(sizeof(thread_args_t), args->num_threads);
-	if (!thread_args) {
-		fprintf(stderr, "ERROR: cannot allocate thread_args\n");
-		goto failExit;
-	}
+    /*** party is over ***/
 
-	for (i = 0; i < args->num_threads; i++) {
-		thread_args[i].thread_id = i;
-		thread_args[i].database_index = i % args->num_databases;
+    /* wait for everyone to finish */
+    for (auto i = 0; i < args.num_threads; i++) {
+        fmt::print(debugme, "DEBUG: worker_thread {} joining\n", i);
+        worker_threads[i].join();
+    }
 
-		for (int op = 0; op < MAX_OP; op++) {
-			if (args->txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-				thread_args[i].block[op] = (lat_block_t*)malloc(sizeof(lat_block_t));
-				if (thread_args[i].block[op] == NULL) {
-					thread_args[i].is_memory_allocated[op] = false;
-					thread_args[i].elem_size[op] = 0;
-				} else {
-					thread_args[i].is_memory_allocated[op] = true;
-					thread_args[i].block[op]->next_block = NULL;
-					thread_args[i].elem_size[op] = LAT_BLOCK_SIZE;
-				}
-			}
-		}
-		thread_args[i].process = &process;
-		rc = pthread_create(&worker_threads[i], NULL, worker_thread, (void*)&thread_args[i]);
-		if (rc != 0) {
-			fprintf(stderr, "ERROR: cannot create a new worker thread %d\n", i);
-			/* ignore this thread? */
-		}
-	}
+    /* stop the network thread */
+    fmt::print(debugme, "DEBUG: fdb_stop_network\n");
+    err = network::stop();
+    if (err) {
+        fmt::print(stderr, "ERROR: stop_network(): {}\n", err.what());
+    }
 
-	/*** party is over ***/
+    /* wait for the network thread to join */
+    fmt::print(debugme, "DEBUG: network_thread joining\n");
+    network_thread.join();
 
-	/* wait for everyone to finish */
-	for (i = 0; i < args->num_threads; i++) {
-		fprintf(debugme, "DEBUG: worker_thread %d joining\n", i);
-		rc = pthread_join(worker_threads[i], NULL);
-		if (rc != 0) {
-			fprintf(stderr, "ERROR: threads %d failed to join\n", i);
-		}
-	}
-
-failExit:
-	if (worker_threads)
-		free(worker_threads);
-	if (thread_args)
-		free(thread_args);
-
-	/* clean up database and cluster */
-	for (size_t i = 0; i < args->num_databases; i++) {
-		fdb_database_destroy(process.databases[i]);
-	}
-
-#if FDB_API_VERSION < 610
-	fdb_cluster_destroy(cluster);
-#endif
-
-	/* stop the network thread */
-	fprintf(debugme, "DEBUG: fdb_stop_network\n");
-	err = fdb_stop_network();
-	check_fdb_error(err);
-
-	/* wait for the network thread to join */
-	fprintf(debugme, "DEBUG: network_thread joining\n");
-	rc = pthread_join(network_thread, NULL);
-	if (rc != 0) {
-		fprintf(stderr, "ERROR: network thread failed to join\n");
-	}
-
-	return 0;
+    return 0;
 }
 
 /* initialize the parameters with default values */
 int init_args(mako_args_t* args) {
-	int i;
-	if (!args)
-		return -1;
-	memset(args, 0, sizeof(mako_args_t)); /* zero-out everything */
-	args->num_fdb_clusters = 0;
-	args->num_databases = 1;
-	args->api_version = fdb_get_max_api_version();
-	args->json = 0;
-	args->num_processes = 1;
-	args->num_threads = 1;
-	args->mode = MODE_INVALID;
-	args->rows = 100000;
-	args->seconds = 30;
-	args->iteration = 0;
-	args->tpsmax = 0;
-	args->tpsmin = -1;
-	args->tpsinterval = 10;
-	args->tpschange = TPS_SIN;
-	args->sampling = 1000;
-	args->key_length = 32;
-	args->value_length = 16;
-	args->zipf = 0;
-	args->commit_get = 0;
-	args->verbose = 1;
-	args->flatbuffers = 0; /* internal */
-	args->knobs[0] = '\0';
-	args->log_group[0] = '\0';
-	args->prefixpadding = 0;
-	args->trace = 0;
-	args->tracepath[0] = '\0';
-	args->traceformat = 0; /* default to client's default (XML) */
-	args->streaming_mode = FDB_STREAMING_MODE_WANT_ALL;
-	args->txntrace = 0;
-	args->txntagging = 0;
-	memset(args->txntagging_prefix, 0, TAGPREFIXLENGTH_MAX);
-	for (i = 0; i < MAX_OP; i++) {
-		args->txnspec.ops[i][OP_COUNT] = 0;
-	}
-	args->client_threads_per_version = 0;
-	args->disable_ryw = 0;
-	args->json_output_path[0] = '\0';
-	args->bg_materialize_files = false;
-	args->bg_file_path[0] = '\0';
-	return 0;
+    int i;
+    if (!args)
+        return -1;
+    memset(args, 0, sizeof(mako_args_t)); /* zero-out everything */
+    args->num_fdb_clusters = 0;
+    args->num_databases = 1;
+    args->api_version = max_api_version();
+    args->json = 0;
+    args->num_processes = 1;
+    args->num_threads = 1;
+    args->mode = MODE_INVALID;
+    args->rows = 100000;
+    args->row_digits = digits(args->rows);
+    args->seconds = 30;
+    args->iteration = 0;
+    args->tpsmax = 0;
+    args->tpsmin = -1;
+    args->tpsinterval = 10;
+    args->tpschange = TPS_SIN;
+    args->sampling = 1000;
+    args->key_length = 32;
+    args->value_length = 16;
+    args->zipf = 0;
+    args->commit_get = 0;
+    args->verbose = 1;
+    args->flatbuffers = 0; /* internal */
+    args->knobs[0] = '\0';
+    args->log_group[0] = '\0';
+    args->prefixpadding = 0;
+    args->trace = 0;
+    args->tracepath[0] = '\0';
+    args->traceformat = 0; /* default to client's default (XML) */
+    args->streaming_mode = FDB_STREAMING_MODE_WANT_ALL;
+    args->txntrace = 0;
+    args->txntagging = 0;
+    memset(args->txntagging_prefix, 0, TAGPREFIXLENGTH_MAX);
+    for (i = 0; i < MAX_OP; i++) {
+        args->txnspec.ops[i][OP_COUNT] = 0;
+    }
+    args->client_threads_per_version = 0;
+    args->disable_ryw = 0;
+    args->json_output_path[0] = '\0';
+    args->bg_materialize_files = false;
+    args->bg_file_path[0] = '\0';
+    return 0;
 }
 
 /* parse transaction specification */
-int parse_transaction(mako_args_t* args, char* optarg) {
-	char* ptr = optarg;
-	int op = 0;
-	int rangeop = 0;
-	int num;
-	int error = 0;
+int parse_transaction(mako_args_t* args, char const* optarg) {
+    char const* ptr = optarg;
+    int op = 0;
+    int rangeop = 0;
+    int num;
+    int error = 0;
 
-	for (op = 0; op < MAX_OP; op++) {
-		args->txnspec.ops[op][OP_COUNT] = 0;
-		args->txnspec.ops[op][OP_RANGE] = 0;
-	}
+    for (op = 0; op < MAX_OP; op++) {
+        args->txnspec.ops[op][OP_COUNT] = 0;
+        args->txnspec.ops[op][OP_RANGE] = 0;
+    }
 
-	op = 0;
-	while (*ptr) {
+    op = 0;
+    while (*ptr) {
 // Clang gives false positive array bounds warning, which must be ignored:
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Warray-bounds"
-		if (strncmp(ptr, "grv", 3) == 0) {
-			op = OP_GETREADVERSION;
-			ptr += 3;
-		} else if (strncmp(ptr, "gr", 2) == 0) {
-			op = OP_GETRANGE;
-			rangeop = 1;
-			ptr += 2;
-		} else if (strncmp(ptr, "g", 1) == 0) {
-			op = OP_GET;
-			ptr++;
-		} else if (strncmp(ptr, "sgr", 3) == 0) {
-			op = OP_SGETRANGE;
-			rangeop = 1;
-			ptr += 3;
-		} else if (strncmp(ptr, "sg", 2) == 0) {
-			op = OP_SGET;
-			ptr += 2;
-		} else if (strncmp(ptr, "u", 1) == 0) {
-			op = OP_UPDATE;
-			ptr++;
-		} else if (strncmp(ptr, "ir", 2) == 0) {
-			op = OP_INSERTRANGE;
-			rangeop = 1;
-			ptr += 2;
-		} else if (strncmp(ptr, "i", 1) == 0) {
-			op = OP_INSERT;
-			ptr++;
-		} else if (strncmp(ptr, "o", 1) == 0) {
-			op = OP_OVERWRITE;
-			ptr++;
-		} else if (strncmp(ptr, "cr", 2) == 0) {
-			op = OP_CLEARRANGE;
-			rangeop = 1;
-			ptr += 2;
-		} else if (strncmp(ptr, "c", 1) == 0) {
-			op = OP_CLEAR;
-			ptr++;
-		} else if (strncmp(ptr, "scr", 3) == 0) {
-			op = OP_SETCLEARRANGE;
-			rangeop = 1;
-			ptr += 3;
-		} else if (strncmp(ptr, "sc", 2) == 0) {
-			op = OP_SETCLEAR;
-			ptr += 2;
-		} else if (strncmp(ptr, "bg", 2) == 0) {
-			op = OP_READ_BG;
-			rangeop = 1;
-			ptr += 2;
-		} else {
-			fprintf(debugme, "Error: Invalid transaction spec: %s\n", ptr);
-			error = 1;
-			break;
-		}
+        if (strncmp(ptr, "grv", 3) == 0) {
+            op = OP_GETREADVERSION;
+            ptr += 3;
+        } else if (strncmp(ptr, "gr", 2) == 0) {
+            op = OP_GETRANGE;
+            rangeop = 1;
+            ptr += 2;
+        } else if (strncmp(ptr, "g", 1) == 0) {
+            op = OP_GET;
+            ptr++;
+        } else if (strncmp(ptr, "sgr", 3) == 0) {
+            op = OP_SGETRANGE;
+            rangeop = 1;
+            ptr += 3;
+        } else if (strncmp(ptr, "sg", 2) == 0) {
+            op = OP_SGET;
+            ptr += 2;
+        } else if (strncmp(ptr, "u", 1) == 0) {
+            op = OP_UPDATE;
+            ptr++;
+        } else if (strncmp(ptr, "ir", 2) == 0) {
+            op = OP_INSERTRANGE;
+            rangeop = 1;
+            ptr += 2;
+        } else if (strncmp(ptr, "i", 1) == 0) {
+            op = OP_INSERT;
+            ptr++;
+        } else if (strncmp(ptr, "cr", 2) == 0) {
+            op = OP_CLEARRANGE;
+            rangeop = 1;
+            ptr += 2;
+        } else if (strncmp(ptr, "c", 1) == 0) {
+            op = OP_CLEAR;
+            ptr++;
+        } else if (strncmp(ptr, "scr", 3) == 0) {
+            op = OP_SETCLEARRANGE;
+            rangeop = 1;
+            ptr += 3;
+        } else if (strncmp(ptr, "sc", 2) == 0) {
+            op = OP_SETCLEAR;
+            ptr += 2;
+        } else if (strncmp(ptr, "bg", 2) == 0) {
+            op = OP_READ_BG;
+            rangeop = 1;
+            ptr += 2;
+        } else {
+            fprintf(debugme, "Error: Invalid transaction spec: %s\n", ptr);
+            error = 1;
+            break;
+        }
 #pragma clang diagnostic pop
 
-		/* count */
-		num = 0;
-		if ((*ptr < '0') || (*ptr > '9')) {
-			num = 1; /* if omitted, set it to 1 */
-		} else {
-			while ((*ptr >= '0') && (*ptr <= '9')) {
-				num = num * 10 + *ptr - '0';
-				ptr++;
-			}
-		}
-		/* set count */
-		args->txnspec.ops[op][OP_COUNT] = num;
+        /* count */
+        num = 0;
+        if ((*ptr < '0') || (*ptr > '9')) {
+            num = 1; /* if omitted, set it to 1 */
+        } else {
+            while ((*ptr >= '0') && (*ptr <= '9')) {
+                num = num * 10 + *ptr - '0';
+                ptr++;
+            }
+        }
+        /* set count */
+        args->txnspec.ops[op][OP_COUNT] = num;
 
-		if (rangeop) {
-			if (*ptr != ':') {
-				error = 1;
-				break;
-			} else {
-				ptr++; /* skip ':' */
-				/* check negative '-' sign */
-				if (*ptr == '-') {
-					args->txnspec.ops[op][OP_REVERSE] = 1;
-					ptr++;
-				} else {
-					args->txnspec.ops[op][OP_REVERSE] = 0;
-				}
-				num = 0;
-				if ((*ptr < '0') || (*ptr > '9')) {
-					error = 1;
-					break;
-				}
-				while ((*ptr >= '0') && (*ptr <= '9')) {
-					num = num * 10 + *ptr - '0';
-					ptr++;
-				}
-				/* set range */
-				args->txnspec.ops[op][OP_RANGE] = num;
-			}
-		}
-		rangeop = 0;
-	}
+        if (rangeop) {
+            if (*ptr != ':') {
+                error = 1;
+                break;
+            } else {
+                ptr++; /* skip ':' */
+                /* check negative '-' sign */
+                if (*ptr == '-') {
+                    args->txnspec.ops[op][OP_REVERSE] = 1;
+                    ptr++;
+                } else {
+                    args->txnspec.ops[op][OP_REVERSE] = 0;
+                }
+                num = 0;
+                if ((*ptr < '0') || (*ptr > '9')) {
+                    error = 1;
+                    break;
+                }
+                while ((*ptr >= '0') && (*ptr <= '9')) {
+                    num = num * 10 + *ptr - '0';
+                    ptr++;
+                }
+                /* set range */
+                args->txnspec.ops[op][OP_RANGE] = num;
+            }
+        }
+        rangeop = 0;
+    }
 
-	if (error) {
-		fprintf(stderr, "ERROR: invalid transaction specification %s\n", optarg);
-		return -1;
-	}
+    if (error) {
+        fprintf(stderr, "ERROR: invalid transaction specification %s\n", optarg);
+        return -1;
+    }
 
-	if (args->verbose == VERBOSE_DEBUG) {
-		for (op = 0; op < MAX_OP; op++) {
-			fprintf(debugme, "DEBUG: OP: %d: %d: %d\n", op, args->txnspec.ops[op][0], args->txnspec.ops[op][1]);
-		}
-	}
+    if (args->verbose == VERBOSE_DEBUG) {
+        for (op = 0; op < MAX_OP; op++) {
+            fprintf(debugme, "DEBUG: OP: %d: %d: %d\n", op, args->txnspec.ops[op][0], args->txnspec.ops[op][1]);
+        }
+    }
 
-	return 0;
+    return 0;
 }
 
 void usage() {
-	printf("Usage:\n");
-	printf("%-24s %s\n", "-h, --help", "Print this message");
-	printf("%-24s %s\n", "    --version", "Print FDB version");
-	printf("%-24s %s\n", "-v, --verbose", "Specify verbosity");
-	printf("%-24s %s\n", "-a, --api_version=API_VERSION", "Specify API_VERSION to use");
-	printf("%-24s %s\n", "-c, --cluster=FILE", "Specify FDB cluster file");
-	printf("%-24s %s\n", "-d, --num_databases=NUM_DATABASES", "Specify number of databases");
-	printf("%-24s %s\n", "-p, --procs=PROCS", "Specify number of worker processes");
-	printf("%-24s %s\n", "-t, --threads=THREADS", "Specify number of worker threads");
-	printf("%-24s %s\n", "-r, --rows=ROWS", "Specify number of records");
-	printf("%-24s %s\n", "-s, --seconds=SECONDS", "Specify the test duration in seconds\n");
-	printf("%-24s %s\n", "", "This option cannot be specified with --iteration.");
-	printf("%-24s %s\n", "-i, --iteration=ITERS", "Specify the number of iterations.\n");
-	printf("%-24s %s\n", "", "This option cannot be specified with --seconds.");
-	printf("%-24s %s\n", "    --keylen=LENGTH", "Specify the key lengths");
-	printf("%-24s %s\n", "    --vallen=LENGTH", "Specify the value lengths");
-	printf("%-24s %s\n", "-x, --transaction=SPEC", "Transaction specification");
-	printf("%-24s %s\n", "    --tps|--tpsmax=TPS", "Specify the target max TPS");
-	printf("%-24s %s\n", "    --tpsmin=TPS", "Specify the target min TPS");
-	printf("%-24s %s\n", "    --tpsinterval=SEC", "Specify the TPS change interval (Default: 10 seconds)");
-	printf("%-24s %s\n", "    --tpschange=<sin|square|pulse>", "Specify the TPS change type (Default: sin)");
-	printf("%-24s %s\n", "    --sampling=RATE", "Specify the sampling rate for latency stats");
-	printf("%-24s %s\n", "-m, --mode=MODE", "Specify the mode (build, run, clean)");
-	printf("%-24s %s\n", "-z, --zipf", "Use zipfian distribution instead of uniform distribution");
-	printf("%-24s %s\n", "    --commitget", "Commit GETs");
-	printf("%-24s %s\n", "    --loggroup=LOGGROUP", "Set client log group");
-	printf("%-24s %s\n", "    --prefix_padding", "Pad key by prefixing data (Default: postfix padding)");
-	printf("%-24s %s\n", "    --trace", "Enable tracing");
-	printf("%-24s %s\n", "    --tracepath=PATH", "Set trace file path");
-	printf("%-24s %s\n", "    --trace_format <xml|json>", "Set trace format (Default: json)");
-	printf("%-24s %s\n", "    --txntrace=sec", "Specify transaction tracing interval (Default: 0)");
-	printf(
-	    "%-24s %s\n", "    --txntagging", "Specify the number of different transaction tag (Default: 0, max = 1000)");
-	printf("%-24s %s\n",
-	       "    --txntagging_prefix",
-	       "Specify the prefix of transaction tag - mako${txntagging_prefix} (Default: '')");
-	printf("%-24s %s\n", "    --knobs=KNOBS", "Set client knobs");
-	printf("%-24s %s\n", "    --flatbuffers", "Use flatbuffers");
-	printf("%-24s %s\n", "    --streaming", "Streaming mode: all (default), iterator, small, medium, large, serial");
-	printf("%-24s %s\n", "    --disable_ryw", "Disable snapshot read-your-writes");
-	printf("%-24s %s\n", "    --json_report=PATH", "Output stats to the specified json file (Default: mako.json)");
-	printf("%-24s %s\n",
-	       "    --bg_file_path=PATH",
-	       "Read blob granule files from the local filesystem at PATH and materialize the results.");
+    printf("Usage:\n");
+    printf("%-24s %s\n", "-h, --help", "Print this message");
+    printf("%-24s %s\n", "    --version", "Print FDB version");
+    printf("%-24s %s\n", "-v, --verbose", "Specify verbosity");
+    printf("%-24s %s\n", "-a, --api_version=API_VERSION", "Specify API_VERSION to use");
+    printf("%-24s %s\n", "-c, --cluster=FILE", "Specify FDB cluster file");
+    printf("%-24s %s\n", "-d, --num_databases=NUM_DATABASES", "Specify number of databases");
+    printf("%-24s %s\n", "-p, --procs=PROCS", "Specify number of worker processes");
+    printf("%-24s %s\n", "-t, --threads=THREADS", "Specify number of worker threads");
+    printf("%-24s %s\n", "-r, --rows=ROWS", "Specify number of records");
+    printf("%-24s %s\n", "-s, --seconds=SECONDS", "Specify the test duration in seconds\n");
+    printf("%-24s %s\n", "", "This option cannot be specified with --iteration.");
+    printf("%-24s %s\n", "-i, --iteration=ITERS", "Specify the number of iterations.\n");
+    printf("%-24s %s\n", "", "This option cannot be specified with --seconds.");
+    printf("%-24s %s\n", "    --keylen=LENGTH", "Specify the key lengths");
+    printf("%-24s %s\n", "    --vallen=LENGTH", "Specify the value lengths");
+    printf("%-24s %s\n", "-x, --transaction=SPEC", "Transaction specification");
+    printf("%-24s %s\n", "    --tps|--tpsmax=TPS", "Specify the target max TPS");
+    printf("%-24s %s\n", "    --tpsmin=TPS", "Specify the target min TPS");
+    printf("%-24s %s\n", "    --tpsinterval=SEC", "Specify the TPS change interval (Default: 10 seconds)");
+    printf("%-24s %s\n", "    --tpschange=<sin|square|pulse>", "Specify the TPS change type (Default: sin)");
+    printf("%-24s %s\n", "    --sampling=RATE", "Specify the sampling rate for latency stats");
+    printf("%-24s %s\n", "-m, --mode=MODE", "Specify the mode (build, run, clean)");
+    printf("%-24s %s\n", "-z, --zipf", "Use zipfian distribution instead of uniform distribution");
+    printf("%-24s %s\n", "    --commitget", "Commit GETs");
+    printf("%-24s %s\n", "    --loggroup=LOGGROUP", "Set client log group");
+    printf("%-24s %s\n", "    --prefix_padding", "Pad key by prefixing data (Default: postfix padding)");
+    printf("%-24s %s\n", "    --trace", "Enable tracing");
+    printf("%-24s %s\n", "    --tracepath=PATH", "Set trace file path");
+    printf("%-24s %s\n", "    --trace_format <xml|json>", "Set trace format (Default: json)");
+    printf("%-24s %s\n", "    --txntrace=sec", "Specify transaction tracing interval (Default: 0)");
+    printf(
+        "%-24s %s\n", "    --txntagging", "Specify the number of different transaction tag (Default: 0, max = 1000)");
+    printf("%-24s %s\n",
+           "    --txntagging_prefix",
+           "Specify the prefix of transaction tag - mako${txntagging_prefix} (Default: '')");
+    printf("%-24s %s\n", "    --knobs=KNOBS", "Set client knobs");
+    printf("%-24s %s\n", "    --flatbuffers", "Use flatbuffers");
+    printf("%-24s %s\n", "    --streaming", "Streaming mode: all (default), iterator, small, medium, large, serial");
+    printf("%-24s %s\n", "    --disable_ryw", "Disable snapshot read-your-writes");
+    printf("%-24s %s\n", "    --json_report=PATH", "Output stats to the specified json file (Default: mako.json)");
+    printf("%-24s %s\n",
+           "    --bg_file_path=PATH",
+           "Read blob granule files from the local filesystem at PATH and materialize the results.");
 }
 
 /* parse benchmark paramters */
 int parse_args(int argc, char* argv[], mako_args_t* args) {
-	int rc;
-	int c;
-	int idx;
-	while (1) {
-		const char* short_options = "a:c:d:p:t:r:s:i:x:v:m:hz";
-		static struct option long_options[] = {
-			/* name, has_arg, flag, val */
-			{ "api_version", required_argument, NULL, 'a' },
-			{ "cluster", required_argument, NULL, 'c' },
-			{ "num_databases", optional_argument, NULL, 'd' },
-			{ "procs", required_argument, NULL, 'p' },
-			{ "threads", required_argument, NULL, 't' },
-			{ "rows", required_argument, NULL, 'r' },
-			{ "seconds", required_argument, NULL, 's' },
-			{ "iteration", required_argument, NULL, 'i' },
-			{ "keylen", required_argument, NULL, ARG_KEYLEN },
-			{ "vallen", required_argument, NULL, ARG_VALLEN },
-			{ "transaction", required_argument, NULL, 'x' },
-			{ "tps", required_argument, NULL, ARG_TPS },
-			{ "tpsmax", required_argument, NULL, ARG_TPSMAX },
-			{ "tpsmin", required_argument, NULL, ARG_TPSMIN },
-			{ "tpsinterval", required_argument, NULL, ARG_TPSINTERVAL },
-			{ "tpschange", required_argument, NULL, ARG_TPSCHANGE },
-			{ "sampling", required_argument, NULL, ARG_SAMPLING },
-			{ "verbose", required_argument, NULL, 'v' },
-			{ "mode", required_argument, NULL, 'm' },
-			{ "knobs", required_argument, NULL, ARG_KNOBS },
-			{ "loggroup", required_argument, NULL, ARG_LOGGROUP },
-			{ "tracepath", required_argument, NULL, ARG_TRACEPATH },
-			{ "trace_format", required_argument, NULL, ARG_TRACEFORMAT },
-			{ "streaming", required_argument, NULL, ARG_STREAMING_MODE },
-			{ "txntrace", required_argument, NULL, ARG_TXNTRACE },
-			/* no args */
-			{ "help", no_argument, NULL, 'h' },
-			{ "zipf", no_argument, NULL, 'z' },
-			{ "commitget", no_argument, NULL, ARG_COMMITGET },
-			{ "flatbuffers", no_argument, NULL, ARG_FLATBUFFERS },
-			{ "prefix_padding", no_argument, NULL, ARG_PREFIXPADDING },
-			{ "trace", no_argument, NULL, ARG_TRACE },
-			{ "txntagging", required_argument, NULL, ARG_TXNTAGGING },
-			{ "txntagging_prefix", required_argument, NULL, ARG_TXNTAGGINGPREFIX },
-			{ "version", no_argument, NULL, ARG_VERSION },
-			{ "client_threads_per_version", required_argument, NULL, ARG_CLIENT_THREADS_PER_VERSION },
-			{ "disable_ryw", no_argument, NULL, ARG_DISABLE_RYW },
-			{ "json_report", optional_argument, NULL, ARG_JSON_REPORT },
-			{ "bg_file_path", required_argument, NULL, ARG_BG_FILE_PATH },
-			{ NULL, 0, NULL, 0 }
-		};
-		idx = 0;
-		c = getopt_long(argc, argv, short_options, long_options, &idx);
-		if (c < 0) {
-			break;
-		}
-		switch (c) {
-		case '?':
-		case 'h':
-			usage();
-			return -1;
-		case 'a':
-			args->api_version = atoi(optarg);
-			break;
-		case 'c': {
-			const char delim[] = ",";
-			char* cluster_file = strtok(optarg, delim);
-			while (cluster_file != NULL) {
-				strcpy(args->cluster_files[args->num_fdb_clusters++], cluster_file);
-				cluster_file = strtok(NULL, delim);
-			}
-			break;
-		}
-		case 'd':
-			args->num_databases = atoi(optarg);
-			break;
-		case 'p':
-			args->num_processes = atoi(optarg);
-			break;
-		case 't':
-			args->num_threads = atoi(optarg);
-			break;
-		case 'r':
-			args->rows = atoi(optarg);
-			break;
-		case 's':
-			args->seconds = atoi(optarg);
-			break;
-		case 'i':
-			args->iteration = atoi(optarg);
-			break;
-		case 'x':
-			rc = parse_transaction(args, optarg);
-			if (rc < 0)
-				return -1;
-			break;
-		case 'v':
-			args->verbose = atoi(optarg);
-			break;
-		case 'z':
-			args->zipf = 1;
-			break;
-		case 'm':
-			if (strcmp(optarg, "clean") == 0) {
-				args->mode = MODE_CLEAN;
-			} else if (strcmp(optarg, "build") == 0) {
-				args->mode = MODE_BUILD;
-			} else if (strcmp(optarg, "run") == 0) {
-				args->mode = MODE_RUN;
-			}
-			break;
-		case ARG_KEYLEN:
-			args->key_length = atoi(optarg);
-			break;
-		case ARG_VALLEN:
-			args->value_length = atoi(optarg);
-			break;
-		case ARG_TPS:
-		case ARG_TPSMAX:
-			args->tpsmax = atoi(optarg);
-			break;
-		case ARG_TPSMIN:
-			args->tpsmin = atoi(optarg);
-			break;
-		case ARG_TPSINTERVAL:
-			args->tpsinterval = atoi(optarg);
-			break;
-		case ARG_TPSCHANGE:
-			if (strcmp(optarg, "sin") == 0)
-				args->tpschange = TPS_SIN;
-			else if (strcmp(optarg, "square") == 0)
-				args->tpschange = TPS_SQUARE;
-			else if (strcmp(optarg, "pulse") == 0)
-				args->tpschange = TPS_PULSE;
-			else {
-				fprintf(stderr, "--tpschange must be sin, square or pulse\n");
-				return -1;
-			}
-			break;
-		case ARG_SAMPLING:
-			args->sampling = atoi(optarg);
-			break;
-		case ARG_VERSION:
-			fprintf(stderr, "Version: %d\n", FDB_API_VERSION);
-			exit(0);
-			break;
-		case ARG_COMMITGET:
-			args->commit_get = 1;
-			break;
-		case ARG_FLATBUFFERS:
-			args->flatbuffers = 1;
-			break;
-		case ARG_KNOBS:
-			memcpy(args->knobs, optarg, strlen(optarg) + 1);
-			break;
-		case ARG_LOGGROUP:
-			memcpy(args->log_group, optarg, strlen(optarg) + 1);
-			break;
-		case ARG_PREFIXPADDING:
-			args->prefixpadding = 1;
-			break;
-		case ARG_TRACE:
-			args->trace = 1;
-			break;
-		case ARG_TRACEPATH:
-			args->trace = 1;
-			memcpy(args->tracepath, optarg, strlen(optarg) + 1);
-			break;
-		case ARG_TRACEFORMAT:
-			if (strncmp(optarg, "json", 5) == 0) {
-				args->traceformat = 1;
-			} else if (strncmp(optarg, "xml", 4) == 0) {
-				args->traceformat = 0;
-			} else {
-				fprintf(stderr, "Error: Invalid trace_format %s\n", optarg);
-				return -1;
-			}
-			break;
-		case ARG_STREAMING_MODE:
-			if (strncmp(optarg, "all", 3) == 0) {
-				args->streaming_mode = FDB_STREAMING_MODE_WANT_ALL;
-			} else if (strncmp(optarg, "iterator", 8) == 0) {
-				args->streaming_mode = FDB_STREAMING_MODE_ITERATOR;
-			} else if (strncmp(optarg, "small", 5) == 0) {
-				args->streaming_mode = FDB_STREAMING_MODE_SMALL;
-			} else if (strncmp(optarg, "medium", 6) == 0) {
-				args->streaming_mode = FDB_STREAMING_MODE_MEDIUM;
-			} else if (strncmp(optarg, "large", 5) == 0) {
-				args->streaming_mode = FDB_STREAMING_MODE_LARGE;
-			} else if (strncmp(optarg, "serial", 6) == 0) {
-				args->streaming_mode = FDB_STREAMING_MODE_SERIAL;
-			} else {
-				fprintf(stderr, "Error: Invalid streaming mode %s\n", optarg);
-				return -1;
-			}
-			break;
-		case ARG_TXNTRACE:
-			args->txntrace = atoi(optarg);
-			break;
+    int rc;
+    int c;
+    int idx;
+    while (1) {
+        const char* short_options = "a:c:d:p:t:r:s:i:x:v:m:hz";
+        static struct option long_options[] = {
+            /* name, has_arg, flag, val */
+            { "api_version", required_argument, NULL, 'a' },
+            { "cluster", required_argument, NULL, 'c' },
+            { "num_databases", optional_argument, NULL, 'd' },
+            { "procs", required_argument, NULL, 'p' },
+            { "threads", required_argument, NULL, 't' },
+            { "rows", required_argument, NULL, 'r' },
+            { "seconds", required_argument, NULL, 's' },
+            { "iteration", required_argument, NULL, 'i' },
+            { "keylen", required_argument, NULL, ARG_KEYLEN },
+            { "vallen", required_argument, NULL, ARG_VALLEN },
+            { "transaction", required_argument, NULL, 'x' },
+            { "tps", required_argument, NULL, ARG_TPS },
+            { "tpsmax", required_argument, NULL, ARG_TPSMAX },
+            { "tpsmin", required_argument, NULL, ARG_TPSMIN },
+            { "tpsinterval", required_argument, NULL, ARG_TPSINTERVAL },
+            { "tpschange", required_argument, NULL, ARG_TPSCHANGE },
+            { "sampling", required_argument, NULL, ARG_SAMPLING },
+            { "verbose", required_argument, NULL, 'v' },
+            { "mode", required_argument, NULL, 'm' },
+            { "knobs", required_argument, NULL, ARG_KNOBS },
+            { "loggroup", required_argument, NULL, ARG_LOGGROUP },
+            { "tracepath", required_argument, NULL, ARG_TRACEPATH },
+            { "trace_format", required_argument, NULL, ARG_TRACEFORMAT },
+            { "streaming", required_argument, NULL, ARG_STREAMING_MODE },
+            { "txntrace", required_argument, NULL, ARG_TXNTRACE },
+            /* no args */
+            { "help", no_argument, NULL, 'h' },
+            { "zipf", no_argument, NULL, 'z' },
+            { "commitget", no_argument, NULL, ARG_COMMITGET },
+            { "flatbuffers", no_argument, NULL, ARG_FLATBUFFERS },
+            { "prefix_padding", no_argument, NULL, ARG_PREFIXPADDING },
+            { "trace", no_argument, NULL, ARG_TRACE },
+            { "txntagging", required_argument, NULL, ARG_TXNTAGGING },
+            { "txntagging_prefix", required_argument, NULL, ARG_TXNTAGGINGPREFIX },
+            { "version", no_argument, NULL, ARG_VERSION },
+            { "client_threads_per_version", required_argument, NULL, ARG_CLIENT_THREADS_PER_VERSION },
+            { "disable_ryw", no_argument, NULL, ARG_DISABLE_RYW },
+            { "json_report", optional_argument, NULL, ARG_JSON_REPORT },
+            { "bg_file_path", required_argument, NULL, ARG_BG_FILE_PATH },
+            { NULL, 0, NULL, 0 }
+        };
+        idx = 0;
+        c = getopt_long(argc, argv, short_options, long_options, &idx);
+        if (c < 0) {
+            break;
+        }
+        switch (c) {
+        case '?':
+        case 'h':
+            usage();
+            return -1;
+        case 'a':
+            args->api_version = atoi(optarg);
+            break;
+        case 'c': {
+            const char delim[] = ",";
+            char* cluster_file = strtok(optarg, delim);
+            while (cluster_file != NULL) {
+                strcpy(args->cluster_files[args->num_fdb_clusters++], cluster_file);
+                cluster_file = strtok(NULL, delim);
+            }
+            break;
+        }
+        case 'd':
+            args->num_databases = atoi(optarg);
+            break;
+        case 'p':
+            args->num_processes = atoi(optarg);
+            break;
+        case 't':
+            args->num_threads = atoi(optarg);
+            break;
+        case 'r':
+            args->rows = atoi(optarg);
+            args->row_digits = digits(args->rows);
+            break;
+        case 's':
+            args->seconds = atoi(optarg);
+            break;
+        case 'i':
+            args->iteration = atoi(optarg);
+            break;
+        case 'x':
+            rc = parse_transaction(args, optarg);
+            if (rc < 0)
+                return -1;
+            break;
+        case 'v':
+            args->verbose = atoi(optarg);
+            break;
+        case 'z':
+            args->zipf = 1;
+            break;
+        case 'm':
+            if (strcmp(optarg, "clean") == 0) {
+                args->mode = MODE_CLEAN;
+            } else if (strcmp(optarg, "build") == 0) {
+                args->mode = MODE_BUILD;
+            } else if (strcmp(optarg, "run") == 0) {
+                args->mode = MODE_RUN;
+            }
+            break;
+        case ARG_KEYLEN:
+            args->key_length = atoi(optarg);
+            break;
+        case ARG_VALLEN:
+            args->value_length = atoi(optarg);
+            break;
+        case ARG_TPS:
+        case ARG_TPSMAX:
+            args->tpsmax = atoi(optarg);
+            break;
+        case ARG_TPSMIN:
+            args->tpsmin = atoi(optarg);
+            break;
+        case ARG_TPSINTERVAL:
+            args->tpsinterval = atoi(optarg);
+            break;
+        case ARG_TPSCHANGE:
+            if (strcmp(optarg, "sin") == 0)
+                args->tpschange = TPS_SIN;
+            else if (strcmp(optarg, "square") == 0)
+                args->tpschange = TPS_SQUARE;
+            else if (strcmp(optarg, "pulse") == 0)
+                args->tpschange = TPS_PULSE;
+            else {
+                fprintf(stderr, "--tpschange must be sin, square or pulse\n");
+                return -1;
+            }
+            break;
+        case ARG_SAMPLING:
+            args->sampling = atoi(optarg);
+            break;
+        case ARG_VERSION:
+            fprintf(stderr, "Version: %d\n", FDB_API_VERSION);
+            exit(0);
+            break;
+        case ARG_COMMITGET:
+            args->commit_get = 1;
+            break;
+        case ARG_FLATBUFFERS:
+            args->flatbuffers = 1;
+            break;
+        case ARG_KNOBS:
+            memcpy(args->knobs, optarg, strlen(optarg) + 1);
+            break;
+        case ARG_LOGGROUP:
+            memcpy(args->log_group, optarg, strlen(optarg) + 1);
+            break;
+        case ARG_PREFIXPADDING:
+            args->prefixpadding = 1;
+            break;
+        case ARG_TRACE:
+            args->trace = 1;
+            break;
+        case ARG_TRACEPATH:
+            args->trace = 1;
+            memcpy(args->tracepath, optarg, strlen(optarg) + 1);
+            break;
+        case ARG_TRACEFORMAT:
+            if (strncmp(optarg, "json", 5) == 0) {
+                args->traceformat = 1;
+            } else if (strncmp(optarg, "xml", 4) == 0) {
+                args->traceformat = 0;
+            } else {
+                fprintf(stderr, "Error: Invalid trace_format %s\n", optarg);
+                return -1;
+            }
+            break;
+        case ARG_STREAMING_MODE:
+            if (strncmp(optarg, "all", 3) == 0) {
+                args->streaming_mode = FDB_STREAMING_MODE_WANT_ALL;
+            } else if (strncmp(optarg, "iterator", 8) == 0) {
+                args->streaming_mode = FDB_STREAMING_MODE_ITERATOR;
+            } else if (strncmp(optarg, "small", 5) == 0) {
+                args->streaming_mode = FDB_STREAMING_MODE_SMALL;
+            } else if (strncmp(optarg, "medium", 6) == 0) {
+                args->streaming_mode = FDB_STREAMING_MODE_MEDIUM;
+            } else if (strncmp(optarg, "large", 5) == 0) {
+                args->streaming_mode = FDB_STREAMING_MODE_LARGE;
+            } else if (strncmp(optarg, "serial", 6) == 0) {
+                args->streaming_mode = FDB_STREAMING_MODE_SERIAL;
+            } else {
+                fprintf(stderr, "Error: Invalid streaming mode %s\n", optarg);
+                return -1;
+            }
+            break;
+        case ARG_TXNTRACE:
+            args->txntrace = atoi(optarg);
+            break;
 
-		case ARG_TXNTAGGING:
-			args->txntagging = atoi(optarg);
-			if (args->txntagging > 1000) {
-				args->txntagging = 1000;
-			}
-			break;
-		case ARG_TXNTAGGINGPREFIX:
-			if (strlen(optarg) > TAGPREFIXLENGTH_MAX) {
-				fprintf(stderr, "Error: the length of txntagging_prefix is larger than %d\n", TAGPREFIXLENGTH_MAX);
-				exit(0);
-			}
-			memcpy(args->txntagging_prefix, optarg, strlen(optarg));
-			break;
-		case ARG_CLIENT_THREADS_PER_VERSION:
-			args->client_threads_per_version = atoi(optarg);
-			break;
-		case ARG_DISABLE_RYW:
-			args->disable_ryw = 1;
-			break;
-		case ARG_JSON_REPORT:
-			if (optarg == NULL && (argv[optind] == NULL || (argv[optind] != NULL && argv[optind][0] == '-'))) {
-				// if --report_json is the last option and no file is specified
-				// or --report_json is followed by another option
-				char default_file[] = "mako.json";
-				strncpy(args->json_output_path, default_file, strlen(default_file));
-			} else {
-				strncpy(args->json_output_path, optarg, strlen(optarg) + 1);
-			}
-			break;
-		case ARG_BG_FILE_PATH:
-			args->bg_materialize_files = true;
-			strncpy(args->bg_file_path, optarg, strlen(optarg) + 1);
-		}
-	}
+        case ARG_TXNTAGGING:
+            args->txntagging = atoi(optarg);
+            if (args->txntagging > 1000) {
+                args->txntagging = 1000;
+            }
+            break;
+        case ARG_TXNTAGGINGPREFIX:
+            if (strlen(optarg) > TAGPREFIXLENGTH_MAX) {
+                fprintf(stderr, "Error: the length of txntagging_prefix is larger than %d\n", TAGPREFIXLENGTH_MAX);
+                exit(0);
+            }
+            memcpy(args->txntagging_prefix, optarg, strlen(optarg));
+            break;
+        case ARG_CLIENT_THREADS_PER_VERSION:
+            args->client_threads_per_version = atoi(optarg);
+            break;
+        case ARG_DISABLE_RYW:
+            args->disable_ryw = 1;
+            break;
+        case ARG_JSON_REPORT:
+            if (optarg == NULL && (argv[optind] == NULL || (argv[optind] != NULL && argv[optind][0] == '-'))) {
+                // if --report_json is the last option and no file is specified
+                // or --report_json is followed by another option
+                char default_file[] = "mako.json";
+                strncpy(args->json_output_path, default_file, strlen(default_file));
+            } else {
+                strncpy(args->json_output_path, optarg, strlen(optarg) + 1);
+            }
+            break;
+        case ARG_BG_FILE_PATH:
+            args->bg_materialize_files = true;
+            strncpy(args->bg_file_path, optarg, strlen(optarg) + 1);
+        }
+    }
 
-	if ((args->tpsmin == -1) || (args->tpsmin > args->tpsmax)) {
-		args->tpsmin = args->tpsmax;
-	}
+    if ((args->tpsmin == -1) || (args->tpsmin > args->tpsmax)) {
+        args->tpsmin = args->tpsmax;
+    }
 
-	if (args->verbose >= VERBOSE_DEFAULT) {
-		printme = stdout;
-	} else {
-		printme = fopen("/dev/null", "w");
-	}
-	if (args->verbose >= VERBOSE_ANNOYING) {
-		annoyme = stdout;
-	} else {
-		annoyme = fopen("/dev/null", "w");
-	}
-	if (args->verbose >= VERBOSE_DEBUG) {
-		debugme = stdout;
-	} else {
-		debugme = fopen("/dev/null", "w");
-	}
+    if (args->verbose >= VERBOSE_DEFAULT) {
+        printme = stdout;
+    } else {
+        printme = fopen("/dev/null", "w");
+    }
+    if (args->verbose >= VERBOSE_ANNOYING) {
+        annoyme = stdout;
+    } else {
+        annoyme = fopen("/dev/null", "w");
+    }
+    if (args->verbose >= VERBOSE_DEBUG) {
+        debugme = stdout;
+    } else {
+        debugme = fopen("/dev/null", "w");
+    }
 
-	return 0;
+    return 0;
 }
 
-char* get_ops_name(int ops_code) {
-	switch (ops_code) {
-	case OP_GETREADVERSION:
-		return "GRV";
-	case OP_GET:
-		return "GET";
-	case OP_GETRANGE:
-		return "GETRANGE";
-	case OP_SGET:
-		return "SGET";
-	case OP_SGETRANGE:
-		return "SGETRANGE";
-	case OP_UPDATE:
-		return "UPDATE";
-	case OP_INSERT:
-		return "INSERT";
-	case OP_INSERTRANGE:
-		return "INSERTRANGE";
-	case OP_OVERWRITE:
-		return "OVERWRITE";
-	case OP_CLEAR:
-		return "CLEAR";
-	case OP_SETCLEAR:
-		return "SETCLEAR";
-	case OP_CLEARRANGE:
-		return "CLEARRANGE";
-	case OP_SETCLEARRANGE:
-		return "SETCLEARRANGE";
-	case OP_COMMIT:
-		return "COMMIT";
-	case OP_TRANSACTION:
-		return "TRANSACTION";
-	case OP_READ_BG:
-		return "READBLOBGRANULE";
-	default:
-		return "";
-	}
+char const* get_ops_name(int ops_code) {
+    if (ops_code >= 0 && ops_code < MAX_OP)
+        return op_desc[ops_code].name().data();
+    return "";
 }
 
 int validate_args(mako_args_t* args) {
-	if (args->mode == MODE_INVALID) {
-		fprintf(stderr, "ERROR: --mode has to be set\n");
-		return -1;
-	}
-	if (args->rows <= 0) {
-		fprintf(stderr, "ERROR: --rows must be a positive integer\n");
-		return -1;
-	}
-	if (args->key_length < 0) {
-		fprintf(stderr, "ERROR: --keylen must be a positive integer\n");
-		return -1;
-	}
-	if (args->value_length < 0) {
-		fprintf(stderr, "ERROR: --vallen must be a positive integer\n");
-		return -1;
-	}
-	if (args->num_fdb_clusters > NUM_CLUSTERS_MAX) {
-		fprintf(stderr, "ERROR: Mako is not supported to do work to more than %d clusters\n", NUM_CLUSTERS_MAX);
-		return -1;
-	}
-	if (args->num_databases > NUM_DATABASES_MAX) {
-		fprintf(stderr, "ERROR: Mako is not supported to do work to more than %d databases\n", NUM_DATABASES_MAX);
-		return -1;
-	}
-	if (args->num_databases < args->num_fdb_clusters) {
-		fprintf(stderr,
-		        "ERROR: --num_databases (%d) must be >= number of clusters(%d)\n",
-		        args->num_databases,
-		        args->num_fdb_clusters);
-		return -1;
-	}
-	if (args->num_threads < args->num_databases) {
-		fprintf(stderr,
-		        "ERROR: --threads (%d) must be >= number of databases (%d)\n",
-		        args->num_threads,
-		        args->num_databases);
-		return -1;
-	}
-	if (args->key_length < 4 /* "mako" */ + digits(args->rows)) {
-		fprintf(stderr,
-		        "ERROR: --keylen must be larger than %d to store \"mako\" prefix "
-		        "and maximum row number\n",
-		        4 + digits(args->rows));
-		return -1;
-	}
-	if (args->mode == MODE_RUN) {
-		if ((args->seconds > 0) && (args->iteration > 0)) {
-			fprintf(stderr, "ERROR: Cannot specify seconds and iteration together\n");
-			return -1;
-		}
-		if ((args->seconds == 0) && (args->iteration == 0)) {
-			fprintf(stderr, "ERROR: Must specify either seconds or iteration\n");
-			return -1;
-		}
-		if (args->txntagging < 0) {
-			fprintf(stderr, "ERROR: --txntagging must be a non-negative integer\n");
-			return -1;
-		}
-	}
-	return 0;
+    if (args->mode == MODE_INVALID) {
+        fprintf(stderr, "ERROR: --mode has to be set\n");
+        return -1;
+    }
+    if (args->rows <= 0) {
+        fprintf(stderr, "ERROR: --rows must be a positive integer\n");
+        return -1;
+    }
+    if (args->key_length < 0) {
+        fprintf(stderr, "ERROR: --keylen must be a positive integer\n");
+        return -1;
+    }
+    if (args->value_length < 0) {
+        fprintf(stderr, "ERROR: --vallen must be a positive integer\n");
+        return -1;
+    }
+    if (args->num_fdb_clusters > NUM_CLUSTERS_MAX) {
+        fprintf(stderr, "ERROR: Mako is not supported to do work to more than %d clusters\n", NUM_CLUSTERS_MAX);
+        return -1;
+    }
+    if (args->num_databases > NUM_DATABASES_MAX) {
+        fprintf(stderr, "ERROR: Mako is not supported to do work to more than %d databases\n", NUM_DATABASES_MAX);
+        return -1;
+    }
+    if (args->num_databases < args->num_fdb_clusters) {
+        fprintf(stderr,
+                "ERROR: --num_databases (%d) must be >= number of clusters(%d)\n",
+                args->num_databases,
+                args->num_fdb_clusters);
+        return -1;
+    }
+    if (args->num_threads < args->num_databases) {
+        fprintf(stderr,
+                "ERROR: --threads (%d) must be >= number of databases (%d)\n",
+                args->num_threads,
+                args->num_databases);
+        return -1;
+    }
+    if (args->key_length < 4 /* "mako" */ + args->row_digits) {
+        fprintf(stderr,
+                "ERROR: --keylen must be larger than %d to store \"mako\" prefix "
+                "and maximum row number\n",
+                4 + args->row_digits);
+        return -1;
+    }
+    if (args->mode == MODE_RUN) {
+        if ((args->seconds > 0) && (args->iteration > 0)) {
+            fprintf(stderr, "ERROR: Cannot specify seconds and iteration together\n");
+            return -1;
+        }
+        if ((args->seconds == 0) && (args->iteration == 0)) {
+            fprintf(stderr, "ERROR: Must specify either seconds or iteration\n");
+            return -1;
+        }
+        if (args->txntagging < 0) {
+            fprintf(stderr, "ERROR: --txntagging must be a non-negative integer\n");
+            return -1;
+        }
+    }
+    return 0;
 }
 
-/* stats output formatting */
-#define STR2(x) #x
-#define STR(x) STR2(x)
-#define STATS_TITLE_WIDTH 12
-#define STATS_FIELD_WIDTH 12
+void print_stats(mako_args_t const& args, mako_stats_t const* stats,
+                 double const duration_sec, FILE* fp) {
+    static mako_stats_t prev;
 
-void print_stats(mako_args_t* args, mako_stats_t* stats, struct timespec* now, struct timespec* prev, FILE* fp) {
-	int i, j;
-	int op;
-	int print_err;
-	static uint64_t ops_total_prev[MAX_OP] = { 0 };
-	uint64_t ops_total[MAX_OP] = { 0 };
-	static uint64_t errors_total_prev[MAX_OP] = { 0 };
-	uint64_t errors_total[MAX_OP] = { 0 };
-	uint64_t errors_diff[MAX_OP] = { 0 };
-	static uint64_t totalxacts_prev = 0;
-	uint64_t totalxacts = 0;
-	static uint64_t conflicts_prev = 0;
-	uint64_t conflicts = 0;
-	double duration_nsec = (now->tv_sec - prev->tv_sec) * 1000000000.0 + (now->tv_nsec - prev->tv_nsec);
+    auto current = mako_stats_t{};
+    for (auto i = 0; i < args.num_processes; i++) {
+        for (auto j = 0; j < args.num_threads; j++) {
+            current.combine(stats[(i * args.num_threads) + j]);
+        }
+    }
 
-	for (i = 0; i < args->num_processes; i++) {
-		for (j = 0; j < args->num_threads; j++) {
-			totalxacts += stats[(i * args->num_threads) + j].xacts;
-			conflicts += stats[(i * args->num_threads) + j].conflicts;
-			for (op = 0; op < MAX_OP; op++) {
-				ops_total[op] += stats[(i * args->num_threads) + j].ops[op];
-				errors_total[op] += stats[(i * args->num_threads) + j].errors[op];
-			}
-		}
-	}
+    if (fp) {
+        fwrite("{", 1, 1, fp);
+    }
+    put_title_r("OPS");
+    auto print_err = false;
+    for (auto op = 0; op < MAX_OP; op++) {
+        if (args.txnspec.ops[op][OP_COUNT] > 0) {
+            const auto ops_total_diff = current.get_op_count(op) - prev.get_op_count(op);
+            put_field(ops_total_diff);
+            if (fp) {
+                fmt::print(fp, "\"{}\": {},", get_ops_name(op), ops_total_diff);
+            }
+            print_err = (current.get_error_count(op) - prev.get_error_count(op)) > 0;
+        }
+    }
+    /* TPS */
+    const auto tps = (current.get_tx_count() - prev.get_tx_count()) / duration_sec;
+    put_field_f(tps, 2);
+    if (fp) {
+        fprintf(fp, "\"tps\": %.2f,", tps);
+    }
 
-	if (fp) {
-		fwrite("{", 1, 1, fp);
-	}
-	printf("%" STR(STATS_TITLE_WIDTH) "s ", "OPS");
-	for (op = 0; op < MAX_OP; op++) {
-		if (args->txnspec.ops[op][OP_COUNT] > 0) {
-			uint64_t ops_total_diff = ops_total[op] - ops_total_prev[op];
-			printf("%" STR(STATS_FIELD_WIDTH) PRIu64 " ", ops_total_diff);
-			if (fp) {
-				fprintf(fp, "\"%s\": %" PRIu64 ",", get_ops_name(op), ops_total_diff);
-			}
-			errors_diff[op] = errors_total[op] - errors_total_prev[op];
-			print_err = (errors_diff[op] > 0);
-			ops_total_prev[op] = ops_total[op];
-			errors_total_prev[op] = errors_total[op];
-		}
-	}
-	/* TPS */
-	double tps = (totalxacts - totalxacts_prev) * 1000000000.0 / duration_nsec;
-	printf("%" STR(STATS_FIELD_WIDTH) ".2f ", tps);
-	if (fp) {
-		fprintf(fp, "\"tps\": %.2f,", tps);
-	}
-	totalxacts_prev = totalxacts;
+    /* Conflicts */
+    const auto conflicts_diff =
+        (current.get_conflict_count() - prev.get_conflict_count()) / duration_sec;
+    put_field_f(conflicts_diff, 2);
+    if (fp) {
+        fprintf(fp, "\"conflictsPerSec\": %.2f", conflicts_diff);
+    }
 
-	/* Conflicts */
-	double conflicts_diff = (conflicts - conflicts_prev) * 1000000000.0 / duration_nsec;
-	printf("%" STR(STATS_FIELD_WIDTH) ".2f\n", conflicts_diff);
-	if (fp) {
-		fprintf(fp, "\"conflictsPerSec\": %.2f", conflicts_diff);
-	}
-	conflicts_prev = conflicts;
-
-	if (print_err) {
-		printf("%" STR(STATS_TITLE_WIDTH) "s ", "Errors");
-		for (op = 0; op < MAX_OP; op++) {
-			if (args->txnspec.ops[op][OP_COUNT] > 0) {
-				printf("%" STR(STATS_FIELD_WIDTH) PRIu64 " ", errors_diff[op]);
-				if (fp) {
-					fprintf(fp, ",\"errors\": %.2f", conflicts_diff);
-				}
-			}
-		}
-		printf("\n");
-	}
-	if (fp) {
-		fprintf(fp, "}");
-	}
-
-	return;
+    if (print_err) {
+        put_title_r("Errors");
+        for (auto op = 0; op < MAX_OP; op++) {
+            if (args.txnspec.ops[op][OP_COUNT] > 0) {
+                put_field(current.get_error_count(op) - prev.get_error_count(op));
+                if (fp) {
+                    fprintf(fp, ",\"errors\": %.2f", conflicts_diff);
+                }
+            }
+        }
+        printf("\n");
+    }
+    if (fp) {
+        fprintf(fp, "}");
+    }
+    // swap old stats for new
+    prev = current;
 }
 
-void print_stats_header(mako_args_t* args, bool show_commit, bool is_first_header_empty, bool show_op_stats) {
-	int op;
-	int i;
+void print_stats_header(mako_args_t const& args, bool show_commit, bool is_first_header_empty, bool show_op_stats) {
+    /* header */
+    if (is_first_header_empty) put_title("");
+    for (auto op = 0; op < MAX_OP; op++) {
+        if (args.txnspec.ops[op][OP_COUNT] > 0) {
+            put_field(get_ops_name(op));
+        }
+    }
 
-	/* header */
-	if (is_first_header_empty)
-		for (i = 0; i <= STATS_TITLE_WIDTH; i++)
-			printf(" ");
-	for (op = 0; op < MAX_OP; op++) {
-		if (args->txnspec.ops[op][OP_COUNT] > 0) {
-			printf("%" STR(STATS_FIELD_WIDTH) "s ", get_ops_name(op));
-		}
-	}
+    if (show_commit) put_field("COMMIT");
+    if (show_op_stats) {
+        put_field("TRANSACTION");
+    } else {
+        put_field("TPS");
+        put_field("Conflicts/s");
+    }
+    fmt::print("\n");
 
-	if (show_commit)
-		printf("%" STR(STATS_FIELD_WIDTH) "s ", "COMMIT");
-	if (show_op_stats) {
-		printf("%" STR(STATS_FIELD_WIDTH) "s\n", "TRANSACTION");
-	} else {
-		printf("%" STR(STATS_FIELD_WIDTH) "s ", "TPS");
-		printf("%" STR(STATS_FIELD_WIDTH) "s\n", "Conflicts/s");
-	}
+    put_title_bar();
+    for (auto op = 0; op < MAX_OP; op++) {
+        if (args.txnspec.ops[op][OP_COUNT] > 0) {
+            put_field_bar();
+        }
+    }
 
-	for (i = 0; i < STATS_TITLE_WIDTH; i++)
-		printf("=");
-	printf(" ");
-	for (op = 0; op < MAX_OP; op++) {
-		if (args->txnspec.ops[op][OP_COUNT] > 0) {
-			for (i = 0; i < STATS_FIELD_WIDTH; i++)
-				printf("=");
-			printf(" ");
-		}
-	}
+    /* COMMIT */
+    if (show_commit) put_field_bar();
 
-	/* COMMIT */
-	if (show_commit) {
-		for (i = 0; i < STATS_FIELD_WIDTH; i++)
-			printf("=");
-		printf(" ");
-	}
+    if (show_op_stats) {
+        /* TRANSACTION */
+        put_field_bar();
+    } else {
+        /* TPS */
+        put_field_bar();
 
-	if (show_op_stats) {
-		/* TRANSACTION */
-		for (i = 0; i < STATS_FIELD_WIDTH; i++)
-			printf("=");
-		printf(" ");
-	} else {
-		/* TPS */
-		for (i = 0; i < STATS_FIELD_WIDTH; i++)
-			printf("=");
-		printf(" ");
-
-		/* Conflicts */
-		for (i = 0; i < STATS_FIELD_WIDTH; i++)
-			printf("=");
-	}
-	printf("\n");
+        /* Conflicts */
+        put_field_bar();
+    }
+    fmt::print("\n");
 }
 
-void print_report(mako_args_t* args,
-                  mako_stats_t* stats,
-                  struct timespec* timer_now,
-                  struct timespec* timer_start,
-                  pid_t* pid_main,
+void print_report(mako_args_t const& args,
+                  mako_stats_t const* stats,
+                  double const duration_sec,
+                  pid_t pid_main,
                   FILE* fp) {
-	int i, j, k, op, index;
-	int first_op = 1;
-	uint64_t totalxacts = 0;
-	uint64_t conflicts = 0;
-	uint64_t totalerrors = 0;
-	uint64_t ops_total[MAX_OP] = { 0 };
-	uint64_t errors_total[MAX_OP] = { 0 };
-	uint64_t lat_min[MAX_OP] = { 0 };
-	uint64_t lat_total[MAX_OP] = { 0 };
-	uint64_t lat_samples[MAX_OP] = { 0 };
-	uint64_t lat_max[MAX_OP] = { 0 };
 
-	uint64_t duration_nsec =
-	    (timer_now->tv_sec - timer_start->tv_sec) * 1000000000 + (timer_now->tv_nsec - timer_start->tv_nsec);
+    auto final_stats = mako_stats_t{};
+    for (auto i = 0; i < args.num_processes; i++) {
+        for (auto j = 0; j < args.num_threads; j++) {
+            const auto idx = i * args.num_threads + j;
+            final_stats.combine(stats[idx]);
+        }
+    }
 
-	for (op = 0; op < MAX_OP; op++) {
-		lat_min[op] = 0xFFFFFFFFFFFFFFFF; /* uint64_t */
-		lat_max[op] = 0;
-		lat_total[op] = 0;
-		lat_samples[op] = 0;
-	}
+    /* overall stats */
+    fmt::printf("\n====== Total Duration %6.3f sec ======\n\n", duration_sec);
+    fmt::printf("Total Processes:  %8d\n", args.num_processes);
+    fmt::printf("Total Threads:    %8d\n", args.num_threads);
+    if (args.tpsmax == args.tpsmin)
+        fmt::printf("Target TPS:       %8d\n", args.tpsmax);
+    else {
+        fmt::printf("Target TPS (MAX): %8d\n", args.tpsmax);
+        fmt::printf("Target TPS (MIN): %8d\n", args.tpsmin);
+        fmt::printf("TPS Interval:     %8d\n", args.tpsinterval);
+        fmt::printf("TPS Change:       ");
+        switch (args.tpschange) {
+        case TPS_SIN:
+            fmt::printf("%8s\n", "SIN");
+            break;
+        case TPS_SQUARE:
+            fmt::printf("%8s\n", "SQUARE");
+            break;
+        case TPS_PULSE:
+            fmt::printf("%8s\n", "PULSE");
+            break;
+        }
+    }
+    fmt::printf("Total Xacts:      %8lu\n", final_stats.get_tx_count());
+    fmt::printf("Total Conflicts:  %8lu\n", final_stats.get_conflict_count());
+    fmt::printf("Total Errors:     %8lu\n", final_stats.get_total_error_count());
+    fmt::printf("Overall TPS:      %8lu\n\n", final_stats.get_tx_count() / duration_sec);
 
-	for (i = 0; i < args->num_processes; i++) {
-		for (j = 0; j < args->num_threads; j++) {
-			int idx = i * args->num_threads + j;
-			totalxacts += stats[idx].xacts;
-			conflicts += stats[idx].conflicts;
-			for (op = 0; op < MAX_OP; op++) {
-				if ((args->txnspec.ops[op][OP_COUNT] > 0) || (op == OP_TRANSACTION) || (op == OP_COMMIT)) {
-					totalerrors += stats[idx].errors[op];
-					ops_total[op] += stats[idx].ops[op];
-					errors_total[op] += stats[idx].errors[op];
-					lat_total[op] += stats[idx].latency_us_total[op];
-					lat_samples[op] += stats[idx].latency_samples[op];
-					if (stats[idx].latency_us_min[op] < lat_min[op]) {
-						lat_min[op] = stats[idx].latency_us_min[op];
-					}
-					if (stats[idx].latency_us_max[op] > lat_max[op]) {
-						lat_max[op] = stats[idx].latency_us_max[op];
-					}
-				} /* if count > 0 */
-			}
-		}
-	}
+    if (fp) {
+        fmt::fprintf(fp, "\"results\": {");
+        fmt::fprintf(fp, "\"totalDuration\": %6.3f,", duration_sec);
+        fmt::fprintf(fp, "\"totalProcesses\": %d,", args.num_processes);
+        fmt::fprintf(fp, "\"totalThreads\": %d,", args.num_threads);
+        fmt::fprintf(fp, "\"targetTPS\": %d,", args.tpsmax);
+        fmt::fprintf(fp, "\"totalXacts\": %lu,", final_stats.get_tx_count());
+        fmt::fprintf(fp, "\"totalConflicts\": %lu,", final_stats.get_conflict_count());
+        fmt::fprintf(fp, "\"totalErrors\": %lu,", final_stats.get_total_error_count());
+        fmt::fprintf(fp, "\"overallTPS\": %lu,", final_stats.get_tx_count() / duration_sec);
+    }
 
-	/* overall stats */
-	double total_duration = duration_nsec * 1.0 / 1000000000;
-	printf("\n====== Total Duration %6.3f sec ======\n\n", total_duration);
-	printf("Total Processes:  %8d\n", args->num_processes);
-	printf("Total Threads:    %8d\n", args->num_threads);
-	if (args->tpsmax == args->tpsmin)
-		printf("Target TPS:       %8d\n", args->tpsmax);
-	else {
-		printf("Target TPS (MAX): %8d\n", args->tpsmax);
-		printf("Target TPS (MIN): %8d\n", args->tpsmin);
-		printf("TPS Interval:     %8d\n", args->tpsinterval);
-		printf("TPS Change:       ");
-		switch (args->tpschange) {
-		case TPS_SIN:
-			printf("%8s\n", "SIN");
-			break;
-		case TPS_SQUARE:
-			printf("%8s\n", "SQUARE");
-			break;
-		case TPS_PULSE:
-			printf("%8s\n", "PULSE");
-			break;
-		}
-	}
-	printf("Total Xacts:      %8" PRIu64 "\n", totalxacts);
-	printf("Total Conflicts:  %8" PRIu64 "\n", conflicts);
-	printf("Total Errors:     %8" PRIu64 "\n", totalerrors);
-	printf("Overall TPS:      %8" PRIu64 "\n\n", totalxacts * 1000000000 / duration_nsec);
+    /* per-op stats */
+    print_stats_header(args, true, true, false);
 
-	if (fp) {
-		fprintf(fp, "\"results\": {");
-		fprintf(fp, "\"totalDuration\": %6.3f,", total_duration);
-		fprintf(fp, "\"totalProcesses\": %d,", args->num_processes);
-		fprintf(fp, "\"totalThreads\": %d,", args->num_threads);
-		fprintf(fp, "\"targetTPS\": %d,", args->tpsmax);
-		fprintf(fp, "\"totalXacts\": %" PRIu64 ",", totalxacts);
-		fprintf(fp, "\"totalConflicts\": %" PRIu64 ",", conflicts);
-		fprintf(fp, "\"totalErrors\": %" PRIu64 ",", totalerrors);
-		fprintf(fp, "\"overallTPS\": %" PRIu64 ",", totalxacts * 1000000000 / duration_nsec);
-	}
+    /* OPS */
+    put_title("Total OPS");
+    if (fp) {
+        fmt::fprintf(fp, "\"totalOps\": {");
+    }
+    auto first_op = true;
+    for (auto op = 0; op < MAX_OP; op++) {
+        if ((args.txnspec.ops[op][OP_COUNT] > 0 && op != OP_TRANSACTION) || op == OP_COMMIT) {
+            put_field(final_stats.get_op_count(op));
+            if (fp) {
+                if (first_op) {
+                    first_op = 0;
+                } else {
+                    fmt::fprintf(fp, ",");
+                }
+                fmt::fprintf(fp, "\"%s\": %lu", get_ops_name(op), final_stats.get_op_count(op));
+            }
+        }
+    }
 
-	/* per-op stats */
-	print_stats_header(args, true, true, false);
+    /* TPS */
+    const auto tps = final_stats.get_tx_count() / duration_sec;
+    put_field_f(tps, 2);
 
-	/* OPS */
-	printf("%-" STR(STATS_TITLE_WIDTH) "s ", "Total OPS");
-	if (fp) {
-		fprintf(fp, "\"totalOps\": {");
-	}
-	for (op = 0; op < MAX_OP; op++) {
-		if ((args->txnspec.ops[op][OP_COUNT] > 0 && op != OP_TRANSACTION) || op == OP_COMMIT) {
-			printf("%" STR(STATS_FIELD_WIDTH) PRIu64 " ", ops_total[op]);
-			if (fp) {
-				if (first_op) {
-					first_op = 0;
-				} else {
-					fprintf(fp, ",");
-				}
-				fprintf(fp, "\"%s\": %" PRIu64, get_ops_name(op), ops_total[op]);
-			}
-		}
-	}
+    /* Conflicts */
+    const auto conflicts_rate = final_stats.get_conflict_count() / duration_sec;
+    put_field_f(conflicts_rate, 2);
 
-	/* TPS */
-	double tps = totalxacts * 1000000000.0 / duration_nsec;
-	printf("%" STR(STATS_FIELD_WIDTH) ".2f ", tps);
+    if (fp) {
+        fmt::fprintf(fp, "}, \"tps\": %.2f, \"conflictsPerSec\": %.2f, \"errors\": {", tps, conflicts_rate);
+    }
 
-	/* Conflicts */
-	double conflicts_rate = conflicts * 1000000000.0 / duration_nsec;
-	printf("%" STR(STATS_FIELD_WIDTH) ".2f\n", conflicts_rate);
+    /* Errors */
+    put_title("Errors");
+    first_op = 1;
+    for (auto op = 0; op < MAX_OP; op++) {
+        if (args.txnspec.ops[op][OP_COUNT] > 0 && op != OP_TRANSACTION) {
+            put_field(final_stats.get_error_count(op));
+            if (fp) {
+                if (first_op) {
+                    first_op = 0;
+                } else {
+                    fmt::fprintf(fp, ",");
+                }
+                fmt::fprintf(fp, "\"%s\": %lu",
+                             get_ops_name(op), final_stats.get_error_count(op));
+            }
+        }
+    }
+    if (fp) {
+        fmt::fprintf(fp, "}, \"numSamples\": {");
+    }
+    fmt::print("\n\n");
 
-	if (fp) {
-		fprintf(fp, "}, \"tps\": %.2f, \"conflictsPerSec\": %.2f, \"errors\": {", tps, conflicts_rate);
-	}
+    fmt::print("Latency (us)");
+    print_stats_header(args, true, false, true);
 
-	/* Errors */
-	printf("%-" STR(STATS_TITLE_WIDTH) "s ", "Errors");
-	first_op = 1;
-	for (op = 0; op < MAX_OP; op++) {
-		if (args->txnspec.ops[op][OP_COUNT] > 0 && op != OP_TRANSACTION) {
-			printf("%" STR(STATS_FIELD_WIDTH) PRIu64 " ", errors_total[op]);
-			if (fp) {
-				if (first_op) {
-					first_op = 0;
-				} else {
-					fprintf(fp, ",");
-				}
-				fprintf(fp, "\"%s\": %" PRIu64, get_ops_name(op), errors_total[op]);
-			}
-		}
-	}
-	if (fp) {
-		fprintf(fp, "}, \"numSamples\": {");
-	}
-	printf("\n\n");
+    /* Total Samples */
+    put_title("Samples");
+    first_op = 1;
+    for (auto op = 0; op < MAX_OP; op++) {
+        if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
+            if (final_stats.get_latency_us_total(op)) {
+                put_field(final_stats.get_latency_sample_count(op));
+            } else {
+                put_field("N/A");
+            }
+            if (fp) {
+                if (first_op) {
+                    first_op = 0;
+                } else {
+                    fmt::fprintf(fp, ",");
+                }
+                fmt::fprintf(fp, "\"%s\": %lu",
+                             get_ops_name(op),
+                             final_stats.get_latency_sample_count(op));
+            }
+        }
+    }
+    fmt::print("\n");
 
-	printf("%s", "Latency (us)");
-	print_stats_header(args, true, false, true);
+    /* Min Latency */
+    if (fp) {
+        fmt::fprintf(fp, "}, \"minLatency\": {");
+    }
+    put_title("Min");
+    first_op = 1;
+    for (auto op = 0; op < MAX_OP; op++) {
+        if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
+            const auto lat_min = final_stats.get_latency_us_min(op);
+            if (lat_min == -1) {
+                put_field("N/A");
+            } else {
+                put_field(lat_min);
+                if (fp) {
+                    if (first_op) {
+                        first_op = 0;
+                    } else {
+                        fmt::fprintf(fp, ",");
+                    }
+                    fmt::fprintf(fp, "\"%s\": %lu", get_ops_name(op), lat_min);
+                }
+            }
+        }
+    }
+    fmt::print("\n");
 
-	/* Total Samples */
-	printf("%-" STR(STATS_TITLE_WIDTH) "s ", "Samples");
-	first_op = 1;
-	for (op = 0; op < MAX_OP; op++) {
-		if (args->txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-			if (lat_total[op]) {
-				printf("%" STR(STATS_FIELD_WIDTH) PRIu64 " ", lat_samples[op]);
-			} else {
-				printf("%" STR(STATS_FIELD_WIDTH) "s ", "N/A");
-			}
-			if (fp) {
-				if (first_op) {
-					first_op = 0;
-				} else {
-					fprintf(fp, ",");
-				}
-				fprintf(fp, "\"%s\": %" PRIu64, get_ops_name(op), lat_samples[op]);
-			}
-		}
-	}
-	printf("\n");
+    /* Avg Latency */
+    if (fp) {
+        fmt::fprintf(fp, "}, \"avgLatency\": {");
+    }
+    put_title("Avg");
+    first_op = 1;
+    for (auto op = 0; op < MAX_OP; op++) {
+        if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
+            const auto lat_total = final_stats.get_latency_us_total(op);
+            const auto lat_samples = final_stats.get_latency_sample_count(op);
+            if (lat_total) {
+                put_field(lat_total / lat_samples);
+                if (fp) {
+                    if (first_op) {
+                        first_op = 0;
+                    } else {
+                        fmt::fprintf(fp, ",");
+                    }
+                    fmt::fprintf(fp, "\"%s\": %lu", get_ops_name(op), lat_total / lat_samples);
+                }
+            } else {
+                put_field("N/A");
+            }
+        }
+    }
+    fmt::printf("\n");
 
-	/* Min Latency */
-	if (fp) {
-		fprintf(fp, "}, \"minLatency\": {");
-	}
-	printf("%-" STR(STATS_TITLE_WIDTH) "s ", "Min");
-	first_op = 1;
-	for (op = 0; op < MAX_OP; op++) {
-		if (args->txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-			if (lat_min[op] == -1) {
-				printf("%" STR(STATS_FIELD_WIDTH) "s ", "N/A");
-			} else {
-				printf("%" STR(STATS_FIELD_WIDTH) PRIu64 " ", lat_min[op]);
-				if (fp) {
-					if (first_op) {
-						first_op = 0;
-					} else {
-						fprintf(fp, ",");
-					}
-					fprintf(fp, "\"%s\": %" PRIu64, get_ops_name(op), lat_min[op]);
-				}
-			}
-		}
-	}
-	printf("\n");
+    /* Max Latency */
+    if (fp) {
+        fmt::fprintf(fp, "}, \"maxLatency\": {");
+    }
+    put_title("Max");
+    first_op = 1;
+    for (auto op = 0; op < MAX_OP; op++) {
+        if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
+            const auto lat_max = final_stats.get_latency_us_max(op);
+            if (lat_max == 0) {
+                put_field("N/A");
+            } else {
+                put_field(lat_max);
+                if (fp) {
+                    if (first_op) {
+                        first_op = 0;
+                    } else {
+                        fmt::fprintf(fp, ",");
+                    }
+                    fmt::fprintf(fp, "\"%s\": %lu",
+                                 get_ops_name(op), final_stats.get_latency_us_max(op));
+                }
+            }
+        }
+    }
+    fmt::print("\n");
 
-	/* Avg Latency */
-	if (fp) {
-		fprintf(fp, "}, \"avgLatency\": {");
-	}
-	printf("%-" STR(STATS_TITLE_WIDTH) "s ", "Avg");
-	first_op = 1;
-	for (op = 0; op < MAX_OP; op++) {
-		if (args->txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-			if (lat_total[op]) {
-				printf("%" STR(STATS_FIELD_WIDTH) PRIu64 " ", lat_total[op] / lat_samples[op]);
-				if (fp) {
-					if (first_op) {
-						first_op = 0;
-					} else {
-						fprintf(fp, ",");
-					}
-					fprintf(fp, "\"%s\": %" PRIu64, get_ops_name(op), lat_total[op] / lat_samples[op]);
-				}
-			} else {
-				printf("%" STR(STATS_FIELD_WIDTH) "s ", "N/A");
-			}
-		}
-	}
-	printf("\n");
+    auto data_points = std::array<std::vector<uint64_t>, MAX_OP>{};
 
-	/* Max Latency */
-	if (fp) {
-		fprintf(fp, "}, \"maxLatency\": {");
-	}
-	printf("%-" STR(STATS_TITLE_WIDTH) "s ", "Max");
-	first_op = 1;
-	for (op = 0; op < MAX_OP; op++) {
-		if (args->txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-			if (lat_max[op] == 0) {
-				printf("%" STR(STATS_FIELD_WIDTH) "s ", "N/A");
-			} else {
-				printf("%" STR(STATS_FIELD_WIDTH) PRIu64 " ", lat_max[op]);
-				if (fp) {
-					if (first_op) {
-						first_op = 0;
-					} else {
-						fprintf(fp, ",");
-					}
-					fprintf(fp, "\"%s\": %" PRIu64, get_ops_name(op), lat_max[op]);
-				}
-			}
-		}
-	}
-	printf("\n");
+    /* Median Latency */
+    if (fp) {
+        fmt::fprintf(fp, "}, \"medianLatency\": {");
+    }
+    put_title("Median");
+    first_op = 1;
+    for (auto op = 0; op < MAX_OP; op++) {
+        if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
+            const auto lat_total = final_stats.get_latency_us_total(op);
+            const auto lat_samples = final_stats.get_latency_sample_count(op);
+            if (lat_total && lat_samples) {
+                data_points[op].reserve(lat_samples);
+                for (auto i = 0; i < args.num_processes; i++) {
+                    for (auto j = 0; j < args.num_threads; j++) {
+                        const auto dirname = fmt::format("{}{}", TEMP_DATA_STORE, pid_main);
+                        const auto filename = get_stats_file_name(dirname, i, j, op);
+                        auto fp = fopen(filename.c_str(), "r");
+                        if (!fp) {
+                            fmt::print(stderr, "ERROR: fopen({}): {}\n", strerror(errno));
+                            continue;
+                        }
+                        auto fclose_guard = exit_guard([fp]() { fclose(fp); });
+                        fseek(fp, 0, SEEK_END);
+                        const auto num_points = ftell(fp) / sizeof(uint64_t);
+                        fseek(fp, 0, 0);
+                        auto index = 0u;
+                        while (index < num_points) {
+                            auto value = uint64_t{};
+                            fread(&value, sizeof(uint64_t), 1, fp);
+                            data_points[op].push_back(value);
+                            ++index;
+                        }
+                    }
+                }
+                std::sort(data_points[op].begin(), data_points[op].end());
+                const auto num_points = data_points[op].size();
+                auto median = uint64_t{};
+                if (num_points & 1) {
+                    median = data_points[op][num_points / 2];
+                } else {
+                    median = (data_points[op][num_points / 2] + data_points[op][num_points / 2 - 1]) >> 1;
+                }
+                put_field(median);
+                if (fp) {
+                    if (first_op) {
+                        first_op = 0;
+                    } else {
+                        fmt::fprintf(fp, ",");
+                    }
+                    fmt::fprintf(fp, "\"%s\": %lu", get_ops_name(op), median);
+                }
+            } else {
+                put_field("N/A");
+            }
+        }
+    }
+    fmt::print("\n");
 
-	uint64_t* dataPoints[MAX_OP];
-	uint64_t median;
-	int point_99_9pct, point_99pct, point_95pct;
+    /* 95%ile Latency */
+    if (fp) {
+        fmt::fprintf(fp, "}, \"p95Latency\": {");
+    }
+    put_title("95.0 pctile");
+    first_op = 1;
+    for (auto op = 0; op < MAX_OP; op++) {
+        if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
+            if (data_points[op].empty() || !final_stats.get_latency_us_total(op)) {
+                put_field("N/A");
+                continue;
+            }
+            const auto num_points = data_points[op].size();
+            const auto point_95pct =
+                static_cast<size_t>(std::max(0., (num_points * 0.95) - 1));
+            put_field(data_points[op][point_95pct]);
+            if (fp) {
+                if (first_op) {
+                    first_op = 0;
+                } else {
+                    fmt::fprintf(fp, ",");
+                }
+                fmt::fprintf(fp, "\"%s\": %lu",
+                             get_ops_name(op), data_points[op][point_95pct]);
+            }
+        }
+    }
+    fmt::printf("\n");
 
-	/* Median Latency */
-	if (fp) {
-		fprintf(fp, "}, \"medianLatency\": {");
-	}
-	printf("%-" STR(STATS_TITLE_WIDTH) "s ", "Median");
-	int num_points[MAX_OP] = { 0 };
-	first_op = 1;
-	for (op = 0; op < MAX_OP; op++) {
-		if (args->txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-			if (lat_total[op]) {
-				dataPoints[op] = (uint64_t*)malloc(sizeof(uint64_t) * lat_samples[op]);
-				if (dataPoints[op] == NULL) {
-					printf("%" STR(STATS_FIELD_WIDTH) "s ", "N/A");
-					continue;
-				}
-				k = 0;
-				for (i = 0; i < args->num_processes; i++) {
-					for (j = 0; j < args->num_threads; j++) {
-						char file_name[NAME_MAX] = { '\0' };
-						sprintf(file_name, "%s%d", TEMP_DATA_STORE, *pid_main);
-						get_stats_file_name(file_name, i, j, op);
-						FILE* f = fopen(file_name, "r");
-						fseek(f, 0, SEEK_END);
-						int numPoints = ftell(f) / sizeof(uint64_t);
-						fseek(f, 0, 0);
-						index = 0;
-						while (index < numPoints) {
-							fread(&dataPoints[op][k++], sizeof(uint64_t), 1, f);
-							++index;
-						}
-						fclose(f);
-					}
-				}
-				num_points[op] = k;
-				quick_sort(dataPoints[op], num_points[op]);
-				if (num_points[op] & 1) {
-					median = dataPoints[op][num_points[op] / 2];
-				} else {
-					median = (dataPoints[op][num_points[op] / 2] + dataPoints[op][num_points[op] / 2 - 1]) >> 1;
-				}
-				printf("%" STR(STATS_FIELD_WIDTH) PRIu64 " ", median);
-				if (fp) {
-					if (first_op) {
-						first_op = 0;
-					} else {
-						fprintf(fp, ",");
-					}
-					fprintf(fp, "\"%s\": %" PRIu64, get_ops_name(op), median);
-				}
-			} else {
-				printf("%" STR(STATS_FIELD_WIDTH) "s ", "N/A");
-			}
-		}
-	}
-	printf("\n");
+    /* 99%ile Latency */
+    if (fp) {
+        fmt::fprintf(fp, "}, \"p99Latency\": {");
+    }
+    put_title("99.0 pctile");
+    first_op = 1;
+    for (auto op = 0; op < MAX_OP; op++) {
+        if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
+            if (data_points[op].empty() || !final_stats.get_latency_us_total(op)) {
+                put_field("N/A");
+                continue;
+            }
+            const auto num_points = data_points[op].size();
+            const auto point_99pct =
+                static_cast<size_t>(std::max(0., (num_points * 0.99) - 1));
+            put_field(data_points[op][point_99pct]);
+            if (fp) {
+                if (first_op) {
+                    first_op = 0;
+                } else {
+                    fmt::fprintf(fp, ",");
+                }
+                fmt::fprintf(fp, "\"%s\": %lu",
+                             get_ops_name(op), data_points[op][point_99pct]);
+            }
+        }
+    }
+    fmt::print("\n");
 
-	/* 95%ile Latency */
-	if (fp) {
-		fprintf(fp, "}, \"p95Latency\": {");
-	}
-	printf("%-" STR(STATS_TITLE_WIDTH) "s ", "95.0 pctile");
-	first_op = 1;
-	for (op = 0; op < MAX_OP; op++) {
-		if (args->txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-			if (dataPoints[op] == NULL) {
-				printf("%" STR(STATS_FIELD_WIDTH) "s ", "N/A");
-				continue;
-			}
-			if (lat_total[op]) {
-				point_95pct = ((float)(num_points[op]) * 0.95) - 1;
-				printf("%" STR(STATS_FIELD_WIDTH) PRIu64 " ", dataPoints[op][point_95pct]);
-				if (fp) {
-					if (first_op) {
-						first_op = 0;
-					} else {
-						fprintf(fp, ",");
-					}
-					fprintf(fp, "\"%s\": %" PRIu64, get_ops_name(op), dataPoints[op][point_95pct]);
-				}
-			} else {
-				printf("%" STR(STATS_FIELD_WIDTH) "s ", "N/A");
-			}
-		}
-	}
-	printf("\n");
+    /* 99.9%ile Latency */
+    if (fp) {
+        fmt::fprintf(fp, "}, \"p99.9Latency\": {");
+    }
+    put_title("99.9 pctile");
+    first_op = 1;
+    for (auto op = 0; op < MAX_OP; op++) {
+        if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
+            if (data_points[op].empty() || !final_stats.get_latency_us_total(op)) {
+                put_field("N/A");
+                continue;
+            }
+            const auto num_points = data_points[op].size();
+            const auto point_99_9pct =
+                static_cast<size_t>(std::max(0., (num_points * 0.999) - 1));
+            put_field(data_points[op][point_99_9pct]);
+            if (fp) {
+                if (first_op) {
+                    first_op = 0;
+                } else {
+                    fmt::fprintf(fp, ",");
+                }
+                fmt::fprintf(fp, "\"%s\": %lu",
+                             get_ops_name(op), data_points[op][point_99_9pct]);
+            }
+        }
+    }
+    fmt::print("\n");
+    if (fp) {
+        fmt::fprintf(fp, "}}");
+    }
 
-	/* 99%ile Latency */
-	if (fp) {
-		fprintf(fp, "}, \"p99Latency\": {");
-	}
-	printf("%-" STR(STATS_TITLE_WIDTH) "s ", "99.0 pctile");
-	first_op = 1;
-	for (op = 0; op < MAX_OP; op++) {
-		if (args->txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-			if (dataPoints[op] == NULL) {
-				printf("%" STR(STATS_FIELD_WIDTH) "s ", "N/A");
-				continue;
-			}
-			if (lat_total[op]) {
-				point_99pct = ((float)(num_points[op]) * 0.99) - 1;
-				printf("%" STR(STATS_FIELD_WIDTH) PRIu64 " ", dataPoints[op][point_99pct]);
-				if (fp) {
-					if (first_op) {
-						first_op = 0;
-					} else {
-						fprintf(fp, ",");
-					}
-					fprintf(fp, "\"%s\": %" PRIu64, get_ops_name(op), dataPoints[op][point_99pct]);
-				}
-			} else {
-				printf("%" STR(STATS_FIELD_WIDTH) "s ", "N/A");
-			}
-		}
-	}
-	printf("\n");
-
-	/* 99.9%ile Latency */
-	if (fp) {
-		fprintf(fp, "}, \"p99.9Latency\": {");
-	}
-	printf("%-" STR(STATS_TITLE_WIDTH) "s ", "99.9 pctile");
-	first_op = 1;
-	for (op = 0; op < MAX_OP; op++) {
-		if (args->txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-			if (dataPoints[op] == NULL) {
-				printf("%" STR(STATS_FIELD_WIDTH) "s ", "N/A");
-				continue;
-			}
-			if (lat_total[op]) {
-				point_99_9pct = ((float)(num_points[op]) * 0.999) - 1;
-				printf("%" STR(STATS_FIELD_WIDTH) PRIu64 " ", dataPoints[op][point_99_9pct]);
-				if (fp) {
-					if (first_op) {
-						first_op = 0;
-					} else {
-						fprintf(fp, ",");
-					}
-					fprintf(fp, "\"%s\": %" PRIu64, get_ops_name(op), dataPoints[op][point_99_9pct]);
-				}
-			} else {
-				printf("%" STR(STATS_FIELD_WIDTH) "s ", "N/A");
-			}
-		}
-	}
-	printf("\n");
-	if (fp) {
-		fprintf(fp, "}}");
-	}
-
-	char command_remove[NAME_MAX] = { '\0' };
-	sprintf(command_remove, "rm -rf %s%d", TEMP_DATA_STORE, *pid_main);
-	system(command_remove);
-
-	for (op = 0; op < MAX_OP; op++) {
-		if (args->txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION) {
-			if (lat_total[op])
-				free(dataPoints[op]);
-		}
-	}
+    const auto command_remove = fmt::format("rm -rf {}{}", TEMP_DATA_STORE, pid_main);
+    system(command_remove.c_str());
 }
 
-int stats_process_main(mako_args_t* args,
+int stats_process_main(mako_args_t const& args,
                        mako_stats_t* stats,
-                       volatile double* throttle_factor,
-                       volatile int* signal,
-                       volatile int* stopcount,
-                       pid_t* pid_main) {
-	struct timespec timer_start, timer_prev, timer_now;
-	double sin_factor;
-	int first_stats = 1;
+                       std::atomic<double>& throttle_factor,
+                       std::atomic<int>& signal,
+                       std::atomic<int>& stopcount,
+                       pid_t pid_main) {
+    bool first_stats = true;
 
-	/* wait until the signal turn on */
-	while (*signal == SIGNAL_OFF) {
-		usleep(10000); /* 10ms */
-	}
+    /* wait until the signal turn on */
+    while (signal.load() == SIGNAL_OFF) {
+        usleep(10000); /* 10ms */
+    }
 
-	if (args->verbose >= VERBOSE_DEFAULT)
-		print_stats_header(args, false, true, false);
+    if (args.verbose >= VERBOSE_DEFAULT)
+        print_stats_header(args, false, true, false);
 
-	FILE* fp = NULL;
-	if (args->json_output_path[0] != '\0') {
-		fp = fopen(args->json_output_path, "w");
-		fprintf(fp, "{\"makoArgs\": {");
-		fprintf(fp, "\"api_version\": %d,", args->api_version);
-		fprintf(fp, "\"json\": %d,", args->json);
-		fprintf(fp, "\"num_processes\": %d,", args->num_processes);
-		fprintf(fp, "\"num_threads\": %d,", args->num_threads);
-		fprintf(fp, "\"mode\": %d,", args->mode);
-		fprintf(fp, "\"rows\": %d,", args->rows);
-		fprintf(fp, "\"seconds\": %d,", args->seconds);
-		fprintf(fp, "\"iteration\": %d,", args->iteration);
-		fprintf(fp, "\"tpsmax\": %d,", args->tpsmax);
-		fprintf(fp, "\"tpsmin\": %d,", args->tpsmin);
-		fprintf(fp, "\"tpsinterval\": %d,", args->tpsinterval);
-		fprintf(fp, "\"tpschange\": %d,", args->tpschange);
-		fprintf(fp, "\"sampling\": %d,", args->sampling);
-		fprintf(fp, "\"key_length\": %d,", args->key_length);
-		fprintf(fp, "\"value_length\": %d,", args->value_length);
-		fprintf(fp, "\"commit_get\": %d,", args->commit_get);
-		fprintf(fp, "\"verbose\": %d,", args->verbose);
-		fprintf(fp, "\"cluster_files\": \"%s\",", args->cluster_files[0]);
-		fprintf(fp, "\"log_group\": \"%s\",", args->log_group);
-		fprintf(fp, "\"prefixpadding\": %d,", args->prefixpadding);
-		fprintf(fp, "\"trace\": %d,", args->trace);
-		fprintf(fp, "\"tracepath\": \"%s\",", args->tracepath);
-		fprintf(fp, "\"traceformat\": %d,", args->traceformat);
-		fprintf(fp, "\"knobs\": \"%s\",", args->knobs);
-		fprintf(fp, "\"flatbuffers\": %d,", args->flatbuffers);
-		fprintf(fp, "\"txntrace\": %d,", args->txntrace);
-		fprintf(fp, "\"txntagging\": %d,", args->txntagging);
-		fprintf(fp, "\"txntagging_prefix\": \"%s\",", args->txntagging_prefix);
-		fprintf(fp, "\"streaming_mode\": %d,", args->streaming_mode);
-		fprintf(fp, "\"disable_ryw\": %d,", args->disable_ryw);
-		fprintf(fp, "\"json_output_path\": \"%s\"", args->json_output_path);
-		fprintf(fp, "},\"samples\": [");
-	}
+    FILE* fp = NULL;
+    if (args.json_output_path[0] != '\0') {
+        fp = fopen(args.json_output_path, "w");
+        fmt::fprintf(fp, "{\"makoArgs\": {");
+        fmt::fprintf(fp, "\"api_version\": %d,", args.api_version);
+        fmt::fprintf(fp, "\"json\": %d,", args.json);
+        fmt::fprintf(fp, "\"num_processes\": %d,", args.num_processes);
+        fmt::fprintf(fp, "\"num_threads\": %d,", args.num_threads);
+        fmt::fprintf(fp, "\"mode\": %d,", args.mode);
+        fmt::fprintf(fp, "\"rows\": %d,", args.rows);
+        fmt::fprintf(fp, "\"seconds\": %d,", args.seconds);
+        fmt::fprintf(fp, "\"iteration\": %d,", args.iteration);
+        fmt::fprintf(fp, "\"tpsmax\": %d,", args.tpsmax);
+        fmt::fprintf(fp, "\"tpsmin\": %d,", args.tpsmin);
+        fmt::fprintf(fp, "\"tpsinterval\": %d,", args.tpsinterval);
+        fmt::fprintf(fp, "\"tpschange\": %d,", args.tpschange);
+        fmt::fprintf(fp, "\"sampling\": %d,", args.sampling);
+        fmt::fprintf(fp, "\"key_length\": %d,", args.key_length);
+        fmt::fprintf(fp, "\"value_length\": %d,", args.value_length);
+        fmt::fprintf(fp, "\"commit_get\": %d,", args.commit_get);
+        fmt::fprintf(fp, "\"verbose\": %d,", args.verbose);
+        fmt::fprintf(fp, "\"cluster_files\": \"%s\",", args.cluster_files[0]);
+        fmt::fprintf(fp, "\"log_group\": \"%s\",", args.log_group);
+        fmt::fprintf(fp, "\"prefixpadding\": %d,", args.prefixpadding);
+        fmt::fprintf(fp, "\"trace\": %d,", args.trace);
+        fmt::fprintf(fp, "\"tracepath\": \"%s\",", args.tracepath);
+        fmt::fprintf(fp, "\"traceformat\": %d,", args.traceformat);
+        fmt::fprintf(fp, "\"knobs\": \"%s\",", args.knobs);
+        fmt::fprintf(fp, "\"flatbuffers\": %d,", args.flatbuffers);
+        fmt::fprintf(fp, "\"txntrace\": %d,", args.txntrace);
+        fmt::fprintf(fp, "\"txntagging\": %d,", args.txntagging);
+        fmt::fprintf(fp, "\"txntagging_prefix\": \"%s\",", args.txntagging_prefix);
+        fmt::fprintf(fp, "\"streaming_mode\": %d,", args.streaming_mode);
+        fmt::fprintf(fp, "\"disable_ryw\": %d,", args.disable_ryw);
+        fmt::fprintf(fp, "\"json_output_path\": \"%s\"", args.json_output_path);
+        fmt::fprintf(fp, "},\"samples\": [");
+    }
 
-	clock_gettime(CLOCK_MONOTONIC_COARSE, &timer_start);
-	timer_prev.tv_sec = timer_start.tv_sec;
-	timer_prev.tv_nsec = timer_start.tv_nsec;
-	while (*signal != SIGNAL_RED) {
-		usleep(100000); /* sleep for 100ms */
-		clock_gettime(CLOCK_MONOTONIC_COARSE, &timer_now);
+    const auto time_start = steady_clock::now();
+    auto time_prev = time_start;
+    while (signal.load() != SIGNAL_RED) {
+        usleep(100000); /* sleep for 100ms */
+        auto time_now = steady_clock::now();
 
-		/* print stats every (roughly) 1 sec */
-		if (timer_now.tv_sec > timer_prev.tv_sec) {
+        /* print stats every (roughly) 1 sec */
+        if (to_double_seconds(time_now - time_prev) >= 1.0) {
 
-			/* adjust throttle rate if needed */
-			if (args->tpsmax != args->tpsmin) {
-				/* set the throttle factor between 0.0 and 1.0 */
-				switch (args->tpschange) {
-				case TPS_SIN:
-					sin_factor =
-					    sin((timer_now.tv_sec % args->tpsinterval) / (double)args->tpsinterval * M_PI * 2) / 2.0 + 0.5;
-					*throttle_factor = 1 - (sin_factor * (1.0 - ((double)args->tpsmin / args->tpsmax)));
-					break;
-				case TPS_SQUARE:
-					if (timer_now.tv_sec % args->tpsinterval < (args->tpsinterval / 2)) {
-						/* set to max */
-						*throttle_factor = 1.0;
-					} else {
-						/* set to min */
-						*throttle_factor = (double)args->tpsmin / (double)args->tpsmax;
-					}
-					break;
-				case TPS_PULSE:
-					if (timer_now.tv_sec % args->tpsinterval == 0) {
-						/* set to max */
-						*throttle_factor = 1.0;
-					} else {
-						/* set to min */
-						*throttle_factor = (double)args->tpsmin / (double)args->tpsmax;
-					}
-					break;
-				}
-			}
+            /* adjust throttle rate if needed */
+            if (args.tpsmax != args.tpsmin) {
+                const auto tpsinterval = static_cast<double>(args.tpsinterval);
+                const auto tpsmin = static_cast<double>(args.tpsmin);
+                const auto tpsmax = static_cast<double>(args.tpsmax);
+                const auto pos = fmod(to_double_seconds(time_now - time_start), tpsinterval);
+                auto sin_factor = 0.;
+                /* set the throttle factor between 0.0 and 1.0 */
+                switch (args.tpschange) {
+                case TPS_SIN:
+                    sin_factor = sin(pos / tpsinterval * M_PI * 2.0) / 2.0 + 0.5;
+                    throttle_factor = 1 - (sin_factor * (1.0 - (tpsmin / tpsmax)));
+                    break;
+                case TPS_SQUARE:
+                    if (pos < (args.tpsinterval / 2)) {
+                        /* set to max */
+                        throttle_factor = 1.0;
+                    } else {
+                        /* set to min */
+                        throttle_factor = tpsmin / tpsmax;
+                    }
+                    break;
+                case TPS_PULSE:
+                    if (pos < (1.0 / tpsinterval)) {
+                        /* set to max */
+                        throttle_factor = 1.0;
+                    } else {
+                        /* set to min */
+                        throttle_factor = tpsmin / tpsmax;
+                    }
+                    break;
+                }
+            }
 
-			if (args->verbose >= VERBOSE_DEFAULT) {
-				if (first_stats) {
-					first_stats = 0;
-				} else {
-					if (fp)
-						fprintf(fp, ",");
-				}
-				print_stats(args, stats, &timer_now, &timer_prev, fp);
-			}
-			timer_prev.tv_sec = timer_now.tv_sec;
-			timer_prev.tv_nsec = timer_now.tv_nsec;
-		}
-	}
+            if (args.verbose >= VERBOSE_DEFAULT) {
+                if (first_stats) {
+                    first_stats = false;
+                } else {
+                    if (fp)
+                        fmt::fprintf(fp, ",");
+                }
+                print_stats(args, stats, to_double_seconds(time_now - time_prev), fp);
+            }
+            time_prev = time_now;
+        }
+    }
 
-	if (fp) {
-		fprintf(fp, "],");
-	}
+    if (fp) {
+        fmt::fprintf(fp, "],");
+    }
 
-	/* print report */
-	if (args->verbose >= VERBOSE_DEFAULT) {
-		clock_gettime(CLOCK_MONOTONIC_COARSE, &timer_now);
-		while (*stopcount < args->num_threads * args->num_processes) {
-			usleep(10000); /* 10ms */
-		}
-		print_report(args, stats, &timer_now, &timer_start, pid_main, fp);
-	}
+    /* print report */
+    if (args.verbose >= VERBOSE_DEFAULT) {
+        auto time_now = steady_clock::now();
+        while (stopcount.load() < args.num_threads * args.num_processes) {
+            usleep(10000); /* 10ms */
+        }
+        print_report(args, stats, to_double_seconds(time_now - time_start), pid_main, fp);
+    }
 
-	if (fp) {
-		fprintf(fp, "}");
-		fclose(fp);
-	}
+    if (fp) {
+        fmt::fprintf(fp, "}");
+        fclose(fp);
+    }
 
-	return 0;
+    return 0;
 }
 
 int main(int argc, char* argv[]) {
-	int rc;
-	mako_args_t args;
-	int p;
-	pid_t* worker_pids = NULL;
-	proc_type_t proc_type = proc_master;
-	int worker_id;
-	pid_t pid;
-	int status;
-	mako_shmhdr_t* shm; /* shmhdr + stats */
-	int shmfd;
-	char shmpath[NAME_MAX];
-	size_t shmsize;
-	mako_stats_t* stats;
-	pid_t pid_main;
+    setlinebuf(stdout);
 
-	setlinebuf(stdout);
+    auto rc = int{};
+    auto args = mako_args_t{};
+    rc = init_args(&args);
+    if (rc < 0) {
+        fmt::print(stderr, "ERROR: init_args failed\n");
+        return -1;
+    }
+    rc = parse_args(argc, argv, &args);
+    if (rc < 0) {
+        /* usage printed */
+        return 0;
+    }
 
-	rc = init_args(&args);
-	if (rc < 0) {
-		fprintf(stderr, "ERROR: init_args failed\n");
-		return -1;
-	}
-	rc = parse_args(argc, argv, &args);
-	if (rc < 0) {
-		/* usage printed */
-		return 0;
-	}
+    rc = validate_args(&args);
+    if (rc < 0)
+        return -1;
 
-	rc = validate_args(&args);
-	if (rc < 0)
-		return -1;
+    if (args.mode == MODE_CLEAN) {
+        /* cleanup will be done from a single thread */
+        args.num_processes = 1;
+        args.num_threads = 1;
+    }
 
-	if (args.mode == MODE_CLEAN) {
-		/* cleanup will be done from a single thread */
-		args.num_processes = 1;
-		args.num_threads = 1;
-	}
+    if (args.mode == MODE_BUILD) {
+        if (args.txnspec.ops[OP_INSERT][OP_COUNT] == 0) {
+            parse_transaction(&args, "i100");
+        }
+    }
 
-	if (args.mode == MODE_BUILD) {
-		if (args.txnspec.ops[OP_INSERT][OP_COUNT] == 0) {
-			parse_transaction(&args, "i100");
-		}
-	}
+    const auto pid_main = getpid();
+    /* create the shared memory for stats */
+    const auto shmpath = fmt::format("mako{}", pid_main);
+    auto shmfd = shm_open(shmpath.c_str(), O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
+    if (shmfd < 0) {
+        fmt::print(stderr, "ERROR: shm_open failed\n");
+        return -1;
+    }
+    auto shmfd_guard = exit_guard([shmfd, &shmpath]() {
+            close(shmfd);
+            shm_unlink(shmpath.c_str());
+            unlink(shmpath.c_str());
+        });
 
-	pid_main = getpid();
-	/* create the shared memory for stats */
-	sprintf(shmpath, "mako%d", pid_main);
-	shmfd = shm_open(shmpath, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
-	if (shmfd < 0) {
-		fprintf(stderr, "ERROR: shm_open failed\n");
-		return -1;
-	}
+    /* allocate */
+    const auto shmsize = sizeof(mako_shmhdr_t) + (sizeof(mako_stats_t) * args.num_processes * args.num_threads);
+    auto shm = static_cast<mako_shmhdr_t*>(nullptr);
+    if (ftruncate(shmfd, shmsize) < 0) {
+        shm = static_cast<mako_shmhdr_t*>(MAP_FAILED);
+        fmt::print(stderr, "ERROR: ftruncate (fd:{} size:{}) failed\n", shmfd, shmsize);
+        return -1;
+    }
 
-	/* allocate */
-	shmsize = sizeof(mako_shmhdr_t) + (sizeof(mako_stats_t) * args.num_processes * args.num_threads);
-	if (ftruncate(shmfd, shmsize) < 0) {
-		shm = MAP_FAILED;
-		fprintf(stderr, "ERROR: ftruncate (fd:%d size:%llu) failed\n", shmfd, (unsigned long long)shmsize);
-		goto failExit;
-	}
+    /* map it */
+    shm = static_cast<mako_shmhdr_t*>(
+            mmap(NULL, shmsize, PROT_READ | PROT_WRITE, MAP_SHARED, shmfd, 0));
+    if (shm == MAP_FAILED) {
+        fmt::print(stderr, "ERROR: mmap (fd:{} size:{}) failed\n", shmfd, shmsize);
+        return -1;
+    }
+    auto munmap_guard = exit_guard([=]() { munmap(shm, shmsize); });
 
-	/* map it */
-	shm = (mako_shmhdr_t*)mmap(NULL, shmsize, PROT_READ | PROT_WRITE, MAP_SHARED, shmfd, 0);
-	if (shm == MAP_FAILED) {
-		fprintf(stderr, "ERROR: mmap (fd:%d size:%llu) failed\n", shmfd, (unsigned long long)shmsize);
-		goto failExit;
-	}
+    static_assert(std::is_same_v<decltype(shm), mako_shmhdr_t*>);
+    auto stats = reinterpret_cast<mako_stats_t*>(shm + 1);
 
-	stats = (mako_stats_t*)((void*)shm + sizeof(mako_shmhdr_t));
+    /* initialize the shared memory */
+    memset(shm, 0, shmsize);
 
-	/* initialize the shared memory */
-	memset(shm, 0, shmsize);
+    /* get ready */
+    shm->signal = SIGNAL_OFF;
+    shm->readycount = 0;
+    shm->stopcount = 0;
+    shm->throttle_factor = 1.0;
 
-	/* get ready */
-	shm->signal = SIGNAL_OFF;
-	shm->readycount = 0;
-	shm->stopcount = 0;
-	shm->throttle_factor = 1.0;
+    auto proc_type = proc_master;
+    /* fork worker processes + 1 stats process */
+    auto worker_pids = std::vector<pid_t>(args.num_processes + 1);
 
-	/* fork worker processes + 1 stats process */
-	worker_pids = (pid_t*)calloc(sizeof(pid_t), args.num_processes + 1);
-	if (!worker_pids) {
-		fprintf(stderr, "ERROR: cannot allocate worker_pids (%d processes)\n", args.num_processes);
-		goto failExit;
-	}
+    auto worker_id = int{};
 
-	/* forking (num_process + 1) children */
-	/* last process is the stats handler */
-	for (p = 0; p < args.num_processes + 1; p++) {
-		pid = fork();
-		if (pid != 0) {
-			/* master */
-			worker_pids[p] = pid;
-			if (args.verbose == VERBOSE_DEBUG) {
-				printf("DEBUG: worker %d (PID:%d) forked\n", p, worker_pids[p]);
-			}
-		} else {
-			if (p < args.num_processes) {
-				/* worker process */
-				proc_type = proc_worker;
-				worker_id = p;
-			} else {
-				/* stats */
-				proc_type = proc_stats;
-			}
-			break;
-		}
-	}
+    /* forking (num_process + 1) children */
+    /* last process is the stats handler */
+    for (auto p = 0; p < args.num_processes + 1; p++) {
+        auto pid = fork();
+        if (pid != 0) {
+            /* master */
+            worker_pids[p] = pid;
+            if (args.verbose == VERBOSE_DEBUG) {
+                printf("DEBUG: worker %d (PID:%d) forked\n", p, worker_pids[p]);
+            }
+        } else {
+            if (p < args.num_processes) {
+                /* worker process */
+                proc_type = proc_worker;
+                worker_id = p;
+            } else {
+                /* stats */
+                proc_type = proc_stats;
+            }
+            break;
+        }
+    }
 
-	/* initialize the randomizer */
-	srand(time(0) * getpid());
+    /* initialize the randomizer */
+    srand(time(0) * getpid());
 
-	/* initialize zipfian if necessary (per-process) */
-	if (args.zipf) {
-		zipfian_generator(args.rows);
-	}
+    /* initialize zipfian if necessary (per-process) */
+    if (args.zipf) {
+        zipfian_generator(args.rows);
+    }
 
-	if (proc_type == proc_worker) {
-		/* worker process */
-		worker_process_main(&args, worker_id, shm, &pid_main);
-		/* worker can exit here */
-		exit(0);
-	} else if (proc_type == proc_stats) {
-		/* stats */
-		if (args.mode == MODE_CLEAN) {
-			/* no stats needed for clean mode */
-			exit(0);
-		}
-		stats_process_main(&args, stats, &shm->throttle_factor, &shm->signal, &shm->stopcount, &pid_main);
-		exit(0);
-	}
+    if (proc_type == proc_worker) {
+        /* worker process */
+        worker_process_main(args, worker_id, shm, pid_main);
+        /* worker can exit here */
+        exit(0);
+    } else if (proc_type == proc_stats) {
+        /* stats */
+        if (args.mode == MODE_CLEAN) {
+            /* no stats needed for clean mode */
+            exit(0);
+        }
+        stats_process_main(args, stats, shm->throttle_factor, shm->signal, shm->stopcount, pid_main);
+        exit(0);
+    }
 
-	/* master */
-	/* wait for everyone to be ready */
-	while (shm->readycount < (args.num_processes * args.num_threads)) {
-		usleep(1000);
-	}
-	shm->signal = SIGNAL_GREEN;
+    /* master */
+    /* wait for everyone to be ready */
+    while (shm->readycount < (args.num_processes * args.num_threads)) {
+        usleep(1000);
+    }
+    shm->signal = SIGNAL_GREEN;
 
-	if (args.mode == MODE_RUN) {
-		struct timespec timer_start, timer_now;
+    if (args.mode == MODE_RUN) {
+        /* run the benchmark */
 
-		/* run the benchamrk */
+        /* if seconds is specified, stop child processes after the specified
+         * duration */
+        if (args.seconds > 0) {
+            if (args.verbose == VERBOSE_DEBUG) {
+                printf("DEBUG: master sleeping for %d seconds\n", args.seconds);
+            }
 
-		/* if seconds is specified, stop child processes after the specified
-		 * duration */
-		if (args.seconds > 0) {
-			if (args.verbose == VERBOSE_DEBUG) {
-				printf("DEBUG: master sleeping for %d seconds\n", args.seconds);
-			}
+            auto time_start = steady_clock::now();
+            while (1) {
+                usleep(100000); /* sleep for 100ms */
+                auto time_now = steady_clock::now();
+                /* doesn't have to be precise */
+                if (to_double_seconds(time_now - time_start) > args.seconds) {
+                    if (args.verbose == VERBOSE_DEBUG) {
+                        printf("DEBUG: time's up (%d seconds)\n", args.seconds);
+                    }
+                    break;
+                }
+            }
 
-			clock_gettime(CLOCK_MONOTONIC_COARSE, &timer_start);
-			while (1) {
-				usleep(100000); /* sleep for 100ms */
-				clock_gettime(CLOCK_MONOTONIC_COARSE, &timer_now);
-				/* doesn't have to be precise */
-				if (timer_now.tv_sec - timer_start.tv_sec > args.seconds) {
-					if (args.verbose == VERBOSE_DEBUG) {
-						printf("DEBUG: time's up (%d seconds)\n", args.seconds);
-					}
-					break;
-				}
-			}
+            /* notify everyone the time's up */
+            shm->signal = SIGNAL_RED;
+        }
+    }
 
-			/* notify everyone the time's up */
-			shm->signal = SIGNAL_RED;
-		}
-	}
+    auto status = int{};
+    /* wait for worker processes to exit */
+    for (auto p = 0; p < args.num_processes; p++) {
+        if (args.verbose == VERBOSE_DEBUG) {
+            fmt::print("DEBUG: waiting worker {} (PID:{}) to exit\n", p, worker_pids[p]);
+        }
+        auto pid = waitpid(worker_pids[p], &status, 0 /* or what? */);
+        if (pid < 0) {
+            fmt::print(stderr, "ERROR: waitpid failed for worker process PID {}\n",
+                       worker_pids[p]);
+        }
+        if (args.verbose == VERBOSE_DEBUG) {
+            fmt::print("DEBUG: worker {} (PID:{}) exited\n", p, worker_pids[p]);
+        }
+    }
 
-	/* wait for worker processes to exit */
-	for (p = 0; p < args.num_processes; p++) {
-		if (args.verbose == VERBOSE_DEBUG) {
-			printf("DEBUG: waiting worker %d (PID:%d) to exit\n", p, worker_pids[p]);
-		}
-		pid = waitpid(worker_pids[p], &status, 0 /* or what? */);
-		if (pid < 0) {
-			fprintf(stderr, "ERROR: waitpid failed for worker process PID %d\n", worker_pids[p]);
-		}
-		if (args.verbose == VERBOSE_DEBUG) {
-			printf("DEBUG: worker %d (PID:%d) exited\n", p, worker_pids[p]);
-		}
-	}
+    /* all worker threads finished, stop the stats */
+    if (args.mode == MODE_BUILD || args.iteration > 0) {
+        shm->signal = SIGNAL_RED;
+    }
 
-	/* all worker threads finished, stop the stats */
-	if (args.mode == MODE_BUILD || args.iteration > 0) {
-		shm->signal = SIGNAL_RED;
-	}
+    /* wait for stats to stop */
+    auto pid = waitpid(worker_pids[args.num_processes], &status, 0 /* or what? */);
+    if (pid < 0) {
+        fmt::print(stderr, "ERROR: waitpid failed for stats process PID {}\n",
+                   worker_pids[args.num_processes]);
+    }
 
-	/* wait for stats to stop */
-	pid = waitpid(worker_pids[args.num_processes], &status, 0 /* or what? */);
-	if (pid < 0) {
-		fprintf(stderr, "ERROR: waitpid failed for stats process PID %d\n", worker_pids[args.num_processes]);
-	}
-
-failExit:
-
-	if (worker_pids)
-		free(worker_pids);
-
-	if (shm != MAP_FAILED)
-		munmap(shm, shmsize);
-
-	if (shmfd) {
-		close(shmfd);
-		shm_unlink(shmpath);
-		unlink(shmpath);
-	}
-
-	return 0;
+    return 0;
 }
diff --git a/bindings/c/test/mako/mako.hpp b/bindings/c/test/mako/mako.hpp
index 617ad9265d..d539b6e1a9 100644
--- a/bindings/c/test/mako/mako.hpp
+++ b/bindings/c/test/mako/mako.hpp
@@ -1,12 +1,17 @@
-#ifndef MAKO_H
-#define MAKO_H
+#ifndef MAKO_HPP
+#define MAKO_HPP
 #pragma once
 
 #ifndef FDB_API_VERSION
 #define FDB_API_VERSION 710
 #endif
 
-#include <foundationdb/fdb_c.h>
+#include <array>
+#include <atomic>
+#include <list>
+#include <vector>
+#include <string_view>
+#include <fdb.hpp>
 #include <pthread.h>
 #include <sys/types.h>
 #include <stdbool.h>
@@ -18,192 +23,337 @@
 #include <limits.h>
 #endif
 
-#define VERBOSE_NONE 0
-#define VERBOSE_DEFAULT 1
-#define VERBOSE_ANNOYING 2
-#define VERBOSE_DEBUG 3
+constexpr const int VERBOSE_NONE     = 0;
+constexpr const int VERBOSE_DEFAULT  = 1;
+constexpr const int VERBOSE_ANNOYING = 2;
+constexpr const int VERBOSE_DEBUG    = 3;
 
-#define MODE_INVALID -1
-#define MODE_CLEAN 0
-#define MODE_BUILD 1
-#define MODE_RUN 2
+constexpr const int MODE_INVALID = -1;
+constexpr const int MODE_CLEAN   = 0;
+constexpr const int MODE_BUILD   = 1;
+constexpr const int MODE_RUN     = 2;
 
-#define FDB_SUCCESS 0
-#define FDB_ERROR_RETRY -1
-#define FDB_ERROR_ABORT -2
-#define FDB_ERROR_CONFLICT -3
-
-#define LAT_BLOCK_SIZE 511 /* size of each block to get detailed latency for each operation */
+/* size of each block to get detailed latency for each operation */
+constexpr const size_t LAT_BLOCK_SIZE = 511;
 
 /* transaction specification */
 enum Operations {
-	OP_GETREADVERSION,
-	OP_GET,
-	OP_GETRANGE,
-	OP_SGET,
-	OP_SGETRANGE,
-	OP_UPDATE,
-	OP_INSERT,
-	OP_INSERTRANGE,
-	OP_OVERWRITE,
-	OP_CLEAR,
-	OP_SETCLEAR,
-	OP_CLEARRANGE,
-	OP_SETCLEARRANGE,
-	OP_COMMIT,
-	OP_TRANSACTION, /* pseudo-operation - cumulative time for the operation + commit */
-	OP_READ_BG,
-	MAX_OP /* must be the last item */
+    OP_GETREADVERSION,
+    OP_GET,
+    OP_GETRANGE,
+    OP_SGET,
+    OP_SGETRANGE,
+    OP_UPDATE,
+    OP_INSERT,
+    OP_INSERTRANGE,
+    OP_OVERWRITE,
+    OP_CLEAR,
+    OP_SETCLEAR,
+    OP_CLEARRANGE,
+    OP_SETCLEARRANGE,
+    OP_COMMIT,
+    OP_TRANSACTION, /* pseudo-operation - cumulative time for the operation + commit */
+    OP_READ_BG,
+    MAX_OP /* must be the last item */
 };
 
-#define OP_COUNT 0
-#define OP_RANGE 1
-#define OP_REVERSE 2
+constexpr const int OP_COUNT   = 0;
+constexpr const int OP_RANGE   = 1;
+constexpr const int OP_REVERSE = 2;
 
 /* for long arguments */
 enum Arguments {
-	ARG_KEYLEN,
-	ARG_VALLEN,
-	ARG_TPS,
-	ARG_COMMITGET,
-	ARG_SAMPLING,
-	ARG_VERSION,
-	ARG_KNOBS,
-	ARG_FLATBUFFERS,
-	ARG_LOGGROUP,
-	ARG_PREFIXPADDING,
-	ARG_TRACE,
-	ARG_TRACEPATH,
-	ARG_TRACEFORMAT,
-	ARG_TPSMAX,
-	ARG_TPSMIN,
-	ARG_TPSINTERVAL,
-	ARG_TPSCHANGE,
-	ARG_TXNTRACE,
-	ARG_TXNTAGGING,
-	ARG_TXNTAGGINGPREFIX,
-	ARG_STREAMING_MODE,
-	ARG_DISABLE_RYW,
-	ARG_CLIENT_THREADS_PER_VERSION,
-	ARG_JSON_REPORT,
-	ARG_BG_FILE_PATH // if blob granule files are stored locally, mako will read and materialize them if this is set
+    ARG_KEYLEN,
+    ARG_VALLEN,
+    ARG_TPS,
+    ARG_COMMITGET,
+    ARG_SAMPLING,
+    ARG_VERSION,
+    ARG_KNOBS,
+    ARG_FLATBUFFERS,
+    ARG_LOGGROUP,
+    ARG_PREFIXPADDING,
+    ARG_TRACE,
+    ARG_TRACEPATH,
+    ARG_TRACEFORMAT,
+    ARG_TPSMAX,
+    ARG_TPSMIN,
+    ARG_TPSINTERVAL,
+    ARG_TPSCHANGE,
+    ARG_TXNTRACE,
+    ARG_TXNTAGGING,
+    ARG_TXNTAGGINGPREFIX,
+    ARG_STREAMING_MODE,
+    ARG_DISABLE_RYW,
+    ARG_CLIENT_THREADS_PER_VERSION,
+    ARG_JSON_REPORT,
+    ARG_BG_FILE_PATH // if blob granule files are stored locally, mako will read and materialize them if this is set
 };
 
 enum TPSChangeTypes { TPS_SIN, TPS_SQUARE, TPS_PULSE };
 
-#define KEYPREFIX "mako"
-#define KEYPREFIXLEN 4
-
-#define TEMP_DATA_STORE "/tmp/makoTemp"
-
 /* we set mako_txnspec_t and mako_args_t only once in the master process,
  * and won't be touched by child processes.
  */
 
 typedef struct {
-	/* for each operation, it stores "count", "range" and "reverse" */
-	int ops[MAX_OP][3];
+    /* for each operation, it stores "count", "range" and "reverse" */
+    int ops[MAX_OP][3];
 } mako_txnspec_t;
 
-#define LOGGROUP_MAX 256
-#define KNOB_MAX 256
-#define TAGPREFIXLENGTH_MAX 8
-#define NUM_CLUSTERS_MAX 3
-#define NUM_DATABASES_MAX 10
-#define MAX_BG_IDS 1000
+constexpr const int LOGGROUP_MAX        = 256;
+constexpr const int KNOB_MAX            = 256;
+constexpr const int TAGPREFIXLENGTH_MAX = 8;
+constexpr const int NUM_CLUSTERS_MAX    = 3;
+constexpr const int NUM_DATABASES_MAX   = 10;
+constexpr const int MAX_BG_IDS          = 1000;
 
 /* benchmark parameters */
-typedef struct {
-	int api_version;
-	int json;
-	int num_processes;
-	int num_threads;
-	int mode;
-	int rows; /* is 2 billion enough? */
-	int seconds;
-	int iteration;
-	int tpsmax;
-	int tpsmin;
-	int tpsinterval;
-	int tpschange;
-	int sampling;
-	int key_length;
-	int value_length;
-	int zipf;
-	int commit_get;
-	int verbose;
-	mako_txnspec_t txnspec;
-	char cluster_files[NUM_CLUSTERS_MAX][PATH_MAX];
-	int num_fdb_clusters;
-	int num_databases;
-	char log_group[LOGGROUP_MAX];
-	int prefixpadding;
-	int trace;
-	char tracepath[PATH_MAX];
-	int traceformat; /* 0 - XML, 1 - JSON */
-	char knobs[KNOB_MAX];
-	uint8_t flatbuffers;
-	int txntrace;
-	int txntagging;
-	char txntagging_prefix[TAGPREFIXLENGTH_MAX];
-	FDBStreamingMode streaming_mode;
-	int client_threads_per_version;
-	int disable_ryw;
-	char json_output_path[PATH_MAX];
-	bool bg_materialize_files;
-	char bg_file_path[PATH_MAX];
-} mako_args_t;
+struct mako_args_t {
+    int api_version;
+    int json;
+    int num_processes;
+    int num_threads;
+    int mode;
+    int rows; /* is 2 billion enough? */
+    int row_digits;
+    int seconds;
+    int iteration;
+    int tpsmax;
+    int tpsmin;
+    int tpsinterval;
+    int tpschange;
+    int sampling;
+    int key_length;
+    int value_length;
+    int zipf;
+    int commit_get;
+    int verbose;
+    mako_txnspec_t txnspec;
+    char cluster_files[NUM_CLUSTERS_MAX][PATH_MAX];
+    int num_fdb_clusters;
+    int num_databases;
+    char log_group[LOGGROUP_MAX];
+    int prefixpadding;
+    int trace;
+    char tracepath[PATH_MAX];
+    int traceformat; /* 0 - XML, 1 - JSON */
+    char knobs[KNOB_MAX];
+    uint8_t flatbuffers;
+    int txntrace;
+    int txntagging;
+    char txntagging_prefix[TAGPREFIXLENGTH_MAX];
+    FDBStreamingMode streaming_mode;
+    int64_t client_threads_per_version;
+    int disable_ryw;
+    char json_output_path[PATH_MAX];
+    bool bg_materialize_files;
+    char bg_file_path[PATH_MAX];
+};
 
 /* shared memory */
-#define SIGNAL_RED 0
-#define SIGNAL_GREEN 1
-#define SIGNAL_OFF 2
+constexpr const int SIGNAL_RED = 0;
+constexpr const int SIGNAL_GREEN = 1;
+constexpr const int SIGNAL_OFF = 2;
 
-typedef struct {
-	int signal;
-	int readycount;
-	double throttle_factor;
-	int stopcount;
-} mako_shmhdr_t;
+struct mako_shmhdr_t {
+    std::atomic<int> signal;
+    std::atomic<int> readycount;
+    std::atomic<double> throttle_factor;
+    std::atomic<int> stopcount;
+};
 
-/* memory block allocated to each operation when collecting detailed latency */
-typedef struct {
-	uint64_t data[LAT_BLOCK_SIZE];
-	void* next_block;
-} lat_block_t;
+class alignas(64) mako_stats_t {
+    uint64_t xacts;
+    uint64_t conflicts;
+    uint64_t total_errors;
+    uint64_t ops[MAX_OP];
+    uint64_t errors[MAX_OP];
+    uint64_t latency_samples[MAX_OP];
+    uint64_t latency_us_total[MAX_OP];
+    uint64_t latency_us_min[MAX_OP];
+    uint64_t latency_us_max[MAX_OP];
+public:
+    mako_stats_t() noexcept {
+        memset(this, 0, sizeof(mako_stats_t));
+        memset(latency_us_max, 0xff, sizeof(latency_us_max));
+    }
 
-typedef struct {
-	uint64_t xacts;
-	uint64_t conflicts;
-	uint64_t ops[MAX_OP];
-	uint64_t errors[MAX_OP];
-	uint64_t latency_samples[MAX_OP];
-	uint64_t latency_us_total[MAX_OP];
-	uint64_t latency_us_min[MAX_OP];
-	uint64_t latency_us_max[MAX_OP];
-} mako_stats_t;
+    mako_stats_t(const mako_stats_t& other) noexcept = default;
+    mako_stats_t& operator=(const mako_stats_t& other) noexcept = default;
+
+    uint64_t get_tx_count() const noexcept {
+        return xacts;
+    }
+
+    uint64_t get_conflict_count() const noexcept {
+        return conflicts;
+    }
+
+    uint64_t get_op_count(int op) const noexcept {
+        return ops[op];
+    }
+
+    uint64_t get_error_count(int op) const noexcept {
+        return errors[op];
+    }
+
+    uint64_t get_total_error_count() const noexcept {
+        return total_errors;
+    }
+
+    uint64_t get_latency_sample_count(int op) const noexcept {
+        return latency_samples[op];
+    }
+
+    uint64_t get_latency_us_total(int op) const noexcept {
+        return latency_us_total[op];
+    }
+
+    uint64_t get_latency_us_min(int op) const noexcept {
+        return latency_us_min[op];
+    }
+
+    uint64_t get_latency_us_max(int op) const noexcept {
+        return latency_us_max[op];
+    }
+
+    // with 'this' as final aggregation, factor in 'other'
+    void combine(const mako_stats_t& other) {
+        xacts += other.xacts;
+        conflicts += other.conflicts;
+        for (auto op = 0; op < MAX_OP; op++) {
+            ops[op] += other.ops[op];
+            errors[op] += other.errors[op];
+            total_errors += other.errors[op];
+            latency_samples[op] += other.latency_samples[op];
+            latency_us_total[op] += other.latency_us_total[op];
+            if (latency_us_min[op] > other.latency_us_min[op])
+                latency_us_min[op] = other.latency_us_min[op];
+            if (latency_us_min[op] < other.latency_us_min[op])
+                latency_us_max[op] = other.latency_us_max[op];
+        }
+    }
+
+    void incr_tx_count() noexcept { xacts++; }
+    void incr_conflict_count() noexcept { conflicts++; }
+
+    // non-commit write operations aren't measured for time.
+    void incr_count_immediate(int op) noexcept { ops[op]++; }
+
+    void incr_error_count(int op) noexcept {
+        total_errors++;
+        errors[op]++;
+    }
+
+    void add_latency(int op, uint64_t latency_us) noexcept {
+        latency_samples[op]++;
+        latency_us_total[op] += latency_us;
+        if (latency_us_min[op] > latency_us)
+            latency_us_min[op] = latency_us;
+        if (latency_us_max[op] < latency_us)
+            latency_us_max[op] = latency_us;
+        ops[op]++;
+    }
+};
 
 /* per-process information */
 typedef struct {
-	int worker_id;
-	pid_t parent_id;
-	mako_args_t* args;
-	mako_shmhdr_t* shm;
-	FDBDatabase* databases[NUM_DATABASES_MAX];
+    int worker_id;
+    pid_t parent_id;
+    mako_args_t* args;
+    mako_shmhdr_t* shm;
+    std::vector<fdb::Database> databases;
 } process_info_t;
 
+/* memory block allocated to each operation when collecting detailed latency */
+class lat_block_t {
+	uint64_t samples[LAT_BLOCK_SIZE]{0, };
+    uint32_t index{0};
+public:
+    lat_block_t() noexcept = default;
+    bool full() const noexcept { return index >= LAT_BLOCK_SIZE; }
+    void put(uint64_t point) {
+        assert(!full());
+        samples[index++] = point;
+    }
+    // return {data block, number of samples}
+    std::pair<uint64_t const*, size_t> data() const noexcept {
+        return {samples, index};
+    }
+};
+
+/* collect sampled latencies */
+class sample_bin {
+    std::list<lat_block_t> blocks;
+public:
+    void reserve_one() {
+        if (blocks.empty())
+            blocks.emplace_back();
+    }
+
+    void put(uint64_t latency_us) {
+        if (blocks.empty() || blocks.back().full())
+            blocks.emplace_back();
+        blocks.back().put(latency_us);
+    }
+
+    // iterate & apply for each block user function void(uint64_t const*, size_t)
+    template <typename Func>
+    void for_each_block(Func&& fn) const {
+        for (const auto& block : blocks) {
+            auto [ptr, cnt] = block.data();
+            fn(ptr, cnt);
+        }
+    }
+};
+
+using sample_bin_array_t = std::array<sample_bin, MAX_OP>;
 /* args for threads */
-typedef struct {
+struct alignas(64) thread_args_t {
 	int thread_id;
 	int database_index; // index of the database to do work to
-	int elem_size[MAX_OP]; /* stores the multiple of LAT_BLOCK_SIZE to check the memory allocation of each operation */
-	bool is_memory_allocated[MAX_OP]; /* flag specified for each operation, whether the memory was allocated to that
-	                                     specific operation */
-	lat_block_t* block[MAX_OP];
+    sample_bin_array_t sample_bins;
 	process_info_t* process;
-} thread_args_t;
+};
 
 /* process type */
 typedef enum { proc_master = 0, proc_worker, proc_stats } proc_type_t;
 
-#endif /* MAKO_H */
+// determines how resultant future will be handled
+enum class StepKind {
+    NONE,    ///< not part of the table: OP_TRANSACTION, OP_COMMIT
+    IMM,     ///< non-future ops that return immediately: e.g. set, clear_range
+    READ,    ///< blockable reads: get(), get_range(), get_read_version, ...
+    COMMIT,  ///< self-explanatory
+    ON_ERROR ///< future is a result of tx.on_error()
+};
+
+class OpDesc {
+    std::string_view name_;
+    std::vector<StepKind> steps_;
+    bool needs_commit_;
+public:
+    OpDesc(std::string_view name, std::vector<StepKind>&& steps, bool needs_commit) :
+        name_(name), steps_(std::move(steps)), needs_commit_(needs_commit)
+    {}
+
+    std::string_view name() const noexcept {
+        return name_;
+    }
+    // what 
+    StepKind step_kind(int step) const noexcept {
+        assert(step < steps());
+        return steps_[step];
+    }
+    // how many steps in this op?
+    int steps() const noexcept {
+        return static_cast<int>(steps_.size());
+    }
+    // does the op needs to commit some time after its final step?
+    bool needs_commit() const noexcept {
+        return needs_commit_;
+    }
+};
+
+#endif /* MAKO_HPP */
diff --git a/bindings/c/test/mako/utils.cpp b/bindings/c/test/mako/utils.cpp
index 0cda133cc4..ba42361593 100644
--- a/bindings/c/test/mako/utils.cpp
+++ b/bindings/c/test/mako/utils.cpp
@@ -1,9 +1,10 @@
-#include "utils.h"
-#include "mako.h"
-#include <math.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
+#include "utils.hpp"
+#include "mako.hpp"
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <fmt/format.h>
 
 /* uniform-distribution random */
 int urand(int low, int high) {
@@ -12,26 +13,6 @@ int urand(int low, int high) {
 	return (int)((r * range) + low);
 }
 
-/* random string */
-/* len is the buffer size, must include null */
-void randstr(char* str, int len) {
-	int i;
-	for (i = 0; i < len - 1; i++) {
-		str[i] = '!' + urand(0, 'z' - '!'); /* generage a char from '!' to 'z' */
-	}
-	str[len - 1] = '\0';
-}
-
-/* random numeric string */
-/* len is the buffer size, must include null */
-void randnumstr(char* str, int len) {
-	int i;
-	for (i = 0; i < len - 1; i++) {
-		str[i] = '0' + urand(0, 9); /* generage a char from '!' to 'z' */
-	}
-	str[len - 1] = '\0';
-}
-
 /* return the first key to be inserted */
 int insert_begin(int rows, int p_idx, int t_idx, int total_p, int total_t) {
 	double interval = (double)rows / total_p / total_t;
@@ -66,71 +47,3 @@ int digits(int num) {
 	}
 	return digits;
 }
-
-/* generate a key for a given key number */
-/* prefix is "mako" by default, prefixpadding = 1 means 'x' will be in front rather than trailing the keyname */
-/* len is the buffer size, key length + null */
-void genkey(char* str, char* prefix, int prefixlen, int prefixpadding, int num, int rows, int len) {
-	const int rowdigit = digits(rows);
-	const int prefixoffset = prefixpadding ? len - (prefixlen + rowdigit) - 1 : 0;
-	char* prefixstr = (char*)alloca(sizeof(char) * (prefixlen + rowdigit + 1));
-	snprintf(prefixstr, prefixlen + rowdigit + 1, "%s%0.*d", prefix, rowdigit, num);
-	memset(str, 'x', len);
-	memcpy(str + prefixoffset, prefixstr, prefixlen + rowdigit);
-	str[len - 1] = '\0';
-}
-
-/* This is another sorting algorithm used to calculate latency parameters */
-/* We moved from radix sort to quick sort to avoid extra space used in radix sort */
-
-#if 0
-uint64_t get_max(uint64_t arr[], int n) {
-	uint64_t mx = arr[0];
-	for (int i = 1; i < n; i++) {
-		if (arr[i] > mx) {
-			mx = arr[i];
-		}
-	}
-	return mx;
-}
-
-void bucket_data(uint64_t arr[], int n, uint64_t exp) {
-	// uint64_t output[n];
-	int i, count[10] = { 0 };
-	uint64_t* output = (uint64_t*)malloc(sizeof(uint64_t) * n);
-
-	for (i = 0; i < n; i++) {
-		count[(arr[i] / exp) % 10]++;
-	}
-	for (i = 1; i < 10; i++) {
-		count[i] += count[i - 1];
-	}
-	for (i = n - 1; i >= 0; i--) {
-		output[count[(arr[i] / exp) % 10] - 1] = arr[i];
-		count[(arr[i] / exp) % 10]--;
-	}
-	for (i = 0; i < n; i++) {
-		arr[i] = output[i];
-	}
-	free(output);
-}
-
-// The main function is to sort arr[] of size n using Radix Sort
-void radix_sort(uint64_t* arr, int n) {
-	// Find the maximum number to know number of digits
-	uint64_t m = get_max(arr, n);
-	for (uint64_t exp = 1; m / exp > 0; exp *= 10) bucket_data(arr, n, exp);
-}
-#endif
-
-int compare(const void* a, const void* b) {
-	const uint64_t* da = (const uint64_t*)a;
-	const uint64_t* db = (const uint64_t*)b;
-
-	return (*da > *db) - (*da < *db);
-}
-
-// The main function is to sort arr[] of size n using Quick Sort
-void quick_sort(uint64_t* arr, int n) {
-	qsort(arr, n, sizeof(uint64_t), compare);
-}
diff --git a/bindings/c/test/mako/utils.hpp b/bindings/c/test/mako/utils.hpp
index 9269e307e0..49beaeed7a 100644
--- a/bindings/c/test/mako/utils.hpp
+++ b/bindings/c/test/mako/utils.hpp
@@ -1,22 +1,40 @@
-#ifndef UTILS_H
-#define UTILS_H
+#ifndef UTILS_HPP
+#define UTILS_HPP
 #pragma once
 
+#include "mako.hpp"
+#include <cassert>
+#include <chrono>
+#include <fmt/format.h>
 #include <stdint.h>
 
 /* uniform-distribution random */
 /* return a uniform random number between low and high, both inclusive */
 int urand(int low, int high);
 
-/* write a random string of the length of (len-1) to memory pointed by str
- * with a null-termination character at str[len-1].
- */
-void randstr(char* str, int len);
+/* random string */
+template <bool Clear=true, typename Char>
+void randstr(std::basic_string<Char>& str, int len) {
+    if constexpr (Clear)
+        str.clear();
+    assert(len >= 0);
+    str.reserve(str.size() + static_cast<size_t>(len));
+	for (auto i = 0; i < len; i++) {
+		str.push_back('!' + urand(0, 'z' - '!')); /* generage a char from '!' to 'z' */
+	}
+}
 
-/* write a random numeric string of the length of (len-1) to memory pointed by str
- * with a null-termination character at str[len-1].
- */
-void randnumstr(char* str, int len);
+/* random numeric string */
+template <bool Clear=true, typename Char>
+void randnumstr(std::basic_string<Char>& str, int len) {
+    if constexpr (Clear)
+        str.clear();
+    assert(len >= 0);
+    str.reserve(str.size() + static_cast<size_t>(len));
+	for (auto i = 0; i < len; i++) {
+		str.push_back('0' + urand(0, 9)); /* generage a char from '0' to '9' */
+	}
+}
 
 /* given the total number of rows to be inserted,
  * the worker process index p_idx and the thread index t_idx (both 0-based),
@@ -46,20 +64,121 @@ int compute_thread_portion(int val, int p_idx, int t_idx, int total_p, int total
 /* get the number of digits */
 int digits(int num);
 
+/* fill (str) with configured key prefix: i.e. non-numeric part
+ * (str) is appended with concat([padding], PREFIX)
+ */
+template <bool Clear=true, typename Char>
+void genkeyprefix(std::basic_string<Char>& str,
+                  std::string_view prefix,
+                  mako_args_t const& args) {
+    // concat('x' * padding_len, key_prefix)
+    if constexpr (Clear)
+        str.clear();
+    const auto padding_len = args.prefixpadding ?
+        (args.key_length - args.row_digits - static_cast<int>(prefix.size())) : 0;
+    assert(padding_len >= 0);
+    str.reserve(str.size() + padding_len + prefix.size());
+    fmt::format_to(std::back_inserter(str),
+                   "{0:x>{1}}{2}", "", padding_len, prefix);
+}
+
 /* generate a key for a given key number */
 /* prefix is "mako" by default, prefixpadding = 1 means 'x' will be in front rather than trailing the keyname */
-/* len is the buffer size, key length + null */
-void genkey(char* str, char* prefix, int prefixlen, int prefixpadding, int num, int rows, int len);
+template <bool Clear=true, typename Char>
+void genkey(std::basic_string<Char>& str,
+            std::string_view prefix,
+            mako_args_t const& args, int num) {
+    static_assert(sizeof(Char) == 1);
+	const auto pad_len = args.prefixpadding ?
+                         args.key_length - (static_cast<int>(prefix.size()) + args.row_digits) : 0;
+    assert(pad_len >= 0);
+    if constexpr (Clear)
+        str.clear();
+    str.reserve(str.size() + static_cast<size_t>(args.key_length));
+    fmt::format_to(std::back_inserter(str),
+                   "{0:x>{1}}{2}{3:0{4}d}{5:x>{6}}",
+                   "", pad_len,
+                   prefix,
+                   num, args.row_digits,
+                   "", args.key_length - pad_len - static_cast<int>(prefix.size()) - args.row_digits);
+}
 
-#if 0
-// The main function is to sort arr[] of size n using Radix Sort
-void radix_sort(uint64_t arr[], int n);
-void bucket_data(uint64_t arr[], int n, uint64_t exp);
-uint64_t get_max(uint64_t arr[], int n);
-#endif
+// invoke user-provided callable when object goes out of scope.
+template <typename Func>
+class exit_guard {
+    std::decay_t<Func> fn;
+public:
+    exit_guard(Func&& fn) : fn(std::forward<Func>(fn)) {}
 
-// The main function is to sort arr[] of size n using Quick Sort
-void quick_sort(uint64_t arr[], int n);
-int compare(const void* a, const void* b);
+    ~exit_guard() {
+        fn();
+    }
+};
 
-#endif /* UTILS_H */
+// invoke user-provided callable when stack unwinds by exception.
+template <typename Func>
+class fail_guard {
+    std::decay_t<Func> fn;
+public:
+    fail_guard(Func&& fn) : fn(std::forward<Func>(fn)) {}
+
+    ~fail_guard() {
+        if (std::uncaught_exceptions()) {
+            fn();
+        }
+    }
+};
+
+// timing helpers
+using std::chrono::steady_clock;
+using timepoint_t = decltype(steady_clock::now());
+
+template <typename Duration>
+double to_double_seconds(Duration duration) {
+    return std::chrono::duration_cast<std::chrono::duration<double>>(duration).count();
+}
+
+template <typename Duration>
+uint64_t to_integer_seconds(Duration duration) {
+    return std::chrono::duration_cast<std::chrono::duration<uint64_t>>(duration).count();
+}
+
+template <typename Duration>
+uint64_t to_integer_microseconds(Duration duration) {
+    return std::chrono::duration_cast<std::chrono::duration<uint64_t, std::micro>>(duration).count();
+}
+
+// trace helpers
+constexpr const int STATS_TITLE_WIDTH = 12;
+constexpr const int STATS_FIELD_WIDTH = 12;
+
+template <typename Value>
+void put_title(Value&& value) {
+    fmt::print("{0: <{1}} ", std::forward<Value>(value), STATS_TITLE_WIDTH);
+}
+
+template <typename Value>
+void put_title_r(Value&& value) {
+    fmt::print("{0: >{1}} ", std::forward<Value>(value), STATS_TITLE_WIDTH);
+}
+
+inline void put_title_bar() {
+    fmt::print("{0:=<{1}} ", "", STATS_TITLE_WIDTH);
+}
+
+template <typename Value>
+void put_field(Value&& value) {
+    fmt::print("{0: >{1}} ", std::forward<Value>(value), STATS_FIELD_WIDTH);
+}
+
+inline void put_field_bar() {
+    fmt::print("{0:=>{1}} ", "", STATS_FIELD_WIDTH);
+}
+
+template <typename Value>
+void put_field_f(Value&& value, int precision) {
+    fmt::print("{0: >{1}.{2}f} ",
+               std::forward<Value>(value), STATS_FIELD_WIDTH, precision);
+}
+
+#endif /* UTILS_HPP */

From 2247a353618341e35a7770255b7b93538b42bf3f Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Thu, 3 Mar 2022 13:33:58 +0100
Subject: [PATCH 04/84] Clang-format mako-cpp

---
 bindings/c/test/fdb.hpp        |  771 +++---
 bindings/c/test/mako/mako.cpp  | 4188 ++++++++++++++++----------------
 bindings/c/test/mako/mako.hpp  |  457 ++--
 bindings/c/test/mako/utils.hpp |  124 +-
 4 files changed, 2712 insertions(+), 2828 deletions(-)

diff --git a/bindings/c/test/fdb.hpp b/bindings/c/test/fdb.hpp
index f0538ebcc0..94383d3d32 100644
--- a/bindings/c/test/fdb.hpp
+++ b/bindings/c/test/fdb.hpp
@@ -28,178 +28,168 @@ using KeyRef = BytesRef;
 using ValueRef = BytesRef;
 
 inline uint8_t const* to_byte_ptr(char const* ptr) noexcept {
-    return reinterpret_cast<uint8_t const*>(ptr);
+	return reinterpret_cast<uint8_t const*>(ptr);
 }
 
 // get bytestring view from charstring: e.g. std::basic_string{_view}<char>
 template <template <class...> class StringLike, class Char>
 BytesRef to_bytes_ref(const StringLike<Char>& s) noexcept {
-    static_assert(sizeof(Char) == 1);
-    return BytesRef(reinterpret_cast<uint8_t const*>(s.data()),
-                    s.size());
+	static_assert(sizeof(Char) == 1);
+	return BytesRef(reinterpret_cast<uint8_t const*>(s.data()), s.size());
 }
 
 // get charstring view from bytestring: e.g. std::basic_string{_view}<uint8_t>
 template <template <class...> class StringLike, class Char>
 CharsRef to_chars_ref(const StringLike<Char>& s) noexcept {
-    static_assert(sizeof(Char) == 1);
-    return CharsRef(reinterpret_cast<char const*>(s.data()),
-                    s.size());
+	static_assert(sizeof(Char) == 1);
+	return CharsRef(reinterpret_cast<char const*>(s.data()), s.size());
 }
 
 [[maybe_unused]] constexpr const bool overflow_check = false;
 
 inline int intsize(BytesRef b) {
-    if constexpr (overflow_check) {
-        if (b.size() > static_cast<size_t>(std::numeric_limits<int>::max()))
-            throw std::overflow_error("byte strlen goes beyond int bounds");
-    }
-    return static_cast<int>(b.size());
+	if constexpr (overflow_check) {
+		if (b.size() > static_cast<size_t>(std::numeric_limits<int>::max()))
+			throw std::overflow_error("byte strlen goes beyond int bounds");
+	}
+	return static_cast<int>(b.size());
 }
 
 class Error {
 public:
-    using code_type = native::fdb_error_t;
+	using code_type = native::fdb_error_t;
 
-    Error() noexcept : err(0) {}
+	Error() noexcept : err(0) {}
 
-    explicit Error(code_type err) noexcept : err(err) {}
+	explicit Error(code_type err) noexcept : err(err) {}
 
-    char const* what() noexcept { return native::fdb_get_error(err); }
+	char const* what() noexcept { return native::fdb_get_error(err); }
 
-    explicit operator bool() const noexcept { return err != 0; }
+	explicit operator bool() const noexcept { return err != 0; }
 
-    bool is(code_type other) const noexcept { return err != other; }
+	bool is(code_type other) const noexcept { return err != other; }
 
-    code_type code() const noexcept { return err; }
+	code_type code() const noexcept { return err; }
+
+	bool retryable() const noexcept { return native::fdb_error_predicate(FDB_ERROR_PREDICATE_RETRYABLE, err) != 0; }
 
-    bool retryable() const noexcept {
-        return native::fdb_error_predicate(FDB_ERROR_PREDICATE_RETRYABLE, err) != 0;
-    }
 private:
-    code_type err;
+	code_type err;
 };
 
 /* Traits of value types held by ready futures.
    Holds type and value extraction function. */
 namespace future_var {
-    struct None {
-        struct type {};
-        static Error extract(native::FDBFuture*, type&) noexcept {
-            return Error(0);
-        }
-    };
-    struct Int64 {
-        using type = int64_t;
-        static Error extract(native::FDBFuture* f, type& out) noexcept {
-            return Error(native::fdb_future_get_int64(f, &out));
-        }
-    };
-    struct Key {
-        using type = std::pair<uint8_t const*, int>;
-        static Error extract(native::FDBFuture* f, type& out) noexcept {
-            auto& [out_key, out_key_length] = out;
-            return Error(native::fdb_future_get_key(f, &out_key, &out_key_length));
-        }
-    };
-    struct Value {
-        using type = std::tuple<bool, uint8_t const*, int>;
-        static Error extract(native::FDBFuture* f, type& out) noexcept {
-            auto& [out_present, out_value, out_value_length] = out;
-            auto out_present_native = native::fdb_bool_t{};
-            auto err = native::fdb_future_get_value(f, &out_present_native,
-                                            &out_value, &out_value_length);
-            out_present = (out_present_native != 0);
-            return Error(err);
-        }
-    };
-    struct StringArray {
-        using type = std::pair<const char**, int>;
-        static Error extract(native::FDBFuture* f, type& out) noexcept {
-            auto& [out_strings, out_count] = out;
-            return Error(native::fdb_future_get_string_array(f, &out_strings, &out_count));
-        }
-    };
-    struct KeyValueArray {
-        using type = std::tuple<native::FDBKeyValue const *, int, bool>;
-        static Error extract(native::FDBFuture* f, type& out) noexcept {
-            auto& [out_kv, out_count, out_more] = out;
-            auto out_more_native = native::fdb_bool_t{};
-            auto err = native::fdb_future_get_keyvalue_array(f, &out_kv, &out_count, &out_more_native);
-            out_more = (out_more_native != 0);
-            return Error(err);
-        }
-    };
+struct None {
+	struct type {};
+	static Error extract(native::FDBFuture*, type&) noexcept { return Error(0); }
+};
+struct Int64 {
+	using type = int64_t;
+	static Error extract(native::FDBFuture* f, type& out) noexcept {
+		return Error(native::fdb_future_get_int64(f, &out));
+	}
+};
+struct Key {
+	using type = std::pair<uint8_t const*, int>;
+	static Error extract(native::FDBFuture* f, type& out) noexcept {
+		auto& [out_key, out_key_length] = out;
+		return Error(native::fdb_future_get_key(f, &out_key, &out_key_length));
+	}
+};
+struct Value {
+	using type = std::tuple<bool, uint8_t const*, int>;
+	static Error extract(native::FDBFuture* f, type& out) noexcept {
+		auto& [out_present, out_value, out_value_length] = out;
+		auto out_present_native = native::fdb_bool_t{};
+		auto err = native::fdb_future_get_value(f, &out_present_native, &out_value, &out_value_length);
+		out_present = (out_present_native != 0);
+		return Error(err);
+	}
+};
+struct StringArray {
+	using type = std::pair<const char**, int>;
+	static Error extract(native::FDBFuture* f, type& out) noexcept {
+		auto& [out_strings, out_count] = out;
+		return Error(native::fdb_future_get_string_array(f, &out_strings, &out_count));
+	}
+};
+struct KeyValueArray {
+	using type = std::tuple<native::FDBKeyValue const*, int, bool>;
+	static Error extract(native::FDBFuture* f, type& out) noexcept {
+		auto& [out_kv, out_count, out_more] = out;
+		auto out_more_native = native::fdb_bool_t{};
+		auto err = native::fdb_future_get_keyvalue_array(f, &out_kv, &out_count, &out_more_native);
+		out_more = (out_more_native != 0);
+		return Error(err);
+	}
+};
 } // namespace future_var
 
 [[noreturn]] inline void throw_error(std::string_view preamble, Error err) {
-    auto msg = std::string(preamble);
-    msg.append(err.what());
-    throw std::runtime_error(msg);
+	auto msg = std::string(preamble);
+	msg.append(err.what());
+	throw std::runtime_error(msg);
 }
 
 inline int max_api_version() {
-    return native::fdb_get_max_api_version();
+	return native::fdb_get_max_api_version();
 }
 
 inline Error select_api_version_nothrow(int version) {
-    return Error(native::fdb_select_api_version(version));
+	return Error(native::fdb_select_api_version(version));
 }
 
 inline void select_api_version(int version) {
-    if (auto err = select_api_version_nothrow(version)) {
-        throw_error(fmt::format("ERROR: fdb_select_api_version({}): ", version), err);
-    }
+	if (auto err = select_api_version_nothrow(version)) {
+		throw_error(fmt::format("ERROR: fdb_select_api_version({}): ", version), err);
+	}
 }
 
 namespace network {
 
-    inline Error set_option_nothrow(FDBNetworkOption option, BytesRef str) noexcept {
-        return Error(native::fdb_network_set_option(option, str.data(), intsize(str)));
-    }
+inline Error set_option_nothrow(FDBNetworkOption option, BytesRef str) noexcept {
+	return Error(native::fdb_network_set_option(option, str.data(), intsize(str)));
+}
 
-    inline Error set_option_nothrow(FDBNetworkOption option, int64_t value) noexcept {
-        return Error(native::fdb_network_set_option(
-                    option,
-                    reinterpret_cast<const uint8_t*>(&value),
-                    static_cast<int>(sizeof(value))));
-    }
+inline Error set_option_nothrow(FDBNetworkOption option, int64_t value) noexcept {
+	return Error(native::fdb_network_set_option(
+	    option, reinterpret_cast<const uint8_t*>(&value), static_cast<int>(sizeof(value))));
+}
 
-    inline void set_option(FDBNetworkOption option, BytesRef str) {
-        if (auto err = set_option_nothrow(option, str)) {
-            throw_error(
-                    fmt::format("ERROR: fdb_network_set_option({}): ",
-                                static_cast<std::underlying_type_t<FDBNetworkOption>>(option)),
-                    err);
-        }
-    }
+inline void set_option(FDBNetworkOption option, BytesRef str) {
+	if (auto err = set_option_nothrow(option, str)) {
+		throw_error(fmt::format("ERROR: fdb_network_set_option({}): ",
+		                        static_cast<std::underlying_type_t<FDBNetworkOption>>(option)),
+		            err);
+	}
+}
 
-    inline void set_option(FDBNetworkOption option, int64_t value) {
-        if (auto err = set_option_nothrow(option, value)) {
-            throw_error(
-                    fmt::format("ERROR: fdb_network_set_option({}, {}): ",
-                                static_cast<std::underlying_type_t<FDBNetworkOption>>(option),
-                                value),
-                    err);
-        }
-    }
+inline void set_option(FDBNetworkOption option, int64_t value) {
+	if (auto err = set_option_nothrow(option, value)) {
+		throw_error(fmt::format("ERROR: fdb_network_set_option({}, {}): ",
+		                        static_cast<std::underlying_type_t<FDBNetworkOption>>(option),
+		                        value),
+		            err);
+	}
+}
 
-    inline Error setup_nothrow() noexcept {
-        return Error(native::fdb_setup_network());
-    }
+inline Error setup_nothrow() noexcept {
+	return Error(native::fdb_setup_network());
+}
 
-    inline void setup() {
-        if (auto err = setup_nothrow())
-            throw_error("ERROR: fdb_network_setup(): ", err);
-    }
+inline void setup() {
+	if (auto err = setup_nothrow())
+		throw_error("ERROR: fdb_network_setup(): ", err);
+}
 
-    inline Error run() {
-        return Error(native::fdb_run_network());
-    }
+inline Error run() {
+	return Error(native::fdb_run_network());
+}
 
-    inline Error stop() {
-        return Error(native::fdb_stop_network());
-    }
+inline Error stop() {
+	return Error(native::fdb_stop_network());
+}
 
 } // namespace network
 
@@ -207,346 +197,347 @@ class TX;
 class Database;
 
 class Result {
-    friend class TX;
-    std::shared_ptr<native::FDBResult> r;
+	friend class TX;
+	std::shared_ptr<native::FDBResult> r;
+
+	Result(native::FDBResult* result) {
+		if (result)
+			r = std::shared_ptr<native::FDBResult>(result, &native::fdb_result_destroy);
+	}
 
-    Result(native::FDBResult* result) {
-        if (result) r = std::shared_ptr<native::FDBResult>(result, &native::fdb_result_destroy);
-    }
 public:
+	using KeyValueArray = future_var::KeyValueArray::type;
 
-    using KeyValueArray = future_var::KeyValueArray::type;
-
-    Error get_keyvalue_array_nothrow(KeyValueArray& out) const noexcept {
-        auto out_more_native = native::fdb_bool_t{};
-        auto& [out_kv, out_count, out_more] = out;
-        auto err_raw = native::fdb_result_get_keyvalue_array(r.get(), &out_kv,
-                                                     &out_count, &out_more_native);
-        out_more = out_more_native != 0;
-        return Error(err_raw);
-    }
-
-    KeyValueArray get_keyvalue_array() const {
-        auto ret = KeyValueArray{};
-        if (auto err = get_keyvalue_array_nothrow(ret))
-            throw_error("ERROR: result_get_keyvalue_array(): ", err);
-        return ret;
-    }
+	Error get_keyvalue_array_nothrow(KeyValueArray& out) const noexcept {
+		auto out_more_native = native::fdb_bool_t{};
+		auto& [out_kv, out_count, out_more] = out;
+		auto err_raw = native::fdb_result_get_keyvalue_array(r.get(), &out_kv, &out_count, &out_more_native);
+		out_more = out_more_native != 0;
+		return Error(err_raw);
+	}
 
+	KeyValueArray get_keyvalue_array() const {
+		auto ret = KeyValueArray{};
+		if (auto err = get_keyvalue_array_nothrow(ret))
+			throw_error("ERROR: result_get_keyvalue_array(): ", err);
+		return ret;
+	}
 };
 
 class Future {
 protected:
-    friend class TX;
-    std::shared_ptr<native::FDBFuture> f;
+	friend class TX;
+	std::shared_ptr<native::FDBFuture> f;
 
-    Future(native::FDBFuture* future)
-    {
-        if (future) f = std::shared_ptr<native::FDBFuture>(future, &native::fdb_future_destroy);
-    }
+	Future(native::FDBFuture* future) {
+		if (future)
+			f = std::shared_ptr<native::FDBFuture>(future, &native::fdb_future_destroy);
+	}
 
-    // wrap any capturing lambda as callback passable to fdb_future_set_callback().
-    // destroy after invocation.
-    template <class Fn>
-    static void callback(native::FDBFuture*, void* param) {
-        auto fp = static_cast<Fn*>(param);
-        try {
-            (*fp)();
-        } catch (const std::exception& e) {
-            fmt::print(stderr, "ERROR: Exception thrown in user callback: {}", e.what());
-        }
-        delete fp;
-    }
+	// wrap any capturing lambda as callback passable to fdb_future_set_callback().
+	// destroy after invocation.
+	template <class Fn>
+	static void callback(native::FDBFuture*, void* param) {
+		auto fp = static_cast<Fn*>(param);
+		try {
+			(*fp)();
+		} catch (const std::exception& e) {
+			fmt::print(stderr, "ERROR: Exception thrown in user callback: {}", e.what());
+		}
+		delete fp;
+	}
 
-    // set as callback user-defined completion handler of signature void(Future)
-    template <class FutureType, class UserFunc>
-    void then(UserFunc&& fn) {
-        auto cb = [fut=FutureType(*this), fn=std::forward<UserFunc>(fn)]() {
-            fn(fut);
-        };
-        using cb_type = std::decay_t<decltype(cb)>;
-        auto fp = new cb_type(std::move(cb));
-        native::fdb_future_set_callback(f.get(), &callback<cb_type>, fp);
-    }
+	// set as callback user-defined completion handler of signature void(Future)
+	template <class FutureType, class UserFunc>
+	void then(UserFunc&& fn) {
+		auto cb = [fut = FutureType(*this), fn = std::forward<UserFunc>(fn)]() { fn(fut); };
+		using cb_type = std::decay_t<decltype(cb)>;
+		auto fp = new cb_type(std::move(cb));
+		native::fdb_future_set_callback(f.get(), &callback<cb_type>, fp);
+	}
 
 public:
-    Future() noexcept : Future(nullptr) {}
-    Future(const Future&) noexcept = default;
-    Future& operator=(const Future&) noexcept = default;
+	Future() noexcept : Future(nullptr) {}
+	Future(const Future&) noexcept = default;
+	Future& operator=(const Future&) noexcept = default;
 
-    bool valid() const noexcept { return f != nullptr; }
+	bool valid() const noexcept { return f != nullptr; }
 
-    explicit operator bool() const noexcept { return valid(); }
+	explicit operator bool() const noexcept { return valid(); }
 
-    bool ready() const noexcept {
-        assert(valid());
-        return native::fdb_future_is_ready(f.get()) != 0;
-    }
+	bool ready() const noexcept {
+		assert(valid());
+		return native::fdb_future_is_ready(f.get()) != 0;
+	}
 
-    Error block_until_ready() const noexcept {
-        assert(valid());
-        return Error(native::fdb_future_block_until_ready(f.get()));
-    }
+	Error block_until_ready() const noexcept {
+		assert(valid());
+		return Error(native::fdb_future_block_until_ready(f.get()));
+	}
 
-    Error error() const noexcept {
-        assert(valid());
-        return Error(native::fdb_future_get_error(f.get()));
-    }
+	Error error() const noexcept {
+		assert(valid());
+		return Error(native::fdb_future_get_error(f.get()));
+	}
 
-    void cancel() noexcept {
-        native::fdb_future_cancel(f.get());
-    }
+	void cancel() noexcept { native::fdb_future_cancel(f.get()); }
 
-    template <class VarTraits>
-    typename VarTraits::type get() const {
-        assert(valid());
-        assert(!error());
-        auto out = typename VarTraits::Type{};
-        if (auto err = VarTraits::extract(f.get(), out)) {
-            throw_error("future_get: ", err);
-        }
-        return out;
-    }
+	template <class VarTraits>
+	typename VarTraits::type get() const {
+		assert(valid());
+		assert(!error());
+		auto out = typename VarTraits::Type{};
+		if (auto err = VarTraits::extract(f.get(), out)) {
+			throw_error("future_get: ", err);
+		}
+		return out;
+	}
 
-    template <class VarTraits>
-    Error get_nothrow(typename VarTraits::type& var) const noexcept {
-        assert(valid());
-        assert(!error());
-        auto out = typename VarTraits::Type{};
-        return VarTraits::extract(f.get(), out);
-    }
+	template <class VarTraits>
+	Error get_nothrow(typename VarTraits::type& var) const noexcept {
+		assert(valid());
+		assert(!error());
+		auto out = typename VarTraits::Type{};
+		return VarTraits::extract(f.get(), out);
+	}
 
-    template <class UserFunc>
-    void then(UserFunc&& fn) {
-        then<Future>(std::forward<UserFunc>(fn));
-    }
+	template <class UserFunc>
+	void then(UserFunc&& fn) {
+		then<Future>(std::forward<UserFunc>(fn));
+	}
 };
 
 template <typename VarTraits>
 class TypedFuture : public Future {
-    friend class TX;
-    using self_type = TypedFuture<VarTraits>;
-    using Future::Future;
-    // hide type-unsafe inherited functions
-    using Future::get;
-    using Future::get_nothrow;
-    using Future::then;
-    TypedFuture(const Future& f) noexcept : Future(f) {}
+	friend class TX;
+	using self_type = TypedFuture<VarTraits>;
+	using Future::Future;
+	// hide type-unsafe inherited functions
+	using Future::get;
+	using Future::get_nothrow;
+	using Future::then;
+	TypedFuture(const Future& f) noexcept : Future(f) {}
+
 public:
-    using contained_type = typename VarTraits::type;
+	using contained_type = typename VarTraits::type;
 
-    Future erase_type() const noexcept {
-        return static_cast<Future const&>(*this);
-    }
+	Future erase_type() const noexcept { return static_cast<Future const&>(*this); }
 
-    contained_type get() const {
-        return get<VarTraits>();
-    }
+	contained_type get() const { return get<VarTraits>(); }
 
-    Error get_nothrow(contained_type& out) const noexcept {
-        return get_nothrow<VarTraits>(out);
-    }
+	Error get_nothrow(contained_type& out) const noexcept { return get_nothrow<VarTraits>(out); }
 
-    template <class UserFunc>
-    void then(UserFunc&& fn) {
-        Future::then<self_type>(std::forward<UserFunc>(fn));
-    }
+	template <class UserFunc>
+	void then(UserFunc&& fn) {
+		Future::then<self_type>(std::forward<UserFunc>(fn));
+	}
 };
 
 namespace key_select {
 
-    struct inclusive { static constexpr const bool value = true; };
+struct inclusive {
+	static constexpr const bool value = true;
+};
 
-    struct exclusive { static constexpr const bool value = false; };
-}
+struct exclusive {
+	static constexpr const bool value = false;
+};
+} // namespace key_select
 
 class TX {
-    friend class Database;
-    std::shared_ptr<native::FDBTransaction> tr;
+	friend class Database;
+	std::shared_ptr<native::FDBTransaction> tr;
+
+	explicit TX(native::FDBTransaction* tr_raw) {
+		if (tr_raw)
+			tr = std::shared_ptr<native::FDBTransaction>(tr_raw, &native::fdb_transaction_destroy);
+	}
 
-    explicit TX(native::FDBTransaction* tr_raw) {
-        if (tr_raw) tr = std::shared_ptr<native::FDBTransaction>(tr_raw, &native::fdb_transaction_destroy);
-    }
 public:
-    TX() noexcept : TX(nullptr) {}
-    TX(const TX&) noexcept = default;
-    TX& operator=(const TX&) noexcept = default;
+	TX() noexcept : TX(nullptr) {}
+	TX(const TX&) noexcept = default;
+	TX& operator=(const TX&) noexcept = default;
 
-    bool valid() const noexcept { return tr != nullptr; }
+	bool valid() const noexcept { return tr != nullptr; }
 
-    explicit operator bool() const noexcept { return valid(); }
+	explicit operator bool() const noexcept { return valid(); }
 
-    Error set_option_nothrow(FDBTransactionOption option, int64_t value) noexcept {
-        return Error(native::fdb_transaction_set_option(
-                        tr.get(), option,
-                        reinterpret_cast<const uint8_t*>(&value),
-                        static_cast<int>(sizeof(value))));
-    }
+	Error set_option_nothrow(FDBTransactionOption option, int64_t value) noexcept {
+		return Error(native::fdb_transaction_set_option(
+		    tr.get(), option, reinterpret_cast<const uint8_t*>(&value), static_cast<int>(sizeof(value))));
+	}
 
-    Error set_option_nothrow(FDBTransactionOption option, BytesRef str) noexcept {
-        return Error(native::fdb_transaction_set_option(
-                        tr.get(), option, str.data(), intsize(str)));
-    }
+	Error set_option_nothrow(FDBTransactionOption option, BytesRef str) noexcept {
+		return Error(native::fdb_transaction_set_option(tr.get(), option, str.data(), intsize(str)));
+	}
 
-    void set_option(FDBTransactionOption option, int64_t value) {
-        if (auto err = set_option_nothrow(option, value)) {
-            throw_error(fmt::format("transaction_set_option({}, {}) returned error: ",
-                        static_cast<std::underlying_type_t<FDBTransactionOption>>(option),
-                        value),
-                        err);
-        }
-    }
+	void set_option(FDBTransactionOption option, int64_t value) {
+		if (auto err = set_option_nothrow(option, value)) {
+			throw_error(fmt::format("transaction_set_option({}, {}) returned error: ",
+			                        static_cast<std::underlying_type_t<FDBTransactionOption>>(option),
+			                        value),
+			            err);
+		}
+	}
 
-    void set_option(FDBTransactionOption option, BytesRef str) {
-        if (auto err = set_option_nothrow(option, str)) {
-            throw_error(
-                    fmt::format("transaction_set_option({}) returned error: ",
-                        static_cast<std::underlying_type_t<FDBTransactionOption>>(option)),
-                    err);
-        }
-    }
+	void set_option(FDBTransactionOption option, BytesRef str) {
+		if (auto err = set_option_nothrow(option, str)) {
+			throw_error(fmt::format("transaction_set_option({}) returned error: ",
+			                        static_cast<std::underlying_type_t<FDBTransactionOption>>(option)),
+			            err);
+		}
+	}
 
-    TypedFuture<future_var::Int64> get_read_version() {
-        return native::fdb_transaction_get_read_version(tr.get());
-    }
+	TypedFuture<future_var::Int64> get_read_version() { return native::fdb_transaction_get_read_version(tr.get()); }
 
-    Error get_committed_version_nothrow(int64_t& out) {
-        return Error(native::fdb_transaction_get_committed_version(tr.get(), &out));
-    }
+	Error get_committed_version_nothrow(int64_t& out) {
+		return Error(native::fdb_transaction_get_committed_version(tr.get(), &out));
+	}
 
-    int64_t get_committed_version() {
-        auto out = int64_t{};
-        if (auto err = get_committed_version_nothrow(out)) {
-            throw_error("get_committed_version: ", err);
-        }
-        return out;
-    }
+	int64_t get_committed_version() {
+		auto out = int64_t{};
+		if (auto err = get_committed_version_nothrow(out)) {
+			throw_error("get_committed_version: ", err);
+		}
+		return out;
+	}
 
-    // Func should have signature void(Future f, bool need_retry)
-    // Func should first check that retry == false and f.error() == 0
-    // before attempting to extract value from f
-    TypedFuture<future_var::Value> get(KeyRef key, bool snapshot) {
-        return native::fdb_transaction_get(tr.get(), key.data(), intsize(key), snapshot);
-    }
+	// Func should have signature void(Future f, bool need_retry)
+	// Func should first check that retry == false and f.error() == 0
+	// before attempting to extract value from f
+	TypedFuture<future_var::Value> get(KeyRef key, bool snapshot) {
+		return native::fdb_transaction_get(tr.get(), key.data(), intsize(key), snapshot);
+	}
 
-    // Usage: tx.get_range<key_select::inclusive, key_select::exclusive>(begin, end, ...);
-    // gets key-value pairs in key range [begin, end)
-    template <class FirstInclusive, class LastInclusive>
-    TypedFuture<future_var::KeyValueArray> get_range(KeyRef begin, KeyRef end,
-                   int limit, int target_bytes, FDBStreamingMode mode,
-                   int iteration, bool snapshot, bool reverse) {
-        if constexpr (FirstInclusive::value && LastInclusive::value) {
-            return native::fdb_transaction_get_range(tr.get(),
-                    FDB_KEYSEL_FIRST_GREATER_OR_EQUAL(begin.data(), intsize(begin)),
-                    FDB_KEYSEL_LAST_LESS_OR_EQUAL(end.data(), intsize(end)),
-                    limit, target_bytes, mode, iteration, snapshot, reverse);
-        } else if constexpr (FirstInclusive::value && !LastInclusive::value) {
-            return native::fdb_transaction_get_range(tr.get(),
-                    FDB_KEYSEL_FIRST_GREATER_OR_EQUAL(begin.data(), intsize(begin)),
-                    FDB_KEYSEL_LAST_LESS_THAN(end.data(), intsize(end)),
-                    limit, target_bytes, mode, iteration, snapshot, reverse);
-        } else if constexpr (!FirstInclusive::value && LastInclusive::value) {
-            return native::fdb_transaction_get_range(tr.get(),
-                    FDB_KEYSEL_FIRST_GREATER_THAN(begin.data(), intsize(begin)),
-                    FDB_KEYSEL_LAST_LESS_OR_EQUAL(end.data(), intsize(end)),
-                    limit, target_bytes, mode, iteration, snapshot, reverse);
-        } else {
-            return native::fdb_transaction_get_range(tr.get(),
-                    FDB_KEYSEL_FIRST_GREATER_THAN(begin.data(), intsize(begin)),
-                    FDB_KEYSEL_LAST_LESS_THAN(end.data(), intsize(end)),
-                    limit, target_bytes, mode, iteration, snapshot, reverse);
-        }
-    }
+	// Usage: tx.get_range<key_select::inclusive, key_select::exclusive>(begin, end, ...);
+	// gets key-value pairs in key range [begin, end)
+	template <class FirstInclusive, class LastInclusive>
+	TypedFuture<future_var::KeyValueArray> get_range(KeyRef begin,
+	                                                 KeyRef end,
+	                                                 int limit,
+	                                                 int target_bytes,
+	                                                 FDBStreamingMode mode,
+	                                                 int iteration,
+	                                                 bool snapshot,
+	                                                 bool reverse) {
+		if constexpr (FirstInclusive::value && LastInclusive::value) {
+			return native::fdb_transaction_get_range(tr.get(),
+			                                         FDB_KEYSEL_FIRST_GREATER_OR_EQUAL(begin.data(), intsize(begin)),
+			                                         FDB_KEYSEL_LAST_LESS_OR_EQUAL(end.data(), intsize(end)),
+			                                         limit,
+			                                         target_bytes,
+			                                         mode,
+			                                         iteration,
+			                                         snapshot,
+			                                         reverse);
+		} else if constexpr (FirstInclusive::value && !LastInclusive::value) {
+			return native::fdb_transaction_get_range(tr.get(),
+			                                         FDB_KEYSEL_FIRST_GREATER_OR_EQUAL(begin.data(), intsize(begin)),
+			                                         FDB_KEYSEL_LAST_LESS_THAN(end.data(), intsize(end)),
+			                                         limit,
+			                                         target_bytes,
+			                                         mode,
+			                                         iteration,
+			                                         snapshot,
+			                                         reverse);
+		} else if constexpr (!FirstInclusive::value && LastInclusive::value) {
+			return native::fdb_transaction_get_range(tr.get(),
+			                                         FDB_KEYSEL_FIRST_GREATER_THAN(begin.data(), intsize(begin)),
+			                                         FDB_KEYSEL_LAST_LESS_OR_EQUAL(end.data(), intsize(end)),
+			                                         limit,
+			                                         target_bytes,
+			                                         mode,
+			                                         iteration,
+			                                         snapshot,
+			                                         reverse);
+		} else {
+			return native::fdb_transaction_get_range(tr.get(),
+			                                         FDB_KEYSEL_FIRST_GREATER_THAN(begin.data(), intsize(begin)),
+			                                         FDB_KEYSEL_LAST_LESS_THAN(end.data(), intsize(end)),
+			                                         limit,
+			                                         target_bytes,
+			                                         mode,
+			                                         iteration,
+			                                         snapshot,
+			                                         reverse);
+		}
+	}
 
-    Result read_blob_granules(KeyRef begin, KeyRef end,
-                              int64_t begin_version, int64_t read_version,
-                              native::FDBReadBlobGranuleContext context) {
-        return Result(native::fdb_transaction_read_blob_granules(tr.get(),
-                    begin.data(), intsize(begin),
-                    end.data(), intsize(end),
-                    begin_version, read_version, context));
-    }
+	Result read_blob_granules(KeyRef begin,
+	                          KeyRef end,
+	                          int64_t begin_version,
+	                          int64_t read_version,
+	                          native::FDBReadBlobGranuleContext context) {
+		return Result(native::fdb_transaction_read_blob_granules(
+		    tr.get(), begin.data(), intsize(begin), end.data(), intsize(end), begin_version, read_version, context));
+	}
 
-    TypedFuture<future_var::None> commit() {
-        return native::fdb_transaction_commit(tr.get());
-    }
+	TypedFuture<future_var::None> commit() { return native::fdb_transaction_commit(tr.get()); }
 
-    TypedFuture<future_var::None> on_error(Error err) {
-        return native::fdb_transaction_on_error(tr.get(), err.code());
-    }
+	TypedFuture<future_var::None> on_error(Error err) { return native::fdb_transaction_on_error(tr.get(), err.code()); }
 
-    void reset() {
-        return native::fdb_transaction_reset(tr.get());
-    }
+	void reset() { return native::fdb_transaction_reset(tr.get()); }
 
-    void set(KeyRef key, ValueRef value) {
-        native::fdb_transaction_set(tr.get(), key.data(), intsize(key), value.data(), intsize(value));
-    }
+	void set(KeyRef key, ValueRef value) {
+		native::fdb_transaction_set(tr.get(), key.data(), intsize(key), value.data(), intsize(value));
+	}
 
-    void clear(KeyRef key) {
-        native::fdb_transaction_clear(tr.get(), key.data(), intsize(key));
-    }
-
-    void clear_range(KeyRef begin, KeyRef end) {
-        native::fdb_transaction_clear_range(tr.get(), begin.data(), intsize(begin),
-                                    end.data(), intsize(end));
-    }
+	void clear(KeyRef key) { native::fdb_transaction_clear(tr.get(), key.data(), intsize(key)); }
 
+	void clear_range(KeyRef begin, KeyRef end) {
+		native::fdb_transaction_clear_range(tr.get(), begin.data(), intsize(begin), end.data(), intsize(end));
+	}
 };
 
 class Database {
-    std::shared_ptr<native::FDBDatabase> db;
+	std::shared_ptr<native::FDBDatabase> db;
+
 public:
-    Database(const Database&) noexcept = default;
-    Database& operator=(const Database&) noexcept = default;
-    Database(const std::string& cluster_file_path) : db(nullptr) {
-        auto db_raw = static_cast<native::FDBDatabase*>(nullptr);
-        if (auto err = Error(native::fdb_create_database(cluster_file_path.c_str(), &db_raw)))
-            throw_error(
-                    fmt::format("Failed to create database with '{}': ", cluster_file_path),
-                    err);
-        db = std::shared_ptr<native::FDBDatabase>(db_raw, &native::fdb_database_destroy);
-    }
-    Database() noexcept : db(nullptr) {}
+	Database(const Database&) noexcept = default;
+	Database& operator=(const Database&) noexcept = default;
+	Database(const std::string& cluster_file_path) : db(nullptr) {
+		auto db_raw = static_cast<native::FDBDatabase*>(nullptr);
+		if (auto err = Error(native::fdb_create_database(cluster_file_path.c_str(), &db_raw)))
+			throw_error(fmt::format("Failed to create database with '{}': ", cluster_file_path), err);
+		db = std::shared_ptr<native::FDBDatabase>(db_raw, &native::fdb_database_destroy);
+	}
+	Database() noexcept : db(nullptr) {}
 
-    Error set_option_nothrow(FDBDatabaseOption option, int64_t value) noexcept {
-        return Error(native::fdb_database_set_option(
-                        db.get(), option,
-                        reinterpret_cast<const uint8_t*>(&value),
-                        static_cast<int>(sizeof(value))));
-    }
+	Error set_option_nothrow(FDBDatabaseOption option, int64_t value) noexcept {
+		return Error(native::fdb_database_set_option(
+		    db.get(), option, reinterpret_cast<const uint8_t*>(&value), static_cast<int>(sizeof(value))));
+	}
 
-    Error set_option_nothrow(FDBDatabaseOption option, BytesRef str) noexcept {
-        return Error(native::fdb_database_set_option(
-                        db.get(), option, str.data(), intsize(str)));
-    }
+	Error set_option_nothrow(FDBDatabaseOption option, BytesRef str) noexcept {
+		return Error(native::fdb_database_set_option(db.get(), option, str.data(), intsize(str)));
+	}
 
-    void set_option(FDBDatabaseOption option, int64_t value) {
-        if (auto err = set_option_nothrow(option, value)) {
-            throw_error(
-                fmt::format("database_set_option({}, {}) returned error: ",
-                static_cast<std::underlying_type_t<FDBDatabaseOption>>(option),
-                value),
-                err);
-        }
-    }
+	void set_option(FDBDatabaseOption option, int64_t value) {
+		if (auto err = set_option_nothrow(option, value)) {
+			throw_error(fmt::format("database_set_option({}, {}) returned error: ",
+			                        static_cast<std::underlying_type_t<FDBDatabaseOption>>(option),
+			                        value),
+			            err);
+		}
+	}
 
-    void set_option(FDBDatabaseOption option, BytesRef str) {
-        if (auto err = set_option_nothrow(option, str)) {
-            throw_error(
-                fmt::format("database_set_option({}) returned error: ",
-                    static_cast<std::underlying_type_t<FDBDatabaseOption>>(option)),
-                err);
-        }
-    }
+	void set_option(FDBDatabaseOption option, BytesRef str) {
+		if (auto err = set_option_nothrow(option, str)) {
+			throw_error(fmt::format("database_set_option({}) returned error: ",
+			                        static_cast<std::underlying_type_t<FDBDatabaseOption>>(option)),
+			            err);
+		}
+	}
 
-    TX create_tx() {
-        if (!db) throw std::runtime_error("create_transaction from null database");
-        auto tx_native = static_cast<native::FDBTransaction*>(nullptr);
-        auto err = Error(native::fdb_database_create_transaction(db.get(), &tx_native));
-        if (err) throw_error("Failed to create transaction: ", err);
-        return TX(tx_native);
-    }
+	TX create_tx() {
+		if (!db)
+			throw std::runtime_error("create_transaction from null database");
+		auto tx_native = static_cast<native::FDBTransaction*>(nullptr);
+		auto err = Error(native::fdb_database_create_transaction(db.get(), &tx_native));
+		if (err)
+			throw_error("Failed to create transaction: ", err);
+		return TX(tx_native);
+	}
 };
 
 } // namespace fdb
diff --git a/bindings/c/test/mako/mako.cpp b/bindings/c/test/mako/mako.cpp
index 977e0f9458..985a4c5a9b 100644
--- a/bindings/c/test/mako/mako.cpp
+++ b/bindings/c/test/mako/mako.cpp
@@ -38,103 +38,94 @@
 
 using namespace fdb;
 
-const std::string KEY_PREFIX{"mako"};
-const std::string TEMP_DATA_STORE{"/tmp/makoTemp"};
+const std::string KEY_PREFIX{ "mako" };
+const std::string TEMP_DATA_STORE{ "/tmp/makoTemp" };
 
 /* global variables */
 FILE* printme; /* descriptor used for default messages */
 FILE* annoyme; /* descriptor used for annoying messages */
 FILE* debugme; /* descriptor used for debug messages */
 
-enum class FutureRC {
-    OK,
-    RETRY,
-    CONFLICT,
-    ABORT
-};
+enum class FutureRC { OK, RETRY, CONFLICT, ABORT };
 
 template <class FutureType>
 FutureRC wait_and_handle_for_on_error(TX tx, FutureType f, std::string_view operation) {
-    assert(f);
-    auto err = Error{};
-    if ((err = f.block_until_ready())) {
-        fmt::print(stderr, "ERROR: Error while on_error() blocking for {}: {}\n",
-                   operation, err.what());
-        return FutureRC::ABORT;
-    }
-    if ((err = f.error())) {
-        fmt::print(stderr, "ERROR: Unretryable on_error() error from {}: {}\n",
-                   operation, err.what());
-        return FutureRC::ABORT;
-    } else {
-        return FutureRC::OK;
-    }
+	assert(f);
+	auto err = Error{};
+	if ((err = f.block_until_ready())) {
+		fmt::print(stderr, "ERROR: Error while on_error() blocking for {}: {}\n", operation, err.what());
+		return FutureRC::ABORT;
+	}
+	if ((err = f.error())) {
+		fmt::print(stderr, "ERROR: Unretryable on_error() error from {}: {}\n", operation, err.what());
+		return FutureRC::ABORT;
+	} else {
+		return FutureRC::OK;
+	}
 }
 
 // wait on any non-immediate tx-related operation to complete. Follow up with on_error().
 template <class FutureType>
 FutureRC wait_and_handle_error(TX tx, FutureType f, std::string_view operation) {
-    assert(f);
-    auto err = Error{};
-    if ((err = f.block_until_ready())) {
-        const auto retry = err.retryable();
-        auto fp = retry ? annoyme : stderr;
-        fmt::print(fp, "ERROR: {} error in {}: {}\n",
-                   (retry ? "Retryable" : "Unretryable"),
-                   operation, err.what());
-        return retry ? FutureRC::RETRY : FutureRC::ABORT;
-    }
-    err = f.error();
-    if (!err) return FutureRC::OK;
-    auto fp = err.retryable() ? annoyme : stderr;
-    fmt::print(fp, "ERROR: Error in {}: {}\n", operation, err.what());
-    // implicit backoff
-    auto follow_up = tx.on_error(err);
-    auto rc = wait_and_handle_for_on_error(tx, f, operation);
-    if (rc == FutureRC::OK) {
-        if (err.is(1020/*not_committed*/))
-            return FutureRC::CONFLICT;
-        else
-            return FutureRC::RETRY;
-    } else {
-        tx.reset();
-        return rc;
-    }
+	assert(f);
+	auto err = Error{};
+	if ((err = f.block_until_ready())) {
+		const auto retry = err.retryable();
+		auto fp = retry ? annoyme : stderr;
+		fmt::print(fp, "ERROR: {} error in {}: {}\n", (retry ? "Retryable" : "Unretryable"), operation, err.what());
+		return retry ? FutureRC::RETRY : FutureRC::ABORT;
+	}
+	err = f.error();
+	if (!err)
+		return FutureRC::OK;
+	auto fp = err.retryable() ? annoyme : stderr;
+	fmt::print(fp, "ERROR: Error in {}: {}\n", operation, err.what());
+	// implicit backoff
+	auto follow_up = tx.on_error(err);
+	auto rc = wait_and_handle_for_on_error(tx, f, operation);
+	if (rc == FutureRC::OK) {
+		if (err.is(1020 /*not_committed*/))
+			return FutureRC::CONFLICT;
+		else
+			return FutureRC::RETRY;
+	} else {
+		tx.reset();
+		return rc;
+	}
 }
 
 /* cleanup database */
 int cleanup(TX tx, mako_args_t const& args) {
-    auto beginstr = ByteString{};
-    beginstr.reserve(args.key_length);
-    genkeyprefix(beginstr, KEY_PREFIX, args);
-    beginstr.push_back(0);
+	auto beginstr = ByteString{};
+	beginstr.reserve(args.key_length);
+	genkeyprefix(beginstr, KEY_PREFIX, args);
+	beginstr.push_back(0);
 
-    auto endstr = ByteString{};
-    endstr.reserve(args.key_length);
-    genkeyprefix(endstr, KEY_PREFIX, args);
-    endstr.push_back(0xff);
+	auto endstr = ByteString{};
+	endstr.reserve(args.key_length);
+	genkeyprefix(endstr, KEY_PREFIX, args);
+	endstr.push_back(0xff);
 
-    const auto time_start = steady_clock::now();
+	const auto time_start = steady_clock::now();
 
-    while (true) {
-        tx.clear_range(beginstr, endstr);
-        auto future_commit = tx.commit();
-        const auto rc = wait_and_handle_error(tx, future_commit, "COMMIT_CLEANUP");
-        if (rc == FutureRC::OK) {
-            break;
-        } else if (rc == FutureRC::RETRY || rc == FutureRC::CONFLICT) {
-            // tx already reset
-            continue;
-        } else {
-            return -1;
-        }
-    }
+	while (true) {
+		tx.clear_range(beginstr, endstr);
+		auto future_commit = tx.commit();
+		const auto rc = wait_and_handle_error(tx, future_commit, "COMMIT_CLEANUP");
+		if (rc == FutureRC::OK) {
+			break;
+		} else if (rc == FutureRC::RETRY || rc == FutureRC::CONFLICT) {
+			// tx already reset
+			continue;
+		} else {
+			return -1;
+		}
+	}
 
-    tx.reset();
-    const auto time_end = steady_clock::now();
-    fmt::print(printme, "INFO: Clear range: {:6.3f} sec\n",
-               to_double_seconds(time_end - time_start));
-    return 0;
+	tx.reset();
+	const auto time_end = steady_clock::now();
+	fmt::print(printme, "INFO: Clear range: {:6.3f} sec\n", to_double_seconds(time_end - time_start));
+	return 0;
 }
 
 /* populate database */
@@ -145,118 +136,111 @@ int populate(TX tx,
              int thread_tps,
              mako_stats_t& stats,
              sample_bin_array_t& sample_bins) {
-    const auto key_begin = insert_begin(args.rows, worker_id, thread_id,
-                                        args.num_processes, args.num_threads);
-    const auto key_end = insert_end(args.rows, worker_id, thread_id,
-                                    args.num_processes, args.num_threads);
-    auto xacts = 0;
+	const auto key_begin = insert_begin(args.rows, worker_id, thread_id, args.num_processes, args.num_threads);
+	const auto key_end = insert_end(args.rows, worker_id, thread_id, args.num_processes, args.num_threads);
+	auto xacts = 0;
 
-    auto keystr = ByteString{};
-    auto valstr = ByteString{};
-    keystr.reserve(args.key_length);
-    valstr.reserve(args.value_length);
-    const auto time_start = steady_clock::now();
-    const auto num_commit_every = args.txnspec.ops[OP_INSERT][OP_COUNT];
-    auto time_prev = time_start; // for throttling
-    auto time_tx_start = time_start;
-    auto time_last_traced = time_start;
-    auto key_checkpoint = key_begin; // in case of commit failure, restart from this key
+	auto keystr = ByteString{};
+	auto valstr = ByteString{};
+	keystr.reserve(args.key_length);
+	valstr.reserve(args.value_length);
+	const auto time_start = steady_clock::now();
+	const auto num_commit_every = args.txnspec.ops[OP_INSERT][OP_COUNT];
+	auto time_prev = time_start; // for throttling
+	auto time_tx_start = time_start;
+	auto time_last_traced = time_start;
+	auto key_checkpoint = key_begin; // in case of commit failure, restart from this key
 
-    for (auto i = key_begin; i <= key_end; i++) {
-        /* sequential keys */
-        genkey(keystr, KEY_PREFIX, args, i);
-        /* random values */
-        randstr(valstr, args.value_length);
+	for (auto i = key_begin; i <= key_end; i++) {
+		/* sequential keys */
+		genkey(keystr, KEY_PREFIX, args, i);
+		/* random values */
+		randstr(valstr, args.value_length);
 
-        while (thread_tps > 0 && xacts >= thread_tps /* throttle */) {
-            const auto time_now = steady_clock::now();
-            if (to_integer_seconds(time_now - time_prev) >= 1) {
-                xacts = 0;
-                time_prev = time_now;
-            } else {
-                usleep(1000);
-            }
-        }
-        if (args.txntrace) {
-            const auto time_now = steady_clock::now();
-            if (to_integer_seconds(time_now - time_last_traced) >= args.txntrace) {
-                time_last_traced = time_now;
-                fmt::print(debugme, "DEBUG: txn tracing {}\n", to_chars_ref(keystr));
-                auto err = Error{};
-                err = tx.set_option_nothrow(
-                    FDB_TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER, keystr);
-                if (err) {
-                    fmt::print(stderr,
-                               "ERROR: set_option(TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER): {}\n",
-                                err.what());
-                }
-                err = tx.set_option_nothrow(FDB_TR_OPTION_LOG_TRANSACTION, BytesRef());
-                if (err) {
-                    fmt::print(stderr,
-                               "ERROR: set_option(TR_OPTION_LOG_TRANSACTION): {}\n",
-                               err.what());
-                }
-            }
-        }
+		while (thread_tps > 0 && xacts >= thread_tps /* throttle */) {
+			const auto time_now = steady_clock::now();
+			if (to_integer_seconds(time_now - time_prev) >= 1) {
+				xacts = 0;
+				time_prev = time_now;
+			} else {
+				usleep(1000);
+			}
+		}
+		if (args.txntrace) {
+			const auto time_now = steady_clock::now();
+			if (to_integer_seconds(time_now - time_last_traced) >= args.txntrace) {
+				time_last_traced = time_now;
+				fmt::print(debugme, "DEBUG: txn tracing {}\n", to_chars_ref(keystr));
+				auto err = Error{};
+				err = tx.set_option_nothrow(FDB_TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER, keystr);
+				if (err) {
+					fmt::print(stderr, "ERROR: set_option(TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER): {}\n", err.what());
+				}
+				err = tx.set_option_nothrow(FDB_TR_OPTION_LOG_TRANSACTION, BytesRef());
+				if (err) {
+					fmt::print(stderr, "ERROR: set_option(TR_OPTION_LOG_TRANSACTION): {}\n", err.what());
+				}
+			}
+		}
 
-        /* insert (SET) */
-        tx.set(keystr, valstr);
-        stats.incr_count_immediate(OP_INSERT);
+		/* insert (SET) */
+		tx.set(keystr, valstr);
+		stats.incr_count_immediate(OP_INSERT);
 
-        /* commit every 100 inserts (default) or if this is the last key */
-        if (i == key_end || (i - key_begin + 1) % num_commit_every == 0) {
-            auto time_commit_start = timepoint_t{};
-            const auto is_sample_target = (stats.get_tx_count() % args.sampling) == 0;
-            if (is_sample_target) time_commit_start = steady_clock::now();
-            auto future_commit = tx.commit();
-            const auto rc = wait_and_handle_error(tx, future_commit,
-                                                  "COMMIT_POPULATE_INSERT");
-            if (rc == FutureRC::OK) {
-                key_checkpoint = i + 1; // restart on failures from next key
-            } else if (rc == FutureRC::ABORT) {
-                return -1;
-            } else {
-                i = key_checkpoint - 1; // restart from last committed
-                time_tx_start = steady_clock::now(); // tx shall restart
-                continue;
-            }
+		/* commit every 100 inserts (default) or if this is the last key */
+		if (i == key_end || (i - key_begin + 1) % num_commit_every == 0) {
+			auto time_commit_start = timepoint_t{};
+			const auto is_sample_target = (stats.get_tx_count() % args.sampling) == 0;
+			if (is_sample_target)
+				time_commit_start = steady_clock::now();
+			auto future_commit = tx.commit();
+			const auto rc = wait_and_handle_error(tx, future_commit, "COMMIT_POPULATE_INSERT");
+			if (rc == FutureRC::OK) {
+				key_checkpoint = i + 1; // restart on failures from next key
+			} else if (rc == FutureRC::ABORT) {
+				return -1;
+			} else {
+				i = key_checkpoint - 1; // restart from last committed
+				time_tx_start = steady_clock::now(); // tx shall restart
+				continue;
+			}
 
-            /* xact latency stats */
-            if (is_sample_target) {
-                const auto time_commit_end = steady_clock::now();
-                const auto commit_latency_us =
-                    to_integer_microseconds(time_commit_end - time_commit_start);
-                const auto tx_duration_us =
-                    to_integer_microseconds(time_commit_end - time_tx_start);
-                sample_bins[OP_COMMIT].put(commit_latency_us);
-                sample_bins[OP_TRANSACTION].put(tx_duration_us);
-                stats.add_latency(OP_COMMIT, commit_latency_us);
-                stats.add_latency(OP_TRANSACTION, tx_duration_us);
-            }
+			/* xact latency stats */
+			if (is_sample_target) {
+				const auto time_commit_end = steady_clock::now();
+				const auto commit_latency_us = to_integer_microseconds(time_commit_end - time_commit_start);
+				const auto tx_duration_us = to_integer_microseconds(time_commit_end - time_tx_start);
+				sample_bins[OP_COMMIT].put(commit_latency_us);
+				sample_bins[OP_TRANSACTION].put(tx_duration_us);
+				stats.add_latency(OP_COMMIT, commit_latency_us);
+				stats.add_latency(OP_TRANSACTION, tx_duration_us);
+			}
 
-            time_tx_start = steady_clock::now();
+			time_tx_start = steady_clock::now();
 
-            tx.reset();
-            stats.incr_tx_count();
-            xacts++; /* for throttling */
-        }
-    }
-    const auto time_end = steady_clock::now();
+			tx.reset();
+			stats.incr_tx_count();
+			xacts++; /* for throttling */
+		}
+	}
+	const auto time_end = steady_clock::now();
 
-    fmt::print(debugme,
-            "DEBUG: Populated {} rows [{}, {}]: {:6.3f} sec\n",
-            key_end - key_begin + 1, key_begin, key_end,
-            to_double_seconds(time_end - time_start));
+	fmt::print(debugme,
+	           "DEBUG: Populated {} rows [{}, {}]: {:6.3f} sec\n",
+	           key_end - key_begin + 1,
+	           key_begin,
+	           key_end,
+	           to_double_seconds(time_end - time_start));
 
-    return 0;
+	return 0;
 }
 
 // TODO: could always abstract this into something more generically usable by something other than mako.
 // But outside of testing there are likely few use cases for local granules
 typedef struct {
-    char const* bgFilePath;
-    int nextId;
-    uint8_t** data_by_id;
+	char const* bgFilePath;
+	int nextId;
+	uint8_t** data_by_id;
 } BGLocalFileContext;
 
 int64_t granule_start_load(const char* filename,
@@ -264,481 +248,452 @@ int64_t granule_start_load(const char* filename,
                            int64_t offset,
                            int64_t length,
                            void* userContext) {
-    FILE* fp;
-    char full_fname[PATH_MAX]{0,};
-    int loadId;
-    uint8_t* data;
-    size_t readSize;
+	FILE* fp;
+	char full_fname[PATH_MAX]{
+		0,
+	};
+	int loadId;
+	uint8_t* data;
+	size_t readSize;
 
-    BGLocalFileContext* context = (BGLocalFileContext*)userContext;
+	BGLocalFileContext* context = (BGLocalFileContext*)userContext;
 
-    loadId = context->nextId;
-    if (context->data_by_id[loadId] != 0) {
-        fmt::print(stderr, "ERROR: too many granule file loads at once: {}\n", MAX_BG_IDS);
-        return -1;
-    }
-    context->nextId = (context->nextId + 1) % MAX_BG_IDS;
+	loadId = context->nextId;
+	if (context->data_by_id[loadId] != 0) {
+		fmt::print(stderr, "ERROR: too many granule file loads at once: {}\n", MAX_BG_IDS);
+		return -1;
+	}
+	context->nextId = (context->nextId + 1) % MAX_BG_IDS;
 
-    int ret = snprintf(full_fname, PATH_MAX, "%s%s", context->bgFilePath, filename);
-    if (ret < 0 || ret >= PATH_MAX) {
-        fmt::print(stderr, "ERROR: BG filename too long: {}{}\n", context->bgFilePath, filename);
-        return -1;
-    }
+	int ret = snprintf(full_fname, PATH_MAX, "%s%s", context->bgFilePath, filename);
+	if (ret < 0 || ret >= PATH_MAX) {
+		fmt::print(stderr, "ERROR: BG filename too long: {}{}\n", context->bgFilePath, filename);
+		return -1;
+	}
 
-    fp = fopen(full_fname, "r");
-    if (!fp) {
-        fmt::print(stderr, "ERROR: BG could not open file: {}\n", full_fname);
-        return -1;
-    }
+	fp = fopen(full_fname, "r");
+	if (!fp) {
+		fmt::print(stderr, "ERROR: BG could not open file: {}\n", full_fname);
+		return -1;
+	}
 
-    // don't seek if offset == 0
-    if (offset && fseek(fp, offset, SEEK_SET)) {
-        // if fseek was non-zero, it failed
-        fmt::print(stderr, "ERROR: BG could not seek to %{} in file {}\n", offset, full_fname);
-        fclose(fp);
-        return -1;
-    }
+	// don't seek if offset == 0
+	if (offset && fseek(fp, offset, SEEK_SET)) {
+		// if fseek was non-zero, it failed
+		fmt::print(stderr, "ERROR: BG could not seek to %{} in file {}\n", offset, full_fname);
+		fclose(fp);
+		return -1;
+	}
 
-    data = new uint8_t[length];
-    readSize = fread(data, sizeof(uint8_t), length, fp);
-    fclose(fp);
+	data = new uint8_t[length];
+	readSize = fread(data, sizeof(uint8_t), length, fp);
+	fclose(fp);
 
-    if (readSize != length) {
-        fmt::print(stderr, "ERROR: BG could not read {} bytes from file: {}\n", length, full_fname);
-        return -1;
-    }
+	if (readSize != length) {
+		fmt::print(stderr, "ERROR: BG could not read {} bytes from file: {}\n", length, full_fname);
+		return -1;
+	}
 
-    context->data_by_id[loadId] = data;
-    return loadId;
+	context->data_by_id[loadId] = data;
+	return loadId;
 }
 
 uint8_t* granule_get_load(int64_t loadId, void* userContext) {
-    BGLocalFileContext* context = (BGLocalFileContext*)userContext;
-    if (context->data_by_id[loadId] == 0) {
-        fmt::print(stderr, "ERROR: BG loadId invalid for get_load: {}\n", loadId);
-        return 0;
-    }
-    return context->data_by_id[loadId];
+	BGLocalFileContext* context = (BGLocalFileContext*)userContext;
+	if (context->data_by_id[loadId] == 0) {
+		fmt::print(stderr, "ERROR: BG loadId invalid for get_load: {}\n", loadId);
+		return 0;
+	}
+	return context->data_by_id[loadId];
 }
 
 void granule_free_load(int64_t loadId, void* userContext) {
-    BGLocalFileContext* context = (BGLocalFileContext*)userContext;
-    if (context->data_by_id[loadId] == 0) {
-        fmt::print(stderr, "ERROR: BG loadId invalid for free_load: {}\n", loadId);
-    }
-    delete[] context->data_by_id[loadId];
-    context->data_by_id[loadId] = 0;
+	BGLocalFileContext* context = (BGLocalFileContext*)userContext;
+	if (context->data_by_id[loadId] == 0) {
+		fmt::print(stderr, "ERROR: BG loadId invalid for free_load: {}\n", loadId);
+	}
+	delete[] context->data_by_id[loadId];
+	context->data_by_id[loadId] = 0;
 }
 
 inline int next_key(mako_args_t const& args) {
-    if (args.zipf) return zipfian_next();
-    return urand(0, args.rows - 1);
+	if (args.zipf)
+		return zipfian_next();
+	return urand(0, args.rows - 1);
 }
 
-const std::array<OpDesc, MAX_OP> op_desc{{
-    {"GRV",             {StepKind::READ},                  false },
-    {"GET",             {StepKind::READ},                  false },
-    {"GETRANGE",        {StepKind::READ},                  false },
-    {"SGET",            {StepKind::READ},                  false },
-    {"SGETRANGE",       {StepKind::READ},                  false },
-    {"UPDATE",          {StepKind::COMMIT, StepKind::IMM}, true  },
-    {"INSERT",          {StepKind::IMM},                   true  },
-    {"INSERTRANGE",     {StepKind::IMM},                   true  },
-    {"OVERWRITE",       {StepKind::IMM},                   true  },
-    {"CLEAR",           {StepKind::IMM},                   true  },
-    {"SETCLEAR",        {StepKind::COMMIT, StepKind::IMM}, true  },
-    {"CLEARRANGE",      {StepKind::IMM},                   true  },
-    {"SETCLEARRANGE",   {StepKind::COMMIT, StepKind::IMM}, true  },
-    {"COMMIT",          {StepKind::NONE},                  false },
-    {"TRANSACTION",     {StepKind::NONE},                  false },
-    {"READBLOBGRANULE", {StepKind::ON_ERROR},              false }
-}};
+const std::array<OpDesc, MAX_OP> op_desc{ { { "GRV", { StepKind::READ }, false },
+	                                        { "GET", { StepKind::READ }, false },
+	                                        { "GETRANGE", { StepKind::READ }, false },
+	                                        { "SGET", { StepKind::READ }, false },
+	                                        { "SGETRANGE", { StepKind::READ }, false },
+	                                        { "UPDATE", { StepKind::COMMIT, StepKind::IMM }, true },
+	                                        { "INSERT", { StepKind::IMM }, true },
+	                                        { "INSERTRANGE", { StepKind::IMM }, true },
+	                                        { "OVERWRITE", { StepKind::IMM }, true },
+	                                        { "CLEAR", { StepKind::IMM }, true },
+	                                        { "SETCLEAR", { StepKind::COMMIT, StepKind::IMM }, true },
+	                                        { "CLEARRANGE", { StepKind::IMM }, true },
+	                                        { "SETCLEARRANGE", { StepKind::COMMIT, StepKind::IMM }, true },
+	                                        { "COMMIT", { StepKind::NONE }, false },
+	                                        { "TRANSACTION", { StepKind::NONE }, false },
+	                                        { "READBLOBGRANULE", { StepKind::ON_ERROR }, false } } };
 
-const std::map<std::pair<int/*op*/, int/*sub-op step*/>,
-               Future(*)(TX,
-                         mako_args_t const&,
-                         ByteString&/*key1*/,
-                         ByteString&/*key2*/,
-                         ByteString&/*value*/)> operation_fn_table{
-    {
-        {OP_GETREADVERSION, 0},
-        [](TX tx, mako_args_t const&, ByteString&, ByteString&, ByteString&) {
-            return tx.get_read_version().erase_type();
-        }
-    },
-    {
-        {OP_GET, 0},
-        [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString&) {
-            const auto num = next_key(args);
-            genkey(key, KEY_PREFIX, args, num);
-            return tx.get(key, false/*snapshot*/).erase_type();
-        }
-    },
-    {
-        {OP_GETRANGE, 0},
-        [](TX tx, mako_args_t const& args, ByteString& begin, ByteString& end, ByteString&) {
-            const auto num_begin = next_key(args);
-            genkey(begin, KEY_PREFIX, args, num_begin);
-            auto num_end = num_begin + args.txnspec.ops[OP_GETRANGE][OP_RANGE] - 1;
-            if (num_end > args.rows - 1)
-                num_end = args.rows - 1;
-            genkey(end, KEY_PREFIX, args, num_end);
-            return tx.get_range<key_select::inclusive, key_select::inclusive>(
-                    begin, end, 0/*limit*/, 0/*target_bytes*/, args.streaming_mode,
-                    0/*iteration*/, false/*snapshot*/,
-                    args.txnspec.ops[OP_GETRANGE][OP_REVERSE]).erase_type();
-        }
-    },
-    {
-        {OP_SGET, 0},
-        [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString&) {
-            const auto num = next_key(args);
-            genkey(key, KEY_PREFIX, args, num);
-            return tx.get(key, true/*snapshot*/).erase_type();
-        }
-    },
-    {
-        {OP_SGETRANGE, 0},
-        [](TX tx, mako_args_t const& args, ByteString& begin, ByteString& end, ByteString&) {
-            const auto num_begin = next_key(args);
-            genkey(begin, KEY_PREFIX, args, num_begin);
-            auto num_end = num_begin + args.txnspec.ops[OP_SGETRANGE][OP_RANGE] - 1;
-            if (num_end > args.rows - 1)
-                num_end = args.rows - 1;
-            genkey(end, KEY_PREFIX, args, num_end);
-            return tx.get_range<key_select::inclusive, key_select::inclusive>(
-                    begin, end, 0/*limit*/, 0/*target_bytes*/, args.streaming_mode,
-                    0/*iteration*/, true/*snapshot*/,
-                    args.txnspec.ops[OP_SGETRANGE][OP_REVERSE]).erase_type();
-        }
-    },
-    {
-        {OP_UPDATE, 0},
-        [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString&) {
-            const auto num = next_key(args);
-            genkey(key, KEY_PREFIX, args, num);
-            return tx.get(key, false/*snapshot*/).erase_type();
-        }
-    },
-    {
-        {OP_UPDATE, 1},
-        [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString& value) {
-            randstr(value, args.value_length);
-            tx.set(key, value);
-            return Future();
-        }
-    },
-    {
-        {OP_INSERT, 0},
-        [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString& value) {
-            genkeyprefix(key, KEY_PREFIX, args);
-            // concat([padding], key_prefix, random_string): reasonably unique
-            randstr<false/*clear-before-append*/>(
-                    key, args.key_length - static_cast<int>(key.size()));
-            randstr(value, args.value_length);
-            tx.set(key, value);
-            return Future();
-        }
-    },
-    {
-        {OP_INSERTRANGE, 0},
-        [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString& value) {
-            genkeyprefix(key, KEY_PREFIX, args);
-            const auto prefix_len = static_cast<int>(key.size());
-            const auto range = args.txnspec.ops[OP_INSERTRANGE][OP_RANGE];
-            assert(range > 0);
-            const auto range_digits = digits(range);
-            assert(args.key_length - prefix_len >= range_digits);
-            const auto rand_len = args.key_length - prefix_len - range_digits;
-            // concat([padding], prefix, random_string, range_digits)
-            randstr<false/*clear-before-append*/>(key, rand_len);
-            randstr(value, args.value_length);
-            for (auto i = 0; i < range; i++) {
-                fmt::format_to(std::back_inserter(key), "{0:0{1}d}", i, range_digits);
-                tx.set(key, value);
-                key.resize(key.size() - static_cast<size_t>(range_digits));
-            }
-            return Future();
-        }
-    },
-    {
-        {OP_OVERWRITE, 0},
-        [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString& value) {
-            genkey(key, KEY_PREFIX, args, next_key(args));
-            randstr(value, args.value_length);
-            return Future();
-        }
-    },
-    {
-        {OP_CLEAR, 0},
-        [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString&) {
-            genkey(key, KEY_PREFIX, args, next_key(args));
-            tx.clear(key);
-            return Future();
-        }
-    },
-    {
-        {OP_SETCLEAR, 0},
-        [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString& value) {
-            genkeyprefix(key, KEY_PREFIX, args);
-            const auto prefix_len = static_cast<int>(key.size());
-            randstr<false/*append-after-clear*/>(key, args.key_length - prefix_len);
-            randstr(value, args.value_length);
-            tx.set(key, value);
-            return tx.commit().erase_type();
-        }
-    },
-    {
-        {OP_SETCLEAR, 1},
-        [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString&) {
-            tx.reset(); // assuming commit from step 0 worked.
-            tx.clear(key); // key should forward unchanged from step 0
-            return Future();
-        }
-    },
-    {
-        {OP_CLEARRANGE, 0},
-        [](TX tx, mako_args_t const& args, ByteString& begin, ByteString& end, ByteString&) {
-            const auto num_begin = next_key(args);
-            genkey(begin, KEY_PREFIX, args, num_begin);
-            const auto range = args.txnspec.ops[OP_CLEARRANGE][OP_RANGE];
-            assert(range > 0);
-            genkey(end, KEY_PREFIX, args, std::min(args.rows - 1, num_begin + range - 1));
-            tx.clear_range(begin, end);
-            return Future();
-        }
-    },
-    {
-        {OP_SETCLEARRANGE, 0},
-        [](TX tx, mako_args_t const& args, ByteString& key_begin, ByteString& key, ByteString& value) {
-            genkeyprefix(key, KEY_PREFIX, args);
-            const auto prefix_len = static_cast<int>(key.size());
-            const auto range = args.txnspec.ops[OP_SETCLEARRANGE][OP_RANGE];
-            assert(range > 0);
-            const auto range_digits = digits(range);
-            assert(args.key_length - prefix_len >= range_digits);
-            const auto rand_len = args.key_length - prefix_len - range_digits;
-            // concat([padding], prefix, random_string, range_digits)
-            randstr<false/*clear-before-append*/>(key, rand_len);
-            randstr(value, args.value_length);
-            for (auto i = 0; i <= range; i++) {
-                fmt::format_to(std::back_inserter(key), "{0:0{1}d}", i, range_digits);
-                if (i == range) break; // preserve "exclusive last"
-                // preserve first key for step 1
-                if (i == 0) key_begin = key;
-                tx.set(key, value);
-                // preserve last key for step 1
-                key.resize(key.size() - static_cast<size_t>(range_digits));
-            }
-            return tx.commit().erase_type();
-        }
-    },
-    {
-        {OP_SETCLEARRANGE, 1},
-        [](TX tx, mako_args_t const& args, ByteString& begin, ByteString& end, ByteString&) {
-            tx.reset();
-            tx.clear_range(begin, end);
-            return Future();
-        }
-    },
-    {
-        {OP_READ_BG, 0},
-        [](TX tx, mako_args_t const& args, ByteString& begin, ByteString& end, ByteString&) {
-            const auto num_begin = next_key(args);
-            genkey(begin, KEY_PREFIX, args, num_begin);
-            const auto range = args.txnspec.ops[OP_READ_BG][OP_RANGE];
-            assert(range > 0);
-            genkey(end, KEY_PREFIX, args, std::min(args.rows - 1, num_begin + range - 1));
-            auto err = Error{};
+const std::map<std::pair<int /*op*/, int /*sub-op step*/>,
+               Future (*)(TX, mako_args_t const&, ByteString& /*key1*/, ByteString& /*key2*/, ByteString& /*value*/)>
+    operation_fn_table{
+	    { { OP_GETREADVERSION, 0 },
+	      [](TX tx, mako_args_t const&, ByteString&, ByteString&, ByteString&) {
+	          return tx.get_read_version().erase_type();
+	      } },
+	    { { OP_GET, 0 },
+	      [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString&) {
+	          const auto num = next_key(args);
+	          genkey(key, KEY_PREFIX, args, num);
+	          return tx.get(key, false /*snapshot*/).erase_type();
+	      } },
+	    { { OP_GETRANGE, 0 },
+	      [](TX tx, mako_args_t const& args, ByteString& begin, ByteString& end, ByteString&) {
+	          const auto num_begin = next_key(args);
+	          genkey(begin, KEY_PREFIX, args, num_begin);
+	          auto num_end = num_begin + args.txnspec.ops[OP_GETRANGE][OP_RANGE] - 1;
+	          if (num_end > args.rows - 1)
+		          num_end = args.rows - 1;
+	          genkey(end, KEY_PREFIX, args, num_end);
+	          return tx
+	              .get_range<key_select::inclusive, key_select::inclusive>(begin,
+	                                                                       end,
+	                                                                       0 /*limit*/,
+	                                                                       0 /*target_bytes*/,
+	                                                                       args.streaming_mode,
+	                                                                       0 /*iteration*/,
+	                                                                       false /*snapshot*/,
+	                                                                       args.txnspec.ops[OP_GETRANGE][OP_REVERSE])
+	              .erase_type();
+	      } },
+	    { { OP_SGET, 0 },
+	      [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString&) {
+	          const auto num = next_key(args);
+	          genkey(key, KEY_PREFIX, args, num);
+	          return tx.get(key, true /*snapshot*/).erase_type();
+	      } },
+	    { { OP_SGETRANGE, 0 },
+	      [](TX tx, mako_args_t const& args, ByteString& begin, ByteString& end, ByteString&) {
+	          const auto num_begin = next_key(args);
+	          genkey(begin, KEY_PREFIX, args, num_begin);
+	          auto num_end = num_begin + args.txnspec.ops[OP_SGETRANGE][OP_RANGE] - 1;
+	          if (num_end > args.rows - 1)
+		          num_end = args.rows - 1;
+	          genkey(end, KEY_PREFIX, args, num_end);
+	          return tx
+	              .get_range<key_select::inclusive, key_select::inclusive>(begin,
+	                                                                       end,
+	                                                                       0 /*limit*/,
+	                                                                       0 /*target_bytes*/,
+	                                                                       args.streaming_mode,
+	                                                                       0 /*iteration*/,
+	                                                                       true /*snapshot*/,
+	                                                                       args.txnspec.ops[OP_SGETRANGE][OP_REVERSE])
+	              .erase_type();
+	      } },
+	    { { OP_UPDATE, 0 },
+	      [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString&) {
+	          const auto num = next_key(args);
+	          genkey(key, KEY_PREFIX, args, num);
+	          return tx.get(key, false /*snapshot*/).erase_type();
+	      } },
+	    { { OP_UPDATE, 1 },
+	      [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString& value) {
+	          randstr(value, args.value_length);
+	          tx.set(key, value);
+	          return Future();
+	      } },
+	    { { OP_INSERT, 0 },
+	      [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString& value) {
+	          genkeyprefix(key, KEY_PREFIX, args);
+	          // concat([padding], key_prefix, random_string): reasonably unique
+	          randstr<false /*clear-before-append*/>(key, args.key_length - static_cast<int>(key.size()));
+	          randstr(value, args.value_length);
+	          tx.set(key, value);
+	          return Future();
+	      } },
+	    { { OP_INSERTRANGE, 0 },
+	      [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString& value) {
+	          genkeyprefix(key, KEY_PREFIX, args);
+	          const auto prefix_len = static_cast<int>(key.size());
+	          const auto range = args.txnspec.ops[OP_INSERTRANGE][OP_RANGE];
+	          assert(range > 0);
+	          const auto range_digits = digits(range);
+	          assert(args.key_length - prefix_len >= range_digits);
+	          const auto rand_len = args.key_length - prefix_len - range_digits;
+	          // concat([padding], prefix, random_string, range_digits)
+	          randstr<false /*clear-before-append*/>(key, rand_len);
+	          randstr(value, args.value_length);
+	          for (auto i = 0; i < range; i++) {
+		          fmt::format_to(std::back_inserter(key), "{0:0{1}d}", i, range_digits);
+		          tx.set(key, value);
+		          key.resize(key.size() - static_cast<size_t>(range_digits));
+	          }
+	          return Future();
+	      } },
+	    { { OP_OVERWRITE, 0 },
+	      [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString& value) {
+	          genkey(key, KEY_PREFIX, args, next_key(args));
+	          randstr(value, args.value_length);
+	          return Future();
+	      } },
+	    { { OP_CLEAR, 0 },
+	      [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString&) {
+	          genkey(key, KEY_PREFIX, args, next_key(args));
+	          tx.clear(key);
+	          return Future();
+	      } },
+	    { { OP_SETCLEAR, 0 },
+	      [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString& value) {
+	          genkeyprefix(key, KEY_PREFIX, args);
+	          const auto prefix_len = static_cast<int>(key.size());
+	          randstr<false /*append-after-clear*/>(key, args.key_length - prefix_len);
+	          randstr(value, args.value_length);
+	          tx.set(key, value);
+	          return tx.commit().erase_type();
+	      } },
+	    { { OP_SETCLEAR, 1 },
+	      [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString&) {
+	          tx.reset(); // assuming commit from step 0 worked.
+	          tx.clear(key); // key should forward unchanged from step 0
+	          return Future();
+	      } },
+	    { { OP_CLEARRANGE, 0 },
+	      [](TX tx, mako_args_t const& args, ByteString& begin, ByteString& end, ByteString&) {
+	          const auto num_begin = next_key(args);
+	          genkey(begin, KEY_PREFIX, args, num_begin);
+	          const auto range = args.txnspec.ops[OP_CLEARRANGE][OP_RANGE];
+	          assert(range > 0);
+	          genkey(end, KEY_PREFIX, args, std::min(args.rows - 1, num_begin + range - 1));
+	          tx.clear_range(begin, end);
+	          return Future();
+	      } },
+	    { { OP_SETCLEARRANGE, 0 },
+	      [](TX tx, mako_args_t const& args, ByteString& key_begin, ByteString& key, ByteString& value) {
+	          genkeyprefix(key, KEY_PREFIX, args);
+	          const auto prefix_len = static_cast<int>(key.size());
+	          const auto range = args.txnspec.ops[OP_SETCLEARRANGE][OP_RANGE];
+	          assert(range > 0);
+	          const auto range_digits = digits(range);
+	          assert(args.key_length - prefix_len >= range_digits);
+	          const auto rand_len = args.key_length - prefix_len - range_digits;
+	          // concat([padding], prefix, random_string, range_digits)
+	          randstr<false /*clear-before-append*/>(key, rand_len);
+	          randstr(value, args.value_length);
+	          for (auto i = 0; i <= range; i++) {
+		          fmt::format_to(std::back_inserter(key), "{0:0{1}d}", i, range_digits);
+		          if (i == range)
+			          break; // preserve "exclusive last"
+		          // preserve first key for step 1
+		          if (i == 0)
+			          key_begin = key;
+		          tx.set(key, value);
+		          // preserve last key for step 1
+		          key.resize(key.size() - static_cast<size_t>(range_digits));
+	          }
+	          return tx.commit().erase_type();
+	      } },
+	    { { OP_SETCLEARRANGE, 1 },
+	      [](TX tx, mako_args_t const& args, ByteString& begin, ByteString& end, ByteString&) {
+	          tx.reset();
+	          tx.clear_range(begin, end);
+	          return Future();
+	      } },
+	    { { OP_READ_BG, 0 },
+	      [](TX tx, mako_args_t const& args, ByteString& begin, ByteString& end, ByteString&) {
+	          const auto num_begin = next_key(args);
+	          genkey(begin, KEY_PREFIX, args, num_begin);
+	          const auto range = args.txnspec.ops[OP_READ_BG][OP_RANGE];
+	          assert(range > 0);
+	          genkey(end, KEY_PREFIX, args, std::min(args.rows - 1, num_begin + range - 1));
+	          auto err = Error{};
 
-            err = tx.set_option_nothrow(FDB_TR_OPTION_READ_YOUR_WRITES_DISABLE, BytesRef());
-            if (err) {
-                // Issuing read/writes before disabling RYW results in error.
-                // Possible malformed workload?
-                // As workloads execute in sequence, retrying would likely repeat this error.
-                fmt::print(stderr, "ERROR: TR_OPTION_READ_YOUR_WRITES_DISABLE: {}", err.what());
-                return Future();
-            }
+	          err = tx.set_option_nothrow(FDB_TR_OPTION_READ_YOUR_WRITES_DISABLE, BytesRef());
+	          if (err) {
+		          // Issuing read/writes before disabling RYW results in error.
+		          // Possible malformed workload?
+		          // As workloads execute in sequence, retrying would likely repeat this error.
+		          fmt::print(stderr, "ERROR: TR_OPTION_READ_YOUR_WRITES_DISABLE: {}", err.what());
+		          return Future();
+	          }
 
-            auto mem = std::unique_ptr<uint8_t*[]>(new uint8_t*[MAX_BG_IDS]);
-            // Allocate a separate context per call to avoid multiple threads accessing
-            BGLocalFileContext fileContext;
-            fileContext.bgFilePath = args.bg_file_path;
-            fileContext.nextId = 0;
-            fileContext.data_by_id = mem.get();
-            memset(fileContext.data_by_id, 0, MAX_BG_IDS * sizeof(uint8_t*));
+	          auto mem = std::unique_ptr<uint8_t*[]>(new uint8_t*[MAX_BG_IDS]);
+	          // Allocate a separate context per call to avoid multiple threads accessing
+	          BGLocalFileContext fileContext;
+	          fileContext.bgFilePath = args.bg_file_path;
+	          fileContext.nextId = 0;
+	          fileContext.data_by_id = mem.get();
+	          memset(fileContext.data_by_id, 0, MAX_BG_IDS * sizeof(uint8_t*));
 
-            native::FDBReadBlobGranuleContext granuleContext;
-            granuleContext.userContext = &fileContext;
-            granuleContext.start_load_f = &granule_start_load;
-            granuleContext.get_load_f = &granule_get_load;
-            granuleContext.free_load_f = &granule_free_load;
-            granuleContext.debugNoMaterialize = !args.bg_materialize_files;
+	          native::FDBReadBlobGranuleContext granuleContext;
+	          granuleContext.userContext = &fileContext;
+	          granuleContext.start_load_f = &granule_start_load;
+	          granuleContext.get_load_f = &granule_get_load;
+	          granuleContext.free_load_f = &granule_free_load;
+	          granuleContext.debugNoMaterialize = !args.bg_materialize_files;
 
-            auto r = tx.read_blob_granules(
-                    begin, end, 0/*begin_version*/, -1/*end_version, use txn's*/, granuleContext);
+	          auto r =
+	              tx.read_blob_granules(begin, end, 0 /*begin_version*/, -1 /*end_version, use txn's*/, granuleContext);
 
-            mem.reset();
+	          mem.reset();
 
-            auto out = Result::KeyValueArray{};
-            err = r.get_keyvalue_array_nothrow(out);
-            if (!err || err.is(2037/*blob_granule_not_materialized*/))
-                return Future();
-            const auto fp = (err.is(1020/*not_committed*/) ||
-                             err.is(1021/*commit_unknown_result*/) ||
-                             err.is(1213/*tag_throttled*/)) ? annoyme : stderr;
-            fmt::print(fp, "ERROR: get_keyvalue_array() after read_blob_granules(): {}\n",
-                       err.what());
-            return tx.on_error(err).erase_type();
-        }
-    }
-};
+	          auto out = Result::KeyValueArray{};
+	          err = r.get_keyvalue_array_nothrow(out);
+	          if (!err || err.is(2037 /*blob_granule_not_materialized*/))
+		          return Future();
+	          const auto fp = (err.is(1020 /*not_committed*/) || err.is(1021 /*commit_unknown_result*/) ||
+	                           err.is(1213 /*tag_throttled*/))
+	                              ? annoyme
+	                              : stderr;
+	          fmt::print(fp, "ERROR: get_keyvalue_array() after read_blob_granules(): {}\n", err.what());
+	          return tx.on_error(err).erase_type();
+	      } }
+    };
 
-using OpIterator = std::tuple<int/*op*/, int/*count*/, int/*step*/>;
+using OpIterator = std::tuple<int /*op*/, int /*count*/, int /*step*/>;
 
 constexpr const OpIterator OpEnd = OpIterator(MAX_OP, -1, -1);
 
 OpIterator get_op_begin(mako_args_t const& args) noexcept {
-    for (auto op = 0; op < MAX_OP; op++) {
-        if (op == OP_COMMIT || op == OP_TRANSACTION ||
-            args.txnspec.ops[op][OP_COUNT] == 0)
-            continue;
-        return OpIterator(op, 0, 0);
-    }
-    return OpEnd;
+	for (auto op = 0; op < MAX_OP; op++) {
+		if (op == OP_COMMIT || op == OP_TRANSACTION || args.txnspec.ops[op][OP_COUNT] == 0)
+			continue;
+		return OpIterator(op, 0, 0);
+	}
+	return OpEnd;
 }
 
 OpIterator get_op_next(mako_args_t const& args, OpIterator current) noexcept {
-    if (OpEnd == current) return OpEnd;
-    auto [op, count, step] = current;
-    assert(op < MAX_OP && op != OP_TRANSACTION && op != OP_COMMIT);
-    if (op_desc[op].steps() > step + 1)
-        return OpIterator(op, count, step + 1);
-    count++;
-    for ( ; op < MAX_OP; op++, count=0) {
-        if (op == OP_COMMIT || op == OP_TRANSACTION ||
-            args.txnspec.ops[op][OP_COUNT] <= count)
-            continue;
-        return OpIterator(op, count, 0);
-    }
-    return OpEnd;
+	if (OpEnd == current)
+		return OpEnd;
+	auto [op, count, step] = current;
+	assert(op < MAX_OP && op != OP_TRANSACTION && op != OP_COMMIT);
+	if (op_desc[op].steps() > step + 1)
+		return OpIterator(op, count, step + 1);
+	count++;
+	for (; op < MAX_OP; op++, count = 0) {
+		if (op == OP_COMMIT || op == OP_TRANSACTION || args.txnspec.ops[op][OP_COUNT] <= count)
+			continue;
+		return OpIterator(op, count, 0);
+	}
+	return OpEnd;
 }
 
 /* run one transaction */
-int run_one_transaction(TX tx,
-                        mako_args_t const& args,
-                        mako_stats_t& stats,
-                        sample_bin_array_t& sample_bins) {
-    // reuse memory for keys to avoid realloc overhead
-    auto key1 = ByteString{};
-    key1.reserve(args.key_length);
-    auto key2 = ByteString{};
-    key2.reserve(args.key_length);
-    auto val = ByteString{};
-    key2.reserve(args.value_length);
+int run_one_transaction(TX tx, mako_args_t const& args, mako_stats_t& stats, sample_bin_array_t& sample_bins) {
+	// reuse memory for keys to avoid realloc overhead
+	auto key1 = ByteString{};
+	key1.reserve(args.key_length);
+	auto key2 = ByteString{};
+	key2.reserve(args.key_length);
+	auto val = ByteString{};
+	key2.reserve(args.value_length);
 
-    auto time_tx_start = steady_clock::now();
+	auto time_tx_start = steady_clock::now();
 
-    auto op_iter = get_op_begin(args);
-    auto needs_commit = false;
-    auto time_per_op_start = std::array<timepoint_t, MAX_OP>{};
-    const auto do_sample = (stats.get_tx_count() % args.sampling) == 0;
-    while (op_iter != OpEnd) {
-        const auto [op, count, step] = op_iter;
-        const auto step_kind = op_desc[op].step_kind(step);
-        const auto op_key = std::make_pair(op, step);
-        const auto time_step_start = steady_clock::now();
-        if (step == 0 /* first step */) {
-            time_per_op_start[op] = time_step_start;
-        }
-        auto f = operation_fn_table.at(op_key)(tx, args, key1, key2, val);
-        auto future_rc = FutureRC::OK;
-        if (f) {
-            if (step_kind != StepKind::ON_ERROR) {
-                future_rc = wait_and_handle_error(tx, f, op_desc[op].name());
-            } else {
-                auto followup_rc = wait_and_handle_for_on_error(tx, f, op_desc[op].name());
-                if (followup_rc == FutureRC::OK) {
-                    future_rc = FutureRC::RETRY;
-                }
-            }
-        }
-        const auto time_step_end = steady_clock::now();
-        const auto step_usec = to_integer_microseconds(time_step_end - time_step_start);
-        if (future_rc != FutureRC::OK) {
-            if (future_rc == FutureRC::CONFLICT) {
-                stats.incr_conflict_count();
-            } else if (future_rc == FutureRC::RETRY) {
-                stats.incr_error_count(op);
-            } else {
-                // abort
-                tx.reset();
-                return -1;
-            }
-            // retry from first op
-            op_iter = get_op_begin(args);
-            needs_commit = false;
-            continue;
-        }
-        // step successful
-        if (step_kind == StepKind::COMMIT) {
-            const auto tx_usec = to_integer_microseconds(time_step_end - time_tx_start);
-            stats.add_latency(OP_COMMIT, step_usec);
-            stats.add_latency(OP_TRANSACTION, tx_usec);
-            if (do_sample) {
-                sample_bins[OP_COMMIT].put(step_usec);
-                sample_bins[OP_TRANSACTION].put(tx_usec);
-            }
-            time_tx_start = time_step_end; // new tx begins
-        }
+	auto op_iter = get_op_begin(args);
+	auto needs_commit = false;
+	auto time_per_op_start = std::array<timepoint_t, MAX_OP>{};
+	const auto do_sample = (stats.get_tx_count() % args.sampling) == 0;
+	while (op_iter != OpEnd) {
+		const auto [op, count, step] = op_iter;
+		const auto step_kind = op_desc[op].step_kind(step);
+		const auto op_key = std::make_pair(op, step);
+		const auto time_step_start = steady_clock::now();
+		if (step == 0 /* first step */) {
+			time_per_op_start[op] = time_step_start;
+		}
+		auto f = operation_fn_table.at(op_key)(tx, args, key1, key2, val);
+		auto future_rc = FutureRC::OK;
+		if (f) {
+			if (step_kind != StepKind::ON_ERROR) {
+				future_rc = wait_and_handle_error(tx, f, op_desc[op].name());
+			} else {
+				auto followup_rc = wait_and_handle_for_on_error(tx, f, op_desc[op].name());
+				if (followup_rc == FutureRC::OK) {
+					future_rc = FutureRC::RETRY;
+				}
+			}
+		}
+		const auto time_step_end = steady_clock::now();
+		const auto step_usec = to_integer_microseconds(time_step_end - time_step_start);
+		if (future_rc != FutureRC::OK) {
+			if (future_rc == FutureRC::CONFLICT) {
+				stats.incr_conflict_count();
+			} else if (future_rc == FutureRC::RETRY) {
+				stats.incr_error_count(op);
+			} else {
+				// abort
+				tx.reset();
+				return -1;
+			}
+			// retry from first op
+			op_iter = get_op_begin(args);
+			needs_commit = false;
+			continue;
+		}
+		// step successful
+		if (step_kind == StepKind::COMMIT) {
+			const auto tx_usec = to_integer_microseconds(time_step_end - time_tx_start);
+			stats.add_latency(OP_COMMIT, step_usec);
+			stats.add_latency(OP_TRANSACTION, tx_usec);
+			if (do_sample) {
+				sample_bins[OP_COMMIT].put(step_usec);
+				sample_bins[OP_TRANSACTION].put(tx_usec);
+			}
+			time_tx_start = time_step_end; // new tx begins
+		}
 
-        // op completed successfully
-        if (step + 1 == op_desc[op].steps() /* last step */) {
-            if (op_desc[op].needs_commit())
-                needs_commit = true;
-            const auto op_usec =
-                to_integer_microseconds(time_step_end - time_per_op_start[op]);
-            stats.add_latency(op, op_usec);
-            if (do_sample) sample_bins[op].put(op_usec);
-        }
-        // move to next op
-        op_iter = get_op_next(args, op_iter);
+		// op completed successfully
+		if (step + 1 == op_desc[op].steps() /* last step */) {
+			if (op_desc[op].needs_commit())
+				needs_commit = true;
+			const auto op_usec = to_integer_microseconds(time_step_end - time_per_op_start[op]);
+			stats.add_latency(op, op_usec);
+			if (do_sample)
+				sample_bins[op].put(op_usec);
+		}
+		// move to next op
+		op_iter = get_op_next(args, op_iter);
 
-        // reached the end?
-        if (op_iter == OpEnd && (needs_commit || args.commit_get)) {
-            const auto time_commit_start = steady_clock::now();
-            auto f = tx.commit();
-            const auto rc = wait_and_handle_error(tx, f, "COMMIT_AT_TX_END");
-            const auto time_commit_end = steady_clock::now();
-            const auto commit_usec =
-                to_integer_microseconds(time_commit_end - time_commit_start);
-            const auto tx_usec =
-                to_integer_microseconds(time_commit_end - time_tx_start);
-            if (rc == FutureRC::OK) {
-                stats.add_latency(OP_COMMIT, commit_usec);
-                stats.add_latency(OP_TRANSACTION, tx_usec);
-                if (do_sample) {
-                    sample_bins[OP_COMMIT].put(commit_usec);
-                    sample_bins[OP_TRANSACTION].put(tx_usec);
-                }
-            } else {
-                if (rc == FutureRC::CONFLICT)
-                    stats.incr_conflict_count();
-                else
-                    stats.incr_error_count(OP_COMMIT);
-                if (rc == FutureRC::ABORT) {
-                    tx.reset();
-                    return -1;
-                }
-                // restart from beginning
-                op_iter = get_op_begin(args);
-            }
-        }
-    }
-    stats.incr_tx_count();
-    /* make sure to reset transaction */
-    tx.reset();
-    return 0;
+		// reached the end?
+		if (op_iter == OpEnd && (needs_commit || args.commit_get)) {
+			const auto time_commit_start = steady_clock::now();
+			auto f = tx.commit();
+			const auto rc = wait_and_handle_error(tx, f, "COMMIT_AT_TX_END");
+			const auto time_commit_end = steady_clock::now();
+			const auto commit_usec = to_integer_microseconds(time_commit_end - time_commit_start);
+			const auto tx_usec = to_integer_microseconds(time_commit_end - time_tx_start);
+			if (rc == FutureRC::OK) {
+				stats.add_latency(OP_COMMIT, commit_usec);
+				stats.add_latency(OP_TRANSACTION, tx_usec);
+				if (do_sample) {
+					sample_bins[OP_COMMIT].put(commit_usec);
+					sample_bins[OP_TRANSACTION].put(tx_usec);
+				}
+			} else {
+				if (rc == FutureRC::CONFLICT)
+					stats.incr_conflict_count();
+				else
+					stats.incr_error_count(OP_COMMIT);
+				if (rc == FutureRC::ABORT) {
+					tx.reset();
+					return -1;
+				}
+				// restart from beginning
+				op_iter = get_op_begin(args);
+			}
+		}
+	}
+	stats.incr_tx_count();
+	/* make sure to reset transaction */
+	tx.reset();
+	return 0;
 }
 
 int run_workload(TX tx,
@@ -751,1017 +706,993 @@ int run_workload(TX tx,
                  sample_bin_array_t& sample_bins,
                  int const dotrace,
                  int const dotagging) {
-    auto traceid = std::string{};
-    auto tagstr = std::string{};
+	auto traceid = std::string{};
+	auto tagstr = std::string{};
 
-    if (thread_tps < 0) return 0;
+	if (thread_tps < 0)
+		return 0;
 
-    if (dotrace) traceid.reserve(32);
+	if (dotrace)
+		traceid.reserve(32);
 
-    if (dotagging) tagstr.reserve(16);
+	if (dotagging)
+		tagstr.reserve(16);
 
-    auto current_tps = static_cast<int>(thread_tps * throttle_factor.load());
+	auto current_tps = static_cast<int>(thread_tps * throttle_factor.load());
 
-    auto time_prev = steady_clock::now();
-    auto time_last_trace = time_prev;
+	auto time_prev = steady_clock::now();
+	auto time_last_trace = time_prev;
 
-    auto rc = 0;
-    auto xacts = 0;
-    auto total_xacts = int64_t{};
-    /* main transaction loop */
-    while (1) {
-        while ((thread_tps > 0) && (xacts >= current_tps)) {
-            /* throttle on */
-            const auto time_now = steady_clock::now();
-            if (to_double_seconds(time_now - time_prev) >= 1.0) {
-                /* more than 1 second passed, no need to throttle */
-                xacts = 0;
-                time_prev = time_now;
+	auto rc = 0;
+	auto xacts = 0;
+	auto total_xacts = int64_t{};
+	/* main transaction loop */
+	while (1) {
+		while ((thread_tps > 0) && (xacts >= current_tps)) {
+			/* throttle on */
+			const auto time_now = steady_clock::now();
+			if (to_double_seconds(time_now - time_prev) >= 1.0) {
+				/* more than 1 second passed, no need to throttle */
+				xacts = 0;
+				time_prev = time_now;
 
-                /* update throttle rate */
-                current_tps = static_cast<int>(thread_tps * throttle_factor.load());
-            } else {
-                usleep(1000);
-            }
-        }
-        /* enable transaction trace */
-        if (dotrace) {
-            const auto time_now = steady_clock::now();
-            if (to_integer_seconds(time_now - time_last_trace) >= 1) {
-                time_last_trace = time_now;
-                traceid.clear();
-                fmt::format_to(std::back_inserter(traceid),
-                               "makotrace{:0>19d}", total_xacts);
-                fmt::print(debugme, "DEBUG: txn tracing {}\n", traceid);
-                auto err = Error{};
-                err = tx.set_option_nothrow(
-                                    FDB_TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER,
-                                    to_bytes_ref(traceid));
-                if (err) {
-                    fmt::print(
-                        stderr, "ERROR: TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER: {}\n", err.what());
-                }
-                err = tx.set_option_nothrow(FDB_TR_OPTION_LOG_TRANSACTION,
-                                            BytesRef());
-                if (err) {
-                    fmt::print(stderr, "ERROR: TR_OPTION_LOG_TRANSACTION: {}\n", err.what());
-                }
-            }
-        }
+				/* update throttle rate */
+				current_tps = static_cast<int>(thread_tps * throttle_factor.load());
+			} else {
+				usleep(1000);
+			}
+		}
+		/* enable transaction trace */
+		if (dotrace) {
+			const auto time_now = steady_clock::now();
+			if (to_integer_seconds(time_now - time_last_trace) >= 1) {
+				time_last_trace = time_now;
+				traceid.clear();
+				fmt::format_to(std::back_inserter(traceid), "makotrace{:0>19d}", total_xacts);
+				fmt::print(debugme, "DEBUG: txn tracing {}\n", traceid);
+				auto err = Error{};
+				err = tx.set_option_nothrow(FDB_TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER, to_bytes_ref(traceid));
+				if (err) {
+					fmt::print(stderr, "ERROR: TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER: {}\n", err.what());
+				}
+				err = tx.set_option_nothrow(FDB_TR_OPTION_LOG_TRANSACTION, BytesRef());
+				if (err) {
+					fmt::print(stderr, "ERROR: TR_OPTION_LOG_TRANSACTION: {}\n", err.what());
+				}
+			}
+		}
 
-        /* enable transaction tagging */
-        if (dotagging > 0) {
-            tagstr.clear();
-            fmt::format_to(std::back_inserter(tagstr), "{}{}{:0>3d}",
-                           KEY_PREFIX,
-                           args.txntagging_prefix,
-                           urand(0, args.txntagging - 1));
-            auto err = tx.set_option_nothrow(FDB_TR_OPTION_AUTO_THROTTLE_TAG,
-                                                      to_bytes_ref(tagstr));
-            if (err) {
-                fmt::print(stderr, "ERROR: TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER: {}\n",
-                           err.what());
-            }
-        }
+		/* enable transaction tagging */
+		if (dotagging > 0) {
+			tagstr.clear();
+			fmt::format_to(std::back_inserter(tagstr),
+			               "{}{}{:0>3d}",
+			               KEY_PREFIX,
+			               args.txntagging_prefix,
+			               urand(0, args.txntagging - 1));
+			auto err = tx.set_option_nothrow(FDB_TR_OPTION_AUTO_THROTTLE_TAG, to_bytes_ref(tagstr));
+			if (err) {
+				fmt::print(stderr, "ERROR: TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER: {}\n", err.what());
+			}
+		}
 
-        rc = run_one_transaction(tx, args, stats, sample_bins);
-        if (rc) {
-            fmt::print(annoyme, "ERROR: run_one_transaction failed ({})\n", rc);
-        }
+		rc = run_one_transaction(tx, args, stats, sample_bins);
+		if (rc) {
+			fmt::print(annoyme, "ERROR: run_one_transaction failed ({})\n", rc);
+		}
 
-        if (thread_iters > 0) {
-            if (thread_iters == xacts) {
-                /* xact limit reached */
-                break;
-            }
-        } else if (signal.load() == SIGNAL_RED) {
-            /* signal turned red, target duration reached */
-            break;
-        }
-        xacts++;
-        total_xacts++;
-    }
-    return rc;
+		if (thread_iters > 0) {
+			if (thread_iters == xacts) {
+				/* xact limit reached */
+				break;
+			}
+		} else if (signal.load() == SIGNAL_RED) {
+			/* signal turned red, target duration reached */
+			break;
+		}
+		xacts++;
+		total_xacts++;
+	}
+	return rc;
 }
 
-std::string get_stats_file_name(std::string_view dirname,
-                                int worker_id, int thread_id, int op) {
+std::string get_stats_file_name(std::string_view dirname, int worker_id, int thread_id, int op) {
 
-    return fmt::format("{}/{}_{}_{}",
-                       dirname, worker_id + 1, thread_id + 1, op_desc[op].name());
+	return fmt::format("{}/{}_{}_{}", dirname, worker_id + 1, thread_id + 1, op_desc[op].name());
 }
 
 /* mako worker thread */
 void worker_thread(thread_args_t& thread_args) {
-    const auto& args = *thread_args.process->args;
-    const auto parent_id = thread_args.process->parent_id;
-    const auto worker_id = thread_args.process->worker_id;
-    const auto thread_id = thread_args.thread_id;
-    const auto dotrace = (worker_id == 0 && thread_id == 0 && args.txntrace) ? args.txntrace : 0;
-    const auto dotagging = args.txntagging;
-    const auto database_index = thread_args.database_index;
-    const auto& signal = thread_args.process->shm->signal;
-    const auto& throttle_factor = thread_args.process->shm->throttle_factor;
-    auto& readycount = thread_args.process->shm->readycount;
-    auto& stopcount = thread_args.process->shm->stopcount;
-    static_assert(std::is_same_v<
-            decltype(std::decay_t<decltype(*thread_args.process)>::shm), mako_shmhdr_t*>);
-    auto& stats = *(reinterpret_cast<mako_stats_t*>(thread_args.process->shm + 1)/* skip header */ +
-                    (worker_id * args.num_threads + thread_id));
+	const auto& args = *thread_args.process->args;
+	const auto parent_id = thread_args.process->parent_id;
+	const auto worker_id = thread_args.process->worker_id;
+	const auto thread_id = thread_args.thread_id;
+	const auto dotrace = (worker_id == 0 && thread_id == 0 && args.txntrace) ? args.txntrace : 0;
+	const auto dotagging = args.txntagging;
+	const auto database_index = thread_args.database_index;
+	const auto& signal = thread_args.process->shm->signal;
+	const auto& throttle_factor = thread_args.process->shm->throttle_factor;
+	auto& readycount = thread_args.process->shm->readycount;
+	auto& stopcount = thread_args.process->shm->stopcount;
+	static_assert(std::is_same_v<decltype(std::decay_t<decltype(*thread_args.process)>::shm), mako_shmhdr_t*>);
+	auto& stats = *(reinterpret_cast<mako_stats_t*>(thread_args.process->shm + 1) /* skip header */ +
+	                (worker_id * args.num_threads + thread_id));
 
-    /* init per-thread latency statistics */
-    new (&stats) mako_stats_t();
+	/* init per-thread latency statistics */
+	new (&stats) mako_stats_t();
 
-    fmt::print(debugme,
-            "DEBUG: worker_id:{} ({}) thread_id:{} ({}) database_index:{} (tid:{})\n",
-            worker_id, args.num_processes, thread_id, args.num_threads,
-            database_index, fmt::ptr(pthread_self()));
+	fmt::print(debugme,
+	           "DEBUG: worker_id:{} ({}) thread_id:{} ({}) database_index:{} (tid:{})\n",
+	           worker_id,
+	           args.num_processes,
+	           thread_id,
+	           args.num_threads,
+	           database_index,
+	           fmt::ptr(pthread_self()));
 
-    const auto thread_tps =
-        args.tpsmax == 0 ? 0 :
-                           compute_thread_tps(args.tpsmax, worker_id, thread_id,
-                                              args.num_processes, args.num_threads);
+	const auto thread_tps =
+	    args.tpsmax == 0 ? 0
+	                     : compute_thread_tps(args.tpsmax, worker_id, thread_id, args.num_processes, args.num_threads);
 
-    const auto thread_iters =
-        args.iteration == 0 ? 0 :
-                              compute_thread_iters(args.iteration, worker_id, thread_id,
-                                                   args.num_processes, args.num_threads);
+	const auto thread_iters =
+	    args.iteration == 0
+	        ? 0
+	        : compute_thread_iters(args.iteration, worker_id, thread_id, args.num_processes, args.num_threads);
 
-    auto database = thread_args.process->databases[database_index];
-    /* create my own transaction object */
-    auto tx = database.create_tx();
+	auto database = thread_args.process->databases[database_index];
+	/* create my own transaction object */
+	auto tx = database.create_tx();
 
-    /* i'm ready */
-    readycount.fetch_add(1);
-    auto stopcount_guard = exit_guard([&stopcount]() { stopcount.fetch_add(1); });
-    while (signal.load() == SIGNAL_OFF) {
-        usleep(10000); /* 10ms */
-    }
+	/* i'm ready */
+	readycount.fetch_add(1);
+	auto stopcount_guard = exit_guard([&stopcount]() { stopcount.fetch_add(1); });
+	while (signal.load() == SIGNAL_OFF) {
+		usleep(10000); /* 10ms */
+	}
 
-    auto& sample_bins = thread_args.sample_bins;
+	auto& sample_bins = thread_args.sample_bins;
 
-    if (args.mode == MODE_CLEAN) {
-        auto rc = cleanup(tx, args);
-        if (rc < 0) {
-            fmt::print(stderr, "ERROR: cleanup failed\n");
-        }
-    } else if (args.mode == MODE_BUILD) {
-        auto rc =
-            populate(tx, args, worker_id, thread_id, thread_tps, stats, sample_bins);
-        if (rc < 0) {
-            fmt::print(stderr, "ERROR: populate failed\n");
-        }
-    } else if (args.mode == MODE_RUN) {
-        auto rc = run_workload(tx,
-                               args,
-                               thread_tps,
-                               throttle_factor,
-                               thread_iters,
-                               signal,
-                               stats,
-                               sample_bins,
-                               dotrace,
-                               dotagging);
-        if (rc < 0) {
-            fmt::print(stderr, "ERROR: run_workload failed\n");
-        }
-    }
+	if (args.mode == MODE_CLEAN) {
+		auto rc = cleanup(tx, args);
+		if (rc < 0) {
+			fmt::print(stderr, "ERROR: cleanup failed\n");
+		}
+	} else if (args.mode == MODE_BUILD) {
+		auto rc = populate(tx, args, worker_id, thread_id, thread_tps, stats, sample_bins);
+		if (rc < 0) {
+			fmt::print(stderr, "ERROR: populate failed\n");
+		}
+	} else if (args.mode == MODE_RUN) {
+		auto rc = run_workload(
+		    tx, args, thread_tps, throttle_factor, thread_iters, signal, stats, sample_bins, dotrace, dotagging);
+		if (rc < 0) {
+			fmt::print(stderr, "ERROR: run_workload failed\n");
+		}
+	}
 
-    if (args.mode == MODE_BUILD || args.mode == MODE_RUN) {
-        const auto dirname = fmt::format("{}{}", TEMP_DATA_STORE, parent_id);
-        const auto rc = mkdir(dirname.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
-        if (rc < 0) {
-            fmt::print(stderr, "ERROR: mkdir {}: {}\n", dirname, strerror(errno));
-            return;
-        }
-        for (auto op = 0; op < MAX_OP; op++) {
-            if (args.txnspec.ops[op][OP_COUNT] > 0 ||
-                op == OP_COMMIT || op == OP_TRANSACTION) {
-                const auto filename = get_stats_file_name(dirname, worker_id,
-                                                          thread_id, op);
-                auto fp = fopen(filename.c_str(), "w");
-                if (!fp) {
-                    fmt::print(stderr, "ERROR: fopen({}): {}\n", filename, strerror(errno));
-                    continue;
-                }
-                auto fclose_guard = exit_guard([fp]() { fclose(fp); });
-                thread_args.sample_bins[op].for_each_block(
-                        [fp](auto ptr, auto count) {
-                            fwrite(ptr, sizeof(*ptr) * count, 1, fp);
-                        });
-            }
-        }
-    }
+	if (args.mode == MODE_BUILD || args.mode == MODE_RUN) {
+		const auto dirname = fmt::format("{}{}", TEMP_DATA_STORE, parent_id);
+		const auto rc = mkdir(dirname.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
+		if (rc < 0) {
+			fmt::print(stderr, "ERROR: mkdir {}: {}\n", dirname, strerror(errno));
+			return;
+		}
+		for (auto op = 0; op < MAX_OP; op++) {
+			if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_COMMIT || op == OP_TRANSACTION) {
+				const auto filename = get_stats_file_name(dirname, worker_id, thread_id, op);
+				auto fp = fopen(filename.c_str(), "w");
+				if (!fp) {
+					fmt::print(stderr, "ERROR: fopen({}): {}\n", filename, strerror(errno));
+					continue;
+				}
+				auto fclose_guard = exit_guard([fp]() { fclose(fp); });
+				thread_args.sample_bins[op].for_each_block(
+				    [fp](auto ptr, auto count) { fwrite(ptr, sizeof(*ptr) * count, 1, fp); });
+			}
+		}
+	}
 }
 
 /* mako worker process */
 int worker_process_main(mako_args_t& args, int worker_id, mako_shmhdr_t* shm, pid_t pid_main) {
-    process_info_t process;
+	process_info_t process;
 
-    process.worker_id = worker_id;
-    process.parent_id = pid_main;
-    process.args = &args;
-    process.shm = shm;
+	process.worker_id = worker_id;
+	process.parent_id = pid_main;
+	process.args = &args;
+	process.shm = shm;
 
-    fmt::print(debugme, "DEBUG: worker {} started\n", worker_id);
+	fmt::print(debugme, "DEBUG: worker {} started\n", worker_id);
 
-    Error err;
-    /* Everything starts from here */
+	Error err;
+	/* Everything starts from here */
 
-    select_api_version(args.api_version);
+	select_api_version(args.api_version);
 
-    /* enable flatbuffers if specified */
-    if (args.flatbuffers) {
+	/* enable flatbuffers if specified */
+	if (args.flatbuffers) {
 #ifdef FDB_NET_OPTION_USE_FLATBUFFERS
-        fprintf(debugme, "DEBUG: Using flatbuffers\n");
-        err = network::set_option_nothrow(
-                    FDB_NET_OPTION_USE_FLATBUFFERS,
-                    BytesRef(&args.flatbuffers, sizeof(args.flatbuffers)));
-        if (err) {
-            fmt::print(stderr, "ERROR: network_set_option(USE_FLATBUFFERS): {}\n",
-                                err.what());
-        }
+		fprintf(debugme, "DEBUG: Using flatbuffers\n");
+		err = network::set_option_nothrow(FDB_NET_OPTION_USE_FLATBUFFERS,
+		                                  BytesRef(&args.flatbuffers, sizeof(args.flatbuffers)));
+		if (err) {
+			fmt::print(stderr, "ERROR: network_set_option(USE_FLATBUFFERS): {}\n", err.what());
+		}
 #else
-        fmt::print(printme, "INFO: flatbuffers is not supported in FDB API version {}\n", FDB_API_VERSION);
+		fmt::print(printme, "INFO: flatbuffers is not supported in FDB API version {}\n", FDB_API_VERSION);
 #endif
-    }
+	}
 
-    /* Set client Log group */
-    if (args.log_group[0] != '\0') {
-        err = network::set_option_nothrow(FDB_NET_OPTION_TRACE_LOG_GROUP,
-                                          BytesRef(to_byte_ptr(args.log_group)));
-        if (err) {
-            fmt::print(stderr, "ERROR: fdb_network_set_option(FDB_NET_OPTION_TRACE_LOG_GROUP): {}\n", err.what());
-        }
-    }
+	/* Set client Log group */
+	if (args.log_group[0] != '\0') {
+		err = network::set_option_nothrow(FDB_NET_OPTION_TRACE_LOG_GROUP, BytesRef(to_byte_ptr(args.log_group)));
+		if (err) {
+			fmt::print(stderr, "ERROR: fdb_network_set_option(FDB_NET_OPTION_TRACE_LOG_GROUP): {}\n", err.what());
+		}
+	}
 
-    /* enable tracing if specified */
-    if (args.trace) {
-        fmt::print(debugme,
-                   "DEBUG: Enable Tracing in {} ({})\n",
-                   (args.traceformat == 0) ? "XML" : "JSON",
-                   (args.tracepath[0] == '\0') ? "current directory" : args.tracepath);
-        err = network::set_option_nothrow(FDB_NET_OPTION_TRACE_ENABLE,
-                                          BytesRef(to_byte_ptr(args.tracepath)));
-        if (err) {
-            fmt::print(stderr, "ERROR: network_set_option(TRACE_ENABLE): {}\n", err.what());
-        }
-        if (args.traceformat == 1) {
-            err = network::set_option_nothrow(FDB_NET_OPTION_TRACE_FORMAT,
-                                              BytesRef(to_byte_ptr("json")));
-            if (err) {
-                fmt::print(stderr,
-                           "ERROR: fdb_network_set_option(FDB_NET_OPTION_TRACE_FORMAT): {}\n", err.what());
-            }
-        }
-    }
+	/* enable tracing if specified */
+	if (args.trace) {
+		fmt::print(debugme,
+		           "DEBUG: Enable Tracing in {} ({})\n",
+		           (args.traceformat == 0) ? "XML" : "JSON",
+		           (args.tracepath[0] == '\0') ? "current directory" : args.tracepath);
+		err = network::set_option_nothrow(FDB_NET_OPTION_TRACE_ENABLE, BytesRef(to_byte_ptr(args.tracepath)));
+		if (err) {
+			fmt::print(stderr, "ERROR: network_set_option(TRACE_ENABLE): {}\n", err.what());
+		}
+		if (args.traceformat == 1) {
+			err = network::set_option_nothrow(FDB_NET_OPTION_TRACE_FORMAT, BytesRef(to_byte_ptr("json")));
+			if (err) {
+				fmt::print(stderr, "ERROR: fdb_network_set_option(FDB_NET_OPTION_TRACE_FORMAT): {}\n", err.what());
+			}
+		}
+	}
 
-    /* enable knobs if specified */
-    if (args.knobs[0] != '\0') {
-        char delim[] = ", ";
-        auto knob = strtok(args.knobs, delim);
-        while (knob != NULL) {
-            fmt::print(debugme, "DEBUG: Setting client knobs: {}\n", knob);
-            err = network::set_option_nothrow(FDB_NET_OPTION_KNOB,
-                                              BytesRef(to_byte_ptr(knob)));
-            if (err) {
-                fmt::print(stderr, "ERROR: fdb_network_set_option: {}\n", err.what());
-            }
-            knob = strtok(NULL, delim);
-        }
-    }
+	/* enable knobs if specified */
+	if (args.knobs[0] != '\0') {
+		char delim[] = ", ";
+		auto knob = strtok(args.knobs, delim);
+		while (knob != NULL) {
+			fmt::print(debugme, "DEBUG: Setting client knobs: {}\n", knob);
+			err = network::set_option_nothrow(FDB_NET_OPTION_KNOB, BytesRef(to_byte_ptr(knob)));
+			if (err) {
+				fmt::print(stderr, "ERROR: fdb_network_set_option: {}\n", err.what());
+			}
+			knob = strtok(NULL, delim);
+		}
+	}
 
-    if (args.client_threads_per_version > 0) {
-        err = network::set_option_nothrow(
-            FDB_NET_OPTION_CLIENT_THREADS_PER_VERSION,
-            args.client_threads_per_version);
-        if (err) {
-            fmt::print(stderr,
-                       "ERROR: fdb_network_set_option (FDB_NET_OPTION_CLIENT_THREADS_PER_VERSION) ({}): {}\n",
-                       args.client_threads_per_version,
-                       err.what());
-            // let's exit here since we do not want to confuse users
-            // that mako is running with multi-threaded client enabled
-            return -1;
-        }
-    }
+	if (args.client_threads_per_version > 0) {
+		err = network::set_option_nothrow(FDB_NET_OPTION_CLIENT_THREADS_PER_VERSION, args.client_threads_per_version);
+		if (err) {
+			fmt::print(stderr,
+			           "ERROR: fdb_network_set_option (FDB_NET_OPTION_CLIENT_THREADS_PER_VERSION) ({}): {}\n",
+			           args.client_threads_per_version,
+			           err.what());
+			// let's exit here since we do not want to confuse users
+			// that mako is running with multi-threaded client enabled
+			return -1;
+		}
+	}
 
-    /* Network thread must be setup before doing anything */
-    fprintf(debugme, "DEBUG: fdb_setup_network\n");
-    network::setup();
+	/* Network thread must be setup before doing anything */
+	fprintf(debugme, "DEBUG: fdb_setup_network\n");
+	network::setup();
 
-    /* Each worker process will have its own network thread */
-    fprintf(debugme, "DEBUG: creating network thread\n");
-    auto network_thread = std::thread([]() {
-            fmt::print(debugme, "DEBUG: network thread started\n");
-            if (auto err = network::run()) {
-                fmt::print(stderr, "ERROR: fdb_run_network: {}\n", err.what());
-            }
-        });
+	/* Each worker process will have its own network thread */
+	fprintf(debugme, "DEBUG: creating network thread\n");
+	auto network_thread = std::thread([]() {
+		fmt::print(debugme, "DEBUG: network thread started\n");
+		if (auto err = network::run()) {
+			fmt::print(stderr, "ERROR: fdb_run_network: {}\n", err.what());
+		}
+	});
 
-    /*** let's party! ***/
+	/*** let's party! ***/
 
-    /* set up database for worker threads */
-    for (auto i = 0; i < args.num_databases; i++) {
-        size_t cluster_index = args.num_fdb_clusters <= 1 ? 0 : i % args.num_fdb_clusters;
-        process.databases.emplace_back(Database(args.cluster_files[cluster_index]));
-        fmt::print(debugme, "DEBUG: creating database at cluster {}\n", args.cluster_files[cluster_index]);
-        if (args.disable_ryw) {
-            process.databases.back().set_option(FDB_DB_OPTION_SNAPSHOT_RYW_DISABLE, BytesRef{});
-        }
-    }
+	/* set up database for worker threads */
+	for (auto i = 0; i < args.num_databases; i++) {
+		size_t cluster_index = args.num_fdb_clusters <= 1 ? 0 : i % args.num_fdb_clusters;
+		process.databases.emplace_back(Database(args.cluster_files[cluster_index]));
+		fmt::print(debugme, "DEBUG: creating database at cluster {}\n", args.cluster_files[cluster_index]);
+		if (args.disable_ryw) {
+			process.databases.back().set_option(FDB_DB_OPTION_SNAPSHOT_RYW_DISABLE, BytesRef{});
+		}
+	}
 
-    fmt::print(debugme, "DEBUG: creating {} worker threads\n", args.num_threads);
-    auto worker_threads = std::vector<std::thread>(args.num_threads);
+	fmt::print(debugme, "DEBUG: creating {} worker threads\n", args.num_threads);
+	auto worker_threads = std::vector<std::thread>(args.num_threads);
 
-    /* spawn worker threads */
-    auto thread_args = std::vector<thread_args_t>(args.num_threads);
+	/* spawn worker threads */
+	auto thread_args = std::vector<thread_args_t>(args.num_threads);
 
-    for (auto i = 0; i < args.num_threads; i++) {
-        auto& this_args = thread_args[i];
-        this_args.thread_id = i;
-        this_args.database_index = i % args.num_databases;
+	for (auto i = 0; i < args.num_threads; i++) {
+		auto& this_args = thread_args[i];
+		this_args.thread_id = i;
+		this_args.database_index = i % args.num_databases;
 
-        /* for ops to run, pre-allocate one latency sample block */
-        for (int op = 0; op < MAX_OP; op++) {
-            if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-                this_args.sample_bins[op].reserve_one();
-            }
-        }
-        this_args.process = &process;
-        worker_threads[i] = std::thread(worker_thread, std::ref(this_args));
-    }
+		/* for ops to run, pre-allocate one latency sample block */
+		for (int op = 0; op < MAX_OP; op++) {
+			if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
+				this_args.sample_bins[op].reserve_one();
+			}
+		}
+		this_args.process = &process;
+		worker_threads[i] = std::thread(worker_thread, std::ref(this_args));
+	}
 
-    /*** party is over ***/
+	/*** party is over ***/
 
-    /* wait for everyone to finish */
-    for (auto i = 0; i < args.num_threads; i++) {
-        fmt::print(debugme, "DEBUG: worker_thread {} joining\n", i);
-        worker_threads[i].join();
-    }
+	/* wait for everyone to finish */
+	for (auto i = 0; i < args.num_threads; i++) {
+		fmt::print(debugme, "DEBUG: worker_thread {} joining\n", i);
+		worker_threads[i].join();
+	}
 
-    /* stop the network thread */
-    fmt::print(debugme, "DEBUG: fdb_stop_network\n");
-    err = network::stop();
-    if (err) {
-        fmt::print(stderr, "ERROR: stop_network(): {}\n", err.what());
-    }
+	/* stop the network thread */
+	fmt::print(debugme, "DEBUG: fdb_stop_network\n");
+	err = network::stop();
+	if (err) {
+		fmt::print(stderr, "ERROR: stop_network(): {}\n", err.what());
+	}
 
-    /* wait for the network thread to join */
-    fmt::print(debugme, "DEBUG: network_thread joining\n");
-    network_thread.join();
+	/* wait for the network thread to join */
+	fmt::print(debugme, "DEBUG: network_thread joining\n");
+	network_thread.join();
 
-    return 0;
+	return 0;
 }
 
 /* initialize the parameters with default values */
 int init_args(mako_args_t* args) {
-    int i;
-    if (!args)
-        return -1;
-    memset(args, 0, sizeof(mako_args_t)); /* zero-out everything */
-    args->num_fdb_clusters = 0;
-    args->num_databases = 1;
-    args->api_version = max_api_version();
-    args->json = 0;
-    args->num_processes = 1;
-    args->num_threads = 1;
-    args->mode = MODE_INVALID;
-    args->rows = 100000;
-    args->row_digits = digits(args->rows);
-    args->seconds = 30;
-    args->iteration = 0;
-    args->tpsmax = 0;
-    args->tpsmin = -1;
-    args->tpsinterval = 10;
-    args->tpschange = TPS_SIN;
-    args->sampling = 1000;
-    args->key_length = 32;
-    args->value_length = 16;
-    args->zipf = 0;
-    args->commit_get = 0;
-    args->verbose = 1;
-    args->flatbuffers = 0; /* internal */
-    args->knobs[0] = '\0';
-    args->log_group[0] = '\0';
-    args->prefixpadding = 0;
-    args->trace = 0;
-    args->tracepath[0] = '\0';
-    args->traceformat = 0; /* default to client's default (XML) */
-    args->streaming_mode = FDB_STREAMING_MODE_WANT_ALL;
-    args->txntrace = 0;
-    args->txntagging = 0;
-    memset(args->txntagging_prefix, 0, TAGPREFIXLENGTH_MAX);
-    for (i = 0; i < MAX_OP; i++) {
-        args->txnspec.ops[i][OP_COUNT] = 0;
-    }
-    args->client_threads_per_version = 0;
-    args->disable_ryw = 0;
-    args->json_output_path[0] = '\0';
-    args->bg_materialize_files = false;
-    args->bg_file_path[0] = '\0';
-    return 0;
+	int i;
+	if (!args)
+		return -1;
+	memset(args, 0, sizeof(mako_args_t)); /* zero-out everything */
+	args->num_fdb_clusters = 0;
+	args->num_databases = 1;
+	args->api_version = max_api_version();
+	args->json = 0;
+	args->num_processes = 1;
+	args->num_threads = 1;
+	args->mode = MODE_INVALID;
+	args->rows = 100000;
+	args->row_digits = digits(args->rows);
+	args->seconds = 30;
+	args->iteration = 0;
+	args->tpsmax = 0;
+	args->tpsmin = -1;
+	args->tpsinterval = 10;
+	args->tpschange = TPS_SIN;
+	args->sampling = 1000;
+	args->key_length = 32;
+	args->value_length = 16;
+	args->zipf = 0;
+	args->commit_get = 0;
+	args->verbose = 1;
+	args->flatbuffers = 0; /* internal */
+	args->knobs[0] = '\0';
+	args->log_group[0] = '\0';
+	args->prefixpadding = 0;
+	args->trace = 0;
+	args->tracepath[0] = '\0';
+	args->traceformat = 0; /* default to client's default (XML) */
+	args->streaming_mode = FDB_STREAMING_MODE_WANT_ALL;
+	args->txntrace = 0;
+	args->txntagging = 0;
+	memset(args->txntagging_prefix, 0, TAGPREFIXLENGTH_MAX);
+	for (i = 0; i < MAX_OP; i++) {
+		args->txnspec.ops[i][OP_COUNT] = 0;
+	}
+	args->client_threads_per_version = 0;
+	args->disable_ryw = 0;
+	args->json_output_path[0] = '\0';
+	args->bg_materialize_files = false;
+	args->bg_file_path[0] = '\0';
+	return 0;
 }
 
 /* parse transaction specification */
 int parse_transaction(mako_args_t* args, char const* optarg) {
-    char const* ptr = optarg;
-    int op = 0;
-    int rangeop = 0;
-    int num;
-    int error = 0;
+	char const* ptr = optarg;
+	int op = 0;
+	int rangeop = 0;
+	int num;
+	int error = 0;
 
-    for (op = 0; op < MAX_OP; op++) {
-        args->txnspec.ops[op][OP_COUNT] = 0;
-        args->txnspec.ops[op][OP_RANGE] = 0;
-    }
+	for (op = 0; op < MAX_OP; op++) {
+		args->txnspec.ops[op][OP_COUNT] = 0;
+		args->txnspec.ops[op][OP_RANGE] = 0;
+	}
 
-    op = 0;
-    while (*ptr) {
+	op = 0;
+	while (*ptr) {
 // Clang gives false positive array bounds warning, which must be ignored:
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Warray-bounds"
-        if (strncmp(ptr, "grv", 3) == 0) {
-            op = OP_GETREADVERSION;
-            ptr += 3;
-        } else if (strncmp(ptr, "gr", 2) == 0) {
-            op = OP_GETRANGE;
-            rangeop = 1;
-            ptr += 2;
-        } else if (strncmp(ptr, "g", 1) == 0) {
-            op = OP_GET;
-            ptr++;
-        } else if (strncmp(ptr, "sgr", 3) == 0) {
-            op = OP_SGETRANGE;
-            rangeop = 1;
-            ptr += 3;
-        } else if (strncmp(ptr, "sg", 2) == 0) {
-            op = OP_SGET;
-            ptr += 2;
-        } else if (strncmp(ptr, "u", 1) == 0) {
-            op = OP_UPDATE;
-            ptr++;
-        } else if (strncmp(ptr, "ir", 2) == 0) {
-            op = OP_INSERTRANGE;
-            rangeop = 1;
-            ptr += 2;
-        } else if (strncmp(ptr, "i", 1) == 0) {
-            op = OP_INSERT;
-            ptr++;
-        } else if (strncmp(ptr, "cr", 2) == 0) {
-            op = OP_CLEARRANGE;
-            rangeop = 1;
-            ptr += 2;
-        } else if (strncmp(ptr, "c", 1) == 0) {
-            op = OP_CLEAR;
-            ptr++;
-        } else if (strncmp(ptr, "scr", 3) == 0) {
-            op = OP_SETCLEARRANGE;
-            rangeop = 1;
-            ptr += 3;
-        } else if (strncmp(ptr, "sc", 2) == 0) {
-            op = OP_SETCLEAR;
-            ptr += 2;
-        } else if (strncmp(ptr, "bg", 2) == 0) {
-            op = OP_READ_BG;
-            rangeop = 1;
-            ptr += 2;
-        } else {
-            fprintf(debugme, "Error: Invalid transaction spec: %s\n", ptr);
-            error = 1;
-            break;
-        }
+		if (strncmp(ptr, "grv", 3) == 0) {
+			op = OP_GETREADVERSION;
+			ptr += 3;
+		} else if (strncmp(ptr, "gr", 2) == 0) {
+			op = OP_GETRANGE;
+			rangeop = 1;
+			ptr += 2;
+		} else if (strncmp(ptr, "g", 1) == 0) {
+			op = OP_GET;
+			ptr++;
+		} else if (strncmp(ptr, "sgr", 3) == 0) {
+			op = OP_SGETRANGE;
+			rangeop = 1;
+			ptr += 3;
+		} else if (strncmp(ptr, "sg", 2) == 0) {
+			op = OP_SGET;
+			ptr += 2;
+		} else if (strncmp(ptr, "u", 1) == 0) {
+			op = OP_UPDATE;
+			ptr++;
+		} else if (strncmp(ptr, "ir", 2) == 0) {
+			op = OP_INSERTRANGE;
+			rangeop = 1;
+			ptr += 2;
+		} else if (strncmp(ptr, "i", 1) == 0) {
+			op = OP_INSERT;
+			ptr++;
+		} else if (strncmp(ptr, "cr", 2) == 0) {
+			op = OP_CLEARRANGE;
+			rangeop = 1;
+			ptr += 2;
+		} else if (strncmp(ptr, "c", 1) == 0) {
+			op = OP_CLEAR;
+			ptr++;
+		} else if (strncmp(ptr, "scr", 3) == 0) {
+			op = OP_SETCLEARRANGE;
+			rangeop = 1;
+			ptr += 3;
+		} else if (strncmp(ptr, "sc", 2) == 0) {
+			op = OP_SETCLEAR;
+			ptr += 2;
+		} else if (strncmp(ptr, "bg", 2) == 0) {
+			op = OP_READ_BG;
+			rangeop = 1;
+			ptr += 2;
+		} else {
+			fprintf(debugme, "Error: Invalid transaction spec: %s\n", ptr);
+			error = 1;
+			break;
+		}
 #pragma clang diagnostic pop
 
-        /* count */
-        num = 0;
-        if ((*ptr < '0') || (*ptr > '9')) {
-            num = 1; /* if omitted, set it to 1 */
-        } else {
-            while ((*ptr >= '0') && (*ptr <= '9')) {
-                num = num * 10 + *ptr - '0';
-                ptr++;
-            }
-        }
-        /* set count */
-        args->txnspec.ops[op][OP_COUNT] = num;
+		/* count */
+		num = 0;
+		if ((*ptr < '0') || (*ptr > '9')) {
+			num = 1; /* if omitted, set it to 1 */
+		} else {
+			while ((*ptr >= '0') && (*ptr <= '9')) {
+				num = num * 10 + *ptr - '0';
+				ptr++;
+			}
+		}
+		/* set count */
+		args->txnspec.ops[op][OP_COUNT] = num;
 
-        if (rangeop) {
-            if (*ptr != ':') {
-                error = 1;
-                break;
-            } else {
-                ptr++; /* skip ':' */
-                /* check negative '-' sign */
-                if (*ptr == '-') {
-                    args->txnspec.ops[op][OP_REVERSE] = 1;
-                    ptr++;
-                } else {
-                    args->txnspec.ops[op][OP_REVERSE] = 0;
-                }
-                num = 0;
-                if ((*ptr < '0') || (*ptr > '9')) {
-                    error = 1;
-                    break;
-                }
-                while ((*ptr >= '0') && (*ptr <= '9')) {
-                    num = num * 10 + *ptr - '0';
-                    ptr++;
-                }
-                /* set range */
-                args->txnspec.ops[op][OP_RANGE] = num;
-            }
-        }
-        rangeop = 0;
-    }
+		if (rangeop) {
+			if (*ptr != ':') {
+				error = 1;
+				break;
+			} else {
+				ptr++; /* skip ':' */
+				/* check negative '-' sign */
+				if (*ptr == '-') {
+					args->txnspec.ops[op][OP_REVERSE] = 1;
+					ptr++;
+				} else {
+					args->txnspec.ops[op][OP_REVERSE] = 0;
+				}
+				num = 0;
+				if ((*ptr < '0') || (*ptr > '9')) {
+					error = 1;
+					break;
+				}
+				while ((*ptr >= '0') && (*ptr <= '9')) {
+					num = num * 10 + *ptr - '0';
+					ptr++;
+				}
+				/* set range */
+				args->txnspec.ops[op][OP_RANGE] = num;
+			}
+		}
+		rangeop = 0;
+	}
 
-    if (error) {
-        fprintf(stderr, "ERROR: invalid transaction specification %s\n", optarg);
-        return -1;
-    }
+	if (error) {
+		fprintf(stderr, "ERROR: invalid transaction specification %s\n", optarg);
+		return -1;
+	}
 
-    if (args->verbose == VERBOSE_DEBUG) {
-        for (op = 0; op < MAX_OP; op++) {
-            fprintf(debugme, "DEBUG: OP: %d: %d: %d\n", op, args->txnspec.ops[op][0], args->txnspec.ops[op][1]);
-        }
-    }
+	if (args->verbose == VERBOSE_DEBUG) {
+		for (op = 0; op < MAX_OP; op++) {
+			fprintf(debugme, "DEBUG: OP: %d: %d: %d\n", op, args->txnspec.ops[op][0], args->txnspec.ops[op][1]);
+		}
+	}
 
-    return 0;
+	return 0;
 }
 
 void usage() {
-    printf("Usage:\n");
-    printf("%-24s %s\n", "-h, --help", "Print this message");
-    printf("%-24s %s\n", "    --version", "Print FDB version");
-    printf("%-24s %s\n", "-v, --verbose", "Specify verbosity");
-    printf("%-24s %s\n", "-a, --api_version=API_VERSION", "Specify API_VERSION to use");
-    printf("%-24s %s\n", "-c, --cluster=FILE", "Specify FDB cluster file");
-    printf("%-24s %s\n", "-d, --num_databases=NUM_DATABASES", "Specify number of databases");
-    printf("%-24s %s\n", "-p, --procs=PROCS", "Specify number of worker processes");
-    printf("%-24s %s\n", "-t, --threads=THREADS", "Specify number of worker threads");
-    printf("%-24s %s\n", "-r, --rows=ROWS", "Specify number of records");
-    printf("%-24s %s\n", "-s, --seconds=SECONDS", "Specify the test duration in seconds\n");
-    printf("%-24s %s\n", "", "This option cannot be specified with --iteration.");
-    printf("%-24s %s\n", "-i, --iteration=ITERS", "Specify the number of iterations.\n");
-    printf("%-24s %s\n", "", "This option cannot be specified with --seconds.");
-    printf("%-24s %s\n", "    --keylen=LENGTH", "Specify the key lengths");
-    printf("%-24s %s\n", "    --vallen=LENGTH", "Specify the value lengths");
-    printf("%-24s %s\n", "-x, --transaction=SPEC", "Transaction specification");
-    printf("%-24s %s\n", "    --tps|--tpsmax=TPS", "Specify the target max TPS");
-    printf("%-24s %s\n", "    --tpsmin=TPS", "Specify the target min TPS");
-    printf("%-24s %s\n", "    --tpsinterval=SEC", "Specify the TPS change interval (Default: 10 seconds)");
-    printf("%-24s %s\n", "    --tpschange=<sin|square|pulse>", "Specify the TPS change type (Default: sin)");
-    printf("%-24s %s\n", "    --sampling=RATE", "Specify the sampling rate for latency stats");
-    printf("%-24s %s\n", "-m, --mode=MODE", "Specify the mode (build, run, clean)");
-    printf("%-24s %s\n", "-z, --zipf", "Use zipfian distribution instead of uniform distribution");
-    printf("%-24s %s\n", "    --commitget", "Commit GETs");
-    printf("%-24s %s\n", "    --loggroup=LOGGROUP", "Set client log group");
-    printf("%-24s %s\n", "    --prefix_padding", "Pad key by prefixing data (Default: postfix padding)");
-    printf("%-24s %s\n", "    --trace", "Enable tracing");
-    printf("%-24s %s\n", "    --tracepath=PATH", "Set trace file path");
-    printf("%-24s %s\n", "    --trace_format <xml|json>", "Set trace format (Default: json)");
-    printf("%-24s %s\n", "    --txntrace=sec", "Specify transaction tracing interval (Default: 0)");
-    printf(
-        "%-24s %s\n", "    --txntagging", "Specify the number of different transaction tag (Default: 0, max = 1000)");
-    printf("%-24s %s\n",
-           "    --txntagging_prefix",
-           "Specify the prefix of transaction tag - mako${txntagging_prefix} (Default: '')");
-    printf("%-24s %s\n", "    --knobs=KNOBS", "Set client knobs");
-    printf("%-24s %s\n", "    --flatbuffers", "Use flatbuffers");
-    printf("%-24s %s\n", "    --streaming", "Streaming mode: all (default), iterator, small, medium, large, serial");
-    printf("%-24s %s\n", "    --disable_ryw", "Disable snapshot read-your-writes");
-    printf("%-24s %s\n", "    --json_report=PATH", "Output stats to the specified json file (Default: mako.json)");
-    printf("%-24s %s\n",
-           "    --bg_file_path=PATH",
-           "Read blob granule files from the local filesystem at PATH and materialize the results.");
+	printf("Usage:\n");
+	printf("%-24s %s\n", "-h, --help", "Print this message");
+	printf("%-24s %s\n", "    --version", "Print FDB version");
+	printf("%-24s %s\n", "-v, --verbose", "Specify verbosity");
+	printf("%-24s %s\n", "-a, --api_version=API_VERSION", "Specify API_VERSION to use");
+	printf("%-24s %s\n", "-c, --cluster=FILE", "Specify FDB cluster file");
+	printf("%-24s %s\n", "-d, --num_databases=NUM_DATABASES", "Specify number of databases");
+	printf("%-24s %s\n", "-p, --procs=PROCS", "Specify number of worker processes");
+	printf("%-24s %s\n", "-t, --threads=THREADS", "Specify number of worker threads");
+	printf("%-24s %s\n", "-r, --rows=ROWS", "Specify number of records");
+	printf("%-24s %s\n", "-s, --seconds=SECONDS", "Specify the test duration in seconds\n");
+	printf("%-24s %s\n", "", "This option cannot be specified with --iteration.");
+	printf("%-24s %s\n", "-i, --iteration=ITERS", "Specify the number of iterations.\n");
+	printf("%-24s %s\n", "", "This option cannot be specified with --seconds.");
+	printf("%-24s %s\n", "    --keylen=LENGTH", "Specify the key lengths");
+	printf("%-24s %s\n", "    --vallen=LENGTH", "Specify the value lengths");
+	printf("%-24s %s\n", "-x, --transaction=SPEC", "Transaction specification");
+	printf("%-24s %s\n", "    --tps|--tpsmax=TPS", "Specify the target max TPS");
+	printf("%-24s %s\n", "    --tpsmin=TPS", "Specify the target min TPS");
+	printf("%-24s %s\n", "    --tpsinterval=SEC", "Specify the TPS change interval (Default: 10 seconds)");
+	printf("%-24s %s\n", "    --tpschange=<sin|square|pulse>", "Specify the TPS change type (Default: sin)");
+	printf("%-24s %s\n", "    --sampling=RATE", "Specify the sampling rate for latency stats");
+	printf("%-24s %s\n", "-m, --mode=MODE", "Specify the mode (build, run, clean)");
+	printf("%-24s %s\n", "-z, --zipf", "Use zipfian distribution instead of uniform distribution");
+	printf("%-24s %s\n", "    --commitget", "Commit GETs");
+	printf("%-24s %s\n", "    --loggroup=LOGGROUP", "Set client log group");
+	printf("%-24s %s\n", "    --prefix_padding", "Pad key by prefixing data (Default: postfix padding)");
+	printf("%-24s %s\n", "    --trace", "Enable tracing");
+	printf("%-24s %s\n", "    --tracepath=PATH", "Set trace file path");
+	printf("%-24s %s\n", "    --trace_format <xml|json>", "Set trace format (Default: json)");
+	printf("%-24s %s\n", "    --txntrace=sec", "Specify transaction tracing interval (Default: 0)");
+	printf(
+	    "%-24s %s\n", "    --txntagging", "Specify the number of different transaction tag (Default: 0, max = 1000)");
+	printf("%-24s %s\n",
+	       "    --txntagging_prefix",
+	       "Specify the prefix of transaction tag - mako${txntagging_prefix} (Default: '')");
+	printf("%-24s %s\n", "    --knobs=KNOBS", "Set client knobs");
+	printf("%-24s %s\n", "    --flatbuffers", "Use flatbuffers");
+	printf("%-24s %s\n", "    --streaming", "Streaming mode: all (default), iterator, small, medium, large, serial");
+	printf("%-24s %s\n", "    --disable_ryw", "Disable snapshot read-your-writes");
+	printf("%-24s %s\n", "    --json_report=PATH", "Output stats to the specified json file (Default: mako.json)");
+	printf("%-24s %s\n",
+	       "    --bg_file_path=PATH",
+	       "Read blob granule files from the local filesystem at PATH and materialize the results.");
 }
 
 /* parse benchmark paramters */
 int parse_args(int argc, char* argv[], mako_args_t* args) {
-    int rc;
-    int c;
-    int idx;
-    while (1) {
-        const char* short_options = "a:c:d:p:t:r:s:i:x:v:m:hz";
-        static struct option long_options[] = {
-            /* name, has_arg, flag, val */
-            { "api_version", required_argument, NULL, 'a' },
-            { "cluster", required_argument, NULL, 'c' },
-            { "num_databases", optional_argument, NULL, 'd' },
-            { "procs", required_argument, NULL, 'p' },
-            { "threads", required_argument, NULL, 't' },
-            { "rows", required_argument, NULL, 'r' },
-            { "seconds", required_argument, NULL, 's' },
-            { "iteration", required_argument, NULL, 'i' },
-            { "keylen", required_argument, NULL, ARG_KEYLEN },
-            { "vallen", required_argument, NULL, ARG_VALLEN },
-            { "transaction", required_argument, NULL, 'x' },
-            { "tps", required_argument, NULL, ARG_TPS },
-            { "tpsmax", required_argument, NULL, ARG_TPSMAX },
-            { "tpsmin", required_argument, NULL, ARG_TPSMIN },
-            { "tpsinterval", required_argument, NULL, ARG_TPSINTERVAL },
-            { "tpschange", required_argument, NULL, ARG_TPSCHANGE },
-            { "sampling", required_argument, NULL, ARG_SAMPLING },
-            { "verbose", required_argument, NULL, 'v' },
-            { "mode", required_argument, NULL, 'm' },
-            { "knobs", required_argument, NULL, ARG_KNOBS },
-            { "loggroup", required_argument, NULL, ARG_LOGGROUP },
-            { "tracepath", required_argument, NULL, ARG_TRACEPATH },
-            { "trace_format", required_argument, NULL, ARG_TRACEFORMAT },
-            { "streaming", required_argument, NULL, ARG_STREAMING_MODE },
-            { "txntrace", required_argument, NULL, ARG_TXNTRACE },
-            /* no args */
-            { "help", no_argument, NULL, 'h' },
-            { "zipf", no_argument, NULL, 'z' },
-            { "commitget", no_argument, NULL, ARG_COMMITGET },
-            { "flatbuffers", no_argument, NULL, ARG_FLATBUFFERS },
-            { "prefix_padding", no_argument, NULL, ARG_PREFIXPADDING },
-            { "trace", no_argument, NULL, ARG_TRACE },
-            { "txntagging", required_argument, NULL, ARG_TXNTAGGING },
-            { "txntagging_prefix", required_argument, NULL, ARG_TXNTAGGINGPREFIX },
-            { "version", no_argument, NULL, ARG_VERSION },
-            { "client_threads_per_version", required_argument, NULL, ARG_CLIENT_THREADS_PER_VERSION },
-            { "disable_ryw", no_argument, NULL, ARG_DISABLE_RYW },
-            { "json_report", optional_argument, NULL, ARG_JSON_REPORT },
-            { "bg_file_path", required_argument, NULL, ARG_BG_FILE_PATH },
-            { NULL, 0, NULL, 0 }
-        };
-        idx = 0;
-        c = getopt_long(argc, argv, short_options, long_options, &idx);
-        if (c < 0) {
-            break;
-        }
-        switch (c) {
-        case '?':
-        case 'h':
-            usage();
-            return -1;
-        case 'a':
-            args->api_version = atoi(optarg);
-            break;
-        case 'c': {
-            const char delim[] = ",";
-            char* cluster_file = strtok(optarg, delim);
-            while (cluster_file != NULL) {
-                strcpy(args->cluster_files[args->num_fdb_clusters++], cluster_file);
-                cluster_file = strtok(NULL, delim);
-            }
-            break;
-        }
-        case 'd':
-            args->num_databases = atoi(optarg);
-            break;
-        case 'p':
-            args->num_processes = atoi(optarg);
-            break;
-        case 't':
-            args->num_threads = atoi(optarg);
-            break;
-        case 'r':
-            args->rows = atoi(optarg);
-            args->row_digits = digits(args->rows);
-            break;
-        case 's':
-            args->seconds = atoi(optarg);
-            break;
-        case 'i':
-            args->iteration = atoi(optarg);
-            break;
-        case 'x':
-            rc = parse_transaction(args, optarg);
-            if (rc < 0)
-                return -1;
-            break;
-        case 'v':
-            args->verbose = atoi(optarg);
-            break;
-        case 'z':
-            args->zipf = 1;
-            break;
-        case 'm':
-            if (strcmp(optarg, "clean") == 0) {
-                args->mode = MODE_CLEAN;
-            } else if (strcmp(optarg, "build") == 0) {
-                args->mode = MODE_BUILD;
-            } else if (strcmp(optarg, "run") == 0) {
-                args->mode = MODE_RUN;
-            }
-            break;
-        case ARG_KEYLEN:
-            args->key_length = atoi(optarg);
-            break;
-        case ARG_VALLEN:
-            args->value_length = atoi(optarg);
-            break;
-        case ARG_TPS:
-        case ARG_TPSMAX:
-            args->tpsmax = atoi(optarg);
-            break;
-        case ARG_TPSMIN:
-            args->tpsmin = atoi(optarg);
-            break;
-        case ARG_TPSINTERVAL:
-            args->tpsinterval = atoi(optarg);
-            break;
-        case ARG_TPSCHANGE:
-            if (strcmp(optarg, "sin") == 0)
-                args->tpschange = TPS_SIN;
-            else if (strcmp(optarg, "square") == 0)
-                args->tpschange = TPS_SQUARE;
-            else if (strcmp(optarg, "pulse") == 0)
-                args->tpschange = TPS_PULSE;
-            else {
-                fprintf(stderr, "--tpschange must be sin, square or pulse\n");
-                return -1;
-            }
-            break;
-        case ARG_SAMPLING:
-            args->sampling = atoi(optarg);
-            break;
-        case ARG_VERSION:
-            fprintf(stderr, "Version: %d\n", FDB_API_VERSION);
-            exit(0);
-            break;
-        case ARG_COMMITGET:
-            args->commit_get = 1;
-            break;
-        case ARG_FLATBUFFERS:
-            args->flatbuffers = 1;
-            break;
-        case ARG_KNOBS:
-            memcpy(args->knobs, optarg, strlen(optarg) + 1);
-            break;
-        case ARG_LOGGROUP:
-            memcpy(args->log_group, optarg, strlen(optarg) + 1);
-            break;
-        case ARG_PREFIXPADDING:
-            args->prefixpadding = 1;
-            break;
-        case ARG_TRACE:
-            args->trace = 1;
-            break;
-        case ARG_TRACEPATH:
-            args->trace = 1;
-            memcpy(args->tracepath, optarg, strlen(optarg) + 1);
-            break;
-        case ARG_TRACEFORMAT:
-            if (strncmp(optarg, "json", 5) == 0) {
-                args->traceformat = 1;
-            } else if (strncmp(optarg, "xml", 4) == 0) {
-                args->traceformat = 0;
-            } else {
-                fprintf(stderr, "Error: Invalid trace_format %s\n", optarg);
-                return -1;
-            }
-            break;
-        case ARG_STREAMING_MODE:
-            if (strncmp(optarg, "all", 3) == 0) {
-                args->streaming_mode = FDB_STREAMING_MODE_WANT_ALL;
-            } else if (strncmp(optarg, "iterator", 8) == 0) {
-                args->streaming_mode = FDB_STREAMING_MODE_ITERATOR;
-            } else if (strncmp(optarg, "small", 5) == 0) {
-                args->streaming_mode = FDB_STREAMING_MODE_SMALL;
-            } else if (strncmp(optarg, "medium", 6) == 0) {
-                args->streaming_mode = FDB_STREAMING_MODE_MEDIUM;
-            } else if (strncmp(optarg, "large", 5) == 0) {
-                args->streaming_mode = FDB_STREAMING_MODE_LARGE;
-            } else if (strncmp(optarg, "serial", 6) == 0) {
-                args->streaming_mode = FDB_STREAMING_MODE_SERIAL;
-            } else {
-                fprintf(stderr, "Error: Invalid streaming mode %s\n", optarg);
-                return -1;
-            }
-            break;
-        case ARG_TXNTRACE:
-            args->txntrace = atoi(optarg);
-            break;
+	int rc;
+	int c;
+	int idx;
+	while (1) {
+		const char* short_options = "a:c:d:p:t:r:s:i:x:v:m:hz";
+		static struct option long_options[] = {
+			/* name, has_arg, flag, val */
+			{ "api_version", required_argument, NULL, 'a' },
+			{ "cluster", required_argument, NULL, 'c' },
+			{ "num_databases", optional_argument, NULL, 'd' },
+			{ "procs", required_argument, NULL, 'p' },
+			{ "threads", required_argument, NULL, 't' },
+			{ "rows", required_argument, NULL, 'r' },
+			{ "seconds", required_argument, NULL, 's' },
+			{ "iteration", required_argument, NULL, 'i' },
+			{ "keylen", required_argument, NULL, ARG_KEYLEN },
+			{ "vallen", required_argument, NULL, ARG_VALLEN },
+			{ "transaction", required_argument, NULL, 'x' },
+			{ "tps", required_argument, NULL, ARG_TPS },
+			{ "tpsmax", required_argument, NULL, ARG_TPSMAX },
+			{ "tpsmin", required_argument, NULL, ARG_TPSMIN },
+			{ "tpsinterval", required_argument, NULL, ARG_TPSINTERVAL },
+			{ "tpschange", required_argument, NULL, ARG_TPSCHANGE },
+			{ "sampling", required_argument, NULL, ARG_SAMPLING },
+			{ "verbose", required_argument, NULL, 'v' },
+			{ "mode", required_argument, NULL, 'm' },
+			{ "knobs", required_argument, NULL, ARG_KNOBS },
+			{ "loggroup", required_argument, NULL, ARG_LOGGROUP },
+			{ "tracepath", required_argument, NULL, ARG_TRACEPATH },
+			{ "trace_format", required_argument, NULL, ARG_TRACEFORMAT },
+			{ "streaming", required_argument, NULL, ARG_STREAMING_MODE },
+			{ "txntrace", required_argument, NULL, ARG_TXNTRACE },
+			/* no args */
+			{ "help", no_argument, NULL, 'h' },
+			{ "zipf", no_argument, NULL, 'z' },
+			{ "commitget", no_argument, NULL, ARG_COMMITGET },
+			{ "flatbuffers", no_argument, NULL, ARG_FLATBUFFERS },
+			{ "prefix_padding", no_argument, NULL, ARG_PREFIXPADDING },
+			{ "trace", no_argument, NULL, ARG_TRACE },
+			{ "txntagging", required_argument, NULL, ARG_TXNTAGGING },
+			{ "txntagging_prefix", required_argument, NULL, ARG_TXNTAGGINGPREFIX },
+			{ "version", no_argument, NULL, ARG_VERSION },
+			{ "client_threads_per_version", required_argument, NULL, ARG_CLIENT_THREADS_PER_VERSION },
+			{ "disable_ryw", no_argument, NULL, ARG_DISABLE_RYW },
+			{ "json_report", optional_argument, NULL, ARG_JSON_REPORT },
+			{ "bg_file_path", required_argument, NULL, ARG_BG_FILE_PATH },
+			{ NULL, 0, NULL, 0 }
+		};
+		idx = 0;
+		c = getopt_long(argc, argv, short_options, long_options, &idx);
+		if (c < 0) {
+			break;
+		}
+		switch (c) {
+		case '?':
+		case 'h':
+			usage();
+			return -1;
+		case 'a':
+			args->api_version = atoi(optarg);
+			break;
+		case 'c': {
+			const char delim[] = ",";
+			char* cluster_file = strtok(optarg, delim);
+			while (cluster_file != NULL) {
+				strcpy(args->cluster_files[args->num_fdb_clusters++], cluster_file);
+				cluster_file = strtok(NULL, delim);
+			}
+			break;
+		}
+		case 'd':
+			args->num_databases = atoi(optarg);
+			break;
+		case 'p':
+			args->num_processes = atoi(optarg);
+			break;
+		case 't':
+			args->num_threads = atoi(optarg);
+			break;
+		case 'r':
+			args->rows = atoi(optarg);
+			args->row_digits = digits(args->rows);
+			break;
+		case 's':
+			args->seconds = atoi(optarg);
+			break;
+		case 'i':
+			args->iteration = atoi(optarg);
+			break;
+		case 'x':
+			rc = parse_transaction(args, optarg);
+			if (rc < 0)
+				return -1;
+			break;
+		case 'v':
+			args->verbose = atoi(optarg);
+			break;
+		case 'z':
+			args->zipf = 1;
+			break;
+		case 'm':
+			if (strcmp(optarg, "clean") == 0) {
+				args->mode = MODE_CLEAN;
+			} else if (strcmp(optarg, "build") == 0) {
+				args->mode = MODE_BUILD;
+			} else if (strcmp(optarg, "run") == 0) {
+				args->mode = MODE_RUN;
+			}
+			break;
+		case ARG_KEYLEN:
+			args->key_length = atoi(optarg);
+			break;
+		case ARG_VALLEN:
+			args->value_length = atoi(optarg);
+			break;
+		case ARG_TPS:
+		case ARG_TPSMAX:
+			args->tpsmax = atoi(optarg);
+			break;
+		case ARG_TPSMIN:
+			args->tpsmin = atoi(optarg);
+			break;
+		case ARG_TPSINTERVAL:
+			args->tpsinterval = atoi(optarg);
+			break;
+		case ARG_TPSCHANGE:
+			if (strcmp(optarg, "sin") == 0)
+				args->tpschange = TPS_SIN;
+			else if (strcmp(optarg, "square") == 0)
+				args->tpschange = TPS_SQUARE;
+			else if (strcmp(optarg, "pulse") == 0)
+				args->tpschange = TPS_PULSE;
+			else {
+				fprintf(stderr, "--tpschange must be sin, square or pulse\n");
+				return -1;
+			}
+			break;
+		case ARG_SAMPLING:
+			args->sampling = atoi(optarg);
+			break;
+		case ARG_VERSION:
+			fprintf(stderr, "Version: %d\n", FDB_API_VERSION);
+			exit(0);
+			break;
+		case ARG_COMMITGET:
+			args->commit_get = 1;
+			break;
+		case ARG_FLATBUFFERS:
+			args->flatbuffers = 1;
+			break;
+		case ARG_KNOBS:
+			memcpy(args->knobs, optarg, strlen(optarg) + 1);
+			break;
+		case ARG_LOGGROUP:
+			memcpy(args->log_group, optarg, strlen(optarg) + 1);
+			break;
+		case ARG_PREFIXPADDING:
+			args->prefixpadding = 1;
+			break;
+		case ARG_TRACE:
+			args->trace = 1;
+			break;
+		case ARG_TRACEPATH:
+			args->trace = 1;
+			memcpy(args->tracepath, optarg, strlen(optarg) + 1);
+			break;
+		case ARG_TRACEFORMAT:
+			if (strncmp(optarg, "json", 5) == 0) {
+				args->traceformat = 1;
+			} else if (strncmp(optarg, "xml", 4) == 0) {
+				args->traceformat = 0;
+			} else {
+				fprintf(stderr, "Error: Invalid trace_format %s\n", optarg);
+				return -1;
+			}
+			break;
+		case ARG_STREAMING_MODE:
+			if (strncmp(optarg, "all", 3) == 0) {
+				args->streaming_mode = FDB_STREAMING_MODE_WANT_ALL;
+			} else if (strncmp(optarg, "iterator", 8) == 0) {
+				args->streaming_mode = FDB_STREAMING_MODE_ITERATOR;
+			} else if (strncmp(optarg, "small", 5) == 0) {
+				args->streaming_mode = FDB_STREAMING_MODE_SMALL;
+			} else if (strncmp(optarg, "medium", 6) == 0) {
+				args->streaming_mode = FDB_STREAMING_MODE_MEDIUM;
+			} else if (strncmp(optarg, "large", 5) == 0) {
+				args->streaming_mode = FDB_STREAMING_MODE_LARGE;
+			} else if (strncmp(optarg, "serial", 6) == 0) {
+				args->streaming_mode = FDB_STREAMING_MODE_SERIAL;
+			} else {
+				fprintf(stderr, "Error: Invalid streaming mode %s\n", optarg);
+				return -1;
+			}
+			break;
+		case ARG_TXNTRACE:
+			args->txntrace = atoi(optarg);
+			break;
 
-        case ARG_TXNTAGGING:
-            args->txntagging = atoi(optarg);
-            if (args->txntagging > 1000) {
-                args->txntagging = 1000;
-            }
-            break;
-        case ARG_TXNTAGGINGPREFIX:
-            if (strlen(optarg) > TAGPREFIXLENGTH_MAX) {
-                fprintf(stderr, "Error: the length of txntagging_prefix is larger than %d\n", TAGPREFIXLENGTH_MAX);
-                exit(0);
-            }
-            memcpy(args->txntagging_prefix, optarg, strlen(optarg));
-            break;
-        case ARG_CLIENT_THREADS_PER_VERSION:
-            args->client_threads_per_version = atoi(optarg);
-            break;
-        case ARG_DISABLE_RYW:
-            args->disable_ryw = 1;
-            break;
-        case ARG_JSON_REPORT:
-            if (optarg == NULL && (argv[optind] == NULL || (argv[optind] != NULL && argv[optind][0] == '-'))) {
-                // if --report_json is the last option and no file is specified
-                // or --report_json is followed by another option
-                char default_file[] = "mako.json";
-                strncpy(args->json_output_path, default_file, strlen(default_file));
-            } else {
-                strncpy(args->json_output_path, optarg, strlen(optarg) + 1);
-            }
-            break;
-        case ARG_BG_FILE_PATH:
-            args->bg_materialize_files = true;
-            strncpy(args->bg_file_path, optarg, strlen(optarg) + 1);
-        }
-    }
+		case ARG_TXNTAGGING:
+			args->txntagging = atoi(optarg);
+			if (args->txntagging > 1000) {
+				args->txntagging = 1000;
+			}
+			break;
+		case ARG_TXNTAGGINGPREFIX:
+			if (strlen(optarg) > TAGPREFIXLENGTH_MAX) {
+				fprintf(stderr, "Error: the length of txntagging_prefix is larger than %d\n", TAGPREFIXLENGTH_MAX);
+				exit(0);
+			}
+			memcpy(args->txntagging_prefix, optarg, strlen(optarg));
+			break;
+		case ARG_CLIENT_THREADS_PER_VERSION:
+			args->client_threads_per_version = atoi(optarg);
+			break;
+		case ARG_DISABLE_RYW:
+			args->disable_ryw = 1;
+			break;
+		case ARG_JSON_REPORT:
+			if (optarg == NULL && (argv[optind] == NULL || (argv[optind] != NULL && argv[optind][0] == '-'))) {
+				// if --report_json is the last option and no file is specified
+				// or --report_json is followed by another option
+				char default_file[] = "mako.json";
+				strncpy(args->json_output_path, default_file, strlen(default_file));
+			} else {
+				strncpy(args->json_output_path, optarg, strlen(optarg) + 1);
+			}
+			break;
+		case ARG_BG_FILE_PATH:
+			args->bg_materialize_files = true;
+			strncpy(args->bg_file_path, optarg, strlen(optarg) + 1);
+		}
+	}
 
-    if ((args->tpsmin == -1) || (args->tpsmin > args->tpsmax)) {
-        args->tpsmin = args->tpsmax;
-    }
+	if ((args->tpsmin == -1) || (args->tpsmin > args->tpsmax)) {
+		args->tpsmin = args->tpsmax;
+	}
 
-    if (args->verbose >= VERBOSE_DEFAULT) {
-        printme = stdout;
-    } else {
-        printme = fopen("/dev/null", "w");
-    }
-    if (args->verbose >= VERBOSE_ANNOYING) {
-        annoyme = stdout;
-    } else {
-        annoyme = fopen("/dev/null", "w");
-    }
-    if (args->verbose >= VERBOSE_DEBUG) {
-        debugme = stdout;
-    } else {
-        debugme = fopen("/dev/null", "w");
-    }
+	if (args->verbose >= VERBOSE_DEFAULT) {
+		printme = stdout;
+	} else {
+		printme = fopen("/dev/null", "w");
+	}
+	if (args->verbose >= VERBOSE_ANNOYING) {
+		annoyme = stdout;
+	} else {
+		annoyme = fopen("/dev/null", "w");
+	}
+	if (args->verbose >= VERBOSE_DEBUG) {
+		debugme = stdout;
+	} else {
+		debugme = fopen("/dev/null", "w");
+	}
 
-    return 0;
+	return 0;
 }
 
 char const* get_ops_name(int ops_code) {
-    if (ops_code >= 0 && ops_code < MAX_OP)
-        return op_desc[ops_code].name().data();
-    return "";
+	if (ops_code >= 0 && ops_code < MAX_OP)
+		return op_desc[ops_code].name().data();
+	return "";
 }
 
 int validate_args(mako_args_t* args) {
-    if (args->mode == MODE_INVALID) {
-        fprintf(stderr, "ERROR: --mode has to be set\n");
-        return -1;
-    }
-    if (args->rows <= 0) {
-        fprintf(stderr, "ERROR: --rows must be a positive integer\n");
-        return -1;
-    }
-    if (args->key_length < 0) {
-        fprintf(stderr, "ERROR: --keylen must be a positive integer\n");
-        return -1;
-    }
-    if (args->value_length < 0) {
-        fprintf(stderr, "ERROR: --vallen must be a positive integer\n");
-        return -1;
-    }
-    if (args->num_fdb_clusters > NUM_CLUSTERS_MAX) {
-        fprintf(stderr, "ERROR: Mako is not supported to do work to more than %d clusters\n", NUM_CLUSTERS_MAX);
-        return -1;
-    }
-    if (args->num_databases > NUM_DATABASES_MAX) {
-        fprintf(stderr, "ERROR: Mako is not supported to do work to more than %d databases\n", NUM_DATABASES_MAX);
-        return -1;
-    }
-    if (args->num_databases < args->num_fdb_clusters) {
-        fprintf(stderr,
-                "ERROR: --num_databases (%d) must be >= number of clusters(%d)\n",
-                args->num_databases,
-                args->num_fdb_clusters);
-        return -1;
-    }
-    if (args->num_threads < args->num_databases) {
-        fprintf(stderr,
-                "ERROR: --threads (%d) must be >= number of databases (%d)\n",
-                args->num_threads,
-                args->num_databases);
-        return -1;
-    }
-    if (args->key_length < 4 /* "mako" */ + args->row_digits) {
-        fprintf(stderr,
-                "ERROR: --keylen must be larger than %d to store \"mako\" prefix "
-                "and maximum row number\n",
-                4 + args->row_digits);
-        return -1;
-    }
-    if (args->mode == MODE_RUN) {
-        if ((args->seconds > 0) && (args->iteration > 0)) {
-            fprintf(stderr, "ERROR: Cannot specify seconds and iteration together\n");
-            return -1;
-        }
-        if ((args->seconds == 0) && (args->iteration == 0)) {
-            fprintf(stderr, "ERROR: Must specify either seconds or iteration\n");
-            return -1;
-        }
-        if (args->txntagging < 0) {
-            fprintf(stderr, "ERROR: --txntagging must be a non-negative integer\n");
-            return -1;
-        }
-    }
-    return 0;
+	if (args->mode == MODE_INVALID) {
+		fprintf(stderr, "ERROR: --mode has to be set\n");
+		return -1;
+	}
+	if (args->rows <= 0) {
+		fprintf(stderr, "ERROR: --rows must be a positive integer\n");
+		return -1;
+	}
+	if (args->key_length < 0) {
+		fprintf(stderr, "ERROR: --keylen must be a positive integer\n");
+		return -1;
+	}
+	if (args->value_length < 0) {
+		fprintf(stderr, "ERROR: --vallen must be a positive integer\n");
+		return -1;
+	}
+	if (args->num_fdb_clusters > NUM_CLUSTERS_MAX) {
+		fprintf(stderr, "ERROR: Mako is not supported to do work to more than %d clusters\n", NUM_CLUSTERS_MAX);
+		return -1;
+	}
+	if (args->num_databases > NUM_DATABASES_MAX) {
+		fprintf(stderr, "ERROR: Mako is not supported to do work to more than %d databases\n", NUM_DATABASES_MAX);
+		return -1;
+	}
+	if (args->num_databases < args->num_fdb_clusters) {
+		fprintf(stderr,
+		        "ERROR: --num_databases (%d) must be >= number of clusters(%d)\n",
+		        args->num_databases,
+		        args->num_fdb_clusters);
+		return -1;
+	}
+	if (args->num_threads < args->num_databases) {
+		fprintf(stderr,
+		        "ERROR: --threads (%d) must be >= number of databases (%d)\n",
+		        args->num_threads,
+		        args->num_databases);
+		return -1;
+	}
+	if (args->key_length < 4 /* "mako" */ + args->row_digits) {
+		fprintf(stderr,
+		        "ERROR: --keylen must be larger than %d to store \"mako\" prefix "
+		        "and maximum row number\n",
+		        4 + args->row_digits);
+		return -1;
+	}
+	if (args->mode == MODE_RUN) {
+		if ((args->seconds > 0) && (args->iteration > 0)) {
+			fprintf(stderr, "ERROR: Cannot specify seconds and iteration together\n");
+			return -1;
+		}
+		if ((args->seconds == 0) && (args->iteration == 0)) {
+			fprintf(stderr, "ERROR: Must specify either seconds or iteration\n");
+			return -1;
+		}
+		if (args->txntagging < 0) {
+			fprintf(stderr, "ERROR: --txntagging must be a non-negative integer\n");
+			return -1;
+		}
+	}
+	return 0;
 }
 
-void print_stats(mako_args_t const& args, mako_stats_t const* stats,
-                 double const duration_sec, FILE* fp) {
-    static mako_stats_t prev;
+void print_stats(mako_args_t const& args, mako_stats_t const* stats, double const duration_sec, FILE* fp) {
+	static mako_stats_t prev;
 
-    auto current = mako_stats_t{};
-    for (auto i = 0; i < args.num_processes; i++) {
-        for (auto j = 0; j < args.num_threads; j++) {
-            current.combine(stats[(i * args.num_threads) + j]);
-        }
-    }
+	auto current = mako_stats_t{};
+	for (auto i = 0; i < args.num_processes; i++) {
+		for (auto j = 0; j < args.num_threads; j++) {
+			current.combine(stats[(i * args.num_threads) + j]);
+		}
+	}
 
-    if (fp) {
-        fwrite("{", 1, 1, fp);
-    }
-    put_title_r("OPS");
-    auto print_err = false;
-    for (auto op = 0; op < MAX_OP; op++) {
-        if (args.txnspec.ops[op][OP_COUNT] > 0) {
-            const auto ops_total_diff = current.get_op_count(op) - prev.get_op_count(op);
-            put_field(ops_total_diff);
-            if (fp) {
-                fmt::print(fp, "\"{}\": {},", get_ops_name(op), ops_total_diff);
-            }
-            print_err = (current.get_error_count(op) - prev.get_error_count(op)) > 0;
-        }
-    }
-    /* TPS */
-    const auto tps = (current.get_tx_count() - prev.get_tx_count()) / duration_sec;
-    put_field_f(tps, 2);
-    if (fp) {
-        fprintf(fp, "\"tps\": %.2f,", tps);
-    }
+	if (fp) {
+		fwrite("{", 1, 1, fp);
+	}
+	put_title_r("OPS");
+	auto print_err = false;
+	for (auto op = 0; op < MAX_OP; op++) {
+		if (args.txnspec.ops[op][OP_COUNT] > 0) {
+			const auto ops_total_diff = current.get_op_count(op) - prev.get_op_count(op);
+			put_field(ops_total_diff);
+			if (fp) {
+				fmt::print(fp, "\"{}\": {},", get_ops_name(op), ops_total_diff);
+			}
+			print_err = (current.get_error_count(op) - prev.get_error_count(op)) > 0;
+		}
+	}
+	/* TPS */
+	const auto tps = (current.get_tx_count() - prev.get_tx_count()) / duration_sec;
+	put_field_f(tps, 2);
+	if (fp) {
+		fprintf(fp, "\"tps\": %.2f,", tps);
+	}
 
-    /* Conflicts */
-    const auto conflicts_diff =
-        (current.get_conflict_count() - prev.get_conflict_count()) / duration_sec;
-    put_field_f(conflicts_diff, 2);
-    if (fp) {
-        fprintf(fp, "\"conflictsPerSec\": %.2f", conflicts_diff);
-    }
+	/* Conflicts */
+	const auto conflicts_diff = (current.get_conflict_count() - prev.get_conflict_count()) / duration_sec;
+	put_field_f(conflicts_diff, 2);
+	if (fp) {
+		fprintf(fp, "\"conflictsPerSec\": %.2f", conflicts_diff);
+	}
 
-    if (print_err) {
-        put_title_r("Errors");
-        for (auto op = 0; op < MAX_OP; op++) {
-            if (args.txnspec.ops[op][OP_COUNT] > 0) {
-                put_field(current.get_error_count(op) - prev.get_error_count(op));
-                if (fp) {
-                    fprintf(fp, ",\"errors\": %.2f", conflicts_diff);
-                }
-            }
-        }
-        printf("\n");
-    }
-    if (fp) {
-        fprintf(fp, "}");
-    }
-    // swap old stats for new
-    prev = current;
+	if (print_err) {
+		put_title_r("Errors");
+		for (auto op = 0; op < MAX_OP; op++) {
+			if (args.txnspec.ops[op][OP_COUNT] > 0) {
+				put_field(current.get_error_count(op) - prev.get_error_count(op));
+				if (fp) {
+					fprintf(fp, ",\"errors\": %.2f", conflicts_diff);
+				}
+			}
+		}
+		printf("\n");
+	}
+	if (fp) {
+		fprintf(fp, "}");
+	}
+	// swap old stats for new
+	prev = current;
 }
 
 void print_stats_header(mako_args_t const& args, bool show_commit, bool is_first_header_empty, bool show_op_stats) {
-    /* header */
-    if (is_first_header_empty) put_title("");
-    for (auto op = 0; op < MAX_OP; op++) {
-        if (args.txnspec.ops[op][OP_COUNT] > 0) {
-            put_field(get_ops_name(op));
-        }
-    }
+	/* header */
+	if (is_first_header_empty)
+		put_title("");
+	for (auto op = 0; op < MAX_OP; op++) {
+		if (args.txnspec.ops[op][OP_COUNT] > 0) {
+			put_field(get_ops_name(op));
+		}
+	}
 
-    if (show_commit) put_field("COMMIT");
-    if (show_op_stats) {
-        put_field("TRANSACTION");
-    } else {
-        put_field("TPS");
-        put_field("Conflicts/s");
-    }
-    fmt::print("\n");
+	if (show_commit)
+		put_field("COMMIT");
+	if (show_op_stats) {
+		put_field("TRANSACTION");
+	} else {
+		put_field("TPS");
+		put_field("Conflicts/s");
+	}
+	fmt::print("\n");
 
-    put_title_bar();
-    for (auto op = 0; op < MAX_OP; op++) {
-        if (args.txnspec.ops[op][OP_COUNT] > 0) {
-            put_field_bar();
-        }
-    }
+	put_title_bar();
+	for (auto op = 0; op < MAX_OP; op++) {
+		if (args.txnspec.ops[op][OP_COUNT] > 0) {
+			put_field_bar();
+		}
+	}
 
-    /* COMMIT */
-    if (show_commit) put_field_bar();
+	/* COMMIT */
+	if (show_commit)
+		put_field_bar();
 
-    if (show_op_stats) {
-        /* TRANSACTION */
-        put_field_bar();
-    } else {
-        /* TPS */
-        put_field_bar();
+	if (show_op_stats) {
+		/* TRANSACTION */
+		put_field_bar();
+	} else {
+		/* TPS */
+		put_field_bar();
 
-        /* Conflicts */
-        put_field_bar();
-    }
-    fmt::print("\n");
+		/* Conflicts */
+		put_field_bar();
+	}
+	fmt::print("\n");
 }
 
 void print_report(mako_args_t const& args,
@@ -1770,370 +1701,360 @@ void print_report(mako_args_t const& args,
                   pid_t pid_main,
                   FILE* fp) {
 
-    auto final_stats = mako_stats_t{};
-    for (auto i = 0; i < args.num_processes; i++) {
-        for (auto j = 0; j < args.num_threads; j++) {
-            const auto idx = i * args.num_threads + j;
-            final_stats.combine(stats[idx]);
-        }
-    }
+	auto final_stats = mako_stats_t{};
+	for (auto i = 0; i < args.num_processes; i++) {
+		for (auto j = 0; j < args.num_threads; j++) {
+			const auto idx = i * args.num_threads + j;
+			final_stats.combine(stats[idx]);
+		}
+	}
 
-    /* overall stats */
-    fmt::printf("\n====== Total Duration %6.3f sec ======\n\n", duration_sec);
-    fmt::printf("Total Processes:  %8d\n", args.num_processes);
-    fmt::printf("Total Threads:    %8d\n", args.num_threads);
-    if (args.tpsmax == args.tpsmin)
-        fmt::printf("Target TPS:       %8d\n", args.tpsmax);
-    else {
-        fmt::printf("Target TPS (MAX): %8d\n", args.tpsmax);
-        fmt::printf("Target TPS (MIN): %8d\n", args.tpsmin);
-        fmt::printf("TPS Interval:     %8d\n", args.tpsinterval);
-        fmt::printf("TPS Change:       ");
-        switch (args.tpschange) {
-        case TPS_SIN:
-            fmt::printf("%8s\n", "SIN");
-            break;
-        case TPS_SQUARE:
-            fmt::printf("%8s\n", "SQUARE");
-            break;
-        case TPS_PULSE:
-            fmt::printf("%8s\n", "PULSE");
-            break;
-        }
-    }
-    fmt::printf("Total Xacts:      %8lu\n", final_stats.get_tx_count());
-    fmt::printf("Total Conflicts:  %8lu\n", final_stats.get_conflict_count());
-    fmt::printf("Total Errors:     %8lu\n", final_stats.get_total_error_count());
-    fmt::printf("Overall TPS:      %8lu\n\n", final_stats.get_tx_count() / duration_sec);
+	/* overall stats */
+	fmt::printf("\n====== Total Duration %6.3f sec ======\n\n", duration_sec);
+	fmt::printf("Total Processes:  %8d\n", args.num_processes);
+	fmt::printf("Total Threads:    %8d\n", args.num_threads);
+	if (args.tpsmax == args.tpsmin)
+		fmt::printf("Target TPS:       %8d\n", args.tpsmax);
+	else {
+		fmt::printf("Target TPS (MAX): %8d\n", args.tpsmax);
+		fmt::printf("Target TPS (MIN): %8d\n", args.tpsmin);
+		fmt::printf("TPS Interval:     %8d\n", args.tpsinterval);
+		fmt::printf("TPS Change:       ");
+		switch (args.tpschange) {
+		case TPS_SIN:
+			fmt::printf("%8s\n", "SIN");
+			break;
+		case TPS_SQUARE:
+			fmt::printf("%8s\n", "SQUARE");
+			break;
+		case TPS_PULSE:
+			fmt::printf("%8s\n", "PULSE");
+			break;
+		}
+	}
+	fmt::printf("Total Xacts:      %8lu\n", final_stats.get_tx_count());
+	fmt::printf("Total Conflicts:  %8lu\n", final_stats.get_conflict_count());
+	fmt::printf("Total Errors:     %8lu\n", final_stats.get_total_error_count());
+	fmt::printf("Overall TPS:      %8lu\n\n", final_stats.get_tx_count() / duration_sec);
 
-    if (fp) {
-        fmt::fprintf(fp, "\"results\": {");
-        fmt::fprintf(fp, "\"totalDuration\": %6.3f,", duration_sec);
-        fmt::fprintf(fp, "\"totalProcesses\": %d,", args.num_processes);
-        fmt::fprintf(fp, "\"totalThreads\": %d,", args.num_threads);
-        fmt::fprintf(fp, "\"targetTPS\": %d,", args.tpsmax);
-        fmt::fprintf(fp, "\"totalXacts\": %lu,", final_stats.get_tx_count());
-        fmt::fprintf(fp, "\"totalConflicts\": %lu,", final_stats.get_conflict_count());
-        fmt::fprintf(fp, "\"totalErrors\": %lu,", final_stats.get_total_error_count());
-        fmt::fprintf(fp, "\"overallTPS\": %lu,", final_stats.get_tx_count() / duration_sec);
-    }
+	if (fp) {
+		fmt::fprintf(fp, "\"results\": {");
+		fmt::fprintf(fp, "\"totalDuration\": %6.3f,", duration_sec);
+		fmt::fprintf(fp, "\"totalProcesses\": %d,", args.num_processes);
+		fmt::fprintf(fp, "\"totalThreads\": %d,", args.num_threads);
+		fmt::fprintf(fp, "\"targetTPS\": %d,", args.tpsmax);
+		fmt::fprintf(fp, "\"totalXacts\": %lu,", final_stats.get_tx_count());
+		fmt::fprintf(fp, "\"totalConflicts\": %lu,", final_stats.get_conflict_count());
+		fmt::fprintf(fp, "\"totalErrors\": %lu,", final_stats.get_total_error_count());
+		fmt::fprintf(fp, "\"overallTPS\": %lu,", final_stats.get_tx_count() / duration_sec);
+	}
 
-    /* per-op stats */
-    print_stats_header(args, true, true, false);
+	/* per-op stats */
+	print_stats_header(args, true, true, false);
 
-    /* OPS */
-    put_title("Total OPS");
-    if (fp) {
-        fmt::fprintf(fp, "\"totalOps\": {");
-    }
-    auto first_op = true;
-    for (auto op = 0; op < MAX_OP; op++) {
-        if ((args.txnspec.ops[op][OP_COUNT] > 0 && op != OP_TRANSACTION) || op == OP_COMMIT) {
-            put_field(final_stats.get_op_count(op));
-            if (fp) {
-                if (first_op) {
-                    first_op = 0;
-                } else {
-                    fmt::fprintf(fp, ",");
-                }
-                fmt::fprintf(fp, "\"%s\": %lu", get_ops_name(op), final_stats.get_op_count(op));
-            }
-        }
-    }
+	/* OPS */
+	put_title("Total OPS");
+	if (fp) {
+		fmt::fprintf(fp, "\"totalOps\": {");
+	}
+	auto first_op = true;
+	for (auto op = 0; op < MAX_OP; op++) {
+		if ((args.txnspec.ops[op][OP_COUNT] > 0 && op != OP_TRANSACTION) || op == OP_COMMIT) {
+			put_field(final_stats.get_op_count(op));
+			if (fp) {
+				if (first_op) {
+					first_op = 0;
+				} else {
+					fmt::fprintf(fp, ",");
+				}
+				fmt::fprintf(fp, "\"%s\": %lu", get_ops_name(op), final_stats.get_op_count(op));
+			}
+		}
+	}
 
-    /* TPS */
-    const auto tps = final_stats.get_tx_count() / duration_sec;
-    put_field_f(tps, 2);
+	/* TPS */
+	const auto tps = final_stats.get_tx_count() / duration_sec;
+	put_field_f(tps, 2);
 
-    /* Conflicts */
-    const auto conflicts_rate = final_stats.get_conflict_count() / duration_sec;
-    put_field_f(conflicts_rate, 2);
+	/* Conflicts */
+	const auto conflicts_rate = final_stats.get_conflict_count() / duration_sec;
+	put_field_f(conflicts_rate, 2);
 
-    if (fp) {
-        fmt::fprintf(fp, "}, \"tps\": %.2f, \"conflictsPerSec\": %.2f, \"errors\": {", tps, conflicts_rate);
-    }
+	if (fp) {
+		fmt::fprintf(fp, "}, \"tps\": %.2f, \"conflictsPerSec\": %.2f, \"errors\": {", tps, conflicts_rate);
+	}
 
-    /* Errors */
-    put_title("Errors");
-    first_op = 1;
-    for (auto op = 0; op < MAX_OP; op++) {
-        if (args.txnspec.ops[op][OP_COUNT] > 0 && op != OP_TRANSACTION) {
-            put_field(final_stats.get_error_count(op));
-            if (fp) {
-                if (first_op) {
-                    first_op = 0;
-                } else {
-                    fmt::fprintf(fp, ",");
-                }
-                fmt::fprintf(fp, "\"%s\": %lu",
-                             get_ops_name(op), final_stats.get_error_count(op));
-            }
-        }
-    }
-    if (fp) {
-        fmt::fprintf(fp, "}, \"numSamples\": {");
-    }
-    fmt::print("\n\n");
+	/* Errors */
+	put_title("Errors");
+	first_op = 1;
+	for (auto op = 0; op < MAX_OP; op++) {
+		if (args.txnspec.ops[op][OP_COUNT] > 0 && op != OP_TRANSACTION) {
+			put_field(final_stats.get_error_count(op));
+			if (fp) {
+				if (first_op) {
+					first_op = 0;
+				} else {
+					fmt::fprintf(fp, ",");
+				}
+				fmt::fprintf(fp, "\"%s\": %lu", get_ops_name(op), final_stats.get_error_count(op));
+			}
+		}
+	}
+	if (fp) {
+		fmt::fprintf(fp, "}, \"numSamples\": {");
+	}
+	fmt::print("\n\n");
 
-    fmt::print("Latency (us)");
-    print_stats_header(args, true, false, true);
+	fmt::print("Latency (us)");
+	print_stats_header(args, true, false, true);
 
-    /* Total Samples */
-    put_title("Samples");
-    first_op = 1;
-    for (auto op = 0; op < MAX_OP; op++) {
-        if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-            if (final_stats.get_latency_us_total(op)) {
-                put_field(final_stats.get_latency_sample_count(op));
-            } else {
-                put_field("N/A");
-            }
-            if (fp) {
-                if (first_op) {
-                    first_op = 0;
-                } else {
-                    fmt::fprintf(fp, ",");
-                }
-                fmt::fprintf(fp, "\"%s\": %lu",
-                             get_ops_name(op),
-                             final_stats.get_latency_sample_count(op));
-            }
-        }
-    }
-    fmt::print("\n");
+	/* Total Samples */
+	put_title("Samples");
+	first_op = 1;
+	for (auto op = 0; op < MAX_OP; op++) {
+		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
+			if (final_stats.get_latency_us_total(op)) {
+				put_field(final_stats.get_latency_sample_count(op));
+			} else {
+				put_field("N/A");
+			}
+			if (fp) {
+				if (first_op) {
+					first_op = 0;
+				} else {
+					fmt::fprintf(fp, ",");
+				}
+				fmt::fprintf(fp, "\"%s\": %lu", get_ops_name(op), final_stats.get_latency_sample_count(op));
+			}
+		}
+	}
+	fmt::print("\n");
 
-    /* Min Latency */
-    if (fp) {
-        fmt::fprintf(fp, "}, \"minLatency\": {");
-    }
-    put_title("Min");
-    first_op = 1;
-    for (auto op = 0; op < MAX_OP; op++) {
-        if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-            const auto lat_min = final_stats.get_latency_us_min(op);
-            if (lat_min == -1) {
-                put_field("N/A");
-            } else {
-                put_field(lat_min);
-                if (fp) {
-                    if (first_op) {
-                        first_op = 0;
-                    } else {
-                        fmt::fprintf(fp, ",");
-                    }
-                    fmt::fprintf(fp, "\"%s\": %lu", get_ops_name(op), lat_min);
-                }
-            }
-        }
-    }
-    fmt::print("\n");
+	/* Min Latency */
+	if (fp) {
+		fmt::fprintf(fp, "}, \"minLatency\": {");
+	}
+	put_title("Min");
+	first_op = 1;
+	for (auto op = 0; op < MAX_OP; op++) {
+		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
+			const auto lat_min = final_stats.get_latency_us_min(op);
+			if (lat_min == -1) {
+				put_field("N/A");
+			} else {
+				put_field(lat_min);
+				if (fp) {
+					if (first_op) {
+						first_op = 0;
+					} else {
+						fmt::fprintf(fp, ",");
+					}
+					fmt::fprintf(fp, "\"%s\": %lu", get_ops_name(op), lat_min);
+				}
+			}
+		}
+	}
+	fmt::print("\n");
 
-    /* Avg Latency */
-    if (fp) {
-        fmt::fprintf(fp, "}, \"avgLatency\": {");
-    }
-    put_title("Avg");
-    first_op = 1;
-    for (auto op = 0; op < MAX_OP; op++) {
-        if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-            const auto lat_total = final_stats.get_latency_us_total(op);
-            const auto lat_samples = final_stats.get_latency_sample_count(op);
-            if (lat_total) {
-                put_field(lat_total / lat_samples);
-                if (fp) {
-                    if (first_op) {
-                        first_op = 0;
-                    } else {
-                        fmt::fprintf(fp, ",");
-                    }
-                    fmt::fprintf(fp, "\"%s\": %lu", get_ops_name(op), lat_total / lat_samples);
-                }
-            } else {
-                put_field("N/A");
-            }
-        }
-    }
-    fmt::printf("\n");
+	/* Avg Latency */
+	if (fp) {
+		fmt::fprintf(fp, "}, \"avgLatency\": {");
+	}
+	put_title("Avg");
+	first_op = 1;
+	for (auto op = 0; op < MAX_OP; op++) {
+		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
+			const auto lat_total = final_stats.get_latency_us_total(op);
+			const auto lat_samples = final_stats.get_latency_sample_count(op);
+			if (lat_total) {
+				put_field(lat_total / lat_samples);
+				if (fp) {
+					if (first_op) {
+						first_op = 0;
+					} else {
+						fmt::fprintf(fp, ",");
+					}
+					fmt::fprintf(fp, "\"%s\": %lu", get_ops_name(op), lat_total / lat_samples);
+				}
+			} else {
+				put_field("N/A");
+			}
+		}
+	}
+	fmt::printf("\n");
 
-    /* Max Latency */
-    if (fp) {
-        fmt::fprintf(fp, "}, \"maxLatency\": {");
-    }
-    put_title("Max");
-    first_op = 1;
-    for (auto op = 0; op < MAX_OP; op++) {
-        if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-            const auto lat_max = final_stats.get_latency_us_max(op);
-            if (lat_max == 0) {
-                put_field("N/A");
-            } else {
-                put_field(lat_max);
-                if (fp) {
-                    if (first_op) {
-                        first_op = 0;
-                    } else {
-                        fmt::fprintf(fp, ",");
-                    }
-                    fmt::fprintf(fp, "\"%s\": %lu",
-                                 get_ops_name(op), final_stats.get_latency_us_max(op));
-                }
-            }
-        }
-    }
-    fmt::print("\n");
+	/* Max Latency */
+	if (fp) {
+		fmt::fprintf(fp, "}, \"maxLatency\": {");
+	}
+	put_title("Max");
+	first_op = 1;
+	for (auto op = 0; op < MAX_OP; op++) {
+		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
+			const auto lat_max = final_stats.get_latency_us_max(op);
+			if (lat_max == 0) {
+				put_field("N/A");
+			} else {
+				put_field(lat_max);
+				if (fp) {
+					if (first_op) {
+						first_op = 0;
+					} else {
+						fmt::fprintf(fp, ",");
+					}
+					fmt::fprintf(fp, "\"%s\": %lu", get_ops_name(op), final_stats.get_latency_us_max(op));
+				}
+			}
+		}
+	}
+	fmt::print("\n");
 
-    auto data_points = std::array<std::vector<uint64_t>, MAX_OP>{};
+	auto data_points = std::array<std::vector<uint64_t>, MAX_OP>{};
 
-    /* Median Latency */
-    if (fp) {
-        fmt::fprintf(fp, "}, \"medianLatency\": {");
-    }
-    put_title("Median");
-    first_op = 1;
-    for (auto op = 0; op < MAX_OP; op++) {
-        if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-            const auto lat_total = final_stats.get_latency_us_total(op);
-            const auto lat_samples = final_stats.get_latency_sample_count(op);
-            if (lat_total && lat_samples) {
-                data_points[op].reserve(lat_samples);
-                for (auto i = 0; i < args.num_processes; i++) {
-                    for (auto j = 0; j < args.num_threads; j++) {
-                        const auto dirname = fmt::format("{}{}", TEMP_DATA_STORE, pid_main);
-                        const auto filename = get_stats_file_name(dirname, i, j, op);
-                        auto fp = fopen(filename.c_str(), "r");
-                        if (!fp) {
-                            fmt::print(stderr, "ERROR: fopen({}): {}\n", strerror(errno));
-                            continue;
-                        }
-                        auto fclose_guard = exit_guard([fp]() { fclose(fp); });
-                        fseek(fp, 0, SEEK_END);
-                        const auto num_points = ftell(fp) / sizeof(uint64_t);
-                        fseek(fp, 0, 0);
-                        auto index = 0u;
-                        while (index < num_points) {
-                            auto value = uint64_t{};
-                            fread(&value, sizeof(uint64_t), 1, fp);
-                            data_points[op].push_back(value);
-                            ++index;
-                        }
-                    }
-                }
-                std::sort(data_points[op].begin(), data_points[op].end());
-                const auto num_points = data_points[op].size();
-                auto median = uint64_t{};
-                if (num_points & 1) {
-                    median = data_points[op][num_points / 2];
-                } else {
-                    median = (data_points[op][num_points / 2] + data_points[op][num_points / 2 - 1]) >> 1;
-                }
-                put_field(median);
-                if (fp) {
-                    if (first_op) {
-                        first_op = 0;
-                    } else {
-                        fmt::fprintf(fp, ",");
-                    }
-                    fmt::fprintf(fp, "\"%s\": %lu", get_ops_name(op), median);
-                }
-            } else {
-                put_field("N/A");
-            }
-        }
-    }
-    fmt::print("\n");
+	/* Median Latency */
+	if (fp) {
+		fmt::fprintf(fp, "}, \"medianLatency\": {");
+	}
+	put_title("Median");
+	first_op = 1;
+	for (auto op = 0; op < MAX_OP; op++) {
+		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
+			const auto lat_total = final_stats.get_latency_us_total(op);
+			const auto lat_samples = final_stats.get_latency_sample_count(op);
+			if (lat_total && lat_samples) {
+				data_points[op].reserve(lat_samples);
+				for (auto i = 0; i < args.num_processes; i++) {
+					for (auto j = 0; j < args.num_threads; j++) {
+						const auto dirname = fmt::format("{}{}", TEMP_DATA_STORE, pid_main);
+						const auto filename = get_stats_file_name(dirname, i, j, op);
+						auto fp = fopen(filename.c_str(), "r");
+						if (!fp) {
+							fmt::print(stderr, "ERROR: fopen({}): {}\n", strerror(errno));
+							continue;
+						}
+						auto fclose_guard = exit_guard([fp]() { fclose(fp); });
+						fseek(fp, 0, SEEK_END);
+						const auto num_points = ftell(fp) / sizeof(uint64_t);
+						fseek(fp, 0, 0);
+						auto index = 0u;
+						while (index < num_points) {
+							auto value = uint64_t{};
+							fread(&value, sizeof(uint64_t), 1, fp);
+							data_points[op].push_back(value);
+							++index;
+						}
+					}
+				}
+				std::sort(data_points[op].begin(), data_points[op].end());
+				const auto num_points = data_points[op].size();
+				auto median = uint64_t{};
+				if (num_points & 1) {
+					median = data_points[op][num_points / 2];
+				} else {
+					median = (data_points[op][num_points / 2] + data_points[op][num_points / 2 - 1]) >> 1;
+				}
+				put_field(median);
+				if (fp) {
+					if (first_op) {
+						first_op = 0;
+					} else {
+						fmt::fprintf(fp, ",");
+					}
+					fmt::fprintf(fp, "\"%s\": %lu", get_ops_name(op), median);
+				}
+			} else {
+				put_field("N/A");
+			}
+		}
+	}
+	fmt::print("\n");
 
-    /* 95%ile Latency */
-    if (fp) {
-        fmt::fprintf(fp, "}, \"p95Latency\": {");
-    }
-    put_title("95.0 pctile");
-    first_op = 1;
-    for (auto op = 0; op < MAX_OP; op++) {
-        if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-            if (data_points[op].empty() || !final_stats.get_latency_us_total(op)) {
-                put_field("N/A");
-                continue;
-            }
-            const auto num_points = data_points[op].size();
-            const auto point_95pct =
-                static_cast<size_t>(std::max(0., (num_points * 0.95) - 1));
-            put_field(data_points[op][point_95pct]);
-            if (fp) {
-                if (first_op) {
-                    first_op = 0;
-                } else {
-                    fmt::fprintf(fp, ",");
-                }
-                fmt::fprintf(fp, "\"%s\": %lu",
-                             get_ops_name(op), data_points[op][point_95pct]);
-            }
-        }
-    }
-    fmt::printf("\n");
+	/* 95%ile Latency */
+	if (fp) {
+		fmt::fprintf(fp, "}, \"p95Latency\": {");
+	}
+	put_title("95.0 pctile");
+	first_op = 1;
+	for (auto op = 0; op < MAX_OP; op++) {
+		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
+			if (data_points[op].empty() || !final_stats.get_latency_us_total(op)) {
+				put_field("N/A");
+				continue;
+			}
+			const auto num_points = data_points[op].size();
+			const auto point_95pct = static_cast<size_t>(std::max(0., (num_points * 0.95) - 1));
+			put_field(data_points[op][point_95pct]);
+			if (fp) {
+				if (first_op) {
+					first_op = 0;
+				} else {
+					fmt::fprintf(fp, ",");
+				}
+				fmt::fprintf(fp, "\"%s\": %lu", get_ops_name(op), data_points[op][point_95pct]);
+			}
+		}
+	}
+	fmt::printf("\n");
 
-    /* 99%ile Latency */
-    if (fp) {
-        fmt::fprintf(fp, "}, \"p99Latency\": {");
-    }
-    put_title("99.0 pctile");
-    first_op = 1;
-    for (auto op = 0; op < MAX_OP; op++) {
-        if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-            if (data_points[op].empty() || !final_stats.get_latency_us_total(op)) {
-                put_field("N/A");
-                continue;
-            }
-            const auto num_points = data_points[op].size();
-            const auto point_99pct =
-                static_cast<size_t>(std::max(0., (num_points * 0.99) - 1));
-            put_field(data_points[op][point_99pct]);
-            if (fp) {
-                if (first_op) {
-                    first_op = 0;
-                } else {
-                    fmt::fprintf(fp, ",");
-                }
-                fmt::fprintf(fp, "\"%s\": %lu",
-                             get_ops_name(op), data_points[op][point_99pct]);
-            }
-        }
-    }
-    fmt::print("\n");
+	/* 99%ile Latency */
+	if (fp) {
+		fmt::fprintf(fp, "}, \"p99Latency\": {");
+	}
+	put_title("99.0 pctile");
+	first_op = 1;
+	for (auto op = 0; op < MAX_OP; op++) {
+		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
+			if (data_points[op].empty() || !final_stats.get_latency_us_total(op)) {
+				put_field("N/A");
+				continue;
+			}
+			const auto num_points = data_points[op].size();
+			const auto point_99pct = static_cast<size_t>(std::max(0., (num_points * 0.99) - 1));
+			put_field(data_points[op][point_99pct]);
+			if (fp) {
+				if (first_op) {
+					first_op = 0;
+				} else {
+					fmt::fprintf(fp, ",");
+				}
+				fmt::fprintf(fp, "\"%s\": %lu", get_ops_name(op), data_points[op][point_99pct]);
+			}
+		}
+	}
+	fmt::print("\n");
 
-    /* 99.9%ile Latency */
-    if (fp) {
-        fmt::fprintf(fp, "}, \"p99.9Latency\": {");
-    }
-    put_title("99.9 pctile");
-    first_op = 1;
-    for (auto op = 0; op < MAX_OP; op++) {
-        if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-            if (data_points[op].empty() || !final_stats.get_latency_us_total(op)) {
-                put_field("N/A");
-                continue;
-            }
-            const auto num_points = data_points[op].size();
-            const auto point_99_9pct =
-                static_cast<size_t>(std::max(0., (num_points * 0.999) - 1));
-            put_field(data_points[op][point_99_9pct]);
-            if (fp) {
-                if (first_op) {
-                    first_op = 0;
-                } else {
-                    fmt::fprintf(fp, ",");
-                }
-                fmt::fprintf(fp, "\"%s\": %lu",
-                             get_ops_name(op), data_points[op][point_99_9pct]);
-            }
-        }
-    }
-    fmt::print("\n");
-    if (fp) {
-        fmt::fprintf(fp, "}}");
-    }
+	/* 99.9%ile Latency */
+	if (fp) {
+		fmt::fprintf(fp, "}, \"p99.9Latency\": {");
+	}
+	put_title("99.9 pctile");
+	first_op = 1;
+	for (auto op = 0; op < MAX_OP; op++) {
+		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
+			if (data_points[op].empty() || !final_stats.get_latency_us_total(op)) {
+				put_field("N/A");
+				continue;
+			}
+			const auto num_points = data_points[op].size();
+			const auto point_99_9pct = static_cast<size_t>(std::max(0., (num_points * 0.999) - 1));
+			put_field(data_points[op][point_99_9pct]);
+			if (fp) {
+				if (first_op) {
+					first_op = 0;
+				} else {
+					fmt::fprintf(fp, ",");
+				}
+				fmt::fprintf(fp, "\"%s\": %lu", get_ops_name(op), data_points[op][point_99_9pct]);
+			}
+		}
+	}
+	fmt::print("\n");
+	if (fp) {
+		fmt::fprintf(fp, "}}");
+	}
 
-    const auto command_remove = fmt::format("rm -rf {}{}", TEMP_DATA_STORE, pid_main);
-    system(command_remove.c_str());
+	const auto command_remove = fmt::format("rm -rf {}{}", TEMP_DATA_STORE, pid_main);
+	system(command_remove.c_str());
 }
 
 int stats_process_main(mako_args_t const& args,
@@ -2142,321 +2063,318 @@ int stats_process_main(mako_args_t const& args,
                        std::atomic<int>& signal,
                        std::atomic<int>& stopcount,
                        pid_t pid_main) {
-    bool first_stats = true;
+	bool first_stats = true;
 
-    /* wait until the signal turn on */
-    while (signal.load() == SIGNAL_OFF) {
-        usleep(10000); /* 10ms */
-    }
+	/* wait until the signal turn on */
+	while (signal.load() == SIGNAL_OFF) {
+		usleep(10000); /* 10ms */
+	}
 
-    if (args.verbose >= VERBOSE_DEFAULT)
-        print_stats_header(args, false, true, false);
+	if (args.verbose >= VERBOSE_DEFAULT)
+		print_stats_header(args, false, true, false);
 
-    FILE* fp = NULL;
-    if (args.json_output_path[0] != '\0') {
-        fp = fopen(args.json_output_path, "w");
-        fmt::fprintf(fp, "{\"makoArgs\": {");
-        fmt::fprintf(fp, "\"api_version\": %d,", args.api_version);
-        fmt::fprintf(fp, "\"json\": %d,", args.json);
-        fmt::fprintf(fp, "\"num_processes\": %d,", args.num_processes);
-        fmt::fprintf(fp, "\"num_threads\": %d,", args.num_threads);
-        fmt::fprintf(fp, "\"mode\": %d,", args.mode);
-        fmt::fprintf(fp, "\"rows\": %d,", args.rows);
-        fmt::fprintf(fp, "\"seconds\": %d,", args.seconds);
-        fmt::fprintf(fp, "\"iteration\": %d,", args.iteration);
-        fmt::fprintf(fp, "\"tpsmax\": %d,", args.tpsmax);
-        fmt::fprintf(fp, "\"tpsmin\": %d,", args.tpsmin);
-        fmt::fprintf(fp, "\"tpsinterval\": %d,", args.tpsinterval);
-        fmt::fprintf(fp, "\"tpschange\": %d,", args.tpschange);
-        fmt::fprintf(fp, "\"sampling\": %d,", args.sampling);
-        fmt::fprintf(fp, "\"key_length\": %d,", args.key_length);
-        fmt::fprintf(fp, "\"value_length\": %d,", args.value_length);
-        fmt::fprintf(fp, "\"commit_get\": %d,", args.commit_get);
-        fmt::fprintf(fp, "\"verbose\": %d,", args.verbose);
-        fmt::fprintf(fp, "\"cluster_files\": \"%s\",", args.cluster_files[0]);
-        fmt::fprintf(fp, "\"log_group\": \"%s\",", args.log_group);
-        fmt::fprintf(fp, "\"prefixpadding\": %d,", args.prefixpadding);
-        fmt::fprintf(fp, "\"trace\": %d,", args.trace);
-        fmt::fprintf(fp, "\"tracepath\": \"%s\",", args.tracepath);
-        fmt::fprintf(fp, "\"traceformat\": %d,", args.traceformat);
-        fmt::fprintf(fp, "\"knobs\": \"%s\",", args.knobs);
-        fmt::fprintf(fp, "\"flatbuffers\": %d,", args.flatbuffers);
-        fmt::fprintf(fp, "\"txntrace\": %d,", args.txntrace);
-        fmt::fprintf(fp, "\"txntagging\": %d,", args.txntagging);
-        fmt::fprintf(fp, "\"txntagging_prefix\": \"%s\",", args.txntagging_prefix);
-        fmt::fprintf(fp, "\"streaming_mode\": %d,", args.streaming_mode);
-        fmt::fprintf(fp, "\"disable_ryw\": %d,", args.disable_ryw);
-        fmt::fprintf(fp, "\"json_output_path\": \"%s\"", args.json_output_path);
-        fmt::fprintf(fp, "},\"samples\": [");
-    }
+	FILE* fp = NULL;
+	if (args.json_output_path[0] != '\0') {
+		fp = fopen(args.json_output_path, "w");
+		fmt::fprintf(fp, "{\"makoArgs\": {");
+		fmt::fprintf(fp, "\"api_version\": %d,", args.api_version);
+		fmt::fprintf(fp, "\"json\": %d,", args.json);
+		fmt::fprintf(fp, "\"num_processes\": %d,", args.num_processes);
+		fmt::fprintf(fp, "\"num_threads\": %d,", args.num_threads);
+		fmt::fprintf(fp, "\"mode\": %d,", args.mode);
+		fmt::fprintf(fp, "\"rows\": %d,", args.rows);
+		fmt::fprintf(fp, "\"seconds\": %d,", args.seconds);
+		fmt::fprintf(fp, "\"iteration\": %d,", args.iteration);
+		fmt::fprintf(fp, "\"tpsmax\": %d,", args.tpsmax);
+		fmt::fprintf(fp, "\"tpsmin\": %d,", args.tpsmin);
+		fmt::fprintf(fp, "\"tpsinterval\": %d,", args.tpsinterval);
+		fmt::fprintf(fp, "\"tpschange\": %d,", args.tpschange);
+		fmt::fprintf(fp, "\"sampling\": %d,", args.sampling);
+		fmt::fprintf(fp, "\"key_length\": %d,", args.key_length);
+		fmt::fprintf(fp, "\"value_length\": %d,", args.value_length);
+		fmt::fprintf(fp, "\"commit_get\": %d,", args.commit_get);
+		fmt::fprintf(fp, "\"verbose\": %d,", args.verbose);
+		fmt::fprintf(fp, "\"cluster_files\": \"%s\",", args.cluster_files[0]);
+		fmt::fprintf(fp, "\"log_group\": \"%s\",", args.log_group);
+		fmt::fprintf(fp, "\"prefixpadding\": %d,", args.prefixpadding);
+		fmt::fprintf(fp, "\"trace\": %d,", args.trace);
+		fmt::fprintf(fp, "\"tracepath\": \"%s\",", args.tracepath);
+		fmt::fprintf(fp, "\"traceformat\": %d,", args.traceformat);
+		fmt::fprintf(fp, "\"knobs\": \"%s\",", args.knobs);
+		fmt::fprintf(fp, "\"flatbuffers\": %d,", args.flatbuffers);
+		fmt::fprintf(fp, "\"txntrace\": %d,", args.txntrace);
+		fmt::fprintf(fp, "\"txntagging\": %d,", args.txntagging);
+		fmt::fprintf(fp, "\"txntagging_prefix\": \"%s\",", args.txntagging_prefix);
+		fmt::fprintf(fp, "\"streaming_mode\": %d,", args.streaming_mode);
+		fmt::fprintf(fp, "\"disable_ryw\": %d,", args.disable_ryw);
+		fmt::fprintf(fp, "\"json_output_path\": \"%s\"", args.json_output_path);
+		fmt::fprintf(fp, "},\"samples\": [");
+	}
 
-    const auto time_start = steady_clock::now();
-    auto time_prev = time_start;
-    while (signal.load() != SIGNAL_RED) {
-        usleep(100000); /* sleep for 100ms */
-        auto time_now = steady_clock::now();
+	const auto time_start = steady_clock::now();
+	auto time_prev = time_start;
+	while (signal.load() != SIGNAL_RED) {
+		usleep(100000); /* sleep for 100ms */
+		auto time_now = steady_clock::now();
 
-        /* print stats every (roughly) 1 sec */
-        if (to_double_seconds(time_now - time_prev) >= 1.0) {
+		/* print stats every (roughly) 1 sec */
+		if (to_double_seconds(time_now - time_prev) >= 1.0) {
 
-            /* adjust throttle rate if needed */
-            if (args.tpsmax != args.tpsmin) {
-                const auto tpsinterval = static_cast<double>(args.tpsinterval);
-                const auto tpsmin = static_cast<double>(args.tpsmin);
-                const auto tpsmax = static_cast<double>(args.tpsmax);
-                const auto pos = fmod(to_double_seconds(time_now - time_start), tpsinterval);
-                auto sin_factor = 0.;
-                /* set the throttle factor between 0.0 and 1.0 */
-                switch (args.tpschange) {
-                case TPS_SIN:
-                    sin_factor = sin(pos / tpsinterval * M_PI * 2.0) / 2.0 + 0.5;
-                    throttle_factor = 1 - (sin_factor * (1.0 - (tpsmin / tpsmax)));
-                    break;
-                case TPS_SQUARE:
-                    if (pos < (args.tpsinterval / 2)) {
-                        /* set to max */
-                        throttle_factor = 1.0;
-                    } else {
-                        /* set to min */
-                        throttle_factor = tpsmin / tpsmax;
-                    }
-                    break;
-                case TPS_PULSE:
-                    if (pos < (1.0 / tpsinterval)) {
-                        /* set to max */
-                        throttle_factor = 1.0;
-                    } else {
-                        /* set to min */
-                        throttle_factor = tpsmin / tpsmax;
-                    }
-                    break;
-                }
-            }
+			/* adjust throttle rate if needed */
+			if (args.tpsmax != args.tpsmin) {
+				const auto tpsinterval = static_cast<double>(args.tpsinterval);
+				const auto tpsmin = static_cast<double>(args.tpsmin);
+				const auto tpsmax = static_cast<double>(args.tpsmax);
+				const auto pos = fmod(to_double_seconds(time_now - time_start), tpsinterval);
+				auto sin_factor = 0.;
+				/* set the throttle factor between 0.0 and 1.0 */
+				switch (args.tpschange) {
+				case TPS_SIN:
+					sin_factor = sin(pos / tpsinterval * M_PI * 2.0) / 2.0 + 0.5;
+					throttle_factor = 1 - (sin_factor * (1.0 - (tpsmin / tpsmax)));
+					break;
+				case TPS_SQUARE:
+					if (pos < (args.tpsinterval / 2)) {
+						/* set to max */
+						throttle_factor = 1.0;
+					} else {
+						/* set to min */
+						throttle_factor = tpsmin / tpsmax;
+					}
+					break;
+				case TPS_PULSE:
+					if (pos < (1.0 / tpsinterval)) {
+						/* set to max */
+						throttle_factor = 1.0;
+					} else {
+						/* set to min */
+						throttle_factor = tpsmin / tpsmax;
+					}
+					break;
+				}
+			}
 
-            if (args.verbose >= VERBOSE_DEFAULT) {
-                if (first_stats) {
-                    first_stats = false;
-                } else {
-                    if (fp)
-                        fmt::fprintf(fp, ",");
-                }
-                print_stats(args, stats, to_double_seconds(time_now - time_prev), fp);
-            }
-            time_prev = time_now;
-        }
-    }
+			if (args.verbose >= VERBOSE_DEFAULT) {
+				if (first_stats) {
+					first_stats = false;
+				} else {
+					if (fp)
+						fmt::fprintf(fp, ",");
+				}
+				print_stats(args, stats, to_double_seconds(time_now - time_prev), fp);
+			}
+			time_prev = time_now;
+		}
+	}
 
-    if (fp) {
-        fmt::fprintf(fp, "],");
-    }
+	if (fp) {
+		fmt::fprintf(fp, "],");
+	}
 
-    /* print report */
-    if (args.verbose >= VERBOSE_DEFAULT) {
-        auto time_now = steady_clock::now();
-        while (stopcount.load() < args.num_threads * args.num_processes) {
-            usleep(10000); /* 10ms */
-        }
-        print_report(args, stats, to_double_seconds(time_now - time_start), pid_main, fp);
-    }
+	/* print report */
+	if (args.verbose >= VERBOSE_DEFAULT) {
+		auto time_now = steady_clock::now();
+		while (stopcount.load() < args.num_threads * args.num_processes) {
+			usleep(10000); /* 10ms */
+		}
+		print_report(args, stats, to_double_seconds(time_now - time_start), pid_main, fp);
+	}
 
-    if (fp) {
-        fmt::fprintf(fp, "}");
-        fclose(fp);
-    }
+	if (fp) {
+		fmt::fprintf(fp, "}");
+		fclose(fp);
+	}
 
-    return 0;
+	return 0;
 }
 
 int main(int argc, char* argv[]) {
-    setlinebuf(stdout);
+	setlinebuf(stdout);
 
-    auto rc = int{};
-    auto args = mako_args_t{};
-    rc = init_args(&args);
-    if (rc < 0) {
-        fmt::print(stderr, "ERROR: init_args failed\n");
-        return -1;
-    }
-    rc = parse_args(argc, argv, &args);
-    if (rc < 0) {
-        /* usage printed */
-        return 0;
-    }
+	auto rc = int{};
+	auto args = mako_args_t{};
+	rc = init_args(&args);
+	if (rc < 0) {
+		fmt::print(stderr, "ERROR: init_args failed\n");
+		return -1;
+	}
+	rc = parse_args(argc, argv, &args);
+	if (rc < 0) {
+		/* usage printed */
+		return 0;
+	}
 
-    rc = validate_args(&args);
-    if (rc < 0)
-        return -1;
+	rc = validate_args(&args);
+	if (rc < 0)
+		return -1;
 
-    if (args.mode == MODE_CLEAN) {
-        /* cleanup will be done from a single thread */
-        args.num_processes = 1;
-        args.num_threads = 1;
-    }
+	if (args.mode == MODE_CLEAN) {
+		/* cleanup will be done from a single thread */
+		args.num_processes = 1;
+		args.num_threads = 1;
+	}
 
-    if (args.mode == MODE_BUILD) {
-        if (args.txnspec.ops[OP_INSERT][OP_COUNT] == 0) {
-            parse_transaction(&args, "i100");
-        }
-    }
+	if (args.mode == MODE_BUILD) {
+		if (args.txnspec.ops[OP_INSERT][OP_COUNT] == 0) {
+			parse_transaction(&args, "i100");
+		}
+	}
 
-    const auto pid_main = getpid();
-    /* create the shared memory for stats */
-    const auto shmpath = fmt::format("mako{}", pid_main);
-    auto shmfd = shm_open(shmpath.c_str(), O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
-    if (shmfd < 0) {
-        fmt::print(stderr, "ERROR: shm_open failed\n");
-        return -1;
-    }
-    auto shmfd_guard = exit_guard([shmfd, &shmpath]() {
-            close(shmfd);
-            shm_unlink(shmpath.c_str());
-            unlink(shmpath.c_str());
-        });
+	const auto pid_main = getpid();
+	/* create the shared memory for stats */
+	const auto shmpath = fmt::format("mako{}", pid_main);
+	auto shmfd = shm_open(shmpath.c_str(), O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
+	if (shmfd < 0) {
+		fmt::print(stderr, "ERROR: shm_open failed\n");
+		return -1;
+	}
+	auto shmfd_guard = exit_guard([shmfd, &shmpath]() {
+		close(shmfd);
+		shm_unlink(shmpath.c_str());
+		unlink(shmpath.c_str());
+	});
 
-    /* allocate */
-    const auto shmsize = sizeof(mako_shmhdr_t) + (sizeof(mako_stats_t) * args.num_processes * args.num_threads);
-    auto shm = static_cast<mako_shmhdr_t*>(nullptr);
-    if (ftruncate(shmfd, shmsize) < 0) {
-        shm = static_cast<mako_shmhdr_t*>(MAP_FAILED);
-        fmt::print(stderr, "ERROR: ftruncate (fd:{} size:{}) failed\n", shmfd, shmsize);
-        return -1;
-    }
+	/* allocate */
+	const auto shmsize = sizeof(mako_shmhdr_t) + (sizeof(mako_stats_t) * args.num_processes * args.num_threads);
+	auto shm = static_cast<mako_shmhdr_t*>(nullptr);
+	if (ftruncate(shmfd, shmsize) < 0) {
+		shm = static_cast<mako_shmhdr_t*>(MAP_FAILED);
+		fmt::print(stderr, "ERROR: ftruncate (fd:{} size:{}) failed\n", shmfd, shmsize);
+		return -1;
+	}
 
-    /* map it */
-    shm = static_cast<mako_shmhdr_t*>(
-            mmap(NULL, shmsize, PROT_READ | PROT_WRITE, MAP_SHARED, shmfd, 0));
-    if (shm == MAP_FAILED) {
-        fmt::print(stderr, "ERROR: mmap (fd:{} size:{}) failed\n", shmfd, shmsize);
-        return -1;
-    }
-    auto munmap_guard = exit_guard([=]() { munmap(shm, shmsize); });
+	/* map it */
+	shm = static_cast<mako_shmhdr_t*>(mmap(NULL, shmsize, PROT_READ | PROT_WRITE, MAP_SHARED, shmfd, 0));
+	if (shm == MAP_FAILED) {
+		fmt::print(stderr, "ERROR: mmap (fd:{} size:{}) failed\n", shmfd, shmsize);
+		return -1;
+	}
+	auto munmap_guard = exit_guard([=]() { munmap(shm, shmsize); });
 
-    static_assert(std::is_same_v<decltype(shm), mako_shmhdr_t*>);
-    auto stats = reinterpret_cast<mako_stats_t*>(shm + 1);
+	static_assert(std::is_same_v<decltype(shm), mako_shmhdr_t*>);
+	auto stats = reinterpret_cast<mako_stats_t*>(shm + 1);
 
-    /* initialize the shared memory */
-    memset(shm, 0, shmsize);
+	/* initialize the shared memory */
+	memset(shm, 0, shmsize);
 
-    /* get ready */
-    shm->signal = SIGNAL_OFF;
-    shm->readycount = 0;
-    shm->stopcount = 0;
-    shm->throttle_factor = 1.0;
+	/* get ready */
+	shm->signal = SIGNAL_OFF;
+	shm->readycount = 0;
+	shm->stopcount = 0;
+	shm->throttle_factor = 1.0;
 
-    auto proc_type = proc_master;
-    /* fork worker processes + 1 stats process */
-    auto worker_pids = std::vector<pid_t>(args.num_processes + 1);
+	auto proc_type = proc_master;
+	/* fork worker processes + 1 stats process */
+	auto worker_pids = std::vector<pid_t>(args.num_processes + 1);
 
-    auto worker_id = int{};
+	auto worker_id = int{};
 
-    /* forking (num_process + 1) children */
-    /* last process is the stats handler */
-    for (auto p = 0; p < args.num_processes + 1; p++) {
-        auto pid = fork();
-        if (pid != 0) {
-            /* master */
-            worker_pids[p] = pid;
-            if (args.verbose == VERBOSE_DEBUG) {
-                printf("DEBUG: worker %d (PID:%d) forked\n", p, worker_pids[p]);
-            }
-        } else {
-            if (p < args.num_processes) {
-                /* worker process */
-                proc_type = proc_worker;
-                worker_id = p;
-            } else {
-                /* stats */
-                proc_type = proc_stats;
-            }
-            break;
-        }
-    }
+	/* forking (num_process + 1) children */
+	/* last process is the stats handler */
+	for (auto p = 0; p < args.num_processes + 1; p++) {
+		auto pid = fork();
+		if (pid != 0) {
+			/* master */
+			worker_pids[p] = pid;
+			if (args.verbose == VERBOSE_DEBUG) {
+				printf("DEBUG: worker %d (PID:%d) forked\n", p, worker_pids[p]);
+			}
+		} else {
+			if (p < args.num_processes) {
+				/* worker process */
+				proc_type = proc_worker;
+				worker_id = p;
+			} else {
+				/* stats */
+				proc_type = proc_stats;
+			}
+			break;
+		}
+	}
 
-    /* initialize the randomizer */
-    srand(time(0) * getpid());
+	/* initialize the randomizer */
+	srand(time(0) * getpid());
 
-    /* initialize zipfian if necessary (per-process) */
-    if (args.zipf) {
-        zipfian_generator(args.rows);
-    }
+	/* initialize zipfian if necessary (per-process) */
+	if (args.zipf) {
+		zipfian_generator(args.rows);
+	}
 
-    if (proc_type == proc_worker) {
-        /* worker process */
-        worker_process_main(args, worker_id, shm, pid_main);
-        /* worker can exit here */
-        exit(0);
-    } else if (proc_type == proc_stats) {
-        /* stats */
-        if (args.mode == MODE_CLEAN) {
-            /* no stats needed for clean mode */
-            exit(0);
-        }
-        stats_process_main(args, stats, shm->throttle_factor, shm->signal, shm->stopcount, pid_main);
-        exit(0);
-    }
+	if (proc_type == proc_worker) {
+		/* worker process */
+		worker_process_main(args, worker_id, shm, pid_main);
+		/* worker can exit here */
+		exit(0);
+	} else if (proc_type == proc_stats) {
+		/* stats */
+		if (args.mode == MODE_CLEAN) {
+			/* no stats needed for clean mode */
+			exit(0);
+		}
+		stats_process_main(args, stats, shm->throttle_factor, shm->signal, shm->stopcount, pid_main);
+		exit(0);
+	}
 
-    /* master */
-    /* wait for everyone to be ready */
-    while (shm->readycount < (args.num_processes * args.num_threads)) {
-        usleep(1000);
-    }
-    shm->signal = SIGNAL_GREEN;
+	/* master */
+	/* wait for everyone to be ready */
+	while (shm->readycount < (args.num_processes * args.num_threads)) {
+		usleep(1000);
+	}
+	shm->signal = SIGNAL_GREEN;
 
-    if (args.mode == MODE_RUN) {
-        /* run the benchmark */
+	if (args.mode == MODE_RUN) {
+		/* run the benchmark */
 
-        /* if seconds is specified, stop child processes after the specified
-         * duration */
-        if (args.seconds > 0) {
-            if (args.verbose == VERBOSE_DEBUG) {
-                printf("DEBUG: master sleeping for %d seconds\n", args.seconds);
-            }
+		/* if seconds is specified, stop child processes after the specified
+		 * duration */
+		if (args.seconds > 0) {
+			if (args.verbose == VERBOSE_DEBUG) {
+				printf("DEBUG: master sleeping for %d seconds\n", args.seconds);
+			}
 
-            auto time_start = steady_clock::now();
-            while (1) {
-                usleep(100000); /* sleep for 100ms */
-                auto time_now = steady_clock::now();
-                /* doesn't have to be precise */
-                if (to_double_seconds(time_now - time_start) > args.seconds) {
-                    if (args.verbose == VERBOSE_DEBUG) {
-                        printf("DEBUG: time's up (%d seconds)\n", args.seconds);
-                    }
-                    break;
-                }
-            }
+			auto time_start = steady_clock::now();
+			while (1) {
+				usleep(100000); /* sleep for 100ms */
+				auto time_now = steady_clock::now();
+				/* doesn't have to be precise */
+				if (to_double_seconds(time_now - time_start) > args.seconds) {
+					if (args.verbose == VERBOSE_DEBUG) {
+						printf("DEBUG: time's up (%d seconds)\n", args.seconds);
+					}
+					break;
+				}
+			}
 
-            /* notify everyone the time's up */
-            shm->signal = SIGNAL_RED;
-        }
-    }
+			/* notify everyone the time's up */
+			shm->signal = SIGNAL_RED;
+		}
+	}
 
-    auto status = int{};
-    /* wait for worker processes to exit */
-    for (auto p = 0; p < args.num_processes; p++) {
-        if (args.verbose == VERBOSE_DEBUG) {
-            fmt::print("DEBUG: waiting worker {} (PID:{}) to exit\n", p, worker_pids[p]);
-        }
-        auto pid = waitpid(worker_pids[p], &status, 0 /* or what? */);
-        if (pid < 0) {
-            fmt::print(stderr, "ERROR: waitpid failed for worker process PID {}\n",
-                       worker_pids[p]);
-        }
-        if (args.verbose == VERBOSE_DEBUG) {
-            fmt::print("DEBUG: worker {} (PID:{}) exited\n", p, worker_pids[p]);
-        }
-    }
+	auto status = int{};
+	/* wait for worker processes to exit */
+	for (auto p = 0; p < args.num_processes; p++) {
+		if (args.verbose == VERBOSE_DEBUG) {
+			fmt::print("DEBUG: waiting worker {} (PID:{}) to exit\n", p, worker_pids[p]);
+		}
+		auto pid = waitpid(worker_pids[p], &status, 0 /* or what? */);
+		if (pid < 0) {
+			fmt::print(stderr, "ERROR: waitpid failed for worker process PID {}\n", worker_pids[p]);
+		}
+		if (args.verbose == VERBOSE_DEBUG) {
+			fmt::print("DEBUG: worker {} (PID:{}) exited\n", p, worker_pids[p]);
+		}
+	}
 
-    /* all worker threads finished, stop the stats */
-    if (args.mode == MODE_BUILD || args.iteration > 0) {
-        shm->signal = SIGNAL_RED;
-    }
+	/* all worker threads finished, stop the stats */
+	if (args.mode == MODE_BUILD || args.iteration > 0) {
+		shm->signal = SIGNAL_RED;
+	}
 
-    /* wait for stats to stop */
-    auto pid = waitpid(worker_pids[args.num_processes], &status, 0 /* or what? */);
-    if (pid < 0) {
-        fmt::print(stderr, "ERROR: waitpid failed for stats process PID {}\n",
-                   worker_pids[args.num_processes]);
-    }
+	/* wait for stats to stop */
+	auto pid = waitpid(worker_pids[args.num_processes], &status, 0 /* or what? */);
+	if (pid < 0) {
+		fmt::print(stderr, "ERROR: waitpid failed for stats process PID {}\n", worker_pids[args.num_processes]);
+	}
 
-    return 0;
+	return 0;
 }
diff --git a/bindings/c/test/mako/mako.hpp b/bindings/c/test/mako/mako.hpp
index d539b6e1a9..c857949925 100644
--- a/bindings/c/test/mako/mako.hpp
+++ b/bindings/c/test/mako/mako.hpp
@@ -23,71 +23,71 @@
 #include <limits.h>
 #endif
 
-constexpr const int VERBOSE_NONE     = 0;
-constexpr const int VERBOSE_DEFAULT  = 1;
+constexpr const int VERBOSE_NONE = 0;
+constexpr const int VERBOSE_DEFAULT = 1;
 constexpr const int VERBOSE_ANNOYING = 2;
-constexpr const int VERBOSE_DEBUG    = 3;
+constexpr const int VERBOSE_DEBUG = 3;
 
 constexpr const int MODE_INVALID = -1;
-constexpr const int MODE_CLEAN   = 0;
-constexpr const int MODE_BUILD   = 1;
-constexpr const int MODE_RUN     = 2;
+constexpr const int MODE_CLEAN = 0;
+constexpr const int MODE_BUILD = 1;
+constexpr const int MODE_RUN = 2;
 
 /* size of each block to get detailed latency for each operation */
 constexpr const size_t LAT_BLOCK_SIZE = 511;
 
 /* transaction specification */
 enum Operations {
-    OP_GETREADVERSION,
-    OP_GET,
-    OP_GETRANGE,
-    OP_SGET,
-    OP_SGETRANGE,
-    OP_UPDATE,
-    OP_INSERT,
-    OP_INSERTRANGE,
-    OP_OVERWRITE,
-    OP_CLEAR,
-    OP_SETCLEAR,
-    OP_CLEARRANGE,
-    OP_SETCLEARRANGE,
-    OP_COMMIT,
-    OP_TRANSACTION, /* pseudo-operation - cumulative time for the operation + commit */
-    OP_READ_BG,
-    MAX_OP /* must be the last item */
+	OP_GETREADVERSION,
+	OP_GET,
+	OP_GETRANGE,
+	OP_SGET,
+	OP_SGETRANGE,
+	OP_UPDATE,
+	OP_INSERT,
+	OP_INSERTRANGE,
+	OP_OVERWRITE,
+	OP_CLEAR,
+	OP_SETCLEAR,
+	OP_CLEARRANGE,
+	OP_SETCLEARRANGE,
+	OP_COMMIT,
+	OP_TRANSACTION, /* pseudo-operation - cumulative time for the operation + commit */
+	OP_READ_BG,
+	MAX_OP /* must be the last item */
 };
 
-constexpr const int OP_COUNT   = 0;
-constexpr const int OP_RANGE   = 1;
+constexpr const int OP_COUNT = 0;
+constexpr const int OP_RANGE = 1;
 constexpr const int OP_REVERSE = 2;
 
 /* for long arguments */
 enum Arguments {
-    ARG_KEYLEN,
-    ARG_VALLEN,
-    ARG_TPS,
-    ARG_COMMITGET,
-    ARG_SAMPLING,
-    ARG_VERSION,
-    ARG_KNOBS,
-    ARG_FLATBUFFERS,
-    ARG_LOGGROUP,
-    ARG_PREFIXPADDING,
-    ARG_TRACE,
-    ARG_TRACEPATH,
-    ARG_TRACEFORMAT,
-    ARG_TPSMAX,
-    ARG_TPSMIN,
-    ARG_TPSINTERVAL,
-    ARG_TPSCHANGE,
-    ARG_TXNTRACE,
-    ARG_TXNTAGGING,
-    ARG_TXNTAGGINGPREFIX,
-    ARG_STREAMING_MODE,
-    ARG_DISABLE_RYW,
-    ARG_CLIENT_THREADS_PER_VERSION,
-    ARG_JSON_REPORT,
-    ARG_BG_FILE_PATH // if blob granule files are stored locally, mako will read and materialize them if this is set
+	ARG_KEYLEN,
+	ARG_VALLEN,
+	ARG_TPS,
+	ARG_COMMITGET,
+	ARG_SAMPLING,
+	ARG_VERSION,
+	ARG_KNOBS,
+	ARG_FLATBUFFERS,
+	ARG_LOGGROUP,
+	ARG_PREFIXPADDING,
+	ARG_TRACE,
+	ARG_TRACEPATH,
+	ARG_TRACEFORMAT,
+	ARG_TPSMAX,
+	ARG_TPSMIN,
+	ARG_TPSINTERVAL,
+	ARG_TPSCHANGE,
+	ARG_TXNTRACE,
+	ARG_TXNTAGGING,
+	ARG_TXNTAGGINGPREFIX,
+	ARG_STREAMING_MODE,
+	ARG_DISABLE_RYW,
+	ARG_CLIENT_THREADS_PER_VERSION,
+	ARG_JSON_REPORT,
+	ARG_BG_FILE_PATH // if blob granule files are stored locally, mako will read and materialize them if this is set
 };
 
 enum TPSChangeTypes { TPS_SIN, TPS_SQUARE, TPS_PULSE };
@@ -97,58 +97,58 @@ enum TPSChangeTypes { TPS_SIN, TPS_SQUARE, TPS_PULSE };
  */
 
 typedef struct {
-    /* for each operation, it stores "count", "range" and "reverse" */
-    int ops[MAX_OP][3];
+	/* for each operation, it stores "count", "range" and "reverse" */
+	int ops[MAX_OP][3];
 } mako_txnspec_t;
 
-constexpr const int LOGGROUP_MAX        = 256;
-constexpr const int KNOB_MAX            = 256;
+constexpr const int LOGGROUP_MAX = 256;
+constexpr const int KNOB_MAX = 256;
 constexpr const int TAGPREFIXLENGTH_MAX = 8;
-constexpr const int NUM_CLUSTERS_MAX    = 3;
-constexpr const int NUM_DATABASES_MAX   = 10;
-constexpr const int MAX_BG_IDS          = 1000;
+constexpr const int NUM_CLUSTERS_MAX = 3;
+constexpr const int NUM_DATABASES_MAX = 10;
+constexpr const int MAX_BG_IDS = 1000;
 
 /* benchmark parameters */
 struct mako_args_t {
-    int api_version;
-    int json;
-    int num_processes;
-    int num_threads;
-    int mode;
-    int rows; /* is 2 billion enough? */
-    int row_digits;
-    int seconds;
-    int iteration;
-    int tpsmax;
-    int tpsmin;
-    int tpsinterval;
-    int tpschange;
-    int sampling;
-    int key_length;
-    int value_length;
-    int zipf;
-    int commit_get;
-    int verbose;
-    mako_txnspec_t txnspec;
-    char cluster_files[NUM_CLUSTERS_MAX][PATH_MAX];
-    int num_fdb_clusters;
-    int num_databases;
-    char log_group[LOGGROUP_MAX];
-    int prefixpadding;
-    int trace;
-    char tracepath[PATH_MAX];
-    int traceformat; /* 0 - XML, 1 - JSON */
-    char knobs[KNOB_MAX];
-    uint8_t flatbuffers;
-    int txntrace;
-    int txntagging;
-    char txntagging_prefix[TAGPREFIXLENGTH_MAX];
-    FDBStreamingMode streaming_mode;
-    int64_t client_threads_per_version;
-    int disable_ryw;
-    char json_output_path[PATH_MAX];
-    bool bg_materialize_files;
-    char bg_file_path[PATH_MAX];
+	int api_version;
+	int json;
+	int num_processes;
+	int num_threads;
+	int mode;
+	int rows; /* is 2 billion enough? */
+	int row_digits;
+	int seconds;
+	int iteration;
+	int tpsmax;
+	int tpsmin;
+	int tpsinterval;
+	int tpschange;
+	int sampling;
+	int key_length;
+	int value_length;
+	int zipf;
+	int commit_get;
+	int verbose;
+	mako_txnspec_t txnspec;
+	char cluster_files[NUM_CLUSTERS_MAX][PATH_MAX];
+	int num_fdb_clusters;
+	int num_databases;
+	char log_group[LOGGROUP_MAX];
+	int prefixpadding;
+	int trace;
+	char tracepath[PATH_MAX];
+	int traceformat; /* 0 - XML, 1 - JSON */
+	char knobs[KNOB_MAX];
+	uint8_t flatbuffers;
+	int txntrace;
+	int txntagging;
+	char txntagging_prefix[TAGPREFIXLENGTH_MAX];
+	FDBStreamingMode streaming_mode;
+	int64_t client_threads_per_version;
+	int disable_ryw;
+	char json_output_path[PATH_MAX];
+	bool bg_materialize_files;
+	char bg_file_path[PATH_MAX];
 };
 
 /* shared memory */
@@ -157,155 +157,140 @@ constexpr const int SIGNAL_GREEN = 1;
 constexpr const int SIGNAL_OFF = 2;
 
 struct mako_shmhdr_t {
-    std::atomic<int> signal;
-    std::atomic<int> readycount;
-    std::atomic<double> throttle_factor;
-    std::atomic<int> stopcount;
+	std::atomic<int> signal;
+	std::atomic<int> readycount;
+	std::atomic<double> throttle_factor;
+	std::atomic<int> stopcount;
 };
 
 class alignas(64) mako_stats_t {
-    uint64_t xacts;
-    uint64_t conflicts;
-    uint64_t total_errors;
-    uint64_t ops[MAX_OP];
-    uint64_t errors[MAX_OP];
-    uint64_t latency_samples[MAX_OP];
-    uint64_t latency_us_total[MAX_OP];
-    uint64_t latency_us_min[MAX_OP];
-    uint64_t latency_us_max[MAX_OP];
+	uint64_t xacts;
+	uint64_t conflicts;
+	uint64_t total_errors;
+	uint64_t ops[MAX_OP];
+	uint64_t errors[MAX_OP];
+	uint64_t latency_samples[MAX_OP];
+	uint64_t latency_us_total[MAX_OP];
+	uint64_t latency_us_min[MAX_OP];
+	uint64_t latency_us_max[MAX_OP];
+
 public:
-    mako_stats_t() noexcept {
-        memset(this, 0, sizeof(mako_stats_t));
-        memset(latency_us_max, 0xff, sizeof(latency_us_max));
-    }
+	mako_stats_t() noexcept {
+		memset(this, 0, sizeof(mako_stats_t));
+		memset(latency_us_max, 0xff, sizeof(latency_us_max));
+	}
 
-    mako_stats_t(const mako_stats_t& other) noexcept = default;
-    mako_stats_t& operator=(const mako_stats_t& other) noexcept = default;
+	mako_stats_t(const mako_stats_t& other) noexcept = default;
+	mako_stats_t& operator=(const mako_stats_t& other) noexcept = default;
 
-    uint64_t get_tx_count() const noexcept {
-        return xacts;
-    }
+	uint64_t get_tx_count() const noexcept { return xacts; }
 
-    uint64_t get_conflict_count() const noexcept {
-        return conflicts;
-    }
+	uint64_t get_conflict_count() const noexcept { return conflicts; }
 
-    uint64_t get_op_count(int op) const noexcept {
-        return ops[op];
-    }
+	uint64_t get_op_count(int op) const noexcept { return ops[op]; }
 
-    uint64_t get_error_count(int op) const noexcept {
-        return errors[op];
-    }
+	uint64_t get_error_count(int op) const noexcept { return errors[op]; }
 
-    uint64_t get_total_error_count() const noexcept {
-        return total_errors;
-    }
+	uint64_t get_total_error_count() const noexcept { return total_errors; }
 
-    uint64_t get_latency_sample_count(int op) const noexcept {
-        return latency_samples[op];
-    }
+	uint64_t get_latency_sample_count(int op) const noexcept { return latency_samples[op]; }
 
-    uint64_t get_latency_us_total(int op) const noexcept {
-        return latency_us_total[op];
-    }
+	uint64_t get_latency_us_total(int op) const noexcept { return latency_us_total[op]; }
 
-    uint64_t get_latency_us_min(int op) const noexcept {
-        return latency_us_min[op];
-    }
+	uint64_t get_latency_us_min(int op) const noexcept { return latency_us_min[op]; }
 
-    uint64_t get_latency_us_max(int op) const noexcept {
-        return latency_us_max[op];
-    }
+	uint64_t get_latency_us_max(int op) const noexcept { return latency_us_max[op]; }
 
-    // with 'this' as final aggregation, factor in 'other'
-    void combine(const mako_stats_t& other) {
-        xacts += other.xacts;
-        conflicts += other.conflicts;
-        for (auto op = 0; op < MAX_OP; op++) {
-            ops[op] += other.ops[op];
-            errors[op] += other.errors[op];
-            total_errors += other.errors[op];
-            latency_samples[op] += other.latency_samples[op];
-            latency_us_total[op] += other.latency_us_total[op];
-            if (latency_us_min[op] > other.latency_us_min[op])
-                latency_us_min[op] = other.latency_us_min[op];
-            if (latency_us_min[op] < other.latency_us_min[op])
-                latency_us_max[op] = other.latency_us_max[op];
-        }
-    }
+	// with 'this' as final aggregation, factor in 'other'
+	void combine(const mako_stats_t& other) {
+		xacts += other.xacts;
+		conflicts += other.conflicts;
+		for (auto op = 0; op < MAX_OP; op++) {
+			ops[op] += other.ops[op];
+			errors[op] += other.errors[op];
+			total_errors += other.errors[op];
+			latency_samples[op] += other.latency_samples[op];
+			latency_us_total[op] += other.latency_us_total[op];
+			if (latency_us_min[op] > other.latency_us_min[op])
+				latency_us_min[op] = other.latency_us_min[op];
+			if (latency_us_min[op] < other.latency_us_min[op])
+				latency_us_max[op] = other.latency_us_max[op];
+		}
+	}
 
-    void incr_tx_count() noexcept { xacts++; }
-    void incr_conflict_count() noexcept { conflicts++; }
+	void incr_tx_count() noexcept { xacts++; }
+	void incr_conflict_count() noexcept { conflicts++; }
 
-    // non-commit write operations aren't measured for time.
-    void incr_count_immediate(int op) noexcept { ops[op]++; }
+	// non-commit write operations aren't measured for time.
+	void incr_count_immediate(int op) noexcept { ops[op]++; }
 
-    void incr_error_count(int op) noexcept {
-        total_errors++;
-        errors[op]++;
-    }
+	void incr_error_count(int op) noexcept {
+		total_errors++;
+		errors[op]++;
+	}
 
-    void add_latency(int op, uint64_t latency_us) noexcept {
-        latency_samples[op]++;
-        latency_us_total[op] += latency_us;
-        if (latency_us_min[op] > latency_us)
-            latency_us_min[op] = latency_us;
-        if (latency_us_max[op] < latency_us)
-            latency_us_max[op] = latency_us;
-        ops[op]++;
-    }
+	void add_latency(int op, uint64_t latency_us) noexcept {
+		latency_samples[op]++;
+		latency_us_total[op] += latency_us;
+		if (latency_us_min[op] > latency_us)
+			latency_us_min[op] = latency_us;
+		if (latency_us_max[op] < latency_us)
+			latency_us_max[op] = latency_us;
+		ops[op]++;
+	}
 };
 
 /* per-process information */
 typedef struct {
-    int worker_id;
-    pid_t parent_id;
-    mako_args_t* args;
-    mako_shmhdr_t* shm;
-    std::vector<fdb::Database> databases;
+	int worker_id;
+	pid_t parent_id;
+	mako_args_t* args;
+	mako_shmhdr_t* shm;
+	std::vector<fdb::Database> databases;
 } process_info_t;
 
 /* memory block allocated to each operation when collecting detailed latency */
 class lat_block_t {
-	uint64_t samples[LAT_BLOCK_SIZE]{0, };
-    uint32_t index{0};
+	uint64_t samples[LAT_BLOCK_SIZE]{
+		0,
+	};
+	uint32_t index{ 0 };
+
 public:
-    lat_block_t() noexcept = default;
-    bool full() const noexcept { return index >= LAT_BLOCK_SIZE; }
-    void put(uint64_t point) {
-        assert(!full());
-        samples[index++] = point;
-    }
-    // return {data block, number of samples}
-    std::pair<uint64_t const*, size_t> data() const noexcept {
-        return {samples, index};
-    }
+	lat_block_t() noexcept = default;
+	bool full() const noexcept { return index >= LAT_BLOCK_SIZE; }
+	void put(uint64_t point) {
+		assert(!full());
+		samples[index++] = point;
+	}
+	// return {data block, number of samples}
+	std::pair<uint64_t const*, size_t> data() const noexcept { return { samples, index }; }
 };
 
 /* collect sampled latencies */
 class sample_bin {
-    std::list<lat_block_t> blocks;
+	std::list<lat_block_t> blocks;
+
 public:
-    void reserve_one() {
-        if (blocks.empty())
-            blocks.emplace_back();
-    }
+	void reserve_one() {
+		if (blocks.empty())
+			blocks.emplace_back();
+	}
 
-    void put(uint64_t latency_us) {
-        if (blocks.empty() || blocks.back().full())
-            blocks.emplace_back();
-        blocks.back().put(latency_us);
-    }
+	void put(uint64_t latency_us) {
+		if (blocks.empty() || blocks.back().full())
+			blocks.emplace_back();
+		blocks.back().put(latency_us);
+	}
 
-    // iterate & apply for each block user function void(uint64_t const*, size_t)
-    template <typename Func>
-    void for_each_block(Func&& fn) const {
-        for (const auto& block : blocks) {
-            auto [ptr, cnt] = block.data();
-            fn(ptr, cnt);
-        }
-    }
+	// iterate & apply for each block user function void(uint64_t const*, size_t)
+	template <typename Func>
+	void for_each_block(Func&& fn) const {
+		for (const auto& block : blocks) {
+			auto [ptr, cnt] = block.data();
+			fn(ptr, cnt);
+		}
+	}
 };
 
 using sample_bin_array_t = std::array<sample_bin, MAX_OP>;
@@ -313,7 +298,7 @@ using sample_bin_array_t = std::array<sample_bin, MAX_OP>;
 struct alignas(64) thread_args_t {
 	int thread_id;
 	int database_index; // index of the database to do work to
-    sample_bin_array_t sample_bins;
+	sample_bin_array_t sample_bins;
 	process_info_t* process;
 };
 
@@ -322,38 +307,32 @@ typedef enum { proc_master = 0, proc_worker, proc_stats } proc_type_t;
 
 // determines how resultant future will be handled
 enum class StepKind {
-    NONE,    ///< not part of the table: OP_TRANSACTION, OP_COMMIT
-    IMM,     ///< non-future ops that return immediately: e.g. set, clear_range
-    READ,    ///< blockable reads: get(), get_range(), get_read_version, ...
-    COMMIT,  ///< self-explanatory
-    ON_ERROR ///< future is a result of tx.on_error()
+	NONE, ///< not part of the table: OP_TRANSACTION, OP_COMMIT
+	IMM, ///< non-future ops that return immediately: e.g. set, clear_range
+	READ, ///< blockable reads: get(), get_range(), get_read_version, ...
+	COMMIT, ///< self-explanatory
+	ON_ERROR ///< future is a result of tx.on_error()
 };
 
 class OpDesc {
-    std::string_view name_;
-    std::vector<StepKind> steps_;
-    bool needs_commit_;
-public:
-    OpDesc(std::string_view name, std::vector<StepKind>&& steps, bool needs_commit) :
-        name_(name), steps_(std::move(steps)), needs_commit_(needs_commit)
-    {}
+	std::string_view name_;
+	std::vector<StepKind> steps_;
+	bool needs_commit_;
 
-    std::string_view name() const noexcept {
-        return name_;
-    }
-    // what 
-    StepKind step_kind(int step) const noexcept {
-        assert(step < steps());
-        return steps_[step];
-    }
-    // how many steps in this op?
-    int steps() const noexcept {
-        return static_cast<int>(steps_.size());
-    }
-    // does the op needs to commit some time after its final step?
-    bool needs_commit() const noexcept {
-        return needs_commit_;
-    }
+public:
+	OpDesc(std::string_view name, std::vector<StepKind>&& steps, bool needs_commit)
+	  : name_(name), steps_(std::move(steps)), needs_commit_(needs_commit) {}
+
+	std::string_view name() const noexcept { return name_; }
+	// what
+	StepKind step_kind(int step) const noexcept {
+		assert(step < steps());
+		return steps_[step];
+	}
+	// how many steps in this op?
+	int steps() const noexcept { return static_cast<int>(steps_.size()); }
+	// does the op needs to commit some time after its final step?
+	bool needs_commit() const noexcept { return needs_commit_; }
 };
 
 #endif /* MAKO_HPP */
diff --git a/bindings/c/test/mako/utils.hpp b/bindings/c/test/mako/utils.hpp
index 49beaeed7a..d8cafb996d 100644
--- a/bindings/c/test/mako/utils.hpp
+++ b/bindings/c/test/mako/utils.hpp
@@ -13,24 +13,24 @@
 int urand(int low, int high);
 
 /* random string */
-template <bool Clear=true, typename Char>
+template <bool Clear = true, typename Char>
 void randstr(std::basic_string<Char>& str, int len) {
-    if constexpr (Clear)
-        str.clear();
-    assert(len >= 0);
-    str.reserve(str.size() + static_cast<size_t>(len));
+	if constexpr (Clear)
+		str.clear();
+	assert(len >= 0);
+	str.reserve(str.size() + static_cast<size_t>(len));
 	for (auto i = 0; i < len; i++) {
 		str.push_back('!' + urand(0, 'z' - '!')); /* generage a char from '!' to 'z' */
 	}
 }
 
 /* random numeric string */
-template <bool Clear=true, typename Char>
+template <bool Clear = true, typename Char>
 void randnumstr(std::basic_string<Char>& str, int len) {
-    if constexpr (Clear)
-        str.clear();
-    assert(len >= 0);
-    str.reserve(str.size() + static_cast<size_t>(len));
+	if constexpr (Clear)
+		str.clear();
+	assert(len >= 0);
+	str.reserve(str.size() + static_cast<size_t>(len));
 	for (auto i = 0; i < len; i++) {
 		str.push_back('0' + urand(0, 9)); /* generage a char from '0' to '9' */
 	}
@@ -67,66 +67,63 @@ int digits(int num);
 /* fill (str) with configured key prefix: i.e. non-numeric part
  * (str) is appended with concat([padding], PREFIX)
  */
-template <bool Clear=true, typename Char>
-void genkeyprefix(std::basic_string<Char>& str,
-                  std::string_view prefix,
-                  mako_args_t const& args) {
-    // concat('x' * padding_len, key_prefix)
-    if constexpr (Clear)
-        str.clear();
-    const auto padding_len = args.prefixpadding ?
-        (args.key_length - args.row_digits - static_cast<int>(prefix.size())) : 0;
-    assert(padding_len >= 0);
-    str.reserve(str.size() + padding_len + prefix.size());
-    fmt::format_to(std::back_inserter(str),
-                   "{0:x>{1}}{2}", "", padding_len, prefix);
+template <bool Clear = true, typename Char>
+void genkeyprefix(std::basic_string<Char>& str, std::string_view prefix, mako_args_t const& args) {
+	// concat('x' * padding_len, key_prefix)
+	if constexpr (Clear)
+		str.clear();
+	const auto padding_len =
+	    args.prefixpadding ? (args.key_length - args.row_digits - static_cast<int>(prefix.size())) : 0;
+	assert(padding_len >= 0);
+	str.reserve(str.size() + padding_len + prefix.size());
+	fmt::format_to(std::back_inserter(str), "{0:x>{1}}{2}", "", padding_len, prefix);
 }
 
 /* generate a key for a given key number */
 /* prefix is "mako" by default, prefixpadding = 1 means 'x' will be in front rather than trailing the keyname */
-template <bool Clear=true, typename Char>
-void genkey(std::basic_string<Char>& str,
-            std::string_view prefix,
-            mako_args_t const& args, int num) {
-    static_assert(sizeof(Char) == 1);
-	const auto pad_len = args.prefixpadding ?
-                         args.key_length - (static_cast<int>(prefix.size()) + args.row_digits) : 0;
-    assert(pad_len >= 0);
-    if constexpr (Clear)
-        str.clear();
-    str.reserve(str.size() + static_cast<size_t>(args.key_length));
-    fmt::format_to(std::back_inserter(str),
-                   "{0:x>{1}}{2}{3:0{4}d}{5:x>{6}}",
-                   "", pad_len,
-                   prefix,
-                   num, args.row_digits,
-                   "", args.key_length - pad_len - static_cast<int>(prefix.size()) - args.row_digits);
+template <bool Clear = true, typename Char>
+void genkey(std::basic_string<Char>& str, std::string_view prefix, mako_args_t const& args, int num) {
+	static_assert(sizeof(Char) == 1);
+	const auto pad_len = args.prefixpadding ? args.key_length - (static_cast<int>(prefix.size()) + args.row_digits) : 0;
+	assert(pad_len >= 0);
+	if constexpr (Clear)
+		str.clear();
+	str.reserve(str.size() + static_cast<size_t>(args.key_length));
+	fmt::format_to(std::back_inserter(str),
+	               "{0:x>{1}}{2}{3:0{4}d}{5:x>{6}}",
+	               "",
+	               pad_len,
+	               prefix,
+	               num,
+	               args.row_digits,
+	               "",
+	               args.key_length - pad_len - static_cast<int>(prefix.size()) - args.row_digits);
 }
 
 // invoke user-provided callable when object goes out of scope.
 template <typename Func>
 class exit_guard {
-    std::decay_t<Func> fn;
-public:
-    exit_guard(Func&& fn) : fn(std::forward<Func>(fn)) {}
+	std::decay_t<Func> fn;
 
-    ~exit_guard() {
-        fn();
-    }
+public:
+	exit_guard(Func&& fn) : fn(std::forward<Func>(fn)) {}
+
+	~exit_guard() { fn(); }
 };
 
 // invoke user-provided callable when stack unwinds by exception.
 template <typename Func>
 class fail_guard {
-    std::decay_t<Func> fn;
-public:
-    fail_guard(Func&& fn) : fn(std::forward<Func>(fn)) {}
+	std::decay_t<Func> fn;
 
-    ~fail_guard() {
-        if (std::uncaught_exceptions()) {
-            fn();
-        }
-    }
+public:
+	fail_guard(Func&& fn) : fn(std::forward<Func>(fn)) {}
+
+	~fail_guard() {
+		if (std::uncaught_exceptions()) {
+			fn();
+		}
+	}
 };
 
 // timing helpers
@@ -135,17 +132,17 @@ using timepoint_t = decltype(steady_clock::now());
 
 template <typename Duration>
 double to_double_seconds(Duration duration) {
-    return std::chrono::duration_cast<std::chrono::duration<double>>(duration).count();
+	return std::chrono::duration_cast<std::chrono::duration<double>>(duration).count();
 }
 
 template <typename Duration>
 uint64_t to_integer_seconds(Duration duration) {
-    return std::chrono::duration_cast<std::chrono::duration<uint64_t>>(duration).count();
+	return std::chrono::duration_cast<std::chrono::duration<uint64_t>>(duration).count();
 }
 
 template <typename Duration>
 uint64_t to_integer_microseconds(Duration duration) {
-    return std::chrono::duration_cast<std::chrono::duration<uint64_t, std::micro>>(duration).count();
+	return std::chrono::duration_cast<std::chrono::duration<uint64_t, std::micro>>(duration).count();
 }
 
 // trace helpers
@@ -154,31 +151,30 @@ constexpr const int STATS_FIELD_WIDTH = 12;
 
 template <typename Value>
 void put_title(Value&& value) {
-    fmt::print("{0: <{1}} ", std::forward<Value>(value), STATS_TITLE_WIDTH);
+	fmt::print("{0: <{1}} ", std::forward<Value>(value), STATS_TITLE_WIDTH);
 }
 
 template <typename Value>
 void put_title_r(Value&& value) {
-    fmt::print("{0: >{1}} ", std::forward<Value>(value), STATS_TITLE_WIDTH);
+	fmt::print("{0: >{1}} ", std::forward<Value>(value), STATS_TITLE_WIDTH);
 }
 
 inline void put_title_bar() {
-    fmt::print("{0:=<{1}} ", "", STATS_TITLE_WIDTH);
+	fmt::print("{0:=<{1}} ", "", STATS_TITLE_WIDTH);
 }
 
 template <typename Value>
 void put_field(Value&& value) {
-    fmt::print("{0: >{1}} ", std::forward<Value>(value), STATS_FIELD_WIDTH);
+	fmt::print("{0: >{1}} ", std::forward<Value>(value), STATS_FIELD_WIDTH);
 }
 
 inline void put_field_bar() {
-    fmt::print("{0:=>{1}} ", "", STATS_FIELD_WIDTH);
+	fmt::print("{0:=>{1}} ", "", STATS_FIELD_WIDTH);
 }
 
 template <typename Value>
 void put_field_f(Value&& value, int precision) {
-    fmt::print("{0: >{1}.{2}f} ",
-               std::forward<Value>(value), STATS_FIELD_WIDTH, precision);
+	fmt::print("{0: >{1}.{2}f} ", std::forward<Value>(value), STATS_FIELD_WIDTH, precision);
 }
 
 #endif /* UTILS_HPP */

From ad3e1b2de2334957b10869526a3128d1a06d6382 Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Fri, 4 Mar 2022 06:16:21 +0100
Subject: [PATCH 05/84] Fix typos and errors

* add missing tx.set() to OP_OVERWRITE
* fix min-max mix-up
* fix printf type mix-up
* misreferenced variables
* add missing line breaks
* (improvement) fix error diff condition being overwritten
* (improvement) fix conflict rate being reported as error diff
---
 bindings/c/test/mako/mako.cpp | 32 ++++++++++++++++++--------------
 bindings/c/test/mako/mako.hpp |  4 ++--
 2 files changed, 20 insertions(+), 16 deletions(-)

diff --git a/bindings/c/test/mako/mako.cpp b/bindings/c/test/mako/mako.cpp
index 985a4c5a9b..210821e751 100644
--- a/bindings/c/test/mako/mako.cpp
+++ b/bindings/c/test/mako/mako.cpp
@@ -189,10 +189,8 @@ int populate(TX tx,
 
 		/* commit every 100 inserts (default) or if this is the last key */
 		if (i == key_end || (i - key_begin + 1) % num_commit_every == 0) {
-			auto time_commit_start = timepoint_t{};
 			const auto is_sample_target = (stats.get_tx_count() % args.sampling) == 0;
-			if (is_sample_target)
-				time_commit_start = steady_clock::now();
+			auto time_commit_start = steady_clock::now();
 			auto future_commit = tx.commit();
 			const auto rc = wait_and_handle_error(tx, future_commit, "COMMIT_POPULATE_INSERT");
 			if (rc == FutureRC::OK) {
@@ -205,15 +203,15 @@ int populate(TX tx,
 				continue;
 			}
 
+			const auto time_commit_end = steady_clock::now();
 			/* xact latency stats */
+			const auto commit_latency_us = to_integer_microseconds(time_commit_end - time_commit_start);
+			const auto tx_duration_us = to_integer_microseconds(time_commit_end - time_tx_start);
+			stats.add_latency(OP_COMMIT, commit_latency_us);
+			stats.add_latency(OP_TRANSACTION, tx_duration_us);
 			if (is_sample_target) {
-				const auto time_commit_end = steady_clock::now();
-				const auto commit_latency_us = to_integer_microseconds(time_commit_end - time_commit_start);
-				const auto tx_duration_us = to_integer_microseconds(time_commit_end - time_tx_start);
 				sample_bins[OP_COMMIT].put(commit_latency_us);
 				sample_bins[OP_TRANSACTION].put(tx_duration_us);
-				stats.add_latency(OP_COMMIT, commit_latency_us);
-				stats.add_latency(OP_TRANSACTION, tx_duration_us);
 			}
 
 			time_tx_start = steady_clock::now();
@@ -440,6 +438,7 @@ const std::map<std::pair<int /*op*/, int /*sub-op step*/>,
 	      [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString& value) {
 	          genkey(key, KEY_PREFIX, args, next_key(args));
 	          randstr(value, args.value_length);
+	          tx.set(key, value);
 	          return Future();
 	      } },
 	    { { OP_CLEAR, 0 },
@@ -592,7 +591,7 @@ int run_one_transaction(TX tx, mako_args_t const& args, mako_stats_t& stats, sam
 	auto key2 = ByteString{};
 	key2.reserve(args.key_length);
 	auto val = ByteString{};
-	key2.reserve(args.value_length);
+	val.reserve(args.value_length);
 
 	auto time_tx_start = steady_clock::now();
 
@@ -1615,7 +1614,7 @@ void print_stats(mako_args_t const& args, mako_stats_t const* stats, double cons
 			if (fp) {
 				fmt::print(fp, "\"{}\": {},", get_ops_name(op), ops_total_diff);
 			}
-			print_err = (current.get_error_count(op) - prev.get_error_count(op)) > 0;
+			print_err = print_err || (current.get_error_count(op) - prev.get_error_count(op)) > 0;
 		}
 	}
 	/* TPS */
@@ -1628,6 +1627,7 @@ void print_stats(mako_args_t const& args, mako_stats_t const* stats, double cons
 	/* Conflicts */
 	const auto conflicts_diff = (current.get_conflict_count() - prev.get_conflict_count()) / duration_sec;
 	put_field_f(conflicts_diff, 2);
+	fmt::print("\n");
 	if (fp) {
 		fprintf(fp, "\"conflictsPerSec\": %.2f", conflicts_diff);
 	}
@@ -1636,9 +1636,10 @@ void print_stats(mako_args_t const& args, mako_stats_t const* stats, double cons
 		put_title_r("Errors");
 		for (auto op = 0; op < MAX_OP; op++) {
 			if (args.txnspec.ops[op][OP_COUNT] > 0) {
-				put_field(current.get_error_count(op) - prev.get_error_count(op));
+				const auto errors_diff = current.get_error_count(op) - prev.get_error_count(op);
+				put_field(errors_diff);
 				if (fp) {
-					fprintf(fp, ",\"errors\": %.2f", conflicts_diff);
+					fmt::print(fp, ",\"errors\": {}", errors_diff);
 				}
 			}
 		}
@@ -1732,10 +1733,12 @@ void print_report(mako_args_t const& args,
 			break;
 		}
 	}
+	const auto tps_f = final_stats.get_tx_count() / duration_sec;
+	const auto tps_i = static_cast<uint64_t>(tps_f);
 	fmt::printf("Total Xacts:      %8lu\n", final_stats.get_tx_count());
 	fmt::printf("Total Conflicts:  %8lu\n", final_stats.get_conflict_count());
 	fmt::printf("Total Errors:     %8lu\n", final_stats.get_total_error_count());
-	fmt::printf("Overall TPS:      %8lu\n\n", final_stats.get_tx_count() / duration_sec);
+	fmt::printf("Overall TPS:      %8lu\n\n", tps_i);
 
 	if (fp) {
 		fmt::fprintf(fp, "\"results\": {");
@@ -1746,7 +1749,7 @@ void print_report(mako_args_t const& args,
 		fmt::fprintf(fp, "\"totalXacts\": %lu,", final_stats.get_tx_count());
 		fmt::fprintf(fp, "\"totalConflicts\": %lu,", final_stats.get_conflict_count());
 		fmt::fprintf(fp, "\"totalErrors\": %lu,", final_stats.get_total_error_count());
-		fmt::fprintf(fp, "\"overallTPS\": %lu,", final_stats.get_tx_count() / duration_sec);
+		fmt::fprintf(fp, "\"overallTPS\": %lu,", tps_i);
 	}
 
 	/* per-op stats */
@@ -1779,6 +1782,7 @@ void print_report(mako_args_t const& args,
 	/* Conflicts */
 	const auto conflicts_rate = final_stats.get_conflict_count() / duration_sec;
 	put_field_f(conflicts_rate, 2);
+	fmt::print("\n");
 
 	if (fp) {
 		fmt::fprintf(fp, "}, \"tps\": %.2f, \"conflictsPerSec\": %.2f, \"errors\": {", tps, conflicts_rate);
diff --git a/bindings/c/test/mako/mako.hpp b/bindings/c/test/mako/mako.hpp
index c857949925..942c3fe459 100644
--- a/bindings/c/test/mako/mako.hpp
+++ b/bindings/c/test/mako/mako.hpp
@@ -177,7 +177,7 @@ class alignas(64) mako_stats_t {
 public:
 	mako_stats_t() noexcept {
 		memset(this, 0, sizeof(mako_stats_t));
-		memset(latency_us_max, 0xff, sizeof(latency_us_max));
+		memset(latency_us_min, 0xff, sizeof(latency_us_min));
 	}
 
 	mako_stats_t(const mako_stats_t& other) noexcept = default;
@@ -213,7 +213,7 @@ public:
 			latency_us_total[op] += other.latency_us_total[op];
 			if (latency_us_min[op] > other.latency_us_min[op])
 				latency_us_min[op] = other.latency_us_min[op];
-			if (latency_us_min[op] < other.latency_us_min[op])
+			if (latency_us_max[op] < other.latency_us_max[op])
 				latency_us_max[op] = other.latency_us_max[op];
 		}
 	}

From f958e1dc0a29bad1b3c7dec82a91b4e066328a29 Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Sat, 5 Mar 2022 01:39:19 +0100
Subject: [PATCH 06/84] Adhere to sampling interval argument

* stopwatch class for easier timepoint management
---
 bindings/c/test/mako/mako.cpp  | 147 ++++++++++++++++++---------------
 bindings/c/test/mako/mako.hpp  |  56 +++++++++----
 bindings/c/test/mako/utils.hpp |  64 ++++++++------
 3 files changed, 159 insertions(+), 108 deletions(-)

diff --git a/bindings/c/test/mako/mako.cpp b/bindings/c/test/mako/mako.cpp
index 210821e751..b6538dc23a 100644
--- a/bindings/c/test/mako/mako.cpp
+++ b/bindings/c/test/mako/mako.cpp
@@ -106,7 +106,7 @@ int cleanup(TX tx, mako_args_t const& args) {
 	genkeyprefix(endstr, KEY_PREFIX, args);
 	endstr.push_back(0xff);
 
-	const auto time_start = steady_clock::now();
+	auto watch = Stopwatch(start_at_ctor{});
 
 	while (true) {
 		tx.clear_range(beginstr, endstr);
@@ -123,8 +123,7 @@ int cleanup(TX tx, mako_args_t const& args) {
 	}
 
 	tx.reset();
-	const auto time_end = steady_clock::now();
-	fmt::print(printme, "INFO: Clear range: {:6.3f} sec\n", to_double_seconds(time_end - time_start));
+	fmt::print(printme, "INFO: Clear range: {:6.3f} sec\n", to_double_seconds(watch.stop().diff()));
 	return 0;
 }
 
@@ -144,11 +143,11 @@ int populate(TX tx,
 	auto valstr = ByteString{};
 	keystr.reserve(args.key_length);
 	valstr.reserve(args.value_length);
-	const auto time_start = steady_clock::now();
 	const auto num_commit_every = args.txnspec.ops[OP_INSERT][OP_COUNT];
-	auto time_prev = time_start; // for throttling
-	auto time_tx_start = time_start;
-	auto time_last_traced = time_start;
+	auto watch_total = Stopwatch(start_at_ctor{});
+	auto watch_throttle = Stopwatch(watch_total.get_start());
+	auto watch_tx = Stopwatch(watch_total.get_start());
+	auto watch_trace = Stopwatch(watch_total.get_start());
 	auto key_checkpoint = key_begin; // in case of commit failure, restart from this key
 
 	for (auto i = key_begin; i <= key_end; i++) {
@@ -158,18 +157,16 @@ int populate(TX tx,
 		randstr(valstr, args.value_length);
 
 		while (thread_tps > 0 && xacts >= thread_tps /* throttle */) {
-			const auto time_now = steady_clock::now();
-			if (to_integer_seconds(time_now - time_prev) >= 1) {
+			if (to_integer_seconds(watch_throttle.stop().diff()) >= 1) {
 				xacts = 0;
-				time_prev = time_now;
+				watch_throttle.start_from_stop();
 			} else {
 				usleep(1000);
 			}
 		}
 		if (args.txntrace) {
-			const auto time_now = steady_clock::now();
-			if (to_integer_seconds(time_now - time_last_traced) >= args.txntrace) {
-				time_last_traced = time_now;
+			if (to_integer_seconds(watch_trace.stop().diff()) >= args.txntrace) {
+				watch_trace.start_from_stop();
 				fmt::print(debugme, "DEBUG: txn tracing {}\n", to_chars_ref(keystr));
 				auto err = Error{};
 				err = tx.set_option_nothrow(FDB_TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER, keystr);
@@ -185,50 +182,50 @@ int populate(TX tx,
 
 		/* insert (SET) */
 		tx.set(keystr, valstr);
-		stats.incr_count_immediate(OP_INSERT);
+		stats.incr_op_count(OP_INSERT);
 
 		/* commit every 100 inserts (default) or if this is the last key */
 		if (i == key_end || (i - key_begin + 1) % num_commit_every == 0) {
-			const auto is_sample_target = (stats.get_tx_count() % args.sampling) == 0;
-			auto time_commit_start = steady_clock::now();
+			const auto do_sample = (stats.get_tx_count() % args.sampling) == 0;
+			auto watch_commit = Stopwatch(start_at_ctor{});
 			auto future_commit = tx.commit();
 			const auto rc = wait_and_handle_error(tx, future_commit, "COMMIT_POPULATE_INSERT");
+			watch_commit.stop();
+			watch_tx.set_stop(watch_commit.get_stop());
+			auto tx_restarter = ExitGuard([&tx, &watch_tx]() {
+					watch_tx.start_from_stop();
+					tx.reset();
+				});
 			if (rc == FutureRC::OK) {
 				key_checkpoint = i + 1; // restart on failures from next key
 			} else if (rc == FutureRC::ABORT) {
 				return -1;
 			} else {
 				i = key_checkpoint - 1; // restart from last committed
-				time_tx_start = steady_clock::now(); // tx shall restart
 				continue;
 			}
-
-			const auto time_commit_end = steady_clock::now();
 			/* xact latency stats */
-			const auto commit_latency_us = to_integer_microseconds(time_commit_end - time_commit_start);
-			const auto tx_duration_us = to_integer_microseconds(time_commit_end - time_tx_start);
-			stats.add_latency(OP_COMMIT, commit_latency_us);
-			stats.add_latency(OP_TRANSACTION, tx_duration_us);
-			if (is_sample_target) {
-				sample_bins[OP_COMMIT].put(commit_latency_us);
-				sample_bins[OP_TRANSACTION].put(tx_duration_us);
+			if (do_sample) {
+				const auto commit_latency = watch_commit.diff();
+				const auto tx_duration = watch_tx.diff();
+				stats.add_latency(OP_COMMIT, commit_latency);
+				stats.add_latency(OP_TRANSACTION, tx_duration);
+				sample_bins[OP_COMMIT].put(commit_latency);
+				sample_bins[OP_TRANSACTION].put(tx_duration);
 			}
+			stats.incr_op_count(OP_COMMIT);
+			stats.incr_op_count(OP_TRANSACTION);
 
-			time_tx_start = steady_clock::now();
-
-			tx.reset();
 			stats.incr_tx_count();
 			xacts++; /* for throttling */
 		}
 	}
-	const auto time_end = steady_clock::now();
-
 	fmt::print(debugme,
 	           "DEBUG: Populated {} rows [{}, {}]: {:6.3f} sec\n",
 	           key_end - key_begin + 1,
 	           key_begin,
 	           key_end,
-	           to_double_seconds(time_end - time_start));
+	           to_double_seconds(watch_total.stop().diff()));
 
 	return 0;
 }
@@ -593,20 +590,20 @@ int run_one_transaction(TX tx, mako_args_t const& args, mako_stats_t& stats, sam
 	auto val = ByteString{};
 	val.reserve(args.value_length);
 
-	auto time_tx_start = steady_clock::now();
+	auto watch_tx = Stopwatch(start_at_ctor{});
 
 	auto op_iter = get_op_begin(args);
 	auto needs_commit = false;
-	auto time_per_op_start = std::array<timepoint_t, MAX_OP>{};
+	auto watch_per_op = std::array<Stopwatch, MAX_OP>{};
 	const auto do_sample = (stats.get_tx_count() % args.sampling) == 0;
 	while (op_iter != OpEnd) {
 		const auto [op, count, step] = op_iter;
 		const auto step_kind = op_desc[op].step_kind(step);
 		const auto op_key = std::make_pair(op, step);
-		const auto time_step_start = steady_clock::now();
-		if (step == 0 /* first step */) {
-			time_per_op_start[op] = time_step_start;
-		}
+		auto watch_step = Stopwatch{};
+		watch_step.start();
+		if (step == 0 /* first step */)
+			watch_per_op[op] = Stopwatch(watch_step.get_start());
 		auto f = operation_fn_table.at(op_key)(tx, args, key1, key2, val);
 		auto future_rc = FutureRC::OK;
 		if (f) {
@@ -619,8 +616,7 @@ int run_one_transaction(TX tx, mako_args_t const& args, mako_stats_t& stats, sam
 				}
 			}
 		}
-		const auto time_step_end = steady_clock::now();
-		const auto step_usec = to_integer_microseconds(time_step_end - time_step_start);
+		watch_step.stop();
 		if (future_rc != FutureRC::OK) {
 			if (future_rc == FutureRC::CONFLICT) {
 				stats.incr_conflict_count();
@@ -638,55 +634,72 @@ int run_one_transaction(TX tx, mako_args_t const& args, mako_stats_t& stats, sam
 		}
 		// step successful
 		if (step_kind == StepKind::COMMIT) {
-			const auto tx_usec = to_integer_microseconds(time_step_end - time_tx_start);
-			stats.add_latency(OP_COMMIT, step_usec);
-			stats.add_latency(OP_TRANSACTION, tx_usec);
+			// reset transaction boundary
+			const auto step_latency = watch_step.diff();
+			watch_tx.set_stop(watch_step.get_stop());
 			if (do_sample) {
-				sample_bins[OP_COMMIT].put(step_usec);
-				sample_bins[OP_TRANSACTION].put(tx_usec);
+				const auto tx_duration = watch_tx.diff();
+				stats.add_latency(OP_COMMIT, step_latency);
+				stats.add_latency(OP_TRANSACTION, tx_duration);
+				sample_bins[OP_COMMIT].put(step_latency);
+				sample_bins[OP_TRANSACTION].put(tx_duration);
 			}
-			time_tx_start = time_step_end; // new tx begins
+			tx.reset();
+			watch_tx.start_from_stop(); // new tx begins
+			stats.incr_op_count(OP_COMMIT);
+			stats.incr_op_count(OP_TRANSACTION);
+			needs_commit = false;
 		}
 
 		// op completed successfully
 		if (step + 1 == op_desc[op].steps() /* last step */) {
 			if (op_desc[op].needs_commit())
 				needs_commit = true;
-			const auto op_usec = to_integer_microseconds(time_step_end - time_per_op_start[op]);
-			stats.add_latency(op, op_usec);
-			if (do_sample)
-				sample_bins[op].put(op_usec);
+			watch_per_op[op].set_stop(watch_step.get_stop());
+			if (do_sample) {
+				const auto op_latency = watch_per_op[op].diff();
+				stats.add_latency(op, op_latency);
+				sample_bins[op].put(op_latency);
+			}
+			stats.incr_op_count(op);
 		}
 		// move to next op
 		op_iter = get_op_next(args, op_iter);
 
 		// reached the end?
 		if (op_iter == OpEnd && (needs_commit || args.commit_get)) {
-			const auto time_commit_start = steady_clock::now();
+			auto watch_commit = Stopwatch(start_at_ctor{});
 			auto f = tx.commit();
 			const auto rc = wait_and_handle_error(tx, f, "COMMIT_AT_TX_END");
-			const auto time_commit_end = steady_clock::now();
-			const auto commit_usec = to_integer_microseconds(time_commit_end - time_commit_start);
-			const auto tx_usec = to_integer_microseconds(time_commit_end - time_tx_start);
+			watch_commit.stop();
+			watch_tx.set_stop(watch_commit.get_stop());
+			auto tx_resetter = ExitGuard([&watch_tx, &tx]() {
+					tx.reset();
+					watch_tx.start_from_stop();
+				});
 			if (rc == FutureRC::OK) {
-				stats.add_latency(OP_COMMIT, commit_usec);
-				stats.add_latency(OP_TRANSACTION, tx_usec);
 				if (do_sample) {
-					sample_bins[OP_COMMIT].put(commit_usec);
-					sample_bins[OP_TRANSACTION].put(tx_usec);
+					const auto commit_latency = watch_commit.diff();
+					const auto tx_duration = watch_tx.diff();
+					stats.add_latency(OP_COMMIT, commit_latency);
+					stats.add_latency(OP_TRANSACTION, tx_duration);
+					sample_bins[OP_COMMIT].put(commit_latency);
+					sample_bins[OP_TRANSACTION].put(tx_duration);
 				}
+				stats.incr_op_count(OP_COMMIT);
+				stats.incr_op_count(OP_TRANSACTION);
 			} else {
 				if (rc == FutureRC::CONFLICT)
 					stats.incr_conflict_count();
 				else
 					stats.incr_error_count(OP_COMMIT);
 				if (rc == FutureRC::ABORT) {
-					tx.reset();
 					return -1;
 				}
 				// restart from beginning
 				op_iter = get_op_begin(args);
 			}
+			needs_commit = false;
 		}
 	}
 	stats.incr_tx_count();
@@ -844,7 +857,7 @@ void worker_thread(thread_args_t& thread_args) {
 
 	/* i'm ready */
 	readycount.fetch_add(1);
-	auto stopcount_guard = exit_guard([&stopcount]() { stopcount.fetch_add(1); });
+	auto stopcount_guard = ExitGuard([&stopcount]() { stopcount.fetch_add(1); });
 	while (signal.load() == SIGNAL_OFF) {
 		usleep(10000); /* 10ms */
 	}
@@ -884,7 +897,7 @@ void worker_thread(thread_args_t& thread_args) {
 					fmt::print(stderr, "ERROR: fopen({}): {}\n", filename, strerror(errno));
 					continue;
 				}
-				auto fclose_guard = exit_guard([fp]() { fclose(fp); });
+				auto fclose_guard = ExitGuard([fp]() { fclose(fp); });
 				thread_args.sample_bins[op].for_each_block(
 				    [fp](auto ptr, auto count) { fwrite(ptr, sizeof(*ptr) * count, 1, fp); });
 			}
@@ -1926,7 +1939,6 @@ void print_report(mako_args_t const& args,
 			const auto lat_total = final_stats.get_latency_us_total(op);
 			const auto lat_samples = final_stats.get_latency_sample_count(op);
 			if (lat_total && lat_samples) {
-				data_points[op].reserve(lat_samples);
 				for (auto i = 0; i < args.num_processes; i++) {
 					for (auto j = 0; j < args.num_threads; j++) {
 						const auto dirname = fmt::format("{}{}", TEMP_DATA_STORE, pid_main);
@@ -1936,16 +1948,15 @@ void print_report(mako_args_t const& args,
 							fmt::print(stderr, "ERROR: fopen({}): {}\n", strerror(errno));
 							continue;
 						}
-						auto fclose_guard = exit_guard([fp]() { fclose(fp); });
+						auto fclose_guard = ExitGuard([fp]() { fclose(fp); });
 						fseek(fp, 0, SEEK_END);
 						const auto num_points = ftell(fp) / sizeof(uint64_t);
+						data_points[op].reserve(num_points);
 						fseek(fp, 0, 0);
-						auto index = 0u;
-						while (index < num_points) {
+						for (auto index = 0u; index < num_points; index++) {
 							auto value = uint64_t{};
 							fread(&value, sizeof(uint64_t), 1, fp);
 							data_points[op].push_back(value);
-							++index;
 						}
 					}
 				}
@@ -2232,7 +2243,7 @@ int main(int argc, char* argv[]) {
 		fmt::print(stderr, "ERROR: shm_open failed\n");
 		return -1;
 	}
-	auto shmfd_guard = exit_guard([shmfd, &shmpath]() {
+	auto shmfd_guard = ExitGuard([shmfd, &shmpath]() {
 		close(shmfd);
 		shm_unlink(shmpath.c_str());
 		unlink(shmpath.c_str());
@@ -2253,7 +2264,7 @@ int main(int argc, char* argv[]) {
 		fmt::print(stderr, "ERROR: mmap (fd:{} size:{}) failed\n", shmfd, shmsize);
 		return -1;
 	}
-	auto munmap_guard = exit_guard([=]() { munmap(shm, shmsize); });
+	auto munmap_guard = ExitGuard([=]() { munmap(shm, shmsize); });
 
 	static_assert(std::is_same_v<decltype(shm), mako_shmhdr_t*>);
 	auto stats = reinterpret_cast<mako_stats_t*>(shm + 1);
diff --git a/bindings/c/test/mako/mako.hpp b/bindings/c/test/mako/mako.hpp
index 942c3fe459..f60e613283 100644
--- a/bindings/c/test/mako/mako.hpp
+++ b/bindings/c/test/mako/mako.hpp
@@ -8,6 +8,8 @@
 
 #include <array>
 #include <atomic>
+#include <cassert>
+#include <chrono>
 #include <list>
 #include <vector>
 #include <string_view>
@@ -34,7 +36,7 @@ constexpr const int MODE_BUILD = 1;
 constexpr const int MODE_RUN = 2;
 
 /* size of each block to get detailed latency for each operation */
-constexpr const size_t LAT_BLOCK_SIZE = 511;
+constexpr const size_t LAT_BLOCK_SIZE = 16384;
 
 /* transaction specification */
 enum Operations {
@@ -163,6 +165,35 @@ struct mako_shmhdr_t {
 	std::atomic<int> stopcount;
 };
 
+/* per-process information */
+typedef struct {
+	int worker_id;
+	pid_t parent_id;
+	mako_args_t* args;
+	mako_shmhdr_t* shm;
+	std::vector<fdb::Database> databases;
+} process_info_t;
+
+/* time measurement helpers */
+using std::chrono::steady_clock;
+using timepoint_t = decltype(steady_clock::now());
+using timediff_t = decltype(std::declval<timepoint_t>()-std::declval<timepoint_t>());
+
+template <typename Duration>
+double to_double_seconds(Duration duration) {
+	return std::chrono::duration_cast<std::chrono::duration<double>>(duration).count();
+}
+
+template <typename Duration>
+uint64_t to_integer_seconds(Duration duration) {
+	return std::chrono::duration_cast<std::chrono::duration<uint64_t>>(duration).count();
+}
+
+template <typename Duration>
+uint64_t to_integer_microseconds(Duration duration) {
+	return std::chrono::duration_cast<std::chrono::duration<uint64_t, std::micro>>(duration).count();
+}
+
 class alignas(64) mako_stats_t {
 	uint64_t xacts;
 	uint64_t conflicts;
@@ -222,32 +253,25 @@ public:
 	void incr_conflict_count() noexcept { conflicts++; }
 
 	// non-commit write operations aren't measured for time.
-	void incr_count_immediate(int op) noexcept { ops[op]++; }
+	void incr_op_count(int op) noexcept { ops[op]++; }
 
 	void incr_error_count(int op) noexcept {
 		total_errors++;
 		errors[op]++;
 	}
 
-	void add_latency(int op, uint64_t latency_us) noexcept {
+	void add_latency(int op, timediff_t diff) noexcept {
+		const auto latency_us = to_integer_microseconds(diff);
 		latency_samples[op]++;
 		latency_us_total[op] += latency_us;
 		if (latency_us_min[op] > latency_us)
 			latency_us_min[op] = latency_us;
 		if (latency_us_max[op] < latency_us)
 			latency_us_max[op] = latency_us;
-		ops[op]++;
 	}
 };
 
-/* per-process information */
-typedef struct {
-	int worker_id;
-	pid_t parent_id;
-	mako_args_t* args;
-	mako_shmhdr_t* shm;
-	std::vector<fdb::Database> databases;
-} process_info_t;
+
 
 /* memory block allocated to each operation when collecting detailed latency */
 class lat_block_t {
@@ -259,9 +283,9 @@ class lat_block_t {
 public:
 	lat_block_t() noexcept = default;
 	bool full() const noexcept { return index >= LAT_BLOCK_SIZE; }
-	void put(uint64_t point) {
+	void put(timediff_t td) {
 		assert(!full());
-		samples[index++] = point;
+		samples[index++] = to_integer_microseconds(td);
 	}
 	// return {data block, number of samples}
 	std::pair<uint64_t const*, size_t> data() const noexcept { return { samples, index }; }
@@ -277,10 +301,10 @@ public:
 			blocks.emplace_back();
 	}
 
-	void put(uint64_t latency_us) {
+	void put(timediff_t td) {
 		if (blocks.empty() || blocks.back().full())
 			blocks.emplace_back();
-		blocks.back().put(latency_us);
+		blocks.back().put(td);
 	}
 
 	// iterate & apply for each block user function void(uint64_t const*, size_t)
diff --git a/bindings/c/test/mako/utils.hpp b/bindings/c/test/mako/utils.hpp
index d8cafb996d..012a360dfc 100644
--- a/bindings/c/test/mako/utils.hpp
+++ b/bindings/c/test/mako/utils.hpp
@@ -5,9 +5,10 @@
 #include "mako.hpp"
 #include <cassert>
 #include <chrono>
-#include <fmt/format.h>
-#include <stdint.h>
+#include <cstdint>
+#include <type_traits>
 
+#include <fmt/format.h>
 /* uniform-distribution random */
 /* return a uniform random number between low and high, both inclusive */
 int urand(int low, int high);
@@ -102,24 +103,24 @@ void genkey(std::basic_string<Char>& str, std::string_view prefix, mako_args_t c
 
 // invoke user-provided callable when object goes out of scope.
 template <typename Func>
-class exit_guard {
+class ExitGuard {
 	std::decay_t<Func> fn;
 
 public:
-	exit_guard(Func&& fn) : fn(std::forward<Func>(fn)) {}
+	ExitGuard(Func&& fn) : fn(std::forward<Func>(fn)) {}
 
-	~exit_guard() { fn(); }
+	~ExitGuard() { fn(); }
 };
 
 // invoke user-provided callable when stack unwinds by exception.
 template <typename Func>
-class fail_guard {
+class FailGuard {
 	std::decay_t<Func> fn;
 
 public:
-	fail_guard(Func&& fn) : fn(std::forward<Func>(fn)) {}
+	FailGuard(Func&& fn) : fn(std::forward<Func>(fn)) {}
 
-	~fail_guard() {
+	~FailGuard() {
 		if (std::uncaught_exceptions()) {
 			fn();
 		}
@@ -127,23 +128,38 @@ public:
 };
 
 // timing helpers
-using std::chrono::steady_clock;
-using timepoint_t = decltype(steady_clock::now());
+struct start_at_ctor{};
 
-template <typename Duration>
-double to_double_seconds(Duration duration) {
-	return std::chrono::duration_cast<std::chrono::duration<double>>(duration).count();
-}
-
-template <typename Duration>
-uint64_t to_integer_seconds(Duration duration) {
-	return std::chrono::duration_cast<std::chrono::duration<uint64_t>>(duration).count();
-}
-
-template <typename Duration>
-uint64_t to_integer_microseconds(Duration duration) {
-	return std::chrono::duration_cast<std::chrono::duration<uint64_t, std::micro>>(duration).count();
-}
+class Stopwatch {
+	timepoint_t p1, p2;
+public:
+	Stopwatch() noexcept = default;
+	Stopwatch(start_at_ctor) noexcept {
+		start();
+	}
+	Stopwatch(timepoint_t start_time) noexcept : p1(start_time), p2() {}
+	Stopwatch(const Stopwatch&) noexcept = default;
+	Stopwatch& operator=(const Stopwatch&) noexcept = default;
+	timepoint_t get_start() const noexcept { return p1; }
+	timepoint_t get_stop() const noexcept { return p2; }
+	void start() noexcept {
+		p1 = steady_clock::now();
+	}
+	Stopwatch& stop() noexcept {
+		p2 = steady_clock::now();
+		return *this;
+	}
+	Stopwatch& set_stop(timepoint_t p_stop) noexcept {
+		p2 = p_stop;
+		return *this;
+	}
+	void start_from_stop() noexcept {
+		p1 = p2;
+	}
+	auto diff() const noexcept {
+		return p2 - p1;
+	}
+};
 
 // trace helpers
 constexpr const int STATS_TITLE_WIDTH = 12;

From 695022ad19db61009e9bddf595c28529cb7807e1 Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Sat, 5 Mar 2022 02:00:58 +0100
Subject: [PATCH 07/84] Fix thread id output

* for Linux, pthread_t is an unsigned long, not a pointer type
---
 bindings/c/test/mako/mako.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bindings/c/test/mako/mako.cpp b/bindings/c/test/mako/mako.cpp
index b6538dc23a..c9197a2905 100644
--- a/bindings/c/test/mako/mako.cpp
+++ b/bindings/c/test/mako/mako.cpp
@@ -840,7 +840,7 @@ void worker_thread(thread_args_t& thread_args) {
 	           thread_id,
 	           args.num_threads,
 	           database_index,
-	           fmt::ptr(pthread_self()));
+	           reinterpret_cast<uint64_t>(pthread_self()));
 
 	const auto thread_tps =
 	    args.tpsmax == 0 ? 0

From bcf52e6760916c809cec74ca70112f9aa669c43e Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Mon, 7 Mar 2022 01:16:38 +0100
Subject: [PATCH 08/84] Style changes: C > C++

* more controlled shared memory access
* simplified thread arguments
* use namespace 'mako'
* separate headers by their concerns (time, statistics, shared memory)
* introduce Stopwatch class
---
 bindings/c/test/mako/mako.cpp       | 210 ++++++++++++------------
 bindings/c/test/mako/mako.hpp       | 241 ++--------------------------
 bindings/c/test/mako/operations.hpp |  66 ++++++++
 bindings/c/test/mako/shm.hpp        |  75 +++++++++
 bindings/c/test/mako/stats.hpp      | 139 ++++++++++++++++
 bindings/c/test/mako/time.hpp       |  57 +++++++
 bindings/c/test/mako/utils.cpp      |   4 +
 bindings/c/test/mako/utils.hpp      |  43 +----
 8 files changed, 467 insertions(+), 368 deletions(-)
 create mode 100644 bindings/c/test/mako/operations.hpp
 create mode 100644 bindings/c/test/mako/shm.hpp
 create mode 100644 bindings/c/test/mako/stats.hpp
 create mode 100644 bindings/c/test/mako/time.hpp

diff --git a/bindings/c/test/mako/mako.cpp b/bindings/c/test/mako/mako.cpp
index c9197a2905..f0f87c7ed5 100644
--- a/bindings/c/test/mako/mako.cpp
+++ b/bindings/c/test/mako/mako.cpp
@@ -37,6 +37,7 @@
 #include "utils.hpp"
 
 using namespace fdb;
+using namespace mako;
 
 const std::string KEY_PREFIX{ "mako" };
 const std::string TEMP_DATA_STORE{ "/tmp/makoTemp" };
@@ -95,7 +96,7 @@ FutureRC wait_and_handle_error(TX tx, FutureType f, std::string_view operation)
 }
 
 /* cleanup database */
-int cleanup(TX tx, mako_args_t const& args) {
+int cleanup(TX tx, args_t const& args) {
 	auto beginstr = ByteString{};
 	beginstr.reserve(args.key_length);
 	genkeyprefix(beginstr, KEY_PREFIX, args);
@@ -129,11 +130,11 @@ int cleanup(TX tx, mako_args_t const& args) {
 
 /* populate database */
 int populate(TX tx,
-             mako_args_t const& args,
+             args_t const& args,
              int worker_id,
              int thread_id,
              int thread_tps,
-             mako_stats_t& stats,
+             stats_t& stats,
              sample_bin_array_t& sample_bins) {
 	const auto key_begin = insert_begin(args.rows, worker_id, thread_id, args.num_processes, args.num_threads);
 	const auto key_end = insert_end(args.rows, worker_id, thread_id, args.num_processes, args.num_threads);
@@ -144,6 +145,7 @@ int populate(TX tx,
 	keystr.reserve(args.key_length);
 	valstr.reserve(args.value_length);
 	const auto num_commit_every = args.txnspec.ops[OP_INSERT][OP_COUNT];
+	const auto num_seconds_trace_every = args.txntrace;
 	auto watch_total = Stopwatch(start_at_ctor{});
 	auto watch_throttle = Stopwatch(watch_total.get_start());
 	auto watch_tx = Stopwatch(watch_total.get_start());
@@ -164,8 +166,8 @@ int populate(TX tx,
 				usleep(1000);
 			}
 		}
-		if (args.txntrace) {
-			if (to_integer_seconds(watch_trace.stop().diff()) >= args.txntrace) {
+		if (num_seconds_trace_every) {
+			if (to_integer_seconds(watch_trace.stop().diff()) >= num_seconds_trace_every) {
 				watch_trace.start_from_stop();
 				fmt::print(debugme, "DEBUG: txn tracing {}\n", to_chars_ref(keystr));
 				auto err = Error{};
@@ -192,12 +194,10 @@ int populate(TX tx,
 			const auto rc = wait_and_handle_error(tx, future_commit, "COMMIT_POPULATE_INSERT");
 			watch_commit.stop();
 			watch_tx.set_stop(watch_commit.get_stop());
-			auto tx_restarter = ExitGuard([&tx, &watch_tx]() {
-					watch_tx.start_from_stop();
-					tx.reset();
-				});
+			auto tx_restarter = ExitGuard([&watch_tx]() { watch_tx.start_from_stop(); });
 			if (rc == FutureRC::OK) {
 				key_checkpoint = i + 1; // restart on failures from next key
+				tx.reset();
 			} else if (rc == FutureRC::ABORT) {
 				return -1;
 			} else {
@@ -311,7 +311,7 @@ void granule_free_load(int64_t loadId, void* userContext) {
 	context->data_by_id[loadId] = 0;
 }
 
-inline int next_key(mako_args_t const& args) {
+inline int next_key(args_t const& args) {
 	if (args.zipf)
 		return zipfian_next();
 	return urand(0, args.rows - 1);
@@ -335,20 +335,20 @@ const std::array<OpDesc, MAX_OP> op_desc{ { { "GRV", { StepKind::READ }, false }
 	                                        { "READBLOBGRANULE", { StepKind::ON_ERROR }, false } } };
 
 const std::map<std::pair<int /*op*/, int /*sub-op step*/>,
-               Future (*)(TX, mako_args_t const&, ByteString& /*key1*/, ByteString& /*key2*/, ByteString& /*value*/)>
+               Future (*)(TX, args_t const&, ByteString& /*key1*/, ByteString& /*key2*/, ByteString& /*value*/)>
     operation_fn_table{
 	    { { OP_GETREADVERSION, 0 },
-	      [](TX tx, mako_args_t const&, ByteString&, ByteString&, ByteString&) {
+	      [](TX tx, args_t const&, ByteString&, ByteString&, ByteString&) {
 	          return tx.get_read_version().erase_type();
 	      } },
 	    { { OP_GET, 0 },
-	      [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString&) {
+	      [](TX tx, args_t const& args, ByteString& key, ByteString&, ByteString&) {
 	          const auto num = next_key(args);
 	          genkey(key, KEY_PREFIX, args, num);
 	          return tx.get(key, false /*snapshot*/).erase_type();
 	      } },
 	    { { OP_GETRANGE, 0 },
-	      [](TX tx, mako_args_t const& args, ByteString& begin, ByteString& end, ByteString&) {
+	      [](TX tx, args_t const& args, ByteString& begin, ByteString& end, ByteString&) {
 	          const auto num_begin = next_key(args);
 	          genkey(begin, KEY_PREFIX, args, num_begin);
 	          auto num_end = num_begin + args.txnspec.ops[OP_GETRANGE][OP_RANGE] - 1;
@@ -367,13 +367,13 @@ const std::map<std::pair<int /*op*/, int /*sub-op step*/>,
 	              .erase_type();
 	      } },
 	    { { OP_SGET, 0 },
-	      [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString&) {
+	      [](TX tx, args_t const& args, ByteString& key, ByteString&, ByteString&) {
 	          const auto num = next_key(args);
 	          genkey(key, KEY_PREFIX, args, num);
 	          return tx.get(key, true /*snapshot*/).erase_type();
 	      } },
 	    { { OP_SGETRANGE, 0 },
-	      [](TX tx, mako_args_t const& args, ByteString& begin, ByteString& end, ByteString&) {
+	      [](TX tx, args_t const& args, ByteString& begin, ByteString& end, ByteString&) {
 	          const auto num_begin = next_key(args);
 	          genkey(begin, KEY_PREFIX, args, num_begin);
 	          auto num_end = num_begin + args.txnspec.ops[OP_SGETRANGE][OP_RANGE] - 1;
@@ -392,19 +392,19 @@ const std::map<std::pair<int /*op*/, int /*sub-op step*/>,
 	              .erase_type();
 	      } },
 	    { { OP_UPDATE, 0 },
-	      [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString&) {
+	      [](TX tx, args_t const& args, ByteString& key, ByteString&, ByteString&) {
 	          const auto num = next_key(args);
 	          genkey(key, KEY_PREFIX, args, num);
 	          return tx.get(key, false /*snapshot*/).erase_type();
 	      } },
 	    { { OP_UPDATE, 1 },
-	      [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString& value) {
+	      [](TX tx, args_t const& args, ByteString& key, ByteString&, ByteString& value) {
 	          randstr(value, args.value_length);
 	          tx.set(key, value);
 	          return Future();
 	      } },
 	    { { OP_INSERT, 0 },
-	      [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString& value) {
+	      [](TX tx, args_t const& args, ByteString& key, ByteString&, ByteString& value) {
 	          genkeyprefix(key, KEY_PREFIX, args);
 	          // concat([padding], key_prefix, random_string): reasonably unique
 	          randstr<false /*clear-before-append*/>(key, args.key_length - static_cast<int>(key.size()));
@@ -413,7 +413,7 @@ const std::map<std::pair<int /*op*/, int /*sub-op step*/>,
 	          return Future();
 	      } },
 	    { { OP_INSERTRANGE, 0 },
-	      [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString& value) {
+	      [](TX tx, args_t const& args, ByteString& key, ByteString&, ByteString& value) {
 	          genkeyprefix(key, KEY_PREFIX, args);
 	          const auto prefix_len = static_cast<int>(key.size());
 	          const auto range = args.txnspec.ops[OP_INSERTRANGE][OP_RANGE];
@@ -432,20 +432,20 @@ const std::map<std::pair<int /*op*/, int /*sub-op step*/>,
 	          return Future();
 	      } },
 	    { { OP_OVERWRITE, 0 },
-	      [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString& value) {
+	      [](TX tx, args_t const& args, ByteString& key, ByteString&, ByteString& value) {
 	          genkey(key, KEY_PREFIX, args, next_key(args));
 	          randstr(value, args.value_length);
 	          tx.set(key, value);
 	          return Future();
 	      } },
 	    { { OP_CLEAR, 0 },
-	      [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString&) {
+	      [](TX tx, args_t const& args, ByteString& key, ByteString&, ByteString&) {
 	          genkey(key, KEY_PREFIX, args, next_key(args));
 	          tx.clear(key);
 	          return Future();
 	      } },
 	    { { OP_SETCLEAR, 0 },
-	      [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString& value) {
+	      [](TX tx, args_t const& args, ByteString& key, ByteString&, ByteString& value) {
 	          genkeyprefix(key, KEY_PREFIX, args);
 	          const auto prefix_len = static_cast<int>(key.size());
 	          randstr<false /*append-after-clear*/>(key, args.key_length - prefix_len);
@@ -454,13 +454,13 @@ const std::map<std::pair<int /*op*/, int /*sub-op step*/>,
 	          return tx.commit().erase_type();
 	      } },
 	    { { OP_SETCLEAR, 1 },
-	      [](TX tx, mako_args_t const& args, ByteString& key, ByteString&, ByteString&) {
+	      [](TX tx, args_t const& args, ByteString& key, ByteString&, ByteString&) {
 	          tx.reset(); // assuming commit from step 0 worked.
 	          tx.clear(key); // key should forward unchanged from step 0
 	          return Future();
 	      } },
 	    { { OP_CLEARRANGE, 0 },
-	      [](TX tx, mako_args_t const& args, ByteString& begin, ByteString& end, ByteString&) {
+	      [](TX tx, args_t const& args, ByteString& begin, ByteString& end, ByteString&) {
 	          const auto num_begin = next_key(args);
 	          genkey(begin, KEY_PREFIX, args, num_begin);
 	          const auto range = args.txnspec.ops[OP_CLEARRANGE][OP_RANGE];
@@ -470,7 +470,7 @@ const std::map<std::pair<int /*op*/, int /*sub-op step*/>,
 	          return Future();
 	      } },
 	    { { OP_SETCLEARRANGE, 0 },
-	      [](TX tx, mako_args_t const& args, ByteString& key_begin, ByteString& key, ByteString& value) {
+	      [](TX tx, args_t const& args, ByteString& key_begin, ByteString& key, ByteString& value) {
 	          genkeyprefix(key, KEY_PREFIX, args);
 	          const auto prefix_len = static_cast<int>(key.size());
 	          const auto range = args.txnspec.ops[OP_SETCLEARRANGE][OP_RANGE];
@@ -495,13 +495,13 @@ const std::map<std::pair<int /*op*/, int /*sub-op step*/>,
 	          return tx.commit().erase_type();
 	      } },
 	    { { OP_SETCLEARRANGE, 1 },
-	      [](TX tx, mako_args_t const& args, ByteString& begin, ByteString& end, ByteString&) {
+	      [](TX tx, args_t const& args, ByteString& begin, ByteString& end, ByteString&) {
 	          tx.reset();
 	          tx.clear_range(begin, end);
 	          return Future();
 	      } },
 	    { { OP_READ_BG, 0 },
-	      [](TX tx, mako_args_t const& args, ByteString& begin, ByteString& end, ByteString&) {
+	      [](TX tx, args_t const& args, ByteString& begin, ByteString& end, ByteString&) {
 	          const auto num_begin = next_key(args);
 	          genkey(begin, KEY_PREFIX, args, num_begin);
 	          const auto range = args.txnspec.ops[OP_READ_BG][OP_RANGE];
@@ -555,7 +555,7 @@ using OpIterator = std::tuple<int /*op*/, int /*count*/, int /*step*/>;
 
 constexpr const OpIterator OpEnd = OpIterator(MAX_OP, -1, -1);
 
-OpIterator get_op_begin(mako_args_t const& args) noexcept {
+OpIterator get_op_begin(args_t const& args) noexcept {
 	for (auto op = 0; op < MAX_OP; op++) {
 		if (op == OP_COMMIT || op == OP_TRANSACTION || args.txnspec.ops[op][OP_COUNT] == 0)
 			continue;
@@ -564,7 +564,7 @@ OpIterator get_op_begin(mako_args_t const& args) noexcept {
 	return OpEnd;
 }
 
-OpIterator get_op_next(mako_args_t const& args, OpIterator current) noexcept {
+OpIterator get_op_next(args_t const& args, OpIterator current) noexcept {
 	if (OpEnd == current)
 		return OpEnd;
 	auto [op, count, step] = current;
@@ -581,7 +581,7 @@ OpIterator get_op_next(mako_args_t const& args, OpIterator current) noexcept {
 }
 
 /* run one transaction */
-int run_one_transaction(TX tx, mako_args_t const& args, mako_stats_t& stats, sample_bin_array_t& sample_bins) {
+int run_one_transaction(TX tx, args_t const& args, stats_t& stats, sample_bin_array_t& sample_bins) {
 	// reuse memory for keys to avoid realloc overhead
 	auto key1 = ByteString{};
 	key1.reserve(args.key_length);
@@ -709,12 +709,12 @@ int run_one_transaction(TX tx, mako_args_t const& args, mako_stats_t& stats, sam
 }
 
 int run_workload(TX tx,
-                 mako_args_t const& args,
+                 args_t const& args,
                  int const thread_tps,
                  std::atomic<double> const& throttle_factor,
                  int const thread_iters,
                  std::atomic<int> const& signal,
-                 mako_stats_t& stats,
+                 stats_t& stats,
                  sample_bin_array_t& sample_bins,
                  int const dotrace,
                  int const dotagging) {
@@ -815,31 +815,28 @@ std::string get_stats_file_name(std::string_view dirname, int worker_id, int thr
 
 /* mako worker thread */
 void worker_thread(thread_args_t& thread_args) {
-	const auto& args = *thread_args.process->args;
-	const auto parent_id = thread_args.process->parent_id;
-	const auto worker_id = thread_args.process->worker_id;
+	const auto& args = *thread_args.args;
+	const auto parent_id = thread_args.parent_id;
+	const auto worker_id = thread_args.worker_id;
 	const auto thread_id = thread_args.thread_id;
 	const auto dotrace = (worker_id == 0 && thread_id == 0 && args.txntrace) ? args.txntrace : 0;
+	auto database = thread_args.database;
 	const auto dotagging = args.txntagging;
-	const auto database_index = thread_args.database_index;
-	const auto& signal = thread_args.process->shm->signal;
-	const auto& throttle_factor = thread_args.process->shm->throttle_factor;
-	auto& readycount = thread_args.process->shm->readycount;
-	auto& stopcount = thread_args.process->shm->stopcount;
-	static_assert(std::is_same_v<decltype(std::decay_t<decltype(*thread_args.process)>::shm), mako_shmhdr_t*>);
-	auto& stats = *(reinterpret_cast<mako_stats_t*>(thread_args.process->shm + 1) /* skip header */ +
-	                (worker_id * args.num_threads + thread_id));
+	const auto& signal = thread_args.shm.header_const().signal;
+	const auto& throttle_factor = thread_args.shm.header_const().throttle_factor;
+	auto& readycount = thread_args.shm.header().readycount;
+	auto& stopcount = thread_args.shm.header().stopcount;
+	auto& stats = thread_args.shm.stats_slot(worker_id, thread_id);
 
 	/* init per-thread latency statistics */
-	new (&stats) mako_stats_t();
+	new (&stats) stats_t();
 
 	fmt::print(debugme,
-	           "DEBUG: worker_id:{} ({}) thread_id:{} ({}) database_index:{} (tid:{})\n",
+	           "DEBUG: worker_id:{} ({}) thread_id:{} ({}) (tid:{})\n",
 	           worker_id,
 	           args.num_processes,
 	           thread_id,
 	           args.num_threads,
-	           database_index,
 	           reinterpret_cast<uint64_t>(pthread_self()));
 
 	const auto thread_tps =
@@ -851,7 +848,6 @@ void worker_thread(thread_args_t& thread_args) {
 	        ? 0
 	        : compute_thread_iters(args.iteration, worker_id, thread_id, args.num_processes, args.num_threads);
 
-	auto database = thread_args.process->databases[database_index];
 	/* create my own transaction object */
 	auto tx = database.create_tx();
 
@@ -885,7 +881,7 @@ void worker_thread(thread_args_t& thread_args) {
 	if (args.mode == MODE_BUILD || args.mode == MODE_RUN) {
 		const auto dirname = fmt::format("{}{}", TEMP_DATA_STORE, parent_id);
 		const auto rc = mkdir(dirname.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
-		if (rc < 0) {
+		if (rc < 0 && errno != EEXIST) {
 			fmt::print(stderr, "ERROR: mkdir {}: {}\n", dirname, strerror(errno));
 			return;
 		}
@@ -906,17 +902,10 @@ void worker_thread(thread_args_t& thread_args) {
 }
 
 /* mako worker process */
-int worker_process_main(mako_args_t& args, int worker_id, mako_shmhdr_t* shm, pid_t pid_main) {
-	process_info_t process;
-
-	process.worker_id = worker_id;
-	process.parent_id = pid_main;
-	process.args = &args;
-	process.shm = shm;
-
+int worker_process_main(args_t const& args, int worker_id, shm_access_t shm, pid_t pid_main) {
 	fmt::print(debugme, "DEBUG: worker {} started\n", worker_id);
 
-	Error err;
+	auto err = Error{};
 	/* Everything starts from here */
 
 	select_api_version(args.api_version);
@@ -963,15 +952,19 @@ int worker_process_main(mako_args_t& args, int worker_id, mako_shmhdr_t* shm, pi
 
 	/* enable knobs if specified */
 	if (args.knobs[0] != '\0') {
-		char delim[] = ", ";
-		auto knob = strtok(args.knobs, delim);
-		while (knob != NULL) {
-			fmt::print(debugme, "DEBUG: Setting client knobs: {}\n", knob);
-			err = network::set_option_nothrow(FDB_NET_OPTION_KNOB, BytesRef(to_byte_ptr(knob)));
+		auto knobs = std::string_view(args.knobs);
+		const auto delim = std::string_view(", ");
+		while (true) {
+			knobs.remove_prefix(std::min(knobs.find_first_not_of(delim), knobs.size()));
+			auto knob = knobs.substr(0, knobs.find_first_of(delim));
+			if (knob.empty())
+				break;
+			fmt::print(debugme, "DEBUG: Setting client knob: {}\n", knob);
+			err = network::set_option_nothrow(FDB_NET_OPTION_KNOB, to_bytes_ref(knob));
 			if (err) {
-				fmt::print(stderr, "ERROR: fdb_network_set_option: {}\n", err.what());
+				fmt::print(stderr, "ERROR: fdb_network_set_option({}): {}\n", knob, err.what());
 			}
-			knob = strtok(NULL, delim);
+			knobs.remove_prefix(knob.size());
 		}
 	}
 
@@ -1003,13 +996,14 @@ int worker_process_main(mako_args_t& args, int worker_id, mako_shmhdr_t* shm, pi
 
 	/*** let's party! ***/
 
+	auto databases = std::vector<fdb::Database>(args.num_databases);
 	/* set up database for worker threads */
 	for (auto i = 0; i < args.num_databases; i++) {
 		size_t cluster_index = args.num_fdb_clusters <= 1 ? 0 : i % args.num_fdb_clusters;
-		process.databases.emplace_back(Database(args.cluster_files[cluster_index]));
+		databases[i] = Database(args.cluster_files[cluster_index]);
 		fmt::print(debugme, "DEBUG: creating database at cluster {}\n", args.cluster_files[cluster_index]);
 		if (args.disable_ryw) {
-			process.databases.back().set_option(FDB_DB_OPTION_SNAPSHOT_RYW_DISABLE, BytesRef{});
+			databases[i].set_option(FDB_DB_OPTION_SNAPSHOT_RYW_DISABLE, BytesRef{});
 		}
 	}
 
@@ -1021,16 +1015,19 @@ int worker_process_main(mako_args_t& args, int worker_id, mako_shmhdr_t* shm, pi
 
 	for (auto i = 0; i < args.num_threads; i++) {
 		auto& this_args = thread_args[i];
+		this_args.worker_id = worker_id;
 		this_args.thread_id = i;
-		this_args.database_index = i % args.num_databases;
+		this_args.parent_id = pid_main;
+		this_args.args = &args;
+		this_args.shm = shm;
+		this_args.database = databases[i % args.num_databases];
 
 		/* for ops to run, pre-allocate one latency sample block */
-		for (int op = 0; op < MAX_OP; op++) {
+		for (auto op = 0; op < MAX_OP; op++) {
 			if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
 				this_args.sample_bins[op].reserve_one();
 			}
 		}
-		this_args.process = &process;
 		worker_threads[i] = std::thread(worker_thread, std::ref(this_args));
 	}
 
@@ -1057,11 +1054,11 @@ int worker_process_main(mako_args_t& args, int worker_id, mako_shmhdr_t* shm, pi
 }
 
 /* initialize the parameters with default values */
-int init_args(mako_args_t* args) {
+int init_args(args_t* args) {
 	int i;
 	if (!args)
 		return -1;
-	memset(args, 0, sizeof(mako_args_t)); /* zero-out everything */
+	memset(args, 0, sizeof(args_t)); /* zero-out everything */
 	args->num_fdb_clusters = 0;
 	args->num_databases = 1;
 	args->api_version = max_api_version();
@@ -1106,7 +1103,7 @@ int init_args(mako_args_t* args) {
 }
 
 /* parse transaction specification */
-int parse_transaction(mako_args_t* args, char const* optarg) {
+int parse_transaction(args_t* args, char const* optarg) {
 	char const* ptr = optarg;
 	int op = 0;
 	int rangeop = 0;
@@ -1279,7 +1276,7 @@ void usage() {
 }
 
 /* parse benchmark paramters */
-int parse_args(int argc, char* argv[], mako_args_t* args) {
+int parse_args(int argc, char* argv[], args_t* args) {
 	int rc;
 	int c;
 	int idx;
@@ -1542,7 +1539,7 @@ char const* get_ops_name(int ops_code) {
 	return "";
 }
 
-int validate_args(mako_args_t* args) {
+int validate_args(args_t* args) {
 	if (args->mode == MODE_INVALID) {
 		fprintf(stderr, "ERROR: --mode has to be set\n");
 		return -1;
@@ -1605,10 +1602,10 @@ int validate_args(mako_args_t* args) {
 	return 0;
 }
 
-void print_stats(mako_args_t const& args, mako_stats_t const* stats, double const duration_sec, FILE* fp) {
-	static mako_stats_t prev;
+void print_stats(args_t const& args, stats_t const* stats, double const duration_sec, FILE* fp) {
+	static stats_t prev;
 
-	auto current = mako_stats_t{};
+	auto current = stats_t{};
 	for (auto i = 0; i < args.num_processes; i++) {
 		for (auto j = 0; j < args.num_threads; j++) {
 			current.combine(stats[(i * args.num_threads) + j]);
@@ -1665,7 +1662,7 @@ void print_stats(mako_args_t const& args, mako_stats_t const* stats, double cons
 	prev = current;
 }
 
-void print_stats_header(mako_args_t const& args, bool show_commit, bool is_first_header_empty, bool show_op_stats) {
+void print_stats_header(args_t const& args, bool show_commit, bool is_first_header_empty, bool show_op_stats) {
 	/* header */
 	if (is_first_header_empty)
 		put_title("");
@@ -1709,13 +1706,9 @@ void print_stats_header(mako_args_t const& args, bool show_commit, bool is_first
 	fmt::print("\n");
 }
 
-void print_report(mako_args_t const& args,
-                  mako_stats_t const* stats,
-                  double const duration_sec,
-                  pid_t pid_main,
-                  FILE* fp) {
+void print_report(args_t const& args, stats_t const* stats, double const duration_sec, pid_t pid_main, FILE* fp) {
 
-	auto final_stats = mako_stats_t{};
+	auto final_stats = stats_t{};
 	for (auto i = 0; i < args.num_processes; i++) {
 		for (auto j = 0; j < args.num_threads; j++) {
 			const auto idx = i * args.num_threads + j;
@@ -1945,7 +1938,7 @@ void print_report(mako_args_t const& args,
 						const auto filename = get_stats_file_name(dirname, i, j, op);
 						auto fp = fopen(filename.c_str(), "r");
 						if (!fp) {
-							fmt::print(stderr, "ERROR: fopen({}): {}\n", strerror(errno));
+							fmt::print(stderr, "ERROR: fopen({}): {}\n", filename, strerror(errno));
 							continue;
 						}
 						auto fclose_guard = ExitGuard([fp]() { fclose(fp); });
@@ -2072,11 +2065,11 @@ void print_report(mako_args_t const& args,
 	system(command_remove.c_str());
 }
 
-int stats_process_main(mako_args_t const& args,
-                       mako_stats_t* stats,
+int stats_process_main(args_t const& args,
+                       stats_t const* stats,
                        std::atomic<double>& throttle_factor,
-                       std::atomic<int>& signal,
-                       std::atomic<int>& stopcount,
+                       std::atomic<int> const& signal,
+                       std::atomic<int> const& stopcount,
                        pid_t pid_main) {
 	bool first_stats = true;
 
@@ -2207,7 +2200,7 @@ int main(int argc, char* argv[]) {
 	setlinebuf(stdout);
 
 	auto rc = int{};
-	auto args = mako_args_t{};
+	auto args = args_t{};
 	rc = init_args(&args);
 	if (rc < 0) {
 		fmt::print(stderr, "ERROR: init_args failed\n");
@@ -2250,33 +2243,33 @@ int main(int argc, char* argv[]) {
 	});
 
 	/* allocate */
-	const auto shmsize = sizeof(mako_shmhdr_t) + (sizeof(mako_stats_t) * args.num_processes * args.num_threads);
-	auto shm = static_cast<mako_shmhdr_t*>(nullptr);
+	const auto shmsize = shm_storage_size(args.num_processes, args.num_threads);
+	auto shm = std::add_pointer_t<void>{};
 	if (ftruncate(shmfd, shmsize) < 0) {
-		shm = static_cast<mako_shmhdr_t*>(MAP_FAILED);
+		shm = MAP_FAILED;
 		fmt::print(stderr, "ERROR: ftruncate (fd:{} size:{}) failed\n", shmfd, shmsize);
 		return -1;
 	}
 
 	/* map it */
-	shm = static_cast<mako_shmhdr_t*>(mmap(NULL, shmsize, PROT_READ | PROT_WRITE, MAP_SHARED, shmfd, 0));
+	shm = mmap(NULL, shmsize, PROT_READ | PROT_WRITE, MAP_SHARED, shmfd, 0);
 	if (shm == MAP_FAILED) {
 		fmt::print(stderr, "ERROR: mmap (fd:{} size:{}) failed\n", shmfd, shmsize);
 		return -1;
 	}
 	auto munmap_guard = ExitGuard([=]() { munmap(shm, shmsize); });
 
-	static_assert(std::is_same_v<decltype(shm), mako_shmhdr_t*>);
-	auto stats = reinterpret_cast<mako_stats_t*>(shm + 1);
+	auto shm_access = shm_access_t(shm, args.num_processes, args.num_threads);
 
 	/* initialize the shared memory */
-	memset(shm, 0, shmsize);
+	shm_access.reset();
 
 	/* get ready */
-	shm->signal = SIGNAL_OFF;
-	shm->readycount = 0;
-	shm->stopcount = 0;
-	shm->throttle_factor = 1.0;
+	auto& shm_hdr = shm_access.header();
+	shm_hdr.signal = SIGNAL_OFF;
+	shm_hdr.readycount = 0;
+	shm_hdr.stopcount = 0;
+	shm_hdr.throttle_factor = 1.0;
 
 	auto proc_type = proc_master;
 	/* fork worker processes + 1 stats process */
@@ -2317,7 +2310,7 @@ int main(int argc, char* argv[]) {
 
 	if (proc_type == proc_worker) {
 		/* worker process */
-		worker_process_main(args, worker_id, shm, pid_main);
+		worker_process_main(args, worker_id, shm_access, pid_main);
 		/* worker can exit here */
 		exit(0);
 	} else if (proc_type == proc_stats) {
@@ -2326,16 +2319,17 @@ int main(int argc, char* argv[]) {
 			/* no stats needed for clean mode */
 			exit(0);
 		}
-		stats_process_main(args, stats, shm->throttle_factor, shm->signal, shm->stopcount, pid_main);
+		stats_process_main(
+		    args, shm_access.stats_const_array(), shm_hdr.throttle_factor, shm_hdr.signal, shm_hdr.stopcount, pid_main);
 		exit(0);
 	}
 
 	/* master */
 	/* wait for everyone to be ready */
-	while (shm->readycount < (args.num_processes * args.num_threads)) {
+	while (shm_hdr.readycount.load() < (args.num_processes * args.num_threads)) {
 		usleep(1000);
 	}
-	shm->signal = SIGNAL_GREEN;
+	shm_hdr.signal.store(SIGNAL_GREEN);
 
 	if (args.mode == MODE_RUN) {
 		/* run the benchmark */
@@ -2361,7 +2355,7 @@ int main(int argc, char* argv[]) {
 			}
 
 			/* notify everyone the time's up */
-			shm->signal = SIGNAL_RED;
+			shm_hdr.signal.store(SIGNAL_RED);
 		}
 	}
 
@@ -2382,7 +2376,7 @@ int main(int argc, char* argv[]) {
 
 	/* all worker threads finished, stop the stats */
 	if (args.mode == MODE_BUILD || args.iteration > 0) {
-		shm->signal = SIGNAL_RED;
+		shm_hdr.signal.store(SIGNAL_RED);
 	}
 
 	/* wait for stats to stop */
diff --git a/bindings/c/test/mako/mako.hpp b/bindings/c/test/mako/mako.hpp
index f60e613283..bb7276e48b 100644
--- a/bindings/c/test/mako/mako.hpp
+++ b/bindings/c/test/mako/mako.hpp
@@ -1,6 +1,5 @@
 #ifndef MAKO_HPP
 #define MAKO_HPP
-#pragma once
 
 #ifndef FDB_API_VERSION
 #define FDB_API_VERSION 710
@@ -24,6 +23,12 @@
 #else
 #include <limits.h>
 #endif
+#include "operations.hpp"
+#include "shm.hpp"
+#include "stats.hpp"
+#include "time.hpp"
+
+namespace mako {
 
 constexpr const int VERBOSE_NONE = 0;
 constexpr const int VERBOSE_DEFAULT = 1;
@@ -35,34 +40,6 @@ constexpr const int MODE_CLEAN = 0;
 constexpr const int MODE_BUILD = 1;
 constexpr const int MODE_RUN = 2;
 
-/* size of each block to get detailed latency for each operation */
-constexpr const size_t LAT_BLOCK_SIZE = 16384;
-
-/* transaction specification */
-enum Operations {
-	OP_GETREADVERSION,
-	OP_GET,
-	OP_GETRANGE,
-	OP_SGET,
-	OP_SGETRANGE,
-	OP_UPDATE,
-	OP_INSERT,
-	OP_INSERTRANGE,
-	OP_OVERWRITE,
-	OP_CLEAR,
-	OP_SETCLEAR,
-	OP_CLEARRANGE,
-	OP_SETCLEARRANGE,
-	OP_COMMIT,
-	OP_TRANSACTION, /* pseudo-operation - cumulative time for the operation + commit */
-	OP_READ_BG,
-	MAX_OP /* must be the last item */
-};
-
-constexpr const int OP_COUNT = 0;
-constexpr const int OP_RANGE = 1;
-constexpr const int OP_REVERSE = 2;
-
 /* for long arguments */
 enum Arguments {
 	ARG_KEYLEN,
@@ -94,14 +71,14 @@ enum Arguments {
 
 enum TPSChangeTypes { TPS_SIN, TPS_SQUARE, TPS_PULSE };
 
-/* we set mako_txnspec_t and mako_args_t only once in the master process,
+/* we set txnspec_t and args_t only once in the master process,
  * and won't be touched by child processes.
  */
 
-typedef struct {
+struct txnspec_t {
 	/* for each operation, it stores "count", "range" and "reverse" */
 	int ops[MAX_OP][3];
-} mako_txnspec_t;
+};
 
 constexpr const int LOGGROUP_MAX = 256;
 constexpr const int KNOB_MAX = 256;
@@ -111,7 +88,7 @@ constexpr const int NUM_DATABASES_MAX = 10;
 constexpr const int MAX_BG_IDS = 1000;
 
 /* benchmark parameters */
-struct mako_args_t {
+struct args_t {
 	int api_version;
 	int json;
 	int num_processes;
@@ -131,7 +108,7 @@ struct mako_args_t {
 	int zipf;
 	int commit_get;
 	int verbose;
-	mako_txnspec_t txnspec;
+	txnspec_t txnspec;
 	char cluster_files[NUM_CLUSTERS_MAX][PATH_MAX];
 	int num_fdb_clusters;
 	int num_databases;
@@ -158,205 +135,21 @@ constexpr const int SIGNAL_RED = 0;
 constexpr const int SIGNAL_GREEN = 1;
 constexpr const int SIGNAL_OFF = 2;
 
-struct mako_shmhdr_t {
-	std::atomic<int> signal;
-	std::atomic<int> readycount;
-	std::atomic<double> throttle_factor;
-	std::atomic<int> stopcount;
-};
-
-/* per-process information */
-typedef struct {
-	int worker_id;
-	pid_t parent_id;
-	mako_args_t* args;
-	mako_shmhdr_t* shm;
-	std::vector<fdb::Database> databases;
-} process_info_t;
-
-/* time measurement helpers */
-using std::chrono::steady_clock;
-using timepoint_t = decltype(steady_clock::now());
-using timediff_t = decltype(std::declval<timepoint_t>()-std::declval<timepoint_t>());
-
-template <typename Duration>
-double to_double_seconds(Duration duration) {
-	return std::chrono::duration_cast<std::chrono::duration<double>>(duration).count();
-}
-
-template <typename Duration>
-uint64_t to_integer_seconds(Duration duration) {
-	return std::chrono::duration_cast<std::chrono::duration<uint64_t>>(duration).count();
-}
-
-template <typename Duration>
-uint64_t to_integer_microseconds(Duration duration) {
-	return std::chrono::duration_cast<std::chrono::duration<uint64_t, std::micro>>(duration).count();
-}
-
-class alignas(64) mako_stats_t {
-	uint64_t xacts;
-	uint64_t conflicts;
-	uint64_t total_errors;
-	uint64_t ops[MAX_OP];
-	uint64_t errors[MAX_OP];
-	uint64_t latency_samples[MAX_OP];
-	uint64_t latency_us_total[MAX_OP];
-	uint64_t latency_us_min[MAX_OP];
-	uint64_t latency_us_max[MAX_OP];
-
-public:
-	mako_stats_t() noexcept {
-		memset(this, 0, sizeof(mako_stats_t));
-		memset(latency_us_min, 0xff, sizeof(latency_us_min));
-	}
-
-	mako_stats_t(const mako_stats_t& other) noexcept = default;
-	mako_stats_t& operator=(const mako_stats_t& other) noexcept = default;
-
-	uint64_t get_tx_count() const noexcept { return xacts; }
-
-	uint64_t get_conflict_count() const noexcept { return conflicts; }
-
-	uint64_t get_op_count(int op) const noexcept { return ops[op]; }
-
-	uint64_t get_error_count(int op) const noexcept { return errors[op]; }
-
-	uint64_t get_total_error_count() const noexcept { return total_errors; }
-
-	uint64_t get_latency_sample_count(int op) const noexcept { return latency_samples[op]; }
-
-	uint64_t get_latency_us_total(int op) const noexcept { return latency_us_total[op]; }
-
-	uint64_t get_latency_us_min(int op) const noexcept { return latency_us_min[op]; }
-
-	uint64_t get_latency_us_max(int op) const noexcept { return latency_us_max[op]; }
-
-	// with 'this' as final aggregation, factor in 'other'
-	void combine(const mako_stats_t& other) {
-		xacts += other.xacts;
-		conflicts += other.conflicts;
-		for (auto op = 0; op < MAX_OP; op++) {
-			ops[op] += other.ops[op];
-			errors[op] += other.errors[op];
-			total_errors += other.errors[op];
-			latency_samples[op] += other.latency_samples[op];
-			latency_us_total[op] += other.latency_us_total[op];
-			if (latency_us_min[op] > other.latency_us_min[op])
-				latency_us_min[op] = other.latency_us_min[op];
-			if (latency_us_max[op] < other.latency_us_max[op])
-				latency_us_max[op] = other.latency_us_max[op];
-		}
-	}
-
-	void incr_tx_count() noexcept { xacts++; }
-	void incr_conflict_count() noexcept { conflicts++; }
-
-	// non-commit write operations aren't measured for time.
-	void incr_op_count(int op) noexcept { ops[op]++; }
-
-	void incr_error_count(int op) noexcept {
-		total_errors++;
-		errors[op]++;
-	}
-
-	void add_latency(int op, timediff_t diff) noexcept {
-		const auto latency_us = to_integer_microseconds(diff);
-		latency_samples[op]++;
-		latency_us_total[op] += latency_us;
-		if (latency_us_min[op] > latency_us)
-			latency_us_min[op] = latency_us;
-		if (latency_us_max[op] < latency_us)
-			latency_us_max[op] = latency_us;
-	}
-};
-
-
-
-/* memory block allocated to each operation when collecting detailed latency */
-class lat_block_t {
-	uint64_t samples[LAT_BLOCK_SIZE]{
-		0,
-	};
-	uint32_t index{ 0 };
-
-public:
-	lat_block_t() noexcept = default;
-	bool full() const noexcept { return index >= LAT_BLOCK_SIZE; }
-	void put(timediff_t td) {
-		assert(!full());
-		samples[index++] = to_integer_microseconds(td);
-	}
-	// return {data block, number of samples}
-	std::pair<uint64_t const*, size_t> data() const noexcept { return { samples, index }; }
-};
-
-/* collect sampled latencies */
-class sample_bin {
-	std::list<lat_block_t> blocks;
-
-public:
-	void reserve_one() {
-		if (blocks.empty())
-			blocks.emplace_back();
-	}
-
-	void put(timediff_t td) {
-		if (blocks.empty() || blocks.back().full())
-			blocks.emplace_back();
-		blocks.back().put(td);
-	}
-
-	// iterate & apply for each block user function void(uint64_t const*, size_t)
-	template <typename Func>
-	void for_each_block(Func&& fn) const {
-		for (const auto& block : blocks) {
-			auto [ptr, cnt] = block.data();
-			fn(ptr, cnt);
-		}
-	}
-};
-
 using sample_bin_array_t = std::array<sample_bin, MAX_OP>;
 /* args for threads */
 struct alignas(64) thread_args_t {
+	int worker_id;
 	int thread_id;
-	int database_index; // index of the database to do work to
+	pid_t parent_id;
 	sample_bin_array_t sample_bins;
-	process_info_t* process;
+	args_t const* args;
+	shm_access_t shm;
+	fdb::Database database; // database to work with
 };
 
 /* process type */
 typedef enum { proc_master = 0, proc_worker, proc_stats } proc_type_t;
 
-// determines how resultant future will be handled
-enum class StepKind {
-	NONE, ///< not part of the table: OP_TRANSACTION, OP_COMMIT
-	IMM, ///< non-future ops that return immediately: e.g. set, clear_range
-	READ, ///< blockable reads: get(), get_range(), get_read_version, ...
-	COMMIT, ///< self-explanatory
-	ON_ERROR ///< future is a result of tx.on_error()
-};
-
-class OpDesc {
-	std::string_view name_;
-	std::vector<StepKind> steps_;
-	bool needs_commit_;
-
-public:
-	OpDesc(std::string_view name, std::vector<StepKind>&& steps, bool needs_commit)
-	  : name_(name), steps_(std::move(steps)), needs_commit_(needs_commit) {}
-
-	std::string_view name() const noexcept { return name_; }
-	// what
-	StepKind step_kind(int step) const noexcept {
-		assert(step < steps());
-		return steps_[step];
-	}
-	// how many steps in this op?
-	int steps() const noexcept { return static_cast<int>(steps_.size()); }
-	// does the op needs to commit some time after its final step?
-	bool needs_commit() const noexcept { return needs_commit_; }
-};
+} // namespace mako
 
 #endif /* MAKO_HPP */
diff --git a/bindings/c/test/mako/operations.hpp b/bindings/c/test/mako/operations.hpp
new file mode 100644
index 0000000000..f6260101bc
--- /dev/null
+++ b/bindings/c/test/mako/operations.hpp
@@ -0,0 +1,66 @@
+#ifndef MAKO_OPERATIONS_HPP
+#define MAKO_OPERATIONS_HPP
+
+#include <vector>
+#include <string_view>
+
+namespace mako {
+
+/* transaction specification */
+enum Operations {
+	OP_GETREADVERSION,
+	OP_GET,
+	OP_GETRANGE,
+	OP_SGET,
+	OP_SGETRANGE,
+	OP_UPDATE,
+	OP_INSERT,
+	OP_INSERTRANGE,
+	OP_OVERWRITE,
+	OP_CLEAR,
+	OP_SETCLEAR,
+	OP_CLEARRANGE,
+	OP_SETCLEARRANGE,
+	OP_COMMIT,
+	OP_TRANSACTION, /* pseudo-operation - cumulative time for the operation + commit */
+	OP_READ_BG,
+	MAX_OP /* must be the last item */
+};
+
+constexpr const int OP_COUNT = 0;
+constexpr const int OP_RANGE = 1;
+constexpr const int OP_REVERSE = 2;
+
+// determines how resultant future will be handled
+enum class StepKind {
+	NONE, ///< not part of the table: OP_TRANSACTION, OP_COMMIT
+	IMM, ///< non-future ops that return immediately: e.g. set, clear_range
+	READ, ///< blockable reads: get(), get_range(), get_read_version, ...
+	COMMIT, ///< self-explanatory
+	ON_ERROR ///< future is a result of tx.on_error()
+};
+
+class OpDesc {
+	std::string_view name_;
+	std::vector<StepKind> steps_;
+	bool needs_commit_;
+
+public:
+	OpDesc(std::string_view name, std::vector<StepKind>&& steps, bool needs_commit)
+	  : name_(name), steps_(std::move(steps)), needs_commit_(needs_commit) {}
+
+	std::string_view name() const noexcept { return name_; }
+	// what
+	StepKind step_kind(int step) const noexcept {
+		assert(step < steps());
+		return steps_[step];
+	}
+	// how many steps in this op?
+	int steps() const noexcept { return static_cast<int>(steps_.size()); }
+	// does the op needs to commit some time after its final step?
+	bool needs_commit() const noexcept { return needs_commit_; }
+};
+
+} // namespace mako
+
+#endif /* MAKO_OPERATIONS_HPP */
diff --git a/bindings/c/test/mako/shm.hpp b/bindings/c/test/mako/shm.hpp
new file mode 100644
index 0000000000..103458277c
--- /dev/null
+++ b/bindings/c/test/mako/shm.hpp
@@ -0,0 +1,75 @@
+#ifndef MAKO_SHM_HPP
+#define MAKO_SHM_HPP
+
+#include <atomic>
+#include <cassert>
+#include <cstdint>
+#include "stats.hpp"
+
+namespace mako {
+
+struct shmhdr_t {
+	std::atomic<int> signal;
+	std::atomic<int> readycount;
+	std::atomic<double> throttle_factor;
+	std::atomic<int> stopcount;
+};
+
+struct shm_layout_helper {
+	shmhdr_t hdr;
+	stats_t stats;
+};
+
+inline size_t shm_storage_size(int num_processes, int num_threads) noexcept {
+	assert(num_processes >= 1 && num_threads >= 1);
+	return sizeof(shm_layout_helper) + sizeof(stats_t) * ((num_processes * num_threads) - 1);
+}
+
+inline stats_t& shm_stats_slot(void* shm_base, int num_threads, int process_idx, int thread_idx) noexcept {
+	return (&static_cast<shm_layout_helper*>(shm_base)->stats)[process_idx * num_threads + thread_idx];
+}
+
+class shm_access_t {
+protected:
+	void* base;
+	int num_processes;
+	int num_threads;
+
+public:
+	shm_access_t(void* shm, int num_processes, int num_threads) noexcept
+	  : base(shm), num_processes(num_processes), num_threads(num_threads) {}
+
+	shm_access_t() noexcept : shm_access_t(nullptr, 0, 0) {}
+
+	shm_access_t(const shm_access_t&) noexcept = default;
+
+	shm_access_t& operator=(const shm_access_t&) noexcept = default;
+
+	size_t storage_size() const noexcept { return shm_storage_size(num_processes, num_threads); }
+
+	void reset() noexcept { memset(base, 0, storage_size()); }
+
+	shmhdr_t const& header_const() const noexcept { return *static_cast<shmhdr_t const*>(base); }
+
+	shmhdr_t& header() const noexcept { return *static_cast<shmhdr_t*>(base); }
+
+	stats_t const* stats_const_array() const noexcept {
+		return &shm_stats_slot(base, num_threads, 0 /*process_id*/, 0 /*thread_id*/);
+	}
+
+	stats_t* stats_array() const noexcept {
+		return &shm_stats_slot(base, num_threads, 0 /*process_id*/, 0 /*thread_id*/);
+	}
+
+	stats_t const& stats_const_slot(int process_idx, int thread_idx) const noexcept {
+		return shm_stats_slot(base, num_threads, process_idx, thread_idx);
+	}
+
+	stats_t& stats_slot(int process_idx, int thread_idx) const noexcept {
+		return shm_stats_slot(base, num_threads, process_idx, thread_idx);
+	}
+};
+
+} // namespace mako
+
+#endif /* MAKO_SHM_HPP */
diff --git a/bindings/c/test/mako/stats.hpp b/bindings/c/test/mako/stats.hpp
new file mode 100644
index 0000000000..065ab04824
--- /dev/null
+++ b/bindings/c/test/mako/stats.hpp
@@ -0,0 +1,139 @@
+#ifndef MAKO_STATS_HPP
+#define MAKO_STATS_HPP
+
+#include <cstdint>
+#include <cstring>
+#include <list>
+#include <utility>
+#include "operations.hpp"
+#include "time.hpp"
+
+namespace mako {
+
+/* size of each block to get detailed latency for each operation */
+constexpr const size_t LAT_BLOCK_SIZE = 4095;
+
+/* memory block allocated to each operation when collecting detailed latency */
+class lat_block_t {
+	uint64_t samples[LAT_BLOCK_SIZE]{
+		0,
+	};
+	uint32_t index{ 0 };
+
+public:
+	lat_block_t() noexcept = default;
+	bool full() const noexcept { return index >= LAT_BLOCK_SIZE; }
+	void put(timediff_t td) {
+		assert(!full());
+		samples[index++] = to_integer_microseconds(td);
+	}
+	// return {data block, number of samples}
+	std::pair<uint64_t const*, size_t> data() const noexcept { return { samples, index }; }
+};
+
+/* collect sampled latencies */
+class sample_bin {
+	std::list<lat_block_t> blocks;
+
+public:
+	void reserve_one() {
+		if (blocks.empty())
+			blocks.emplace_back();
+	}
+
+	void put(timediff_t td) {
+		if (blocks.empty() || blocks.back().full())
+			blocks.emplace_back();
+		blocks.back().put(td);
+	}
+
+	// iterate & apply for each block user function void(uint64_t const*, size_t)
+	template <typename Func>
+	void for_each_block(Func&& fn) const {
+		for (const auto& block : blocks) {
+			auto [ptr, cnt] = block.data();
+			fn(ptr, cnt);
+		}
+	}
+};
+
+class alignas(64) stats_t {
+	uint64_t xacts;
+	uint64_t conflicts;
+	uint64_t total_errors;
+	uint64_t ops[MAX_OP];
+	uint64_t errors[MAX_OP];
+	uint64_t latency_samples[MAX_OP];
+	uint64_t latency_us_total[MAX_OP];
+	uint64_t latency_us_min[MAX_OP];
+	uint64_t latency_us_max[MAX_OP];
+
+public:
+	stats_t() noexcept {
+		memset(this, 0, sizeof(stats_t));
+		memset(latency_us_min, 0xff, sizeof(latency_us_min));
+	}
+
+	stats_t(const stats_t& other) noexcept = default;
+	stats_t& operator=(const stats_t& other) noexcept = default;
+
+	uint64_t get_tx_count() const noexcept { return xacts; }
+
+	uint64_t get_conflict_count() const noexcept { return conflicts; }
+
+	uint64_t get_op_count(int op) const noexcept { return ops[op]; }
+
+	uint64_t get_error_count(int op) const noexcept { return errors[op]; }
+
+	uint64_t get_total_error_count() const noexcept { return total_errors; }
+
+	uint64_t get_latency_sample_count(int op) const noexcept { return latency_samples[op]; }
+
+	uint64_t get_latency_us_total(int op) const noexcept { return latency_us_total[op]; }
+
+	uint64_t get_latency_us_min(int op) const noexcept { return latency_us_min[op]; }
+
+	uint64_t get_latency_us_max(int op) const noexcept { return latency_us_max[op]; }
+
+	// with 'this' as final aggregation, factor in 'other'
+	void combine(const stats_t& other) {
+		xacts += other.xacts;
+		conflicts += other.conflicts;
+		for (auto op = 0; op < MAX_OP; op++) {
+			ops[op] += other.ops[op];
+			errors[op] += other.errors[op];
+			total_errors += other.errors[op];
+			latency_samples[op] += other.latency_samples[op];
+			latency_us_total[op] += other.latency_us_total[op];
+			if (latency_us_min[op] > other.latency_us_min[op])
+				latency_us_min[op] = other.latency_us_min[op];
+			if (latency_us_max[op] < other.latency_us_max[op])
+				latency_us_max[op] = other.latency_us_max[op];
+		}
+	}
+
+	void incr_tx_count() noexcept { xacts++; }
+	void incr_conflict_count() noexcept { conflicts++; }
+
+	// non-commit write operations aren't measured for time.
+	void incr_op_count(int op) noexcept { ops[op]++; }
+
+	void incr_error_count(int op) noexcept {
+		total_errors++;
+		errors[op]++;
+	}
+
+	void add_latency(int op, timediff_t diff) noexcept {
+		const auto latency_us = to_integer_microseconds(diff);
+		latency_samples[op]++;
+		latency_us_total[op] += latency_us;
+		if (latency_us_min[op] > latency_us)
+			latency_us_min[op] = latency_us;
+		if (latency_us_max[op] < latency_us)
+			latency_us_max[op] = latency_us;
+	}
+};
+
+} // namespace mako
+
+#endif /* MAKO_STATS_HPP */
diff --git a/bindings/c/test/mako/time.hpp b/bindings/c/test/mako/time.hpp
new file mode 100644
index 0000000000..835d4b4f51
--- /dev/null
+++ b/bindings/c/test/mako/time.hpp
@@ -0,0 +1,57 @@
+#ifndef MAKO_TIME_HPP
+#define MAKO_TIME_HPP
+
+#include <chrono>
+
+namespace mako {
+
+/* time measurement helpers */
+using std::chrono::steady_clock;
+using timepoint_t = decltype(steady_clock::now());
+using timediff_t = decltype(std::declval<timepoint_t>() - std::declval<timepoint_t>());
+
+template <typename Duration>
+double to_double_seconds(Duration duration) {
+	return std::chrono::duration_cast<std::chrono::duration<double>>(duration).count();
+}
+
+template <typename Duration>
+uint64_t to_integer_seconds(Duration duration) {
+	return std::chrono::duration_cast<std::chrono::duration<uint64_t>>(duration).count();
+}
+
+template <typename Duration>
+uint64_t to_integer_microseconds(Duration duration) {
+	return std::chrono::duration_cast<std::chrono::duration<uint64_t, std::micro>>(duration).count();
+}
+
+// timing helpers
+struct start_at_ctor {};
+
+class Stopwatch {
+	timepoint_t p1, p2;
+
+public:
+	Stopwatch() noexcept = default;
+	Stopwatch(start_at_ctor) noexcept { start(); }
+	Stopwatch(timepoint_t start_time) noexcept : p1(start_time), p2() {}
+	Stopwatch(const Stopwatch&) noexcept = default;
+	Stopwatch& operator=(const Stopwatch&) noexcept = default;
+	timepoint_t get_start() const noexcept { return p1; }
+	timepoint_t get_stop() const noexcept { return p2; }
+	void start() noexcept { p1 = steady_clock::now(); }
+	Stopwatch& stop() noexcept {
+		p2 = steady_clock::now();
+		return *this;
+	}
+	Stopwatch& set_stop(timepoint_t p_stop) noexcept {
+		p2 = p_stop;
+		return *this;
+	}
+	void start_from_stop() noexcept { p1 = p2; }
+	auto diff() const noexcept { return p2 - p1; }
+};
+
+} // namespace mako
+
+#endif /* MAKO_TIME_HPP */
diff --git a/bindings/c/test/mako/utils.cpp b/bindings/c/test/mako/utils.cpp
index ba42361593..360a761f6a 100644
--- a/bindings/c/test/mako/utils.cpp
+++ b/bindings/c/test/mako/utils.cpp
@@ -6,6 +6,8 @@
 #include <cstring>
 #include <fmt/format.h>
 
+namespace mako {
+
 /* uniform-distribution random */
 int urand(int low, int high) {
 	double r = rand() / (1.0 + RAND_MAX);
@@ -47,3 +49,5 @@ int digits(int num) {
 	}
 	return digits;
 }
+
+} // namespace mako
diff --git a/bindings/c/test/mako/utils.hpp b/bindings/c/test/mako/utils.hpp
index 012a360dfc..2382a9373b 100644
--- a/bindings/c/test/mako/utils.hpp
+++ b/bindings/c/test/mako/utils.hpp
@@ -9,6 +9,9 @@
 #include <type_traits>
 
 #include <fmt/format.h>
+
+namespace mako {
+
 /* uniform-distribution random */
 /* return a uniform random number between low and high, both inclusive */
 int urand(int low, int high);
@@ -69,7 +72,7 @@ int digits(int num);
  * (str) is appended with concat([padding], PREFIX)
  */
 template <bool Clear = true, typename Char>
-void genkeyprefix(std::basic_string<Char>& str, std::string_view prefix, mako_args_t const& args) {
+void genkeyprefix(std::basic_string<Char>& str, std::string_view prefix, args_t const& args) {
 	// concat('x' * padding_len, key_prefix)
 	if constexpr (Clear)
 		str.clear();
@@ -83,7 +86,7 @@ void genkeyprefix(std::basic_string<Char>& str, std::string_view prefix, mako_ar
 /* generate a key for a given key number */
 /* prefix is "mako" by default, prefixpadding = 1 means 'x' will be in front rather than trailing the keyname */
 template <bool Clear = true, typename Char>
-void genkey(std::basic_string<Char>& str, std::string_view prefix, mako_args_t const& args, int num) {
+void genkey(std::basic_string<Char>& str, std::string_view prefix, args_t const& args, int num) {
 	static_assert(sizeof(Char) == 1);
 	const auto pad_len = args.prefixpadding ? args.key_length - (static_cast<int>(prefix.size()) + args.row_digits) : 0;
 	assert(pad_len >= 0);
@@ -127,40 +130,6 @@ public:
 	}
 };
 
-// timing helpers
-struct start_at_ctor{};
-
-class Stopwatch {
-	timepoint_t p1, p2;
-public:
-	Stopwatch() noexcept = default;
-	Stopwatch(start_at_ctor) noexcept {
-		start();
-	}
-	Stopwatch(timepoint_t start_time) noexcept : p1(start_time), p2() {}
-	Stopwatch(const Stopwatch&) noexcept = default;
-	Stopwatch& operator=(const Stopwatch&) noexcept = default;
-	timepoint_t get_start() const noexcept { return p1; }
-	timepoint_t get_stop() const noexcept { return p2; }
-	void start() noexcept {
-		p1 = steady_clock::now();
-	}
-	Stopwatch& stop() noexcept {
-		p2 = steady_clock::now();
-		return *this;
-	}
-	Stopwatch& set_stop(timepoint_t p_stop) noexcept {
-		p2 = p_stop;
-		return *this;
-	}
-	void start_from_stop() noexcept {
-		p1 = p2;
-	}
-	auto diff() const noexcept {
-		return p2 - p1;
-	}
-};
-
 // trace helpers
 constexpr const int STATS_TITLE_WIDTH = 12;
 constexpr const int STATS_FIELD_WIDTH = 12;
@@ -193,4 +162,6 @@ void put_field_f(Value&& value, int precision) {
 	fmt::print("{0: >{1}.{2}f} ", std::forward<Value>(value), STATS_FIELD_WIDTH, precision);
 }
 
+} // namespace mako
+
 #endif /* UTILS_HPP */

From 8c0d3e9469a5ff2f3a1a85b5be08d75ac81d6d2c Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Mon, 7 Mar 2022 04:51:10 +0100
Subject: [PATCH 09/84] Use camelCase for FDB API & Mako classes

---
 bindings/c/test/fdb.hpp        | 282 +++++++++++-----------
 bindings/c/test/mako/mako.cpp  | 424 +++++++++++++++++----------------
 bindings/c/test/mako/mako.hpp  |  21 +-
 bindings/c/test/mako/shm.hpp   |  62 ++---
 bindings/c/test/mako/stats.hpp |  27 ++-
 bindings/c/test/mako/utils.cpp |   6 +-
 bindings/c/test/mako/utils.hpp |  42 ++--
 7 files changed, 438 insertions(+), 426 deletions(-)

diff --git a/bindings/c/test/fdb.hpp b/bindings/c/test/fdb.hpp
index 94383d3d32..fdad6f96f6 100644
--- a/bindings/c/test/fdb.hpp
+++ b/bindings/c/test/fdb.hpp
@@ -27,28 +27,28 @@ using CharsRef = std::string_view;
 using KeyRef = BytesRef;
 using ValueRef = BytesRef;
 
-inline uint8_t const* to_byte_ptr(char const* ptr) noexcept {
+inline uint8_t const* toBytePtr(char const* ptr) noexcept {
 	return reinterpret_cast<uint8_t const*>(ptr);
 }
 
 // get bytestring view from charstring: e.g. std::basic_string{_view}<char>
 template <template <class...> class StringLike, class Char>
-BytesRef to_bytes_ref(const StringLike<Char>& s) noexcept {
+BytesRef toBytesRef(const StringLike<Char>& s) noexcept {
 	static_assert(sizeof(Char) == 1);
 	return BytesRef(reinterpret_cast<uint8_t const*>(s.data()), s.size());
 }
 
 // get charstring view from bytestring: e.g. std::basic_string{_view}<uint8_t>
 template <template <class...> class StringLike, class Char>
-CharsRef to_chars_ref(const StringLike<Char>& s) noexcept {
+CharsRef toCharsRef(const StringLike<Char>& s) noexcept {
 	static_assert(sizeof(Char) == 1);
 	return CharsRef(reinterpret_cast<char const*>(s.data()), s.size());
 }
 
-[[maybe_unused]] constexpr const bool overflow_check = false;
+[[maybe_unused]] constexpr const bool OverflowCheck = false;
 
-inline int intsize(BytesRef b) {
-	if constexpr (overflow_check) {
+inline int intSize(BytesRef b) {
+	if constexpr (OverflowCheck) {
 		if (b.size() > static_cast<size_t>(std::numeric_limits<int>::max()))
 			throw std::overflow_error("byte strlen goes beyond int bounds");
 	}
@@ -57,49 +57,49 @@ inline int intsize(BytesRef b) {
 
 class Error {
 public:
-	using code_type = native::fdb_error_t;
+	using CodeType = native::fdb_error_t;
 
 	Error() noexcept : err(0) {}
 
-	explicit Error(code_type err) noexcept : err(err) {}
+	explicit Error(CodeType err) noexcept : err(err) {}
 
 	char const* what() noexcept { return native::fdb_get_error(err); }
 
 	explicit operator bool() const noexcept { return err != 0; }
 
-	bool is(code_type other) const noexcept { return err != other; }
+	bool is(CodeType other) const noexcept { return err != other; }
 
-	code_type code() const noexcept { return err; }
+	CodeType code() const noexcept { return err; }
 
 	bool retryable() const noexcept { return native::fdb_error_predicate(FDB_ERROR_PREDICATE_RETRYABLE, err) != 0; }
 
 private:
-	code_type err;
+	CodeType err;
 };
 
 /* Traits of value types held by ready futures.
    Holds type and value extraction function. */
 namespace future_var {
 struct None {
-	struct type {};
-	static Error extract(native::FDBFuture*, type&) noexcept { return Error(0); }
+	struct Type {};
+	static Error extract(native::FDBFuture*, Type&) noexcept { return Error(0); }
 };
 struct Int64 {
-	using type = int64_t;
-	static Error extract(native::FDBFuture* f, type& out) noexcept {
+	using Type = int64_t;
+	static Error extract(native::FDBFuture* f, Type& out) noexcept {
 		return Error(native::fdb_future_get_int64(f, &out));
 	}
 };
 struct Key {
-	using type = std::pair<uint8_t const*, int>;
-	static Error extract(native::FDBFuture* f, type& out) noexcept {
+	using Type = std::pair<uint8_t const*, int>;
+	static Error extract(native::FDBFuture* f, Type& out) noexcept {
 		auto& [out_key, out_key_length] = out;
 		return Error(native::fdb_future_get_key(f, &out_key, &out_key_length));
 	}
 };
 struct Value {
-	using type = std::tuple<bool, uint8_t const*, int>;
-	static Error extract(native::FDBFuture* f, type& out) noexcept {
+	using Type = std::tuple<bool, uint8_t const*, int>;
+	static Error extract(native::FDBFuture* f, Type& out) noexcept {
 		auto& [out_present, out_value, out_value_length] = out;
 		auto out_present_native = native::fdb_bool_t{};
 		auto err = native::fdb_future_get_value(f, &out_present_native, &out_value, &out_value_length);
@@ -108,15 +108,15 @@ struct Value {
 	}
 };
 struct StringArray {
-	using type = std::pair<const char**, int>;
-	static Error extract(native::FDBFuture* f, type& out) noexcept {
+	using Type = std::pair<const char**, int>;
+	static Error extract(native::FDBFuture* f, Type& out) noexcept {
 		auto& [out_strings, out_count] = out;
 		return Error(native::fdb_future_get_string_array(f, &out_strings, &out_count));
 	}
 };
 struct KeyValueArray {
-	using type = std::tuple<native::FDBKeyValue const*, int, bool>;
-	static Error extract(native::FDBFuture* f, type& out) noexcept {
+	using Type = std::tuple<native::FDBKeyValue const*, int, bool>;
+	static Error extract(native::FDBFuture* f, Type& out) noexcept {
 		auto& [out_kv, out_count, out_more] = out;
 		auto out_more_native = native::fdb_bool_t{};
 		auto err = native::fdb_future_get_keyvalue_array(f, &out_kv, &out_count, &out_more_native);
@@ -126,61 +126,61 @@ struct KeyValueArray {
 };
 } // namespace future_var
 
-[[noreturn]] inline void throw_error(std::string_view preamble, Error err) {
+[[noreturn]] inline void throwError(std::string_view preamble, Error err) {
 	auto msg = std::string(preamble);
 	msg.append(err.what());
 	throw std::runtime_error(msg);
 }
 
-inline int max_api_version() {
+inline int maxApiVersion() {
 	return native::fdb_get_max_api_version();
 }
 
-inline Error select_api_version_nothrow(int version) {
+inline Error selectApiVersionNothrow(int version) {
 	return Error(native::fdb_select_api_version(version));
 }
 
-inline void select_api_version(int version) {
-	if (auto err = select_api_version_nothrow(version)) {
-		throw_error(fmt::format("ERROR: fdb_select_api_version({}): ", version), err);
+inline void selectApiVersion(int version) {
+	if (auto err = selectApiVersionNothrow(version)) {
+		throwError(fmt::format("ERROR: fdb_select_api_version({}): ", version), err);
 	}
 }
 
 namespace network {
 
-inline Error set_option_nothrow(FDBNetworkOption option, BytesRef str) noexcept {
-	return Error(native::fdb_network_set_option(option, str.data(), intsize(str)));
+inline Error setOptionNothrow(FDBNetworkOption option, BytesRef str) noexcept {
+	return Error(native::fdb_network_set_option(option, str.data(), intSize(str)));
 }
 
-inline Error set_option_nothrow(FDBNetworkOption option, int64_t value) noexcept {
+inline Error setOptionNothrow(FDBNetworkOption option, int64_t value) noexcept {
 	return Error(native::fdb_network_set_option(
 	    option, reinterpret_cast<const uint8_t*>(&value), static_cast<int>(sizeof(value))));
 }
 
-inline void set_option(FDBNetworkOption option, BytesRef str) {
-	if (auto err = set_option_nothrow(option, str)) {
-		throw_error(fmt::format("ERROR: fdb_network_set_option({}): ",
-		                        static_cast<std::underlying_type_t<FDBNetworkOption>>(option)),
-		            err);
+inline void setOption(FDBNetworkOption option, BytesRef str) {
+	if (auto err = setOptionNothrow(option, str)) {
+		throwError(fmt::format("ERROR: fdb_network_set_option({}): ",
+		                       static_cast<std::underlying_type_t<FDBNetworkOption>>(option)),
+		           err);
 	}
 }
 
-inline void set_option(FDBNetworkOption option, int64_t value) {
-	if (auto err = set_option_nothrow(option, value)) {
-		throw_error(fmt::format("ERROR: fdb_network_set_option({}, {}): ",
-		                        static_cast<std::underlying_type_t<FDBNetworkOption>>(option),
-		                        value),
-		            err);
+inline void setOption(FDBNetworkOption option, int64_t value) {
+	if (auto err = setOptionNothrow(option, value)) {
+		throwError(fmt::format("ERROR: fdb_network_set_option({}, {}): ",
+		                       static_cast<std::underlying_type_t<FDBNetworkOption>>(option),
+		                       value),
+		           err);
 	}
 }
 
-inline Error setup_nothrow() noexcept {
+inline Error setupNothrow() noexcept {
 	return Error(native::fdb_setup_network());
 }
 
 inline void setup() {
-	if (auto err = setup_nothrow())
-		throw_error("ERROR: fdb_network_setup(): ", err);
+	if (auto err = setupNothrow())
+		throwError("ERROR: fdb_network_setup(): ", err);
 }
 
 inline Error run() {
@@ -193,11 +193,11 @@ inline Error stop() {
 
 } // namespace network
 
-class TX;
+class Transaction;
 class Database;
 
 class Result {
-	friend class TX;
+	friend class Transaction;
 	std::shared_ptr<native::FDBResult> r;
 
 	Result(native::FDBResult* result) {
@@ -206,9 +206,9 @@ class Result {
 	}
 
 public:
-	using KeyValueArray = future_var::KeyValueArray::type;
+	using KeyValueArray = future_var::KeyValueArray::Type;
 
-	Error get_keyvalue_array_nothrow(KeyValueArray& out) const noexcept {
+	Error getKeyValueArrayNothrow(KeyValueArray& out) const noexcept {
 		auto out_more_native = native::fdb_bool_t{};
 		auto& [out_kv, out_count, out_more] = out;
 		auto err_raw = native::fdb_result_get_keyvalue_array(r.get(), &out_kv, &out_count, &out_more_native);
@@ -216,17 +216,17 @@ public:
 		return Error(err_raw);
 	}
 
-	KeyValueArray get_keyvalue_array() const {
+	KeyValueArray getKeyValueArray() const {
 		auto ret = KeyValueArray{};
-		if (auto err = get_keyvalue_array_nothrow(ret))
-			throw_error("ERROR: result_get_keyvalue_array(): ", err);
+		if (auto err = getKeyValueArrayNothrow(ret))
+			throwError("ERROR: result_get_keyvalue_array(): ", err);
 		return ret;
 	}
 };
 
 class Future {
 protected:
-	friend class TX;
+	friend class Transaction;
 	std::shared_ptr<native::FDBFuture> f;
 
 	Future(native::FDBFuture* future) {
@@ -270,7 +270,7 @@ public:
 		return native::fdb_future_is_ready(f.get()) != 0;
 	}
 
-	Error block_until_ready() const noexcept {
+	Error blockUntilReady() const noexcept {
 		assert(valid());
 		return Error(native::fdb_future_block_until_ready(f.get()));
 	}
@@ -283,18 +283,18 @@ public:
 	void cancel() noexcept { native::fdb_future_cancel(f.get()); }
 
 	template <class VarTraits>
-	typename VarTraits::type get() const {
+	typename VarTraits::Type get() const {
 		assert(valid());
 		assert(!error());
 		auto out = typename VarTraits::Type{};
 		if (auto err = VarTraits::extract(f.get(), out)) {
-			throw_error("future_get: ", err);
+			throwError("future_get: ", err);
 		}
 		return out;
 	}
 
 	template <class VarTraits>
-	Error get_nothrow(typename VarTraits::type& var) const noexcept {
+	Error getNothrow(typename VarTraits::Type& var) const noexcept {
 		assert(valid());
 		assert(!error());
 		auto out = typename VarTraits::Type{};
@@ -309,95 +309,95 @@ public:
 
 template <typename VarTraits>
 class TypedFuture : public Future {
-	friend class TX;
-	using self_type = TypedFuture<VarTraits>;
+	friend class Transaction;
+	using SelfType = TypedFuture<VarTraits>;
 	using Future::Future;
 	// hide type-unsafe inherited functions
 	using Future::get;
-	using Future::get_nothrow;
+	using Future::getNothrow;
 	using Future::then;
 	TypedFuture(const Future& f) noexcept : Future(f) {}
 
 public:
-	using contained_type = typename VarTraits::type;
+	using ContainedType = typename VarTraits::Type;
 
-	Future erase_type() const noexcept { return static_cast<Future const&>(*this); }
+	Future eraseType() const noexcept { return static_cast<Future const&>(*this); }
 
-	contained_type get() const { return get<VarTraits>(); }
+	ContainedType get() const { return get<VarTraits>(); }
 
-	Error get_nothrow(contained_type& out) const noexcept { return get_nothrow<VarTraits>(out); }
+	Error getNothrow(ContainedType& out) const noexcept { return getNothrow<VarTraits>(out); }
 
 	template <class UserFunc>
 	void then(UserFunc&& fn) {
-		Future::then<self_type>(std::forward<UserFunc>(fn));
+		Future::then<SelfType>(std::forward<UserFunc>(fn));
 	}
 };
 
-namespace key_select {
+namespace KeySelect {
 
-struct inclusive {
+struct Inclusive {
 	static constexpr const bool value = true;
 };
 
-struct exclusive {
+struct Exclusive {
 	static constexpr const bool value = false;
 };
-} // namespace key_select
+} // namespace KeySelect
 
-class TX {
+class Transaction {
 	friend class Database;
 	std::shared_ptr<native::FDBTransaction> tr;
 
-	explicit TX(native::FDBTransaction* tr_raw) {
+	explicit Transaction(native::FDBTransaction* tr_raw) {
 		if (tr_raw)
 			tr = std::shared_ptr<native::FDBTransaction>(tr_raw, &native::fdb_transaction_destroy);
 	}
 
 public:
-	TX() noexcept : TX(nullptr) {}
-	TX(const TX&) noexcept = default;
-	TX& operator=(const TX&) noexcept = default;
+	Transaction() noexcept : Transaction(nullptr) {}
+	Transaction(const Transaction&) noexcept = default;
+	Transaction& operator=(const Transaction&) noexcept = default;
 
 	bool valid() const noexcept { return tr != nullptr; }
 
 	explicit operator bool() const noexcept { return valid(); }
 
-	Error set_option_nothrow(FDBTransactionOption option, int64_t value) noexcept {
+	Error setOptionNothrow(FDBTransactionOption option, int64_t value) noexcept {
 		return Error(native::fdb_transaction_set_option(
 		    tr.get(), option, reinterpret_cast<const uint8_t*>(&value), static_cast<int>(sizeof(value))));
 	}
 
-	Error set_option_nothrow(FDBTransactionOption option, BytesRef str) noexcept {
-		return Error(native::fdb_transaction_set_option(tr.get(), option, str.data(), intsize(str)));
+	Error setOptionNothrow(FDBTransactionOption option, BytesRef str) noexcept {
+		return Error(native::fdb_transaction_set_option(tr.get(), option, str.data(), intSize(str)));
 	}
 
-	void set_option(FDBTransactionOption option, int64_t value) {
-		if (auto err = set_option_nothrow(option, value)) {
-			throw_error(fmt::format("transaction_set_option({}, {}) returned error: ",
-			                        static_cast<std::underlying_type_t<FDBTransactionOption>>(option),
-			                        value),
-			            err);
+	void setOption(FDBTransactionOption option, int64_t value) {
+		if (auto err = setOptionNothrow(option, value)) {
+			throwError(fmt::format("transaction_set_option({}, {}) returned error: ",
+			                       static_cast<std::underlying_type_t<FDBTransactionOption>>(option),
+			                       value),
+			           err);
 		}
 	}
 
-	void set_option(FDBTransactionOption option, BytesRef str) {
-		if (auto err = set_option_nothrow(option, str)) {
-			throw_error(fmt::format("transaction_set_option({}) returned error: ",
-			                        static_cast<std::underlying_type_t<FDBTransactionOption>>(option)),
-			            err);
+	void setOption(FDBTransactionOption option, BytesRef str) {
+		if (auto err = setOptionNothrow(option, str)) {
+			throwError(fmt::format("transaction_set_option({}) returned error: ",
+			                       static_cast<std::underlying_type_t<FDBTransactionOption>>(option)),
+			           err);
 		}
 	}
 
-	TypedFuture<future_var::Int64> get_read_version() { return native::fdb_transaction_get_read_version(tr.get()); }
+	TypedFuture<future_var::Int64> getReadVersion() { return native::fdb_transaction_get_read_version(tr.get()); }
 
-	Error get_committed_version_nothrow(int64_t& out) {
+	Error getCommittedVersionNothrow(int64_t& out) {
 		return Error(native::fdb_transaction_get_committed_version(tr.get(), &out));
 	}
 
-	int64_t get_committed_version() {
+	int64_t getCommittedVersion() {
 		auto out = int64_t{};
-		if (auto err = get_committed_version_nothrow(out)) {
-			throw_error("get_committed_version: ", err);
+		if (auto err = getCommittedVersionNothrow(out)) {
+			throwError("get_committed_version: ", err);
 		}
 		return out;
 	}
@@ -406,24 +406,24 @@ public:
 	// Func should first check that retry == false and f.error() == 0
 	// before attempting to extract value from f
 	TypedFuture<future_var::Value> get(KeyRef key, bool snapshot) {
-		return native::fdb_transaction_get(tr.get(), key.data(), intsize(key), snapshot);
+		return native::fdb_transaction_get(tr.get(), key.data(), intSize(key), snapshot);
 	}
 
-	// Usage: tx.get_range<key_select::inclusive, key_select::exclusive>(begin, end, ...);
+	// Usage: tx.get_range<KeySelect::inclusive, KeySelect::exclusive>(begin, end, ...);
 	// gets key-value pairs in key range [begin, end)
 	template <class FirstInclusive, class LastInclusive>
-	TypedFuture<future_var::KeyValueArray> get_range(KeyRef begin,
-	                                                 KeyRef end,
-	                                                 int limit,
-	                                                 int target_bytes,
-	                                                 FDBStreamingMode mode,
-	                                                 int iteration,
-	                                                 bool snapshot,
-	                                                 bool reverse) {
+	TypedFuture<future_var::KeyValueArray> getRange(KeyRef begin,
+	                                                KeyRef end,
+	                                                int limit,
+	                                                int target_bytes,
+	                                                FDBStreamingMode mode,
+	                                                int iteration,
+	                                                bool snapshot,
+	                                                bool reverse) {
 		if constexpr (FirstInclusive::value && LastInclusive::value) {
 			return native::fdb_transaction_get_range(tr.get(),
-			                                         FDB_KEYSEL_FIRST_GREATER_OR_EQUAL(begin.data(), intsize(begin)),
-			                                         FDB_KEYSEL_LAST_LESS_OR_EQUAL(end.data(), intsize(end)),
+			                                         FDB_KEYSEL_FIRST_GREATER_OR_EQUAL(begin.data(), intSize(begin)),
+			                                         FDB_KEYSEL_LAST_LESS_OR_EQUAL(end.data(), intSize(end)),
 			                                         limit,
 			                                         target_bytes,
 			                                         mode,
@@ -432,8 +432,8 @@ public:
 			                                         reverse);
 		} else if constexpr (FirstInclusive::value && !LastInclusive::value) {
 			return native::fdb_transaction_get_range(tr.get(),
-			                                         FDB_KEYSEL_FIRST_GREATER_OR_EQUAL(begin.data(), intsize(begin)),
-			                                         FDB_KEYSEL_LAST_LESS_THAN(end.data(), intsize(end)),
+			                                         FDB_KEYSEL_FIRST_GREATER_OR_EQUAL(begin.data(), intSize(begin)),
+			                                         FDB_KEYSEL_LAST_LESS_THAN(end.data(), intSize(end)),
 			                                         limit,
 			                                         target_bytes,
 			                                         mode,
@@ -442,8 +442,8 @@ public:
 			                                         reverse);
 		} else if constexpr (!FirstInclusive::value && LastInclusive::value) {
 			return native::fdb_transaction_get_range(tr.get(),
-			                                         FDB_KEYSEL_FIRST_GREATER_THAN(begin.data(), intsize(begin)),
-			                                         FDB_KEYSEL_LAST_LESS_OR_EQUAL(end.data(), intsize(end)),
+			                                         FDB_KEYSEL_FIRST_GREATER_THAN(begin.data(), intSize(begin)),
+			                                         FDB_KEYSEL_LAST_LESS_OR_EQUAL(end.data(), intSize(end)),
 			                                         limit,
 			                                         target_bytes,
 			                                         mode,
@@ -452,8 +452,8 @@ public:
 			                                         reverse);
 		} else {
 			return native::fdb_transaction_get_range(tr.get(),
-			                                         FDB_KEYSEL_FIRST_GREATER_THAN(begin.data(), intsize(begin)),
-			                                         FDB_KEYSEL_LAST_LESS_THAN(end.data(), intsize(end)),
+			                                         FDB_KEYSEL_FIRST_GREATER_THAN(begin.data(), intSize(begin)),
+			                                         FDB_KEYSEL_LAST_LESS_THAN(end.data(), intSize(end)),
 			                                         limit,
 			                                         target_bytes,
 			                                         mode,
@@ -463,29 +463,29 @@ public:
 		}
 	}
 
-	Result read_blob_granules(KeyRef begin,
-	                          KeyRef end,
-	                          int64_t begin_version,
-	                          int64_t read_version,
-	                          native::FDBReadBlobGranuleContext context) {
+	Result readBlobGranules(KeyRef begin,
+	                        KeyRef end,
+	                        int64_t begin_version,
+	                        int64_t read_version,
+	                        native::FDBReadBlobGranuleContext context) {
 		return Result(native::fdb_transaction_read_blob_granules(
-		    tr.get(), begin.data(), intsize(begin), end.data(), intsize(end), begin_version, read_version, context));
+		    tr.get(), begin.data(), intSize(begin), end.data(), intSize(end), begin_version, read_version, context));
 	}
 
 	TypedFuture<future_var::None> commit() { return native::fdb_transaction_commit(tr.get()); }
 
-	TypedFuture<future_var::None> on_error(Error err) { return native::fdb_transaction_on_error(tr.get(), err.code()); }
+	TypedFuture<future_var::None> onError(Error err) { return native::fdb_transaction_on_error(tr.get(), err.code()); }
 
 	void reset() { return native::fdb_transaction_reset(tr.get()); }
 
 	void set(KeyRef key, ValueRef value) {
-		native::fdb_transaction_set(tr.get(), key.data(), intsize(key), value.data(), intsize(value));
+		native::fdb_transaction_set(tr.get(), key.data(), intSize(key), value.data(), intSize(value));
 	}
 
-	void clear(KeyRef key) { native::fdb_transaction_clear(tr.get(), key.data(), intsize(key)); }
+	void clear(KeyRef key) { native::fdb_transaction_clear(tr.get(), key.data(), intSize(key)); }
 
-	void clear_range(KeyRef begin, KeyRef end) {
-		native::fdb_transaction_clear_range(tr.get(), begin.data(), intsize(begin), end.data(), intsize(end));
+	void clearRange(KeyRef begin, KeyRef end) {
+		native::fdb_transaction_clear_range(tr.get(), begin.data(), intSize(begin), end.data(), intSize(end));
 	}
 };
 
@@ -498,45 +498,45 @@ public:
 	Database(const std::string& cluster_file_path) : db(nullptr) {
 		auto db_raw = static_cast<native::FDBDatabase*>(nullptr);
 		if (auto err = Error(native::fdb_create_database(cluster_file_path.c_str(), &db_raw)))
-			throw_error(fmt::format("Failed to create database with '{}': ", cluster_file_path), err);
+			throwError(fmt::format("Failed to create database with '{}': ", cluster_file_path), err);
 		db = std::shared_ptr<native::FDBDatabase>(db_raw, &native::fdb_database_destroy);
 	}
 	Database() noexcept : db(nullptr) {}
 
-	Error set_option_nothrow(FDBDatabaseOption option, int64_t value) noexcept {
+	Error setOptionNothrow(FDBDatabaseOption option, int64_t value) noexcept {
 		return Error(native::fdb_database_set_option(
 		    db.get(), option, reinterpret_cast<const uint8_t*>(&value), static_cast<int>(sizeof(value))));
 	}
 
-	Error set_option_nothrow(FDBDatabaseOption option, BytesRef str) noexcept {
-		return Error(native::fdb_database_set_option(db.get(), option, str.data(), intsize(str)));
+	Error setOptionNothrow(FDBDatabaseOption option, BytesRef str) noexcept {
+		return Error(native::fdb_database_set_option(db.get(), option, str.data(), intSize(str)));
 	}
 
-	void set_option(FDBDatabaseOption option, int64_t value) {
-		if (auto err = set_option_nothrow(option, value)) {
-			throw_error(fmt::format("database_set_option({}, {}) returned error: ",
-			                        static_cast<std::underlying_type_t<FDBDatabaseOption>>(option),
-			                        value),
-			            err);
+	void setOption(FDBDatabaseOption option, int64_t value) {
+		if (auto err = setOptionNothrow(option, value)) {
+			throwError(fmt::format("database_set_option({}, {}) returned error: ",
+			                       static_cast<std::underlying_type_t<FDBDatabaseOption>>(option),
+			                       value),
+			           err);
 		}
 	}
 
-	void set_option(FDBDatabaseOption option, BytesRef str) {
-		if (auto err = set_option_nothrow(option, str)) {
-			throw_error(fmt::format("database_set_option({}) returned error: ",
-			                        static_cast<std::underlying_type_t<FDBDatabaseOption>>(option)),
-			            err);
+	void setOption(FDBDatabaseOption option, BytesRef str) {
+		if (auto err = setOptionNothrow(option, str)) {
+			throwError(fmt::format("database_set_option({}) returned error: ",
+			                       static_cast<std::underlying_type_t<FDBDatabaseOption>>(option)),
+			           err);
 		}
 	}
 
-	TX create_tx() {
+	Transaction createTransaction() {
 		if (!db)
 			throw std::runtime_error("create_transaction from null database");
 		auto tx_native = static_cast<native::FDBTransaction*>(nullptr);
 		auto err = Error(native::fdb_database_create_transaction(db.get(), &tx_native));
 		if (err)
-			throw_error("Failed to create transaction: ", err);
-		return TX(tx_native);
+			throwError("Failed to create transaction: ", err);
+		return Transaction(tx_native);
 	}
 };
 
diff --git a/bindings/c/test/mako/mako.cpp b/bindings/c/test/mako/mako.cpp
index f0f87c7ed5..60cc077cf5 100644
--- a/bindings/c/test/mako/mako.cpp
+++ b/bindings/c/test/mako/mako.cpp
@@ -50,10 +50,10 @@ FILE* debugme; /* descriptor used for debug messages */
 enum class FutureRC { OK, RETRY, CONFLICT, ABORT };
 
 template <class FutureType>
-FutureRC wait_and_handle_for_on_error(TX tx, FutureType f, std::string_view operation) {
+FutureRC wait_and_handle_for_on_error(Transaction tx, FutureType f, std::string_view operation) {
 	assert(f);
 	auto err = Error{};
-	if ((err = f.block_until_ready())) {
+	if ((err = f.blockUntilReady())) {
 		fmt::print(stderr, "ERROR: Error while on_error() blocking for {}: {}\n", operation, err.what());
 		return FutureRC::ABORT;
 	}
@@ -67,10 +67,10 @@ FutureRC wait_and_handle_for_on_error(TX tx, FutureType f, std::string_view oper
 
 // wait on any non-immediate tx-related operation to complete. Follow up with on_error().
 template <class FutureType>
-FutureRC wait_and_handle_error(TX tx, FutureType f, std::string_view operation) {
+FutureRC wait_and_handle_error(Transaction tx, FutureType f, std::string_view operation) {
 	assert(f);
 	auto err = Error{};
-	if ((err = f.block_until_ready())) {
+	if ((err = f.blockUntilReady())) {
 		const auto retry = err.retryable();
 		auto fp = retry ? annoyme : stderr;
 		fmt::print(fp, "ERROR: {} error in {}: {}\n", (retry ? "Retryable" : "Unretryable"), operation, err.what());
@@ -82,7 +82,7 @@ FutureRC wait_and_handle_error(TX tx, FutureType f, std::string_view operation)
 	auto fp = err.retryable() ? annoyme : stderr;
 	fmt::print(fp, "ERROR: Error in {}: {}\n", operation, err.what());
 	// implicit backoff
-	auto follow_up = tx.on_error(err);
+	auto follow_up = tx.onError(err);
 	auto rc = wait_and_handle_for_on_error(tx, f, operation);
 	if (rc == FutureRC::OK) {
 		if (err.is(1020 /*not_committed*/))
@@ -96,21 +96,21 @@ FutureRC wait_and_handle_error(TX tx, FutureType f, std::string_view operation)
 }
 
 /* cleanup database */
-int cleanup(TX tx, args_t const& args) {
+int cleanup(Transaction tx, Arguments const& args) {
 	auto beginstr = ByteString{};
 	beginstr.reserve(args.key_length);
-	genkeyprefix(beginstr, KEY_PREFIX, args);
+	genKeyPrefix(beginstr, KEY_PREFIX, args);
 	beginstr.push_back(0);
 
 	auto endstr = ByteString{};
 	endstr.reserve(args.key_length);
-	genkeyprefix(endstr, KEY_PREFIX, args);
+	genKeyPrefix(endstr, KEY_PREFIX, args);
 	endstr.push_back(0xff);
 
 	auto watch = Stopwatch(start_at_ctor{});
 
 	while (true) {
-		tx.clear_range(beginstr, endstr);
+		tx.clearRange(beginstr, endstr);
 		auto future_commit = tx.commit();
 		const auto rc = wait_and_handle_error(tx, future_commit, "COMMIT_CLEANUP");
 		if (rc == FutureRC::OK) {
@@ -129,15 +129,15 @@ int cleanup(TX tx, args_t const& args) {
 }
 
 /* populate database */
-int populate(TX tx,
-             args_t const& args,
+int populate(Transaction tx,
+             Arguments const& args,
              int worker_id,
              int thread_id,
              int thread_tps,
-             stats_t& stats,
-             sample_bin_array_t& sample_bins) {
-	const auto key_begin = insert_begin(args.rows, worker_id, thread_id, args.num_processes, args.num_threads);
-	const auto key_end = insert_end(args.rows, worker_id, thread_id, args.num_processes, args.num_threads);
+             ThreadStatistics& stats,
+             LatencySampleBinArray& sample_bins) {
+	const auto key_begin = insertBegin(args.rows, worker_id, thread_id, args.num_processes, args.num_threads);
+	const auto key_end = insertEnd(args.rows, worker_id, thread_id, args.num_processes, args.num_threads);
 	auto xacts = 0;
 
 	auto keystr = ByteString{};
@@ -154,9 +154,9 @@ int populate(TX tx,
 
 	for (auto i = key_begin; i <= key_end; i++) {
 		/* sequential keys */
-		genkey(keystr, KEY_PREFIX, args, i);
+		genKey(keystr, KEY_PREFIX, args, i);
 		/* random values */
-		randstr(valstr, args.value_length);
+		randomString(valstr, args.value_length);
 
 		while (thread_tps > 0 && xacts >= thread_tps /* throttle */) {
 			if (to_integer_seconds(watch_throttle.stop().diff()) >= 1) {
@@ -169,15 +169,15 @@ int populate(TX tx,
 		if (num_seconds_trace_every) {
 			if (to_integer_seconds(watch_trace.stop().diff()) >= num_seconds_trace_every) {
 				watch_trace.start_from_stop();
-				fmt::print(debugme, "DEBUG: txn tracing {}\n", to_chars_ref(keystr));
+				fmt::print(debugme, "DEBUG: txn tracing {}\n", toCharsRef(keystr));
 				auto err = Error{};
-				err = tx.set_option_nothrow(FDB_TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER, keystr);
+				err = tx.setOptionNothrow(FDB_TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER, keystr);
 				if (err) {
-					fmt::print(stderr, "ERROR: set_option(TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER): {}\n", err.what());
+					fmt::print(stderr, "ERROR: setOption(TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER): {}\n", err.what());
 				}
-				err = tx.set_option_nothrow(FDB_TR_OPTION_LOG_TRANSACTION, BytesRef());
+				err = tx.setOptionNothrow(FDB_TR_OPTION_LOG_TRANSACTION, BytesRef());
 				if (err) {
-					fmt::print(stderr, "ERROR: set_option(TR_OPTION_LOG_TRANSACTION): {}\n", err.what());
+					fmt::print(stderr, "ERROR: setOption(TR_OPTION_LOG_TRANSACTION): {}\n", err.what());
 				}
 			}
 		}
@@ -311,7 +311,7 @@ void granule_free_load(int64_t loadId, void* userContext) {
 	context->data_by_id[loadId] = 0;
 }
 
-inline int next_key(args_t const& args) {
+inline int next_key(Arguments const& args) {
 	if (args.zipf)
 		return zipfian_next();
 	return urand(0, args.rows - 1);
@@ -334,87 +334,88 @@ const std::array<OpDesc, MAX_OP> op_desc{ { { "GRV", { StepKind::READ }, false }
 	                                        { "TRANSACTION", { StepKind::NONE }, false },
 	                                        { "READBLOBGRANULE", { StepKind::ON_ERROR }, false } } };
 
-const std::map<std::pair<int /*op*/, int /*sub-op step*/>,
-               Future (*)(TX, args_t const&, ByteString& /*key1*/, ByteString& /*key2*/, ByteString& /*value*/)>
+const std::map<
+    std::pair<int /*op*/, int /*sub-op step*/>,
+    Future (*)(Transaction, Arguments const&, ByteString& /*key1*/, ByteString& /*key2*/, ByteString& /*value*/)>
     operation_fn_table{
 	    { { OP_GETREADVERSION, 0 },
-	      [](TX tx, args_t const&, ByteString&, ByteString&, ByteString&) {
-	          return tx.get_read_version().erase_type();
+	      [](Transaction tx, Arguments const&, ByteString&, ByteString&, ByteString&) {
+	          return tx.getReadVersion().eraseType();
 	      } },
 	    { { OP_GET, 0 },
-	      [](TX tx, args_t const& args, ByteString& key, ByteString&, ByteString&) {
+	      [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
 	          const auto num = next_key(args);
-	          genkey(key, KEY_PREFIX, args, num);
-	          return tx.get(key, false /*snapshot*/).erase_type();
+	          genKey(key, KEY_PREFIX, args, num);
+	          return tx.get(key, false /*snapshot*/).eraseType();
 	      } },
 	    { { OP_GETRANGE, 0 },
-	      [](TX tx, args_t const& args, ByteString& begin, ByteString& end, ByteString&) {
+	      [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
 	          const auto num_begin = next_key(args);
-	          genkey(begin, KEY_PREFIX, args, num_begin);
+	          genKey(begin, KEY_PREFIX, args, num_begin);
 	          auto num_end = num_begin + args.txnspec.ops[OP_GETRANGE][OP_RANGE] - 1;
 	          if (num_end > args.rows - 1)
 		          num_end = args.rows - 1;
-	          genkey(end, KEY_PREFIX, args, num_end);
+	          genKey(end, KEY_PREFIX, args, num_end);
 	          return tx
-	              .get_range<key_select::inclusive, key_select::inclusive>(begin,
-	                                                                       end,
-	                                                                       0 /*limit*/,
-	                                                                       0 /*target_bytes*/,
-	                                                                       args.streaming_mode,
-	                                                                       0 /*iteration*/,
-	                                                                       false /*snapshot*/,
-	                                                                       args.txnspec.ops[OP_GETRANGE][OP_REVERSE])
-	              .erase_type();
+	              .getRange<KeySelect::Inclusive, KeySelect::Inclusive>(begin,
+	                                                                    end,
+	                                                                    0 /*limit*/,
+	                                                                    0 /*target_bytes*/,
+	                                                                    args.streaming_mode,
+	                                                                    0 /*iteration*/,
+	                                                                    false /*snapshot*/,
+	                                                                    args.txnspec.ops[OP_GETRANGE][OP_REVERSE])
+	              .eraseType();
 	      } },
 	    { { OP_SGET, 0 },
-	      [](TX tx, args_t const& args, ByteString& key, ByteString&, ByteString&) {
+	      [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
 	          const auto num = next_key(args);
-	          genkey(key, KEY_PREFIX, args, num);
-	          return tx.get(key, true /*snapshot*/).erase_type();
+	          genKey(key, KEY_PREFIX, args, num);
+	          return tx.get(key, true /*snapshot*/).eraseType();
 	      } },
 	    { { OP_SGETRANGE, 0 },
-	      [](TX tx, args_t const& args, ByteString& begin, ByteString& end, ByteString&) {
+	      [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
 	          const auto num_begin = next_key(args);
-	          genkey(begin, KEY_PREFIX, args, num_begin);
+	          genKey(begin, KEY_PREFIX, args, num_begin);
 	          auto num_end = num_begin + args.txnspec.ops[OP_SGETRANGE][OP_RANGE] - 1;
 	          if (num_end > args.rows - 1)
 		          num_end = args.rows - 1;
-	          genkey(end, KEY_PREFIX, args, num_end);
+	          genKey(end, KEY_PREFIX, args, num_end);
 	          return tx
-	              .get_range<key_select::inclusive, key_select::inclusive>(begin,
-	                                                                       end,
-	                                                                       0 /*limit*/,
-	                                                                       0 /*target_bytes*/,
-	                                                                       args.streaming_mode,
-	                                                                       0 /*iteration*/,
-	                                                                       true /*snapshot*/,
-	                                                                       args.txnspec.ops[OP_SGETRANGE][OP_REVERSE])
-	              .erase_type();
+	              .getRange<KeySelect::Inclusive, KeySelect::Inclusive>(begin,
+	                                                                    end,
+	                                                                    0 /*limit*/,
+	                                                                    0 /*target_bytes*/,
+	                                                                    args.streaming_mode,
+	                                                                    0 /*iteration*/,
+	                                                                    true /*snapshot*/,
+	                                                                    args.txnspec.ops[OP_SGETRANGE][OP_REVERSE])
+	              .eraseType();
 	      } },
 	    { { OP_UPDATE, 0 },
-	      [](TX tx, args_t const& args, ByteString& key, ByteString&, ByteString&) {
+	      [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
 	          const auto num = next_key(args);
-	          genkey(key, KEY_PREFIX, args, num);
-	          return tx.get(key, false /*snapshot*/).erase_type();
+	          genKey(key, KEY_PREFIX, args, num);
+	          return tx.get(key, false /*snapshot*/).eraseType();
 	      } },
 	    { { OP_UPDATE, 1 },
-	      [](TX tx, args_t const& args, ByteString& key, ByteString&, ByteString& value) {
-	          randstr(value, args.value_length);
+	      [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
+	          randomString(value, args.value_length);
 	          tx.set(key, value);
 	          return Future();
 	      } },
 	    { { OP_INSERT, 0 },
-	      [](TX tx, args_t const& args, ByteString& key, ByteString&, ByteString& value) {
-	          genkeyprefix(key, KEY_PREFIX, args);
+	      [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
+	          genKeyPrefix(key, KEY_PREFIX, args);
 	          // concat([padding], key_prefix, random_string): reasonably unique
-	          randstr<false /*clear-before-append*/>(key, args.key_length - static_cast<int>(key.size()));
-	          randstr(value, args.value_length);
+	          randomString<false /*clear-before-append*/>(key, args.key_length - static_cast<int>(key.size()));
+	          randomString(value, args.value_length);
 	          tx.set(key, value);
 	          return Future();
 	      } },
 	    { { OP_INSERTRANGE, 0 },
-	      [](TX tx, args_t const& args, ByteString& key, ByteString&, ByteString& value) {
-	          genkeyprefix(key, KEY_PREFIX, args);
+	      [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
+	          genKeyPrefix(key, KEY_PREFIX, args);
 	          const auto prefix_len = static_cast<int>(key.size());
 	          const auto range = args.txnspec.ops[OP_INSERTRANGE][OP_RANGE];
 	          assert(range > 0);
@@ -422,8 +423,8 @@ const std::map<std::pair<int /*op*/, int /*sub-op step*/>,
 	          assert(args.key_length - prefix_len >= range_digits);
 	          const auto rand_len = args.key_length - prefix_len - range_digits;
 	          // concat([padding], prefix, random_string, range_digits)
-	          randstr<false /*clear-before-append*/>(key, rand_len);
-	          randstr(value, args.value_length);
+	          randomString<false /*clear-before-append*/>(key, rand_len);
+	          randomString(value, args.value_length);
 	          for (auto i = 0; i < range; i++) {
 		          fmt::format_to(std::back_inserter(key), "{0:0{1}d}", i, range_digits);
 		          tx.set(key, value);
@@ -432,46 +433,46 @@ const std::map<std::pair<int /*op*/, int /*sub-op step*/>,
 	          return Future();
 	      } },
 	    { { OP_OVERWRITE, 0 },
-	      [](TX tx, args_t const& args, ByteString& key, ByteString&, ByteString& value) {
-	          genkey(key, KEY_PREFIX, args, next_key(args));
-	          randstr(value, args.value_length);
+	      [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
+	          genKey(key, KEY_PREFIX, args, next_key(args));
+	          randomString(value, args.value_length);
 	          tx.set(key, value);
 	          return Future();
 	      } },
 	    { { OP_CLEAR, 0 },
-	      [](TX tx, args_t const& args, ByteString& key, ByteString&, ByteString&) {
-	          genkey(key, KEY_PREFIX, args, next_key(args));
+	      [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
+	          genKey(key, KEY_PREFIX, args, next_key(args));
 	          tx.clear(key);
 	          return Future();
 	      } },
 	    { { OP_SETCLEAR, 0 },
-	      [](TX tx, args_t const& args, ByteString& key, ByteString&, ByteString& value) {
-	          genkeyprefix(key, KEY_PREFIX, args);
+	      [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
+	          genKeyPrefix(key, KEY_PREFIX, args);
 	          const auto prefix_len = static_cast<int>(key.size());
-	          randstr<false /*append-after-clear*/>(key, args.key_length - prefix_len);
-	          randstr(value, args.value_length);
+	          randomString<false /*append-after-clear*/>(key, args.key_length - prefix_len);
+	          randomString(value, args.value_length);
 	          tx.set(key, value);
-	          return tx.commit().erase_type();
+	          return tx.commit().eraseType();
 	      } },
 	    { { OP_SETCLEAR, 1 },
-	      [](TX tx, args_t const& args, ByteString& key, ByteString&, ByteString&) {
+	      [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
 	          tx.reset(); // assuming commit from step 0 worked.
 	          tx.clear(key); // key should forward unchanged from step 0
 	          return Future();
 	      } },
 	    { { OP_CLEARRANGE, 0 },
-	      [](TX tx, args_t const& args, ByteString& begin, ByteString& end, ByteString&) {
+	      [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
 	          const auto num_begin = next_key(args);
-	          genkey(begin, KEY_PREFIX, args, num_begin);
+	          genKey(begin, KEY_PREFIX, args, num_begin);
 	          const auto range = args.txnspec.ops[OP_CLEARRANGE][OP_RANGE];
 	          assert(range > 0);
-	          genkey(end, KEY_PREFIX, args, std::min(args.rows - 1, num_begin + range - 1));
-	          tx.clear_range(begin, end);
+	          genKey(end, KEY_PREFIX, args, std::min(args.rows - 1, num_begin + range - 1));
+	          tx.clearRange(begin, end);
 	          return Future();
 	      } },
 	    { { OP_SETCLEARRANGE, 0 },
-	      [](TX tx, args_t const& args, ByteString& key_begin, ByteString& key, ByteString& value) {
-	          genkeyprefix(key, KEY_PREFIX, args);
+	      [](Transaction tx, Arguments const& args, ByteString& key_begin, ByteString& key, ByteString& value) {
+	          genKeyPrefix(key, KEY_PREFIX, args);
 	          const auto prefix_len = static_cast<int>(key.size());
 	          const auto range = args.txnspec.ops[OP_SETCLEARRANGE][OP_RANGE];
 	          assert(range > 0);
@@ -479,8 +480,8 @@ const std::map<std::pair<int /*op*/, int /*sub-op step*/>,
 	          assert(args.key_length - prefix_len >= range_digits);
 	          const auto rand_len = args.key_length - prefix_len - range_digits;
 	          // concat([padding], prefix, random_string, range_digits)
-	          randstr<false /*clear-before-append*/>(key, rand_len);
-	          randstr(value, args.value_length);
+	          randomString<false /*clear-before-append*/>(key, rand_len);
+	          randomString(value, args.value_length);
 	          for (auto i = 0; i <= range; i++) {
 		          fmt::format_to(std::back_inserter(key), "{0:0{1}d}", i, range_digits);
 		          if (i == range)
@@ -492,24 +493,24 @@ const std::map<std::pair<int /*op*/, int /*sub-op step*/>,
 		          // preserve last key for step 1
 		          key.resize(key.size() - static_cast<size_t>(range_digits));
 	          }
-	          return tx.commit().erase_type();
+	          return tx.commit().eraseType();
 	      } },
 	    { { OP_SETCLEARRANGE, 1 },
-	      [](TX tx, args_t const& args, ByteString& begin, ByteString& end, ByteString&) {
+	      [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
 	          tx.reset();
-	          tx.clear_range(begin, end);
+	          tx.clearRange(begin, end);
 	          return Future();
 	      } },
 	    { { OP_READ_BG, 0 },
-	      [](TX tx, args_t const& args, ByteString& begin, ByteString& end, ByteString&) {
+	      [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
 	          const auto num_begin = next_key(args);
-	          genkey(begin, KEY_PREFIX, args, num_begin);
+	          genKey(begin, KEY_PREFIX, args, num_begin);
 	          const auto range = args.txnspec.ops[OP_READ_BG][OP_RANGE];
 	          assert(range > 0);
-	          genkey(end, KEY_PREFIX, args, std::min(args.rows - 1, num_begin + range - 1));
+	          genKey(end, KEY_PREFIX, args, std::min(args.rows - 1, num_begin + range - 1));
 	          auto err = Error{};
 
-	          err = tx.set_option_nothrow(FDB_TR_OPTION_READ_YOUR_WRITES_DISABLE, BytesRef());
+	          err = tx.setOptionNothrow(FDB_TR_OPTION_READ_YOUR_WRITES_DISABLE, BytesRef());
 	          if (err) {
 		          // Issuing read/writes before disabling RYW results in error.
 		          // Possible malformed workload?
@@ -534,20 +535,20 @@ const std::map<std::pair<int /*op*/, int /*sub-op step*/>,
 	          granuleContext.debugNoMaterialize = !args.bg_materialize_files;
 
 	          auto r =
-	              tx.read_blob_granules(begin, end, 0 /*begin_version*/, -1 /*end_version, use txn's*/, granuleContext);
+	              tx.readBlobGranules(begin, end, 0 /*begin_version*/, -1 /*end_version, use txn's*/, granuleContext);
 
 	          mem.reset();
 
 	          auto out = Result::KeyValueArray{};
-	          err = r.get_keyvalue_array_nothrow(out);
+	          err = r.getKeyValueArrayNothrow(out);
 	          if (!err || err.is(2037 /*blob_granule_not_materialized*/))
 		          return Future();
 	          const auto fp = (err.is(1020 /*not_committed*/) || err.is(1021 /*commit_unknown_result*/) ||
 	                           err.is(1213 /*tag_throttled*/))
 	                              ? annoyme
 	                              : stderr;
-	          fmt::print(fp, "ERROR: get_keyvalue_array() after read_blob_granules(): {}\n", err.what());
-	          return tx.on_error(err).erase_type();
+	          fmt::print(fp, "ERROR: get_keyvalue_array() after readBlobGranules(): {}\n", err.what());
+	          return tx.onError(err).eraseType();
 	      } }
     };
 
@@ -555,7 +556,7 @@ using OpIterator = std::tuple<int /*op*/, int /*count*/, int /*step*/>;
 
 constexpr const OpIterator OpEnd = OpIterator(MAX_OP, -1, -1);
 
-OpIterator get_op_begin(args_t const& args) noexcept {
+OpIterator get_op_begin(Arguments const& args) noexcept {
 	for (auto op = 0; op < MAX_OP; op++) {
 		if (op == OP_COMMIT || op == OP_TRANSACTION || args.txnspec.ops[op][OP_COUNT] == 0)
 			continue;
@@ -564,7 +565,7 @@ OpIterator get_op_begin(args_t const& args) noexcept {
 	return OpEnd;
 }
 
-OpIterator get_op_next(args_t const& args, OpIterator current) noexcept {
+OpIterator get_op_next(Arguments const& args, OpIterator current) noexcept {
 	if (OpEnd == current)
 		return OpEnd;
 	auto [op, count, step] = current;
@@ -581,7 +582,10 @@ OpIterator get_op_next(args_t const& args, OpIterator current) noexcept {
 }
 
 /* run one transaction */
-int run_one_transaction(TX tx, args_t const& args, stats_t& stats, sample_bin_array_t& sample_bins) {
+int run_one_transaction(Transaction tx,
+                        Arguments const& args,
+                        ThreadStatistics& stats,
+                        LatencySampleBinArray& sample_bins) {
 	// reuse memory for keys to avoid realloc overhead
 	auto key1 = ByteString{};
 	key1.reserve(args.key_length);
@@ -708,14 +712,14 @@ int run_one_transaction(TX tx, args_t const& args, stats_t& stats, sample_bin_ar
 	return 0;
 }
 
-int run_workload(TX tx,
-                 args_t const& args,
+int run_workload(Transaction tx,
+                 Arguments const& args,
                  int const thread_tps,
                  std::atomic<double> const& throttle_factor,
                  int const thread_iters,
                  std::atomic<int> const& signal,
-                 stats_t& stats,
-                 sample_bin_array_t& sample_bins,
+                 ThreadStatistics& stats,
+                 LatencySampleBinArray& sample_bins,
                  int const dotrace,
                  int const dotagging) {
 	auto traceid = std::string{};
@@ -763,11 +767,11 @@ int run_workload(TX tx,
 				fmt::format_to(std::back_inserter(traceid), "makotrace{:0>19d}", total_xacts);
 				fmt::print(debugme, "DEBUG: txn tracing {}\n", traceid);
 				auto err = Error{};
-				err = tx.set_option_nothrow(FDB_TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER, to_bytes_ref(traceid));
+				err = tx.setOptionNothrow(FDB_TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER, toBytesRef(traceid));
 				if (err) {
 					fmt::print(stderr, "ERROR: TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER: {}\n", err.what());
 				}
-				err = tx.set_option_nothrow(FDB_TR_OPTION_LOG_TRANSACTION, BytesRef());
+				err = tx.setOptionNothrow(FDB_TR_OPTION_LOG_TRANSACTION, BytesRef());
 				if (err) {
 					fmt::print(stderr, "ERROR: TR_OPTION_LOG_TRANSACTION: {}\n", err.what());
 				}
@@ -782,7 +786,7 @@ int run_workload(TX tx,
 			               KEY_PREFIX,
 			               args.txntagging_prefix,
 			               urand(0, args.txntagging - 1));
-			auto err = tx.set_option_nothrow(FDB_TR_OPTION_AUTO_THROTTLE_TAG, to_bytes_ref(tagstr));
+			auto err = tx.setOptionNothrow(FDB_TR_OPTION_AUTO_THROTTLE_TAG, toBytesRef(tagstr));
 			if (err) {
 				fmt::print(stderr, "ERROR: TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER: {}\n", err.what());
 			}
@@ -814,7 +818,7 @@ std::string get_stats_file_name(std::string_view dirname, int worker_id, int thr
 }
 
 /* mako worker thread */
-void worker_thread(thread_args_t& thread_args) {
+void worker_thread(ThreadArgs& thread_args) {
 	const auto& args = *thread_args.args;
 	const auto parent_id = thread_args.parent_id;
 	const auto worker_id = thread_args.worker_id;
@@ -822,14 +826,14 @@ void worker_thread(thread_args_t& thread_args) {
 	const auto dotrace = (worker_id == 0 && thread_id == 0 && args.txntrace) ? args.txntrace : 0;
 	auto database = thread_args.database;
 	const auto dotagging = args.txntagging;
-	const auto& signal = thread_args.shm.header_const().signal;
-	const auto& throttle_factor = thread_args.shm.header_const().throttle_factor;
+	const auto& signal = thread_args.shm.headerConst().signal;
+	const auto& throttle_factor = thread_args.shm.headerConst().throttle_factor;
 	auto& readycount = thread_args.shm.header().readycount;
 	auto& stopcount = thread_args.shm.header().stopcount;
-	auto& stats = thread_args.shm.stats_slot(worker_id, thread_id);
+	auto& stats = thread_args.shm.statsSlot(worker_id, thread_id);
 
 	/* init per-thread latency statistics */
-	new (&stats) stats_t();
+	new (&stats) ThreadStatistics();
 
 	fmt::print(debugme,
 	           "DEBUG: worker_id:{} ({}) thread_id:{} ({}) (tid:{})\n",
@@ -841,15 +845,15 @@ void worker_thread(thread_args_t& thread_args) {
 
 	const auto thread_tps =
 	    args.tpsmax == 0 ? 0
-	                     : compute_thread_tps(args.tpsmax, worker_id, thread_id, args.num_processes, args.num_threads);
+	                     : computeThreadTps(args.tpsmax, worker_id, thread_id, args.num_processes, args.num_threads);
 
 	const auto thread_iters =
 	    args.iteration == 0
 	        ? 0
-	        : compute_thread_iters(args.iteration, worker_id, thread_id, args.num_processes, args.num_threads);
+	        : computeThreadIters(args.iteration, worker_id, thread_id, args.num_processes, args.num_threads);
 
 	/* create my own transaction object */
-	auto tx = database.create_tx();
+	auto tx = database.createTransaction();
 
 	/* i'm ready */
 	readycount.fetch_add(1);
@@ -894,7 +898,7 @@ void worker_thread(thread_args_t& thread_args) {
 					continue;
 				}
 				auto fclose_guard = ExitGuard([fp]() { fclose(fp); });
-				thread_args.sample_bins[op].for_each_block(
+				thread_args.sample_bins[op].forEachBlock(
 				    [fp](auto ptr, auto count) { fwrite(ptr, sizeof(*ptr) * count, 1, fp); });
 			}
 		}
@@ -902,22 +906,22 @@ void worker_thread(thread_args_t& thread_args) {
 }
 
 /* mako worker process */
-int worker_process_main(args_t const& args, int worker_id, shm_access_t shm, pid_t pid_main) {
+int worker_process_main(Arguments const& args, int worker_id, shared_memory::Access shm, pid_t pid_main) {
 	fmt::print(debugme, "DEBUG: worker {} started\n", worker_id);
 
 	auto err = Error{};
 	/* Everything starts from here */
 
-	select_api_version(args.api_version);
+	selectApiVersion(args.api_version);
 
 	/* enable flatbuffers if specified */
 	if (args.flatbuffers) {
 #ifdef FDB_NET_OPTION_USE_FLATBUFFERS
 		fprintf(debugme, "DEBUG: Using flatbuffers\n");
-		err = network::set_option_nothrow(FDB_NET_OPTION_USE_FLATBUFFERS,
-		                                  BytesRef(&args.flatbuffers, sizeof(args.flatbuffers)));
+		err = network::setOptionNothrow(FDB_NET_OPTION_USE_FLATBUFFERS,
+		                                BytesRef(&args.flatbuffers, sizeof(args.flatbuffers)));
 		if (err) {
-			fmt::print(stderr, "ERROR: network_set_option(USE_FLATBUFFERS): {}\n", err.what());
+			fmt::print(stderr, "ERROR: network_setOption(USE_FLATBUFFERS): {}\n", err.what());
 		}
 #else
 		fmt::print(printme, "INFO: flatbuffers is not supported in FDB API version {}\n", FDB_API_VERSION);
@@ -926,9 +930,9 @@ int worker_process_main(args_t const& args, int worker_id, shm_access_t shm, pid
 
 	/* Set client Log group */
 	if (args.log_group[0] != '\0') {
-		err = network::set_option_nothrow(FDB_NET_OPTION_TRACE_LOG_GROUP, BytesRef(to_byte_ptr(args.log_group)));
+		err = network::setOptionNothrow(FDB_NET_OPTION_TRACE_LOG_GROUP, BytesRef(toBytePtr(args.log_group)));
 		if (err) {
-			fmt::print(stderr, "ERROR: fdb_network_set_option(FDB_NET_OPTION_TRACE_LOG_GROUP): {}\n", err.what());
+			fmt::print(stderr, "ERROR: fdb_network_setOption(FDB_NET_OPTION_TRACE_LOG_GROUP): {}\n", err.what());
 		}
 	}
 
@@ -938,14 +942,14 @@ int worker_process_main(args_t const& args, int worker_id, shm_access_t shm, pid
 		           "DEBUG: Enable Tracing in {} ({})\n",
 		           (args.traceformat == 0) ? "XML" : "JSON",
 		           (args.tracepath[0] == '\0') ? "current directory" : args.tracepath);
-		err = network::set_option_nothrow(FDB_NET_OPTION_TRACE_ENABLE, BytesRef(to_byte_ptr(args.tracepath)));
+		err = network::setOptionNothrow(FDB_NET_OPTION_TRACE_ENABLE, BytesRef(toBytePtr(args.tracepath)));
 		if (err) {
-			fmt::print(stderr, "ERROR: network_set_option(TRACE_ENABLE): {}\n", err.what());
+			fmt::print(stderr, "ERROR: network_setOption(TRACE_ENABLE): {}\n", err.what());
 		}
 		if (args.traceformat == 1) {
-			err = network::set_option_nothrow(FDB_NET_OPTION_TRACE_FORMAT, BytesRef(to_byte_ptr("json")));
+			err = network::setOptionNothrow(FDB_NET_OPTION_TRACE_FORMAT, BytesRef(toBytePtr("json")));
 			if (err) {
-				fmt::print(stderr, "ERROR: fdb_network_set_option(FDB_NET_OPTION_TRACE_FORMAT): {}\n", err.what());
+				fmt::print(stderr, "ERROR: fdb_network_setOption(FDB_NET_OPTION_TRACE_FORMAT): {}\n", err.what());
 			}
 		}
 	}
@@ -960,19 +964,19 @@ int worker_process_main(args_t const& args, int worker_id, shm_access_t shm, pid
 			if (knob.empty())
 				break;
 			fmt::print(debugme, "DEBUG: Setting client knob: {}\n", knob);
-			err = network::set_option_nothrow(FDB_NET_OPTION_KNOB, to_bytes_ref(knob));
+			err = network::setOptionNothrow(FDB_NET_OPTION_KNOB, toBytesRef(knob));
 			if (err) {
-				fmt::print(stderr, "ERROR: fdb_network_set_option({}): {}\n", knob, err.what());
+				fmt::print(stderr, "ERROR: fdb_network_setOption({}): {}\n", knob, err.what());
 			}
 			knobs.remove_prefix(knob.size());
 		}
 	}
 
 	if (args.client_threads_per_version > 0) {
-		err = network::set_option_nothrow(FDB_NET_OPTION_CLIENT_THREADS_PER_VERSION, args.client_threads_per_version);
+		err = network::setOptionNothrow(FDB_NET_OPTION_CLIENT_THREADS_PER_VERSION, args.client_threads_per_version);
 		if (err) {
 			fmt::print(stderr,
-			           "ERROR: fdb_network_set_option (FDB_NET_OPTION_CLIENT_THREADS_PER_VERSION) ({}): {}\n",
+			           "ERROR: fdb_network_setOption (FDB_NET_OPTION_CLIENT_THREADS_PER_VERSION) ({}): {}\n",
 			           args.client_threads_per_version,
 			           err.what());
 			// let's exit here since we do not want to confuse users
@@ -1003,7 +1007,7 @@ int worker_process_main(args_t const& args, int worker_id, shm_access_t shm, pid
 		databases[i] = Database(args.cluster_files[cluster_index]);
 		fmt::print(debugme, "DEBUG: creating database at cluster {}\n", args.cluster_files[cluster_index]);
 		if (args.disable_ryw) {
-			databases[i].set_option(FDB_DB_OPTION_SNAPSHOT_RYW_DISABLE, BytesRef{});
+			databases[i].setOption(FDB_DB_OPTION_SNAPSHOT_RYW_DISABLE, BytesRef{});
 		}
 	}
 
@@ -1011,7 +1015,7 @@ int worker_process_main(args_t const& args, int worker_id, shm_access_t shm, pid
 	auto worker_threads = std::vector<std::thread>(args.num_threads);
 
 	/* spawn worker threads */
-	auto thread_args = std::vector<thread_args_t>(args.num_threads);
+	auto thread_args = std::vector<ThreadArgs>(args.num_threads);
 
 	for (auto i = 0; i < args.num_threads; i++) {
 		auto& this_args = thread_args[i];
@@ -1025,7 +1029,7 @@ int worker_process_main(args_t const& args, int worker_id, shm_access_t shm, pid
 		/* for ops to run, pre-allocate one latency sample block */
 		for (auto op = 0; op < MAX_OP; op++) {
 			if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-				this_args.sample_bins[op].reserve_one();
+				this_args.sample_bins[op].reserveOneBlock();
 			}
 		}
 		worker_threads[i] = std::thread(worker_thread, std::ref(this_args));
@@ -1054,14 +1058,14 @@ int worker_process_main(args_t const& args, int worker_id, shm_access_t shm, pid
 }
 
 /* initialize the parameters with default values */
-int init_args(args_t* args) {
+int init_args(Arguments* args) {
 	int i;
 	if (!args)
 		return -1;
-	memset(args, 0, sizeof(args_t)); /* zero-out everything */
+	memset(args, 0, sizeof(Arguments)); /* zero-out everything */
 	args->num_fdb_clusters = 0;
 	args->num_databases = 1;
-	args->api_version = max_api_version();
+	args->api_version = maxApiVersion();
 	args->json = 0;
 	args->num_processes = 1;
 	args->num_threads = 1;
@@ -1103,7 +1107,7 @@ int init_args(args_t* args) {
 }
 
 /* parse transaction specification */
-int parse_transaction(args_t* args, char const* optarg) {
+int parse_transaction(Arguments* args, char const* optarg) {
 	char const* ptr = optarg;
 	int op = 0;
 	int rangeop = 0;
@@ -1276,7 +1280,7 @@ void usage() {
 }
 
 /* parse benchmark paramters */
-int parse_args(int argc, char* argv[], args_t* args) {
+int parse_args(int argc, char* argv[], Arguments* args) {
 	int rc;
 	int c;
 	int idx;
@@ -1539,7 +1543,7 @@ char const* get_ops_name(int ops_code) {
 	return "";
 }
 
-int validate_args(args_t* args) {
+int validate_args(Arguments* args) {
 	if (args->mode == MODE_INVALID) {
 		fprintf(stderr, "ERROR: --mode has to be set\n");
 		return -1;
@@ -1602,10 +1606,10 @@ int validate_args(args_t* args) {
 	return 0;
 }
 
-void print_stats(args_t const& args, stats_t const* stats, double const duration_sec, FILE* fp) {
-	static stats_t prev;
+void print_stats(Arguments const& args, ThreadStatistics const* stats, double const duration_sec, FILE* fp) {
+	static ThreadStatistics prev;
 
-	auto current = stats_t{};
+	auto current = ThreadStatistics{};
 	for (auto i = 0; i < args.num_processes; i++) {
 		for (auto j = 0; j < args.num_threads; j++) {
 			current.combine(stats[(i * args.num_threads) + j]);
@@ -1615,12 +1619,12 @@ void print_stats(args_t const& args, stats_t const* stats, double const duration
 	if (fp) {
 		fwrite("{", 1, 1, fp);
 	}
-	put_title_r("OPS");
+	putTitleRight("OPS");
 	auto print_err = false;
 	for (auto op = 0; op < MAX_OP; op++) {
 		if (args.txnspec.ops[op][OP_COUNT] > 0) {
 			const auto ops_total_diff = current.get_op_count(op) - prev.get_op_count(op);
-			put_field(ops_total_diff);
+			putField(ops_total_diff);
 			if (fp) {
 				fmt::print(fp, "\"{}\": {},", get_ops_name(op), ops_total_diff);
 			}
@@ -1629,25 +1633,25 @@ void print_stats(args_t const& args, stats_t const* stats, double const duration
 	}
 	/* TPS */
 	const auto tps = (current.get_tx_count() - prev.get_tx_count()) / duration_sec;
-	put_field_f(tps, 2);
+	putFieldFloat(tps, 2);
 	if (fp) {
 		fprintf(fp, "\"tps\": %.2f,", tps);
 	}
 
 	/* Conflicts */
 	const auto conflicts_diff = (current.get_conflict_count() - prev.get_conflict_count()) / duration_sec;
-	put_field_f(conflicts_diff, 2);
+	putFieldFloat(conflicts_diff, 2);
 	fmt::print("\n");
 	if (fp) {
 		fprintf(fp, "\"conflictsPerSec\": %.2f", conflicts_diff);
 	}
 
 	if (print_err) {
-		put_title_r("Errors");
+		putTitleRight("Errors");
 		for (auto op = 0; op < MAX_OP; op++) {
 			if (args.txnspec.ops[op][OP_COUNT] > 0) {
 				const auto errors_diff = current.get_error_count(op) - prev.get_error_count(op);
-				put_field(errors_diff);
+				putField(errors_diff);
 				if (fp) {
 					fmt::print(fp, ",\"errors\": {}", errors_diff);
 				}
@@ -1662,53 +1666,57 @@ void print_stats(args_t const& args, stats_t const* stats, double const duration
 	prev = current;
 }
 
-void print_stats_header(args_t const& args, bool show_commit, bool is_first_header_empty, bool show_op_stats) {
+void print_stats_header(Arguments const& args, bool show_commit, bool is_first_header_empty, bool show_op_stats) {
 	/* header */
 	if (is_first_header_empty)
-		put_title("");
+		putTitle("");
 	for (auto op = 0; op < MAX_OP; op++) {
 		if (args.txnspec.ops[op][OP_COUNT] > 0) {
-			put_field(get_ops_name(op));
+			putField(get_ops_name(op));
 		}
 	}
 
 	if (show_commit)
-		put_field("COMMIT");
+		putField("COMMIT");
 	if (show_op_stats) {
-		put_field("TRANSACTION");
+		putField("TRANSACTION");
 	} else {
-		put_field("TPS");
-		put_field("Conflicts/s");
+		putField("TPS");
+		putField("Conflicts/s");
 	}
 	fmt::print("\n");
 
-	put_title_bar();
+	putTitleBar();
 	for (auto op = 0; op < MAX_OP; op++) {
 		if (args.txnspec.ops[op][OP_COUNT] > 0) {
-			put_field_bar();
+			putFieldBar();
 		}
 	}
 
 	/* COMMIT */
 	if (show_commit)
-		put_field_bar();
+		putFieldBar();
 
 	if (show_op_stats) {
 		/* TRANSACTION */
-		put_field_bar();
+		putFieldBar();
 	} else {
 		/* TPS */
-		put_field_bar();
+		putFieldBar();
 
 		/* Conflicts */
-		put_field_bar();
+		putFieldBar();
 	}
 	fmt::print("\n");
 }
 
-void print_report(args_t const& args, stats_t const* stats, double const duration_sec, pid_t pid_main, FILE* fp) {
+void print_report(Arguments const& args,
+                  ThreadStatistics const* stats,
+                  double const duration_sec,
+                  pid_t pid_main,
+                  FILE* fp) {
 
-	auto final_stats = stats_t{};
+	auto final_stats = ThreadStatistics{};
 	for (auto i = 0; i < args.num_processes; i++) {
 		for (auto j = 0; j < args.num_threads; j++) {
 			const auto idx = i * args.num_threads + j;
@@ -1762,14 +1770,14 @@ void print_report(args_t const& args, stats_t const* stats, double const duratio
 	print_stats_header(args, true, true, false);
 
 	/* OPS */
-	put_title("Total OPS");
+	putTitle("Total OPS");
 	if (fp) {
 		fmt::fprintf(fp, "\"totalOps\": {");
 	}
 	auto first_op = true;
 	for (auto op = 0; op < MAX_OP; op++) {
 		if ((args.txnspec.ops[op][OP_COUNT] > 0 && op != OP_TRANSACTION) || op == OP_COMMIT) {
-			put_field(final_stats.get_op_count(op));
+			putField(final_stats.get_op_count(op));
 			if (fp) {
 				if (first_op) {
 					first_op = 0;
@@ -1783,11 +1791,11 @@ void print_report(args_t const& args, stats_t const* stats, double const duratio
 
 	/* TPS */
 	const auto tps = final_stats.get_tx_count() / duration_sec;
-	put_field_f(tps, 2);
+	putFieldFloat(tps, 2);
 
 	/* Conflicts */
 	const auto conflicts_rate = final_stats.get_conflict_count() / duration_sec;
-	put_field_f(conflicts_rate, 2);
+	putFieldFloat(conflicts_rate, 2);
 	fmt::print("\n");
 
 	if (fp) {
@@ -1795,11 +1803,11 @@ void print_report(args_t const& args, stats_t const* stats, double const duratio
 	}
 
 	/* Errors */
-	put_title("Errors");
+	putTitle("Errors");
 	first_op = 1;
 	for (auto op = 0; op < MAX_OP; op++) {
 		if (args.txnspec.ops[op][OP_COUNT] > 0 && op != OP_TRANSACTION) {
-			put_field(final_stats.get_error_count(op));
+			putField(final_stats.get_error_count(op));
 			if (fp) {
 				if (first_op) {
 					first_op = 0;
@@ -1819,14 +1827,14 @@ void print_report(args_t const& args, stats_t const* stats, double const duratio
 	print_stats_header(args, true, false, true);
 
 	/* Total Samples */
-	put_title("Samples");
+	putTitle("Samples");
 	first_op = 1;
 	for (auto op = 0; op < MAX_OP; op++) {
 		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
 			if (final_stats.get_latency_us_total(op)) {
-				put_field(final_stats.get_latency_sample_count(op));
+				putField(final_stats.get_latency_sample_count(op));
 			} else {
-				put_field("N/A");
+				putField("N/A");
 			}
 			if (fp) {
 				if (first_op) {
@@ -1844,15 +1852,15 @@ void print_report(args_t const& args, stats_t const* stats, double const duratio
 	if (fp) {
 		fmt::fprintf(fp, "}, \"minLatency\": {");
 	}
-	put_title("Min");
+	putTitle("Min");
 	first_op = 1;
 	for (auto op = 0; op < MAX_OP; op++) {
 		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
 			const auto lat_min = final_stats.get_latency_us_min(op);
 			if (lat_min == -1) {
-				put_field("N/A");
+				putField("N/A");
 			} else {
-				put_field(lat_min);
+				putField(lat_min);
 				if (fp) {
 					if (first_op) {
 						first_op = 0;
@@ -1870,14 +1878,14 @@ void print_report(args_t const& args, stats_t const* stats, double const duratio
 	if (fp) {
 		fmt::fprintf(fp, "}, \"avgLatency\": {");
 	}
-	put_title("Avg");
+	putTitle("Avg");
 	first_op = 1;
 	for (auto op = 0; op < MAX_OP; op++) {
 		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
 			const auto lat_total = final_stats.get_latency_us_total(op);
 			const auto lat_samples = final_stats.get_latency_sample_count(op);
 			if (lat_total) {
-				put_field(lat_total / lat_samples);
+				putField(lat_total / lat_samples);
 				if (fp) {
 					if (first_op) {
 						first_op = 0;
@@ -1887,7 +1895,7 @@ void print_report(args_t const& args, stats_t const* stats, double const duratio
 					fmt::fprintf(fp, "\"%s\": %lu", get_ops_name(op), lat_total / lat_samples);
 				}
 			} else {
-				put_field("N/A");
+				putField("N/A");
 			}
 		}
 	}
@@ -1897,15 +1905,15 @@ void print_report(args_t const& args, stats_t const* stats, double const duratio
 	if (fp) {
 		fmt::fprintf(fp, "}, \"maxLatency\": {");
 	}
-	put_title("Max");
+	putTitle("Max");
 	first_op = 1;
 	for (auto op = 0; op < MAX_OP; op++) {
 		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
 			const auto lat_max = final_stats.get_latency_us_max(op);
 			if (lat_max == 0) {
-				put_field("N/A");
+				putField("N/A");
 			} else {
-				put_field(lat_max);
+				putField(lat_max);
 				if (fp) {
 					if (first_op) {
 						first_op = 0;
@@ -1925,7 +1933,7 @@ void print_report(args_t const& args, stats_t const* stats, double const duratio
 	if (fp) {
 		fmt::fprintf(fp, "}, \"medianLatency\": {");
 	}
-	put_title("Median");
+	putTitle("Median");
 	first_op = 1;
 	for (auto op = 0; op < MAX_OP; op++) {
 		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
@@ -1961,7 +1969,7 @@ void print_report(args_t const& args, stats_t const* stats, double const duratio
 				} else {
 					median = (data_points[op][num_points / 2] + data_points[op][num_points / 2 - 1]) >> 1;
 				}
-				put_field(median);
+				putField(median);
 				if (fp) {
 					if (first_op) {
 						first_op = 0;
@@ -1971,7 +1979,7 @@ void print_report(args_t const& args, stats_t const* stats, double const duratio
 					fmt::fprintf(fp, "\"%s\": %lu", get_ops_name(op), median);
 				}
 			} else {
-				put_field("N/A");
+				putField("N/A");
 			}
 		}
 	}
@@ -1981,17 +1989,17 @@ void print_report(args_t const& args, stats_t const* stats, double const duratio
 	if (fp) {
 		fmt::fprintf(fp, "}, \"p95Latency\": {");
 	}
-	put_title("95.0 pctile");
+	putTitle("95.0 pctile");
 	first_op = 1;
 	for (auto op = 0; op < MAX_OP; op++) {
 		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
 			if (data_points[op].empty() || !final_stats.get_latency_us_total(op)) {
-				put_field("N/A");
+				putField("N/A");
 				continue;
 			}
 			const auto num_points = data_points[op].size();
 			const auto point_95pct = static_cast<size_t>(std::max(0., (num_points * 0.95) - 1));
-			put_field(data_points[op][point_95pct]);
+			putField(data_points[op][point_95pct]);
 			if (fp) {
 				if (first_op) {
 					first_op = 0;
@@ -2008,17 +2016,17 @@ void print_report(args_t const& args, stats_t const* stats, double const duratio
 	if (fp) {
 		fmt::fprintf(fp, "}, \"p99Latency\": {");
 	}
-	put_title("99.0 pctile");
+	putTitle("99.0 pctile");
 	first_op = 1;
 	for (auto op = 0; op < MAX_OP; op++) {
 		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
 			if (data_points[op].empty() || !final_stats.get_latency_us_total(op)) {
-				put_field("N/A");
+				putField("N/A");
 				continue;
 			}
 			const auto num_points = data_points[op].size();
 			const auto point_99pct = static_cast<size_t>(std::max(0., (num_points * 0.99) - 1));
-			put_field(data_points[op][point_99pct]);
+			putField(data_points[op][point_99pct]);
 			if (fp) {
 				if (first_op) {
 					first_op = 0;
@@ -2035,17 +2043,17 @@ void print_report(args_t const& args, stats_t const* stats, double const duratio
 	if (fp) {
 		fmt::fprintf(fp, "}, \"p99.9Latency\": {");
 	}
-	put_title("99.9 pctile");
+	putTitle("99.9 pctile");
 	first_op = 1;
 	for (auto op = 0; op < MAX_OP; op++) {
 		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
 			if (data_points[op].empty() || !final_stats.get_latency_us_total(op)) {
-				put_field("N/A");
+				putField("N/A");
 				continue;
 			}
 			const auto num_points = data_points[op].size();
 			const auto point_99_9pct = static_cast<size_t>(std::max(0., (num_points * 0.999) - 1));
-			put_field(data_points[op][point_99_9pct]);
+			putField(data_points[op][point_99_9pct]);
 			if (fp) {
 				if (first_op) {
 					first_op = 0;
@@ -2065,8 +2073,8 @@ void print_report(args_t const& args, stats_t const* stats, double const duratio
 	system(command_remove.c_str());
 }
 
-int stats_process_main(args_t const& args,
-                       stats_t const* stats,
+int stats_process_main(Arguments const& args,
+                       ThreadStatistics const* stats,
                        std::atomic<double>& throttle_factor,
                        std::atomic<int> const& signal,
                        std::atomic<int> const& stopcount,
@@ -2200,7 +2208,7 @@ int main(int argc, char* argv[]) {
 	setlinebuf(stdout);
 
 	auto rc = int{};
-	auto args = args_t{};
+	auto args = Arguments{};
 	rc = init_args(&args);
 	if (rc < 0) {
 		fmt::print(stderr, "ERROR: init_args failed\n");
@@ -2243,7 +2251,7 @@ int main(int argc, char* argv[]) {
 	});
 
 	/* allocate */
-	const auto shmsize = shm_storage_size(args.num_processes, args.num_threads);
+	const auto shmsize = shared_memory::storageSize(args.num_processes, args.num_threads);
 	auto shm = std::add_pointer_t<void>{};
 	if (ftruncate(shmfd, shmsize) < 0) {
 		shm = MAP_FAILED;
@@ -2259,7 +2267,7 @@ int main(int argc, char* argv[]) {
 	}
 	auto munmap_guard = ExitGuard([=]() { munmap(shm, shmsize); });
 
-	auto shm_access = shm_access_t(shm, args.num_processes, args.num_threads);
+	auto shm_access = shared_memory::Access(shm, args.num_processes, args.num_threads);
 
 	/* initialize the shared memory */
 	shm_access.reset();
@@ -2271,7 +2279,7 @@ int main(int argc, char* argv[]) {
 	shm_hdr.stopcount = 0;
 	shm_hdr.throttle_factor = 1.0;
 
-	auto proc_type = proc_master;
+	auto proc_type = PROC_MASTER;
 	/* fork worker processes + 1 stats process */
 	auto worker_pids = std::vector<pid_t>(args.num_processes + 1);
 
@@ -2290,11 +2298,11 @@ int main(int argc, char* argv[]) {
 		} else {
 			if (p < args.num_processes) {
 				/* worker process */
-				proc_type = proc_worker;
+				proc_type = PROC_WORKER;
 				worker_id = p;
 			} else {
 				/* stats */
-				proc_type = proc_stats;
+				proc_type = PROC_STATS;
 			}
 			break;
 		}
@@ -2308,19 +2316,19 @@ int main(int argc, char* argv[]) {
 		zipfian_generator(args.rows);
 	}
 
-	if (proc_type == proc_worker) {
+	if (proc_type == PROC_WORKER) {
 		/* worker process */
 		worker_process_main(args, worker_id, shm_access, pid_main);
 		/* worker can exit here */
 		exit(0);
-	} else if (proc_type == proc_stats) {
+	} else if (proc_type == PROC_STATS) {
 		/* stats */
 		if (args.mode == MODE_CLEAN) {
 			/* no stats needed for clean mode */
 			exit(0);
 		}
 		stats_process_main(
-		    args, shm_access.stats_const_array(), shm_hdr.throttle_factor, shm_hdr.signal, shm_hdr.stopcount, pid_main);
+		    args, shm_access.statsConstArray(), shm_hdr.throttle_factor, shm_hdr.signal, shm_hdr.stopcount, pid_main);
 		exit(0);
 	}
 
diff --git a/bindings/c/test/mako/mako.hpp b/bindings/c/test/mako/mako.hpp
index bb7276e48b..9177e84882 100644
--- a/bindings/c/test/mako/mako.hpp
+++ b/bindings/c/test/mako/mako.hpp
@@ -41,7 +41,7 @@ constexpr const int MODE_BUILD = 1;
 constexpr const int MODE_RUN = 2;
 
 /* for long arguments */
-enum Arguments {
+enum ArgKind {
 	ARG_KEYLEN,
 	ARG_VALLEN,
 	ARG_TPS,
@@ -71,11 +71,11 @@ enum Arguments {
 
 enum TPSChangeTypes { TPS_SIN, TPS_SQUARE, TPS_PULSE };
 
-/* we set txnspec_t and args_t only once in the master process,
+/* we set WorkloadSpec and Arguments only once in the master process,
  * and won't be touched by child processes.
  */
 
-struct txnspec_t {
+struct WorkloadSpec {
 	/* for each operation, it stores "count", "range" and "reverse" */
 	int ops[MAX_OP][3];
 };
@@ -88,7 +88,7 @@ constexpr const int NUM_DATABASES_MAX = 10;
 constexpr const int MAX_BG_IDS = 1000;
 
 /* benchmark parameters */
-struct args_t {
+struct Arguments {
 	int api_version;
 	int json;
 	int num_processes;
@@ -108,7 +108,7 @@ struct args_t {
 	int zipf;
 	int commit_get;
 	int verbose;
-	txnspec_t txnspec;
+	WorkloadSpec txnspec;
 	char cluster_files[NUM_CLUSTERS_MAX][PATH_MAX];
 	int num_fdb_clusters;
 	int num_databases;
@@ -135,20 +135,19 @@ constexpr const int SIGNAL_RED = 0;
 constexpr const int SIGNAL_GREEN = 1;
 constexpr const int SIGNAL_OFF = 2;
 
-using sample_bin_array_t = std::array<sample_bin, MAX_OP>;
 /* args for threads */
-struct alignas(64) thread_args_t {
+struct alignas(64) ThreadArgs {
 	int worker_id;
 	int thread_id;
 	pid_t parent_id;
-	sample_bin_array_t sample_bins;
-	args_t const* args;
-	shm_access_t shm;
+	LatencySampleBinArray sample_bins;
+	Arguments const* args;
+	shared_memory::Access shm;
 	fdb::Database database; // database to work with
 };
 
 /* process type */
-typedef enum { proc_master = 0, proc_worker, proc_stats } proc_type_t;
+typedef enum { PROC_MASTER = 0, PROC_WORKER, PROC_STATS } ProcKind;
 
 } // namespace mako
 
diff --git a/bindings/c/test/mako/shm.hpp b/bindings/c/test/mako/shm.hpp
index 103458277c..87d2ee3a47 100644
--- a/bindings/c/test/mako/shm.hpp
+++ b/bindings/c/test/mako/shm.hpp
@@ -6,70 +6,72 @@
 #include <cstdint>
 #include "stats.hpp"
 
-namespace mako {
+namespace mako::shared_memory {
 
-struct shmhdr_t {
+struct Header {
 	std::atomic<int> signal;
 	std::atomic<int> readycount;
 	std::atomic<double> throttle_factor;
 	std::atomic<int> stopcount;
 };
 
-struct shm_layout_helper {
-	shmhdr_t hdr;
-	stats_t stats;
+struct LayoutHelper {
+	Header hdr;
+	ThreadStatistics stats;
 };
 
-inline size_t shm_storage_size(int num_processes, int num_threads) noexcept {
+inline size_t storageSize(int num_processes, int num_threads) noexcept {
 	assert(num_processes >= 1 && num_threads >= 1);
-	return sizeof(shm_layout_helper) + sizeof(stats_t) * ((num_processes * num_threads) - 1);
+	return sizeof(LayoutHelper) + sizeof(ThreadStatistics) * ((num_processes * num_threads) - 1);
 }
 
-inline stats_t& shm_stats_slot(void* shm_base, int num_threads, int process_idx, int thread_idx) noexcept {
-	return (&static_cast<shm_layout_helper*>(shm_base)->stats)[process_idx * num_threads + thread_idx];
-}
-
-class shm_access_t {
-protected:
+class Access {
 	void* base;
 	int num_processes;
 	int num_threads;
 
+	static inline ThreadStatistics& statsSlot(void* shm_base,
+	                                          int num_threads,
+	                                          int process_idx,
+	                                          int thread_idx) noexcept {
+		return (&static_cast<LayoutHelper*>(shm_base)->stats)[process_idx * num_threads + thread_idx];
+	}
+
 public:
-	shm_access_t(void* shm, int num_processes, int num_threads) noexcept
+	Access(void* shm, int num_processes, int num_threads) noexcept
 	  : base(shm), num_processes(num_processes), num_threads(num_threads) {}
 
-	shm_access_t() noexcept : shm_access_t(nullptr, 0, 0) {}
+	Access() noexcept : Access(nullptr, 0, 0) {}
 
-	shm_access_t(const shm_access_t&) noexcept = default;
+	Access(const Access&) noexcept = default;
 
-	shm_access_t& operator=(const shm_access_t&) noexcept = default;
+	Access& operator=(const Access&) noexcept = default;
 
-	size_t storage_size() const noexcept { return shm_storage_size(num_processes, num_threads); }
+	size_t size() const noexcept { return storageSize(num_processes, num_threads); }
 
-	void reset() noexcept { memset(base, 0, storage_size()); }
+	void reset() noexcept { memset(base, 0, size()); }
 
-	shmhdr_t const& header_const() const noexcept { return *static_cast<shmhdr_t const*>(base); }
+	Header const& headerConst() const noexcept { return *static_cast<Header const*>(base); }
 
-	shmhdr_t& header() const noexcept { return *static_cast<shmhdr_t*>(base); }
+	Header& header() const noexcept { return *static_cast<Header*>(base); }
 
-	stats_t const* stats_const_array() const noexcept {
-		return &shm_stats_slot(base, num_threads, 0 /*process_id*/, 0 /*thread_id*/);
+	ThreadStatistics const* statsConstArray() const noexcept {
+		return &statsSlot(base, num_threads, 0 /*process_id*/, 0 /*thread_id*/);
 	}
 
-	stats_t* stats_array() const noexcept {
-		return &shm_stats_slot(base, num_threads, 0 /*process_id*/, 0 /*thread_id*/);
+	ThreadStatistics* statsArray() const noexcept {
+		return &statsSlot(base, num_threads, 0 /*process_id*/, 0 /*thread_id*/);
 	}
 
-	stats_t const& stats_const_slot(int process_idx, int thread_idx) const noexcept {
-		return shm_stats_slot(base, num_threads, process_idx, thread_idx);
+	ThreadStatistics const& statsConstSlot(int process_idx, int thread_idx) const noexcept {
+		return statsSlot(base, num_threads, process_idx, thread_idx);
 	}
 
-	stats_t& stats_slot(int process_idx, int thread_idx) const noexcept {
-		return shm_stats_slot(base, num_threads, process_idx, thread_idx);
+	ThreadStatistics& statsSlot(int process_idx, int thread_idx) const noexcept {
+		return statsSlot(base, num_threads, process_idx, thread_idx);
 	}
 };
 
-} // namespace mako
+} // namespace mako::shared_memory
 
 #endif /* MAKO_SHM_HPP */
diff --git a/bindings/c/test/mako/stats.hpp b/bindings/c/test/mako/stats.hpp
index 065ab04824..442a84451c 100644
--- a/bindings/c/test/mako/stats.hpp
+++ b/bindings/c/test/mako/stats.hpp
@@ -1,6 +1,7 @@
 #ifndef MAKO_STATS_HPP
 #define MAKO_STATS_HPP
 
+#include <array>
 #include <cstdint>
 #include <cstring>
 #include <list>
@@ -14,14 +15,14 @@ namespace mako {
 constexpr const size_t LAT_BLOCK_SIZE = 4095;
 
 /* memory block allocated to each operation when collecting detailed latency */
-class lat_block_t {
+class LatencySampleBlock {
 	uint64_t samples[LAT_BLOCK_SIZE]{
 		0,
 	};
 	uint32_t index{ 0 };
 
 public:
-	lat_block_t() noexcept = default;
+	LatencySampleBlock() noexcept = default;
 	bool full() const noexcept { return index >= LAT_BLOCK_SIZE; }
 	void put(timediff_t td) {
 		assert(!full());
@@ -32,11 +33,11 @@ public:
 };
 
 /* collect sampled latencies */
-class sample_bin {
-	std::list<lat_block_t> blocks;
+class LatencySampleBin {
+	std::list<LatencySampleBlock> blocks;
 
 public:
-	void reserve_one() {
+	void reserveOneBlock() {
 		if (blocks.empty())
 			blocks.emplace_back();
 	}
@@ -49,7 +50,7 @@ public:
 
 	// iterate & apply for each block user function void(uint64_t const*, size_t)
 	template <typename Func>
-	void for_each_block(Func&& fn) const {
+	void forEachBlock(Func&& fn) const {
 		for (const auto& block : blocks) {
 			auto [ptr, cnt] = block.data();
 			fn(ptr, cnt);
@@ -57,7 +58,7 @@ public:
 	}
 };
 
-class alignas(64) stats_t {
+class alignas(64) ThreadStatistics {
 	uint64_t xacts;
 	uint64_t conflicts;
 	uint64_t total_errors;
@@ -69,13 +70,13 @@ class alignas(64) stats_t {
 	uint64_t latency_us_max[MAX_OP];
 
 public:
-	stats_t() noexcept {
-		memset(this, 0, sizeof(stats_t));
+	ThreadStatistics() noexcept {
+		memset(this, 0, sizeof(ThreadStatistics));
 		memset(latency_us_min, 0xff, sizeof(latency_us_min));
 	}
 
-	stats_t(const stats_t& other) noexcept = default;
-	stats_t& operator=(const stats_t& other) noexcept = default;
+	ThreadStatistics(const ThreadStatistics& other) noexcept = default;
+	ThreadStatistics& operator=(const ThreadStatistics& other) noexcept = default;
 
 	uint64_t get_tx_count() const noexcept { return xacts; }
 
@@ -96,7 +97,7 @@ public:
 	uint64_t get_latency_us_max(int op) const noexcept { return latency_us_max[op]; }
 
 	// with 'this' as final aggregation, factor in 'other'
-	void combine(const stats_t& other) {
+	void combine(const ThreadStatistics& other) {
 		xacts += other.xacts;
 		conflicts += other.conflicts;
 		for (auto op = 0; op < MAX_OP; op++) {
@@ -134,6 +135,8 @@ public:
 	}
 };
 
+using LatencySampleBinArray = std::array<LatencySampleBin, MAX_OP>;
+
 } // namespace mako
 
 #endif /* MAKO_STATS_HPP */
diff --git a/bindings/c/test/mako/utils.cpp b/bindings/c/test/mako/utils.cpp
index 360a761f6a..c41abf84e8 100644
--- a/bindings/c/test/mako/utils.cpp
+++ b/bindings/c/test/mako/utils.cpp
@@ -16,19 +16,19 @@ int urand(int low, int high) {
 }
 
 /* return the first key to be inserted */
-int insert_begin(int rows, int p_idx, int t_idx, int total_p, int total_t) {
+int insertBegin(int rows, int p_idx, int t_idx, int total_p, int total_t) {
 	double interval = (double)rows / total_p / total_t;
 	return (int)(round(interval * ((p_idx * total_t) + t_idx)));
 }
 
 /* return the last key to be inserted */
-int insert_end(int rows, int p_idx, int t_idx, int total_p, int total_t) {
+int insertEnd(int rows, int p_idx, int t_idx, int total_p, int total_t) {
 	double interval = (double)rows / total_p / total_t;
 	return (int)(round(interval * ((p_idx * total_t) + t_idx + 1) - 1));
 }
 
 /* devide val equally among threads */
-int compute_thread_portion(int val, int p_idx, int t_idx, int total_p, int total_t) {
+int computeThreadPortion(int val, int p_idx, int t_idx, int total_p, int total_t) {
 	int interval = val / total_p / total_t;
 	int remaining = val - (interval * total_p * total_t);
 	if ((p_idx * total_t + t_idx) < remaining) {
diff --git a/bindings/c/test/mako/utils.hpp b/bindings/c/test/mako/utils.hpp
index 2382a9373b..dd1ea097a9 100644
--- a/bindings/c/test/mako/utils.hpp
+++ b/bindings/c/test/mako/utils.hpp
@@ -18,7 +18,7 @@ int urand(int low, int high);
 
 /* random string */
 template <bool Clear = true, typename Char>
-void randstr(std::basic_string<Char>& str, int len) {
+void randomString(std::basic_string<Char>& str, int len) {
 	if constexpr (Clear)
 		str.clear();
 	assert(len >= 0);
@@ -30,7 +30,7 @@ void randstr(std::basic_string<Char>& str, int len) {
 
 /* random numeric string */
 template <bool Clear = true, typename Char>
-void randnumstr(std::basic_string<Char>& str, int len) {
+void randomNumericString(std::basic_string<Char>& str, int len) {
 	if constexpr (Clear)
 		str.clear();
 	assert(len >= 0);
@@ -45,25 +45,25 @@ void randnumstr(std::basic_string<Char>& str, int len) {
  * and the total number of processes, total_p, and threads, total_t,
  * returns the first row number assigned to this partition.
  */
-int insert_begin(int rows, int p_idx, int t_idx, int total_p, int total_t);
+int insertBegin(int rows, int p_idx, int t_idx, int total_p, int total_t);
 
-/* similar to insert_begin, insert_end returns the last row numer */
-int insert_end(int rows, int p_idx, int t_idx, int total_p, int total_t);
+/* similar to insertBegin, insertEnd returns the last row numer */
+int insertEnd(int rows, int p_idx, int t_idx, int total_p, int total_t);
 
 /* devide a value equally among threads */
-int compute_thread_portion(int val, int p_idx, int t_idx, int total_p, int total_t);
+int computeThreadPortion(int val, int p_idx, int t_idx, int total_p, int total_t);
 
-/* similar to insert_begin/end, compute_thread_tps computes
+/* similar to insertBegin/end, computeThreadTps computes
  * the per-thread target TPS for given configuration.
  */
-#define compute_thread_tps(val, p_idx, t_idx, total_p, total_t)                                                        \
-	compute_thread_portion(val, p_idx, t_idx, total_p, total_t)
+#define computeThreadTps(val, p_idx, t_idx, total_p, total_t)                                                        \
+	computeThreadPortion(val, p_idx, t_idx, total_p, total_t)
 
-/* similar to compute_thread_tps,
- * compute_thread_iters computs the number of iterations.
+/* similar to computeThreadTps,
+ * computeThreadIters computs the number of iterations.
  */
-#define compute_thread_iters(val, p_idx, t_idx, total_p, total_t)                                                      \
-	compute_thread_portion(val, p_idx, t_idx, total_p, total_t)
+#define computeThreadIters(val, p_idx, t_idx, total_p, total_t)                                                      \
+	computeThreadPortion(val, p_idx, t_idx, total_p, total_t)
 
 /* get the number of digits */
 int digits(int num);
@@ -72,7 +72,7 @@ int digits(int num);
  * (str) is appended with concat([padding], PREFIX)
  */
 template <bool Clear = true, typename Char>
-void genkeyprefix(std::basic_string<Char>& str, std::string_view prefix, args_t const& args) {
+void genKeyPrefix(std::basic_string<Char>& str, std::string_view prefix, Arguments const& args) {
 	// concat('x' * padding_len, key_prefix)
 	if constexpr (Clear)
 		str.clear();
@@ -86,7 +86,7 @@ void genkeyprefix(std::basic_string<Char>& str, std::string_view prefix, args_t
 /* generate a key for a given key number */
 /* prefix is "mako" by default, prefixpadding = 1 means 'x' will be in front rather than trailing the keyname */
 template <bool Clear = true, typename Char>
-void genkey(std::basic_string<Char>& str, std::string_view prefix, args_t const& args, int num) {
+void genKey(std::basic_string<Char>& str, std::string_view prefix, Arguments const& args, int num) {
 	static_assert(sizeof(Char) == 1);
 	const auto pad_len = args.prefixpadding ? args.key_length - (static_cast<int>(prefix.size()) + args.row_digits) : 0;
 	assert(pad_len >= 0);
@@ -135,30 +135,30 @@ constexpr const int STATS_TITLE_WIDTH = 12;
 constexpr const int STATS_FIELD_WIDTH = 12;
 
 template <typename Value>
-void put_title(Value&& value) {
+void putTitle(Value&& value) {
 	fmt::print("{0: <{1}} ", std::forward<Value>(value), STATS_TITLE_WIDTH);
 }
 
 template <typename Value>
-void put_title_r(Value&& value) {
+void putTitleRight(Value&& value) {
 	fmt::print("{0: >{1}} ", std::forward<Value>(value), STATS_TITLE_WIDTH);
 }
 
-inline void put_title_bar() {
+inline void putTitleBar() {
 	fmt::print("{0:=<{1}} ", "", STATS_TITLE_WIDTH);
 }
 
 template <typename Value>
-void put_field(Value&& value) {
+void putField(Value&& value) {
 	fmt::print("{0: >{1}} ", std::forward<Value>(value), STATS_FIELD_WIDTH);
 }
 
-inline void put_field_bar() {
+inline void putFieldBar() {
 	fmt::print("{0:=>{1}} ", "", STATS_FIELD_WIDTH);
 }
 
 template <typename Value>
-void put_field_f(Value&& value, int precision) {
+void putFieldFloat(Value&& value, int precision) {
 	fmt::print("{0: >{1}.{2}f} ", std::forward<Value>(value), STATS_FIELD_WIDTH, precision);
 }
 

From ba69fcdd56a5022454e7cca2368f40d7cef26b67 Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Mon, 7 Mar 2022 06:52:27 +0100
Subject: [PATCH 10/84] Clean up operations table

---
 bindings/c/test/mako/mako.cpp       | 487 ++++++++++++++--------------
 bindings/c/test/mako/mako.hpp       |  31 ++
 bindings/c/test/mako/operations.hpp |  23 +-
 3 files changed, 282 insertions(+), 259 deletions(-)

diff --git a/bindings/c/test/mako/mako.cpp b/bindings/c/test/mako/mako.cpp
index 60cc077cf5..8541639a1b 100644
--- a/bindings/c/test/mako/mako.cpp
+++ b/bindings/c/test/mako/mako.cpp
@@ -317,240 +317,254 @@ inline int next_key(Arguments const& args) {
 	return urand(0, args.rows - 1);
 }
 
-const std::array<OpDesc, MAX_OP> op_desc{ { { "GRV", { StepKind::READ }, false },
-	                                        { "GET", { StepKind::READ }, false },
-	                                        { "GETRANGE", { StepKind::READ }, false },
-	                                        { "SGET", { StepKind::READ }, false },
-	                                        { "SGETRANGE", { StepKind::READ }, false },
-	                                        { "UPDATE", { StepKind::COMMIT, StepKind::IMM }, true },
-	                                        { "INSERT", { StepKind::IMM }, true },
-	                                        { "INSERTRANGE", { StepKind::IMM }, true },
-	                                        { "OVERWRITE", { StepKind::IMM }, true },
-	                                        { "CLEAR", { StepKind::IMM }, true },
-	                                        { "SETCLEAR", { StepKind::COMMIT, StepKind::IMM }, true },
-	                                        { "CLEARRANGE", { StepKind::IMM }, true },
-	                                        { "SETCLEARRANGE", { StepKind::COMMIT, StepKind::IMM }, true },
-	                                        { "COMMIT", { StepKind::NONE }, false },
-	                                        { "TRANSACTION", { StepKind::NONE }, false },
-	                                        { "READBLOBGRANULE", { StepKind::ON_ERROR }, false } } };
+const std::array<Operation, MAX_OP> opTable{
+	{ { "GRV",
+	    { { StepKind::READ,
+	        [](Transaction tx, Arguments const&, ByteString&, ByteString&, ByteString&) {
+	            return tx.getReadVersion().eraseType();
+	        } } },
+	    false },
+	  { "GET",
+	    { { StepKind::READ,
+	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
+	            const auto num = next_key(args);
+	            genKey(key, KEY_PREFIX, args, num);
+	            return tx.get(key, false /*snapshot*/).eraseType();
+	        } } },
+	    false },
+	  { "GETRANGE",
+	    { { StepKind::READ,
+	        [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
+	            const auto num_begin = next_key(args);
+	            genKey(begin, KEY_PREFIX, args, num_begin);
+	            auto num_end = num_begin + args.txnspec.ops[OP_GETRANGE][OP_RANGE] - 1;
+	            if (num_end > args.rows - 1)
+		            num_end = args.rows - 1;
+	            genKey(end, KEY_PREFIX, args, num_end);
+	            return tx
+	                .getRange<KeySelect::Inclusive, KeySelect::Inclusive>(begin,
+	                                                                      end,
+	                                                                      0 /*limit*/,
+	                                                                      0 /*target_bytes*/,
+	                                                                      args.streaming_mode,
+	                                                                      0 /*iteration*/,
+	                                                                      false /*snapshot*/,
+	                                                                      args.txnspec.ops[OP_GETRANGE][OP_REVERSE])
+	                .eraseType();
+	        } } },
+	    false },
+	  { "SGET",
+	    { { StepKind::READ,
+	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
+	            const auto num = next_key(args);
+	            genKey(key, KEY_PREFIX, args, num);
+	            return tx.get(key, true /*snapshot*/).eraseType();
+	        } } },
+	    false },
+	  { "SGETRANGE",
+	    { {
 
-const std::map<
-    std::pair<int /*op*/, int /*sub-op step*/>,
-    Future (*)(Transaction, Arguments const&, ByteString& /*key1*/, ByteString& /*key2*/, ByteString& /*value*/)>
-    operation_fn_table{
-	    { { OP_GETREADVERSION, 0 },
-	      [](Transaction tx, Arguments const&, ByteString&, ByteString&, ByteString&) {
-	          return tx.getReadVersion().eraseType();
-	      } },
-	    { { OP_GET, 0 },
-	      [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
-	          const auto num = next_key(args);
-	          genKey(key, KEY_PREFIX, args, num);
-	          return tx.get(key, false /*snapshot*/).eraseType();
-	      } },
-	    { { OP_GETRANGE, 0 },
-	      [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
-	          const auto num_begin = next_key(args);
-	          genKey(begin, KEY_PREFIX, args, num_begin);
-	          auto num_end = num_begin + args.txnspec.ops[OP_GETRANGE][OP_RANGE] - 1;
-	          if (num_end > args.rows - 1)
-		          num_end = args.rows - 1;
-	          genKey(end, KEY_PREFIX, args, num_end);
-	          return tx
-	              .getRange<KeySelect::Inclusive, KeySelect::Inclusive>(begin,
-	                                                                    end,
-	                                                                    0 /*limit*/,
-	                                                                    0 /*target_bytes*/,
-	                                                                    args.streaming_mode,
-	                                                                    0 /*iteration*/,
-	                                                                    false /*snapshot*/,
-	                                                                    args.txnspec.ops[OP_GETRANGE][OP_REVERSE])
-	              .eraseType();
-	      } },
-	    { { OP_SGET, 0 },
-	      [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
-	          const auto num = next_key(args);
-	          genKey(key, KEY_PREFIX, args, num);
-	          return tx.get(key, true /*snapshot*/).eraseType();
-	      } },
-	    { { OP_SGETRANGE, 0 },
-	      [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
-	          const auto num_begin = next_key(args);
-	          genKey(begin, KEY_PREFIX, args, num_begin);
-	          auto num_end = num_begin + args.txnspec.ops[OP_SGETRANGE][OP_RANGE] - 1;
-	          if (num_end > args.rows - 1)
-		          num_end = args.rows - 1;
-	          genKey(end, KEY_PREFIX, args, num_end);
-	          return tx
-	              .getRange<KeySelect::Inclusive, KeySelect::Inclusive>(begin,
-	                                                                    end,
-	                                                                    0 /*limit*/,
-	                                                                    0 /*target_bytes*/,
-	                                                                    args.streaming_mode,
-	                                                                    0 /*iteration*/,
-	                                                                    true /*snapshot*/,
-	                                                                    args.txnspec.ops[OP_SGETRANGE][OP_REVERSE])
-	              .eraseType();
-	      } },
-	    { { OP_UPDATE, 0 },
-	      [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
-	          const auto num = next_key(args);
-	          genKey(key, KEY_PREFIX, args, num);
-	          return tx.get(key, false /*snapshot*/).eraseType();
-	      } },
-	    { { OP_UPDATE, 1 },
-	      [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
-	          randomString(value, args.value_length);
-	          tx.set(key, value);
-	          return Future();
-	      } },
-	    { { OP_INSERT, 0 },
-	      [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
-	          genKeyPrefix(key, KEY_PREFIX, args);
-	          // concat([padding], key_prefix, random_string): reasonably unique
-	          randomString<false /*clear-before-append*/>(key, args.key_length - static_cast<int>(key.size()));
-	          randomString(value, args.value_length);
-	          tx.set(key, value);
-	          return Future();
-	      } },
-	    { { OP_INSERTRANGE, 0 },
-	      [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
-	          genKeyPrefix(key, KEY_PREFIX, args);
-	          const auto prefix_len = static_cast<int>(key.size());
-	          const auto range = args.txnspec.ops[OP_INSERTRANGE][OP_RANGE];
-	          assert(range > 0);
-	          const auto range_digits = digits(range);
-	          assert(args.key_length - prefix_len >= range_digits);
-	          const auto rand_len = args.key_length - prefix_len - range_digits;
-	          // concat([padding], prefix, random_string, range_digits)
-	          randomString<false /*clear-before-append*/>(key, rand_len);
-	          randomString(value, args.value_length);
-	          for (auto i = 0; i < range; i++) {
-		          fmt::format_to(std::back_inserter(key), "{0:0{1}d}", i, range_digits);
-		          tx.set(key, value);
-		          key.resize(key.size() - static_cast<size_t>(range_digits));
-	          }
-	          return Future();
-	      } },
-	    { { OP_OVERWRITE, 0 },
-	      [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
-	          genKey(key, KEY_PREFIX, args, next_key(args));
-	          randomString(value, args.value_length);
-	          tx.set(key, value);
-	          return Future();
-	      } },
-	    { { OP_CLEAR, 0 },
-	      [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
-	          genKey(key, KEY_PREFIX, args, next_key(args));
-	          tx.clear(key);
-	          return Future();
-	      } },
-	    { { OP_SETCLEAR, 0 },
-	      [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
-	          genKeyPrefix(key, KEY_PREFIX, args);
-	          const auto prefix_len = static_cast<int>(key.size());
-	          randomString<false /*append-after-clear*/>(key, args.key_length - prefix_len);
-	          randomString(value, args.value_length);
-	          tx.set(key, value);
-	          return tx.commit().eraseType();
-	      } },
-	    { { OP_SETCLEAR, 1 },
-	      [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
-	          tx.reset(); // assuming commit from step 0 worked.
-	          tx.clear(key); // key should forward unchanged from step 0
-	          return Future();
-	      } },
-	    { { OP_CLEARRANGE, 0 },
-	      [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
-	          const auto num_begin = next_key(args);
-	          genKey(begin, KEY_PREFIX, args, num_begin);
-	          const auto range = args.txnspec.ops[OP_CLEARRANGE][OP_RANGE];
-	          assert(range > 0);
-	          genKey(end, KEY_PREFIX, args, std::min(args.rows - 1, num_begin + range - 1));
-	          tx.clearRange(begin, end);
-	          return Future();
-	      } },
-	    { { OP_SETCLEARRANGE, 0 },
-	      [](Transaction tx, Arguments const& args, ByteString& key_begin, ByteString& key, ByteString& value) {
-	          genKeyPrefix(key, KEY_PREFIX, args);
-	          const auto prefix_len = static_cast<int>(key.size());
-	          const auto range = args.txnspec.ops[OP_SETCLEARRANGE][OP_RANGE];
-	          assert(range > 0);
-	          const auto range_digits = digits(range);
-	          assert(args.key_length - prefix_len >= range_digits);
-	          const auto rand_len = args.key_length - prefix_len - range_digits;
-	          // concat([padding], prefix, random_string, range_digits)
-	          randomString<false /*clear-before-append*/>(key, rand_len);
-	          randomString(value, args.value_length);
-	          for (auto i = 0; i <= range; i++) {
-		          fmt::format_to(std::back_inserter(key), "{0:0{1}d}", i, range_digits);
-		          if (i == range)
-			          break; // preserve "exclusive last"
-		          // preserve first key for step 1
-		          if (i == 0)
-			          key_begin = key;
-		          tx.set(key, value);
-		          // preserve last key for step 1
-		          key.resize(key.size() - static_cast<size_t>(range_digits));
-	          }
-	          return tx.commit().eraseType();
-	      } },
-	    { { OP_SETCLEARRANGE, 1 },
-	      [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
-	          tx.reset();
-	          tx.clearRange(begin, end);
-	          return Future();
-	      } },
-	    { { OP_READ_BG, 0 },
-	      [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
-	          const auto num_begin = next_key(args);
-	          genKey(begin, KEY_PREFIX, args, num_begin);
-	          const auto range = args.txnspec.ops[OP_READ_BG][OP_RANGE];
-	          assert(range > 0);
-	          genKey(end, KEY_PREFIX, args, std::min(args.rows - 1, num_begin + range - 1));
-	          auto err = Error{};
+	        StepKind::READ,
+	        [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
+	            const auto num_begin = next_key(args);
+	            genKey(begin, KEY_PREFIX, args, num_begin);
+	            auto num_end = num_begin + args.txnspec.ops[OP_SGETRANGE][OP_RANGE] - 1;
+	            if (num_end > args.rows - 1)
+		            num_end = args.rows - 1;
+	            genKey(end, KEY_PREFIX, args, num_end);
+	            return tx
+	                .getRange<KeySelect::Inclusive, KeySelect::Inclusive>(begin,
+	                                                                      end,
+	                                                                      0 /*limit*/,
+	                                                                      0 /*target_bytes*/,
+	                                                                      args.streaming_mode,
+	                                                                      0 /*iteration*/,
+	                                                                      true /*snapshot*/,
+	                                                                      args.txnspec.ops[OP_SGETRANGE][OP_REVERSE])
+	                .eraseType();
+	        }
 
-	          err = tx.setOptionNothrow(FDB_TR_OPTION_READ_YOUR_WRITES_DISABLE, BytesRef());
-	          if (err) {
-		          // Issuing read/writes before disabling RYW results in error.
-		          // Possible malformed workload?
-		          // As workloads execute in sequence, retrying would likely repeat this error.
-		          fmt::print(stderr, "ERROR: TR_OPTION_READ_YOUR_WRITES_DISABLE: {}", err.what());
-		          return Future();
-	          }
+	    } },
+	    false },
+	  { "UPDATE",
+	    { { StepKind::READ,
+	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
+	            const auto num = next_key(args);
+	            genKey(key, KEY_PREFIX, args, num);
+	            return tx.get(key, false /*snapshot*/).eraseType();
+	        } },
+	      { StepKind::IMM,
+	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
+	            randomString(value, args.value_length);
+	            tx.set(key, value);
+	            return Future();
+	        } } },
+	    true },
+	  { "INSERT",
+	    { { StepKind::IMM,
+	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
+	            genKeyPrefix(key, KEY_PREFIX, args);
+	            // concat([padding], key_prefix, random_string): reasonably unique
+	            randomString<false /*clear-before-append*/>(key, args.key_length - static_cast<int>(key.size()));
+	            randomString(value, args.value_length);
+	            tx.set(key, value);
+	            return Future();
+	        } } },
+	    true },
+	  { "INSERTRANGE",
+	    { { StepKind::IMM,
+	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
+	            genKeyPrefix(key, KEY_PREFIX, args);
+	            const auto prefix_len = static_cast<int>(key.size());
+	            const auto range = args.txnspec.ops[OP_INSERTRANGE][OP_RANGE];
+	            assert(range > 0);
+	            const auto range_digits = digits(range);
+	            assert(args.key_length - prefix_len >= range_digits);
+	            const auto rand_len = args.key_length - prefix_len - range_digits;
+	            // concat([padding], prefix, random_string, range_digits)
+	            randomString<false /*clear-before-append*/>(key, rand_len);
+	            randomString(value, args.value_length);
+	            for (auto i = 0; i < range; i++) {
+		            fmt::format_to(std::back_inserter(key), "{0:0{1}d}", i, range_digits);
+		            tx.set(key, value);
+		            key.resize(key.size() - static_cast<size_t>(range_digits));
+	            }
+	            return Future();
+	        } } },
+	    true },
+	  { "OVERWRITE",
+	    { { StepKind::IMM,
+	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
+	            genKey(key, KEY_PREFIX, args, next_key(args));
+	            randomString(value, args.value_length);
+	            tx.set(key, value);
+	            return Future();
+	        } } },
+	    true },
+	  { "CLEAR",
+	    { { StepKind::IMM,
+	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
+	            genKey(key, KEY_PREFIX, args, next_key(args));
+	            tx.clear(key);
+	            return Future();
+	        } } },
+	    true },
+	  { "SETCLEAR",
+	    { { StepKind::COMMIT,
+	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
+	            genKeyPrefix(key, KEY_PREFIX, args);
+	            const auto prefix_len = static_cast<int>(key.size());
+	            randomString<false /*append-after-clear*/>(key, args.key_length - prefix_len);
+	            randomString(value, args.value_length);
+	            tx.set(key, value);
+	            return tx.commit().eraseType();
+	        } },
+	      { StepKind::IMM,
+	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
+	            tx.reset(); // assuming commit from step 0 worked.
+	            tx.clear(key); // key should forward unchanged from step 0
+	            return Future();
+	        } } },
+	    true },
+	  { "CLEARRANGE",
+	    { { StepKind::IMM,
+	        [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
+	            const auto num_begin = next_key(args);
+	            genKey(begin, KEY_PREFIX, args, num_begin);
+	            const auto range = args.txnspec.ops[OP_CLEARRANGE][OP_RANGE];
+	            assert(range > 0);
+	            genKey(end, KEY_PREFIX, args, std::min(args.rows - 1, num_begin + range - 1));
+	            tx.clearRange(begin, end);
+	            return Future();
+	        } } },
+	    true },
+	  { "SETCLEARRANGE",
+	    { { StepKind::COMMIT,
+	        [](Transaction tx, Arguments const& args, ByteString& key_begin, ByteString& key, ByteString& value) {
+	            genKeyPrefix(key, KEY_PREFIX, args);
+	            const auto prefix_len = static_cast<int>(key.size());
+	            const auto range = args.txnspec.ops[OP_SETCLEARRANGE][OP_RANGE];
+	            assert(range > 0);
+	            const auto range_digits = digits(range);
+	            assert(args.key_length - prefix_len >= range_digits);
+	            const auto rand_len = args.key_length - prefix_len - range_digits;
+	            // concat([padding], prefix, random_string, range_digits)
+	            randomString<false /*clear-before-append*/>(key, rand_len);
+	            randomString(value, args.value_length);
+	            for (auto i = 0; i <= range; i++) {
+		            fmt::format_to(std::back_inserter(key), "{0:0{1}d}", i, range_digits);
+		            if (i == range)
+			            break; // preserve "exclusive last"
+		            // preserve first key for step 1
+		            if (i == 0)
+			            key_begin = key;
+		            tx.set(key, value);
+		            // preserve last key for step 1
+		            key.resize(key.size() - static_cast<size_t>(range_digits));
+	            }
+	            return tx.commit().eraseType();
+	        } },
+	      { StepKind::IMM,
+	        [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
+	            tx.reset();
+	            tx.clearRange(begin, end);
+	            return Future();
+	        } } },
+	    true },
+	  { "COMMIT", { { StepKind::NONE, nullptr } }, false },
+	  { "TRANSACTION", { { StepKind::NONE, nullptr } }, false },
+	  { "READBLOBGRANULE",
+	    { { StepKind::ON_ERROR,
+	        [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
+	            const auto num_begin = next_key(args);
+	            genKey(begin, KEY_PREFIX, args, num_begin);
+	            const auto range = args.txnspec.ops[OP_READ_BG][OP_RANGE];
+	            assert(range > 0);
+	            genKey(end, KEY_PREFIX, args, std::min(args.rows - 1, num_begin + range - 1));
+	            auto err = Error{};
 
-	          auto mem = std::unique_ptr<uint8_t*[]>(new uint8_t*[MAX_BG_IDS]);
-	          // Allocate a separate context per call to avoid multiple threads accessing
-	          BGLocalFileContext fileContext;
-	          fileContext.bgFilePath = args.bg_file_path;
-	          fileContext.nextId = 0;
-	          fileContext.data_by_id = mem.get();
-	          memset(fileContext.data_by_id, 0, MAX_BG_IDS * sizeof(uint8_t*));
+	            err = tx.setOptionNothrow(FDB_TR_OPTION_READ_YOUR_WRITES_DISABLE, BytesRef());
+	            if (err) {
+		            // Issuing read/writes before disabling RYW results in error.
+		            // Possible malformed workload?
+		            // As workloads execute in sequence, retrying would likely repeat this error.
+		            fmt::print(stderr, "ERROR: TR_OPTION_READ_YOUR_WRITES_DISABLE: {}", err.what());
+		            return Future();
+	            }
 
-	          native::FDBReadBlobGranuleContext granuleContext;
-	          granuleContext.userContext = &fileContext;
-	          granuleContext.start_load_f = &granule_start_load;
-	          granuleContext.get_load_f = &granule_get_load;
-	          granuleContext.free_load_f = &granule_free_load;
-	          granuleContext.debugNoMaterialize = !args.bg_materialize_files;
+	            auto mem = std::unique_ptr<uint8_t*[]>(new uint8_t*[MAX_BG_IDS]);
+	            // Allocate a separate context per call to avoid multiple threads accessing
+	            BGLocalFileContext fileContext;
+	            fileContext.bgFilePath = args.bg_file_path;
+	            fileContext.nextId = 0;
+	            fileContext.data_by_id = mem.get();
+	            memset(fileContext.data_by_id, 0, MAX_BG_IDS * sizeof(uint8_t*));
 
-	          auto r =
-	              tx.readBlobGranules(begin, end, 0 /*begin_version*/, -1 /*end_version, use txn's*/, granuleContext);
+	            native::FDBReadBlobGranuleContext granuleContext;
+	            granuleContext.userContext = &fileContext;
+	            granuleContext.start_load_f = &granule_start_load;
+	            granuleContext.get_load_f = &granule_get_load;
+	            granuleContext.free_load_f = &granule_free_load;
+	            granuleContext.debugNoMaterialize = !args.bg_materialize_files;
 
-	          mem.reset();
+	            auto r =
+	                tx.readBlobGranules(begin, end, 0 /*begin_version*/, -1 /*end_version, use txn's*/, granuleContext);
 
-	          auto out = Result::KeyValueArray{};
-	          err = r.getKeyValueArrayNothrow(out);
-	          if (!err || err.is(2037 /*blob_granule_not_materialized*/))
-		          return Future();
-	          const auto fp = (err.is(1020 /*not_committed*/) || err.is(1021 /*commit_unknown_result*/) ||
-	                           err.is(1213 /*tag_throttled*/))
-	                              ? annoyme
-	                              : stderr;
-	          fmt::print(fp, "ERROR: get_keyvalue_array() after readBlobGranules(): {}\n", err.what());
-	          return tx.onError(err).eraseType();
-	      } }
-    };
+	            mem.reset();
+
+	            auto out = Result::KeyValueArray{};
+	            err = r.getKeyValueArrayNothrow(out);
+	            if (!err || err.is(2037 /*blob_granule_not_materialized*/))
+		            return Future();
+	            const auto fp = (err.is(1020 /*not_committed*/) || err.is(1021 /*commit_unknown_result*/) ||
+	                             err.is(1213 /*tag_throttled*/))
+	                                ? annoyme
+	                                : stderr;
+	            fmt::print(fp, "ERROR: get_keyvalue_array() after readBlobGranules(): {}\n", err.what());
+	            return tx.onError(err).eraseType();
+	        } } },
+	    false } }
+};
 
 using OpIterator = std::tuple<int /*op*/, int /*count*/, int /*step*/>;
 
@@ -570,7 +584,7 @@ OpIterator get_op_next(Arguments const& args, OpIterator current) noexcept {
 		return OpEnd;
 	auto [op, count, step] = current;
 	assert(op < MAX_OP && op != OP_TRANSACTION && op != OP_COMMIT);
-	if (op_desc[op].steps() > step + 1)
+	if (opTable[op].steps() > step + 1)
 		return OpIterator(op, count, step + 1);
 	count++;
 	for (; op < MAX_OP; op++, count = 0) {
@@ -602,19 +616,18 @@ int run_one_transaction(Transaction tx,
 	const auto do_sample = (stats.get_tx_count() % args.sampling) == 0;
 	while (op_iter != OpEnd) {
 		const auto [op, count, step] = op_iter;
-		const auto step_kind = op_desc[op].step_kind(step);
-		const auto op_key = std::make_pair(op, step);
+		const auto step_kind = opTable[op].stepKind(step);
 		auto watch_step = Stopwatch{};
 		watch_step.start();
 		if (step == 0 /* first step */)
 			watch_per_op[op] = Stopwatch(watch_step.get_start());
-		auto f = operation_fn_table.at(op_key)(tx, args, key1, key2, val);
+		auto f = opTable[op].stepFunction(step)(tx, args, key1, key2, val);
 		auto future_rc = FutureRC::OK;
 		if (f) {
 			if (step_kind != StepKind::ON_ERROR) {
-				future_rc = wait_and_handle_error(tx, f, op_desc[op].name());
+				future_rc = wait_and_handle_error(tx, f, opTable[op].name());
 			} else {
-				auto followup_rc = wait_and_handle_for_on_error(tx, f, op_desc[op].name());
+				auto followup_rc = wait_and_handle_for_on_error(tx, f, opTable[op].name());
 				if (followup_rc == FutureRC::OK) {
 					future_rc = FutureRC::RETRY;
 				}
@@ -656,8 +669,8 @@ int run_one_transaction(Transaction tx,
 		}
 
 		// op completed successfully
-		if (step + 1 == op_desc[op].steps() /* last step */) {
-			if (op_desc[op].needs_commit())
+		if (step + 1 == opTable[op].steps() /* last step */) {
+			if (opTable[op].needsCommit())
 				needs_commit = true;
 			watch_per_op[op].set_stop(watch_step.get_stop());
 			if (do_sample) {
@@ -814,7 +827,7 @@ int run_workload(Transaction tx,
 
 std::string get_stats_file_name(std::string_view dirname, int worker_id, int thread_id, int op) {
 
-	return fmt::format("{}/{}_{}_{}", dirname, worker_id + 1, thread_id + 1, op_desc[op].name());
+	return fmt::format("{}/{}_{}_{}", dirname, worker_id + 1, thread_id + 1, opTable[op].name());
 }
 
 /* mako worker thread */
@@ -1539,7 +1552,7 @@ int parse_args(int argc, char* argv[], Arguments* args) {
 
 char const* get_ops_name(int ops_code) {
 	if (ops_code >= 0 && ops_code < MAX_OP)
-		return op_desc[ops_code].name().data();
+		return opTable[ops_code].name().data();
 	return "";
 }
 
diff --git a/bindings/c/test/mako/mako.hpp b/bindings/c/test/mako/mako.hpp
index 9177e84882..9c2700ed5b 100644
--- a/bindings/c/test/mako/mako.hpp
+++ b/bindings/c/test/mako/mako.hpp
@@ -146,9 +146,40 @@ struct alignas(64) ThreadArgs {
 	fdb::Database database; // database to work with
 };
 
+using StepFunction = fdb::Future (*)(fdb::Transaction tx,
+                                     Arguments const&,
+                                     fdb::ByteString& /*key1*/,
+                                     fdb::ByteString& /*key2*/,
+                                     fdb::ByteString& /*value*/);
+
 /* process type */
 typedef enum { PROC_MASTER = 0, PROC_WORKER, PROC_STATS } ProcKind;
 
+class Operation {
+	using Step = std::pair<StepKind, StepFunction>;
+	std::string_view name_;
+	std::vector<Step> steps_;
+	bool needs_commit_;
+
+public:
+	Operation(std::string_view name, std::vector<Step>&& steps, bool needs_commit)
+	  : name_(name), steps_(std::move(steps)), needs_commit_(needs_commit) {}
+
+	std::string_view name() const noexcept { return name_; }
+
+	StepKind stepKind(int step) const noexcept {
+		assert(step < steps());
+		return steps_[step].first;
+	}
+
+	StepFunction stepFunction(int step) const noexcept { return steps_[step].second; }
+
+	// how many steps in this op?
+	int steps() const noexcept { return static_cast<int>(steps_.size()); }
+	// does the op needs to commit some time after its final step?
+	bool needsCommit() const noexcept { return needs_commit_; }
+};
+
 } // namespace mako
 
 #endif /* MAKO_HPP */
diff --git a/bindings/c/test/mako/operations.hpp b/bindings/c/test/mako/operations.hpp
index f6260101bc..d69c6f9f7e 100644
--- a/bindings/c/test/mako/operations.hpp
+++ b/bindings/c/test/mako/operations.hpp
@@ -7,7 +7,7 @@
 namespace mako {
 
 /* transaction specification */
-enum Operations {
+enum OpKind {
 	OP_GETREADVERSION,
 	OP_GET,
 	OP_GETRANGE,
@@ -40,27 +40,6 @@ enum class StepKind {
 	ON_ERROR ///< future is a result of tx.on_error()
 };
 
-class OpDesc {
-	std::string_view name_;
-	std::vector<StepKind> steps_;
-	bool needs_commit_;
-
-public:
-	OpDesc(std::string_view name, std::vector<StepKind>&& steps, bool needs_commit)
-	  : name_(name), steps_(std::move(steps)), needs_commit_(needs_commit) {}
-
-	std::string_view name() const noexcept { return name_; }
-	// what
-	StepKind step_kind(int step) const noexcept {
-		assert(step < steps());
-		return steps_[step];
-	}
-	// how many steps in this op?
-	int steps() const noexcept { return static_cast<int>(steps_.size()); }
-	// does the op needs to commit some time after its final step?
-	bool needs_commit() const noexcept { return needs_commit_; }
-};
-
 } // namespace mako
 
 #endif /* MAKO_OPERATIONS_HPP */

From 8063e2e07ed0a701bd984bec2cf805e955c8bb9c Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Mon, 7 Mar 2022 07:06:35 +0100
Subject: [PATCH 11/84] Further camelCase reformatting

---
 bindings/c/test/mako/mako.cpp | 184 +++++++++++++++++-----------------
 1 file changed, 92 insertions(+), 92 deletions(-)

diff --git a/bindings/c/test/mako/mako.cpp b/bindings/c/test/mako/mako.cpp
index 8541639a1b..ba4db77467 100644
--- a/bindings/c/test/mako/mako.cpp
+++ b/bindings/c/test/mako/mako.cpp
@@ -50,7 +50,7 @@ FILE* debugme; /* descriptor used for debug messages */
 enum class FutureRC { OK, RETRY, CONFLICT, ABORT };
 
 template <class FutureType>
-FutureRC wait_and_handle_for_on_error(Transaction tx, FutureType f, std::string_view operation) {
+FutureRC waitAndHandleForOnError(Transaction tx, FutureType f, std::string_view operation) {
 	assert(f);
 	auto err = Error{};
 	if ((err = f.blockUntilReady())) {
@@ -67,7 +67,7 @@ FutureRC wait_and_handle_for_on_error(Transaction tx, FutureType f, std::string_
 
 // wait on any non-immediate tx-related operation to complete. Follow up with on_error().
 template <class FutureType>
-FutureRC wait_and_handle_error(Transaction tx, FutureType f, std::string_view operation) {
+FutureRC waitAndHandleError(Transaction tx, FutureType f, std::string_view operation) {
 	assert(f);
 	auto err = Error{};
 	if ((err = f.blockUntilReady())) {
@@ -83,7 +83,7 @@ FutureRC wait_and_handle_error(Transaction tx, FutureType f, std::string_view op
 	fmt::print(fp, "ERROR: Error in {}: {}\n", operation, err.what());
 	// implicit backoff
 	auto follow_up = tx.onError(err);
-	auto rc = wait_and_handle_for_on_error(tx, f, operation);
+	auto rc = waitAndHandleForOnError(tx, f, operation);
 	if (rc == FutureRC::OK) {
 		if (err.is(1020 /*not_committed*/))
 			return FutureRC::CONFLICT;
@@ -112,7 +112,7 @@ int cleanup(Transaction tx, Arguments const& args) {
 	while (true) {
 		tx.clearRange(beginstr, endstr);
 		auto future_commit = tx.commit();
-		const auto rc = wait_and_handle_error(tx, future_commit, "COMMIT_CLEANUP");
+		const auto rc = waitAndHandleError(tx, future_commit, "COMMIT_CLEANUP");
 		if (rc == FutureRC::OK) {
 			break;
 		} else if (rc == FutureRC::RETRY || rc == FutureRC::CONFLICT) {
@@ -191,7 +191,7 @@ int populate(Transaction tx,
 			const auto do_sample = (stats.get_tx_count() % args.sampling) == 0;
 			auto watch_commit = Stopwatch(start_at_ctor{});
 			auto future_commit = tx.commit();
-			const auto rc = wait_and_handle_error(tx, future_commit, "COMMIT_POPULATE_INSERT");
+			const auto rc = waitAndHandleError(tx, future_commit, "COMMIT_POPULATE_INSERT");
 			watch_commit.stop();
 			watch_tx.set_stop(watch_commit.get_stop());
 			auto tx_restarter = ExitGuard([&watch_tx]() { watch_tx.start_from_stop(); });
@@ -311,7 +311,7 @@ void granule_free_load(int64_t loadId, void* userContext) {
 	context->data_by_id[loadId] = 0;
 }
 
-inline int next_key(Arguments const& args) {
+inline int nextKey(Arguments const& args) {
 	if (args.zipf)
 		return zipfian_next();
 	return urand(0, args.rows - 1);
@@ -327,7 +327,7 @@ const std::array<Operation, MAX_OP> opTable{
 	  { "GET",
 	    { { StepKind::READ,
 	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
-	            const auto num = next_key(args);
+	            const auto num = nextKey(args);
 	            genKey(key, KEY_PREFIX, args, num);
 	            return tx.get(key, false /*snapshot*/).eraseType();
 	        } } },
@@ -335,7 +335,7 @@ const std::array<Operation, MAX_OP> opTable{
 	  { "GETRANGE",
 	    { { StepKind::READ,
 	        [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
-	            const auto num_begin = next_key(args);
+	            const auto num_begin = nextKey(args);
 	            genKey(begin, KEY_PREFIX, args, num_begin);
 	            auto num_end = num_begin + args.txnspec.ops[OP_GETRANGE][OP_RANGE] - 1;
 	            if (num_end > args.rows - 1)
@@ -356,7 +356,7 @@ const std::array<Operation, MAX_OP> opTable{
 	  { "SGET",
 	    { { StepKind::READ,
 	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
-	            const auto num = next_key(args);
+	            const auto num = nextKey(args);
 	            genKey(key, KEY_PREFIX, args, num);
 	            return tx.get(key, true /*snapshot*/).eraseType();
 	        } } },
@@ -366,7 +366,7 @@ const std::array<Operation, MAX_OP> opTable{
 
 	        StepKind::READ,
 	        [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
-	            const auto num_begin = next_key(args);
+	            const auto num_begin = nextKey(args);
 	            genKey(begin, KEY_PREFIX, args, num_begin);
 	            auto num_end = num_begin + args.txnspec.ops[OP_SGETRANGE][OP_RANGE] - 1;
 	            if (num_end > args.rows - 1)
@@ -389,7 +389,7 @@ const std::array<Operation, MAX_OP> opTable{
 	  { "UPDATE",
 	    { { StepKind::READ,
 	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
-	            const auto num = next_key(args);
+	            const auto num = nextKey(args);
 	            genKey(key, KEY_PREFIX, args, num);
 	            return tx.get(key, false /*snapshot*/).eraseType();
 	        } },
@@ -435,7 +435,7 @@ const std::array<Operation, MAX_OP> opTable{
 	  { "OVERWRITE",
 	    { { StepKind::IMM,
 	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
-	            genKey(key, KEY_PREFIX, args, next_key(args));
+	            genKey(key, KEY_PREFIX, args, nextKey(args));
 	            randomString(value, args.value_length);
 	            tx.set(key, value);
 	            return Future();
@@ -444,7 +444,7 @@ const std::array<Operation, MAX_OP> opTable{
 	  { "CLEAR",
 	    { { StepKind::IMM,
 	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
-	            genKey(key, KEY_PREFIX, args, next_key(args));
+	            genKey(key, KEY_PREFIX, args, nextKey(args));
 	            tx.clear(key);
 	            return Future();
 	        } } },
@@ -469,7 +469,7 @@ const std::array<Operation, MAX_OP> opTable{
 	  { "CLEARRANGE",
 	    { { StepKind::IMM,
 	        [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
-	            const auto num_begin = next_key(args);
+	            const auto num_begin = nextKey(args);
 	            genKey(begin, KEY_PREFIX, args, num_begin);
 	            const auto range = args.txnspec.ops[OP_CLEARRANGE][OP_RANGE];
 	            assert(range > 0);
@@ -516,7 +516,7 @@ const std::array<Operation, MAX_OP> opTable{
 	  { "READBLOBGRANULE",
 	    { { StepKind::ON_ERROR,
 	        [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
-	            const auto num_begin = next_key(args);
+	            const auto num_begin = nextKey(args);
 	            genKey(begin, KEY_PREFIX, args, num_begin);
 	            const auto range = args.txnspec.ops[OP_READ_BG][OP_RANGE];
 	            assert(range > 0);
@@ -570,7 +570,7 @@ using OpIterator = std::tuple<int /*op*/, int /*count*/, int /*step*/>;
 
 constexpr const OpIterator OpEnd = OpIterator(MAX_OP, -1, -1);
 
-OpIterator get_op_begin(Arguments const& args) noexcept {
+OpIterator getOpBegin(Arguments const& args) noexcept {
 	for (auto op = 0; op < MAX_OP; op++) {
 		if (op == OP_COMMIT || op == OP_TRANSACTION || args.txnspec.ops[op][OP_COUNT] == 0)
 			continue;
@@ -579,7 +579,7 @@ OpIterator get_op_begin(Arguments const& args) noexcept {
 	return OpEnd;
 }
 
-OpIterator get_op_next(Arguments const& args, OpIterator current) noexcept {
+OpIterator getOpNext(Arguments const& args, OpIterator current) noexcept {
 	if (OpEnd == current)
 		return OpEnd;
 	auto [op, count, step] = current;
@@ -596,10 +596,10 @@ OpIterator get_op_next(Arguments const& args, OpIterator current) noexcept {
 }
 
 /* run one transaction */
-int run_one_transaction(Transaction tx,
-                        Arguments const& args,
-                        ThreadStatistics& stats,
-                        LatencySampleBinArray& sample_bins) {
+int runOneTransaction(Transaction tx,
+                      Arguments const& args,
+                      ThreadStatistics& stats,
+                      LatencySampleBinArray& sample_bins) {
 	// reuse memory for keys to avoid realloc overhead
 	auto key1 = ByteString{};
 	key1.reserve(args.key_length);
@@ -610,7 +610,7 @@ int run_one_transaction(Transaction tx,
 
 	auto watch_tx = Stopwatch(start_at_ctor{});
 
-	auto op_iter = get_op_begin(args);
+	auto op_iter = getOpBegin(args);
 	auto needs_commit = false;
 	auto watch_per_op = std::array<Stopwatch, MAX_OP>{};
 	const auto do_sample = (stats.get_tx_count() % args.sampling) == 0;
@@ -625,9 +625,9 @@ int run_one_transaction(Transaction tx,
 		auto future_rc = FutureRC::OK;
 		if (f) {
 			if (step_kind != StepKind::ON_ERROR) {
-				future_rc = wait_and_handle_error(tx, f, opTable[op].name());
+				future_rc = waitAndHandleError(tx, f, opTable[op].name());
 			} else {
-				auto followup_rc = wait_and_handle_for_on_error(tx, f, opTable[op].name());
+				auto followup_rc = waitAndHandleForOnError(tx, f, opTable[op].name());
 				if (followup_rc == FutureRC::OK) {
 					future_rc = FutureRC::RETRY;
 				}
@@ -645,7 +645,7 @@ int run_one_transaction(Transaction tx,
 				return -1;
 			}
 			// retry from first op
-			op_iter = get_op_begin(args);
+			op_iter = getOpBegin(args);
 			needs_commit = false;
 			continue;
 		}
@@ -681,13 +681,13 @@ int run_one_transaction(Transaction tx,
 			stats.incr_op_count(op);
 		}
 		// move to next op
-		op_iter = get_op_next(args, op_iter);
+		op_iter = getOpNext(args, op_iter);
 
 		// reached the end?
 		if (op_iter == OpEnd && (needs_commit || args.commit_get)) {
 			auto watch_commit = Stopwatch(start_at_ctor{});
 			auto f = tx.commit();
-			const auto rc = wait_and_handle_error(tx, f, "COMMIT_AT_TX_END");
+			const auto rc = waitAndHandleError(tx, f, "COMMIT_AT_TX_END");
 			watch_commit.stop();
 			watch_tx.set_stop(watch_commit.get_stop());
 			auto tx_resetter = ExitGuard([&watch_tx, &tx]() {
@@ -714,7 +714,7 @@ int run_one_transaction(Transaction tx,
 					return -1;
 				}
 				// restart from beginning
-				op_iter = get_op_begin(args);
+				op_iter = getOpBegin(args);
 			}
 			needs_commit = false;
 		}
@@ -725,16 +725,16 @@ int run_one_transaction(Transaction tx,
 	return 0;
 }
 
-int run_workload(Transaction tx,
-                 Arguments const& args,
-                 int const thread_tps,
-                 std::atomic<double> const& throttle_factor,
-                 int const thread_iters,
-                 std::atomic<int> const& signal,
-                 ThreadStatistics& stats,
-                 LatencySampleBinArray& sample_bins,
-                 int const dotrace,
-                 int const dotagging) {
+int runWorkload(Transaction tx,
+                Arguments const& args,
+                int const thread_tps,
+                std::atomic<double> const& throttle_factor,
+                int const thread_iters,
+                std::atomic<int> const& signal,
+                ThreadStatistics& stats,
+                LatencySampleBinArray& sample_bins,
+                int const dotrace,
+                int const dotagging) {
 	auto traceid = std::string{};
 	auto tagstr = std::string{};
 
@@ -805,9 +805,9 @@ int run_workload(Transaction tx,
 			}
 		}
 
-		rc = run_one_transaction(tx, args, stats, sample_bins);
+		rc = runOneTransaction(tx, args, stats, sample_bins);
 		if (rc) {
-			fmt::print(annoyme, "ERROR: run_one_transaction failed ({})\n", rc);
+			fmt::print(annoyme, "ERROR: runOneTransaction failed ({})\n", rc);
 		}
 
 		if (thread_iters > 0) {
@@ -825,13 +825,13 @@ int run_workload(Transaction tx,
 	return rc;
 }
 
-std::string get_stats_file_name(std::string_view dirname, int worker_id, int thread_id, int op) {
+std::string getStatsFilename(std::string_view dirname, int worker_id, int thread_id, int op) {
 
 	return fmt::format("{}/{}_{}_{}", dirname, worker_id + 1, thread_id + 1, opTable[op].name());
 }
 
 /* mako worker thread */
-void worker_thread(ThreadArgs& thread_args) {
+void workerThread(ThreadArgs& thread_args) {
 	const auto& args = *thread_args.args;
 	const auto parent_id = thread_args.parent_id;
 	const auto worker_id = thread_args.worker_id;
@@ -888,10 +888,10 @@ void worker_thread(ThreadArgs& thread_args) {
 			fmt::print(stderr, "ERROR: populate failed\n");
 		}
 	} else if (args.mode == MODE_RUN) {
-		auto rc = run_workload(
+		auto rc = runWorkload(
 		    tx, args, thread_tps, throttle_factor, thread_iters, signal, stats, sample_bins, dotrace, dotagging);
 		if (rc < 0) {
-			fmt::print(stderr, "ERROR: run_workload failed\n");
+			fmt::print(stderr, "ERROR: runWorkload failed\n");
 		}
 	}
 
@@ -904,7 +904,7 @@ void worker_thread(ThreadArgs& thread_args) {
 		}
 		for (auto op = 0; op < MAX_OP; op++) {
 			if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_COMMIT || op == OP_TRANSACTION) {
-				const auto filename = get_stats_file_name(dirname, worker_id, thread_id, op);
+				const auto filename = getStatsFilename(dirname, worker_id, thread_id, op);
 				auto fp = fopen(filename.c_str(), "w");
 				if (!fp) {
 					fmt::print(stderr, "ERROR: fopen({}): {}\n", filename, strerror(errno));
@@ -919,7 +919,7 @@ void worker_thread(ThreadArgs& thread_args) {
 }
 
 /* mako worker process */
-int worker_process_main(Arguments const& args, int worker_id, shared_memory::Access shm, pid_t pid_main) {
+int workerProcessMain(Arguments const& args, int worker_id, shared_memory::Access shm, pid_t pid_main) {
 	fmt::print(debugme, "DEBUG: worker {} started\n", worker_id);
 
 	auto err = Error{};
@@ -1045,14 +1045,14 @@ int worker_process_main(Arguments const& args, int worker_id, shared_memory::Acc
 				this_args.sample_bins[op].reserveOneBlock();
 			}
 		}
-		worker_threads[i] = std::thread(worker_thread, std::ref(this_args));
+		worker_threads[i] = std::thread(workerThread, std::ref(this_args));
 	}
 
 	/*** party is over ***/
 
 	/* wait for everyone to finish */
 	for (auto i = 0; i < args.num_threads; i++) {
-		fmt::print(debugme, "DEBUG: worker_thread {} joining\n", i);
+		fmt::print(debugme, "DEBUG: workerThread {} joining\n", i);
 		worker_threads[i].join();
 	}
 
@@ -1071,7 +1071,7 @@ int worker_process_main(Arguments const& args, int worker_id, shared_memory::Acc
 }
 
 /* initialize the parameters with default values */
-int init_args(Arguments* args) {
+int initArguments(Arguments* args) {
 	int i;
 	if (!args)
 		return -1;
@@ -1120,7 +1120,7 @@ int init_args(Arguments* args) {
 }
 
 /* parse transaction specification */
-int parse_transaction(Arguments* args, char const* optarg) {
+int parseTransaction(Arguments* args, char const* optarg) {
 	char const* ptr = optarg;
 	int op = 0;
 	int rangeop = 0;
@@ -1293,7 +1293,7 @@ void usage() {
 }
 
 /* parse benchmark paramters */
-int parse_args(int argc, char* argv[], Arguments* args) {
+int parseArguments(int argc, char* argv[], Arguments* args) {
 	int rc;
 	int c;
 	int idx;
@@ -1384,7 +1384,7 @@ int parse_args(int argc, char* argv[], Arguments* args) {
 			args->iteration = atoi(optarg);
 			break;
 		case 'x':
-			rc = parse_transaction(args, optarg);
+			rc = parseTransaction(args, optarg);
 			if (rc < 0)
 				return -1;
 			break;
@@ -1550,13 +1550,13 @@ int parse_args(int argc, char* argv[], Arguments* args) {
 	return 0;
 }
 
-char const* get_ops_name(int ops_code) {
+char const* getOpName(int ops_code) {
 	if (ops_code >= 0 && ops_code < MAX_OP)
 		return opTable[ops_code].name().data();
 	return "";
 }
 
-int validate_args(Arguments* args) {
+int validateArguments(Arguments* args) {
 	if (args->mode == MODE_INVALID) {
 		fprintf(stderr, "ERROR: --mode has to be set\n");
 		return -1;
@@ -1619,7 +1619,7 @@ int validate_args(Arguments* args) {
 	return 0;
 }
 
-void print_stats(Arguments const& args, ThreadStatistics const* stats, double const duration_sec, FILE* fp) {
+void printStats(Arguments const& args, ThreadStatistics const* stats, double const duration_sec, FILE* fp) {
 	static ThreadStatistics prev;
 
 	auto current = ThreadStatistics{};
@@ -1639,7 +1639,7 @@ void print_stats(Arguments const& args, ThreadStatistics const* stats, double co
 			const auto ops_total_diff = current.get_op_count(op) - prev.get_op_count(op);
 			putField(ops_total_diff);
 			if (fp) {
-				fmt::print(fp, "\"{}\": {},", get_ops_name(op), ops_total_diff);
+				fmt::print(fp, "\"{}\": {},", getOpName(op), ops_total_diff);
 			}
 			print_err = print_err || (current.get_error_count(op) - prev.get_error_count(op)) > 0;
 		}
@@ -1679,13 +1679,13 @@ void print_stats(Arguments const& args, ThreadStatistics const* stats, double co
 	prev = current;
 }
 
-void print_stats_header(Arguments const& args, bool show_commit, bool is_first_header_empty, bool show_op_stats) {
+void printStatsHeader(Arguments const& args, bool show_commit, bool is_first_header_empty, bool show_op_stats) {
 	/* header */
 	if (is_first_header_empty)
 		putTitle("");
 	for (auto op = 0; op < MAX_OP; op++) {
 		if (args.txnspec.ops[op][OP_COUNT] > 0) {
-			putField(get_ops_name(op));
+			putField(getOpName(op));
 		}
 	}
 
@@ -1723,11 +1723,11 @@ void print_stats_header(Arguments const& args, bool show_commit, bool is_first_h
 	fmt::print("\n");
 }
 
-void print_report(Arguments const& args,
-                  ThreadStatistics const* stats,
-                  double const duration_sec,
-                  pid_t pid_main,
-                  FILE* fp) {
+void printReport(Arguments const& args,
+                 ThreadStatistics const* stats,
+                 double const duration_sec,
+                 pid_t pid_main,
+                 FILE* fp) {
 
 	auto final_stats = ThreadStatistics{};
 	for (auto i = 0; i < args.num_processes; i++) {
@@ -1780,7 +1780,7 @@ void print_report(Arguments const& args,
 	}
 
 	/* per-op stats */
-	print_stats_header(args, true, true, false);
+	printStatsHeader(args, true, true, false);
 
 	/* OPS */
 	putTitle("Total OPS");
@@ -1797,7 +1797,7 @@ void print_report(Arguments const& args,
 				} else {
 					fmt::fprintf(fp, ",");
 				}
-				fmt::fprintf(fp, "\"%s\": %lu", get_ops_name(op), final_stats.get_op_count(op));
+				fmt::fprintf(fp, "\"%s\": %lu", getOpName(op), final_stats.get_op_count(op));
 			}
 		}
 	}
@@ -1827,7 +1827,7 @@ void print_report(Arguments const& args,
 				} else {
 					fmt::fprintf(fp, ",");
 				}
-				fmt::fprintf(fp, "\"%s\": %lu", get_ops_name(op), final_stats.get_error_count(op));
+				fmt::fprintf(fp, "\"%s\": %lu", getOpName(op), final_stats.get_error_count(op));
 			}
 		}
 	}
@@ -1837,7 +1837,7 @@ void print_report(Arguments const& args,
 	fmt::print("\n\n");
 
 	fmt::print("Latency (us)");
-	print_stats_header(args, true, false, true);
+	printStatsHeader(args, true, false, true);
 
 	/* Total Samples */
 	putTitle("Samples");
@@ -1855,7 +1855,7 @@ void print_report(Arguments const& args,
 				} else {
 					fmt::fprintf(fp, ",");
 				}
-				fmt::fprintf(fp, "\"%s\": %lu", get_ops_name(op), final_stats.get_latency_sample_count(op));
+				fmt::fprintf(fp, "\"%s\": %lu", getOpName(op), final_stats.get_latency_sample_count(op));
 			}
 		}
 	}
@@ -1880,7 +1880,7 @@ void print_report(Arguments const& args,
 					} else {
 						fmt::fprintf(fp, ",");
 					}
-					fmt::fprintf(fp, "\"%s\": %lu", get_ops_name(op), lat_min);
+					fmt::fprintf(fp, "\"%s\": %lu", getOpName(op), lat_min);
 				}
 			}
 		}
@@ -1905,7 +1905,7 @@ void print_report(Arguments const& args,
 					} else {
 						fmt::fprintf(fp, ",");
 					}
-					fmt::fprintf(fp, "\"%s\": %lu", get_ops_name(op), lat_total / lat_samples);
+					fmt::fprintf(fp, "\"%s\": %lu", getOpName(op), lat_total / lat_samples);
 				}
 			} else {
 				putField("N/A");
@@ -1933,7 +1933,7 @@ void print_report(Arguments const& args,
 					} else {
 						fmt::fprintf(fp, ",");
 					}
-					fmt::fprintf(fp, "\"%s\": %lu", get_ops_name(op), final_stats.get_latency_us_max(op));
+					fmt::fprintf(fp, "\"%s\": %lu", getOpName(op), final_stats.get_latency_us_max(op));
 				}
 			}
 		}
@@ -1956,7 +1956,7 @@ void print_report(Arguments const& args,
 				for (auto i = 0; i < args.num_processes; i++) {
 					for (auto j = 0; j < args.num_threads; j++) {
 						const auto dirname = fmt::format("{}{}", TEMP_DATA_STORE, pid_main);
-						const auto filename = get_stats_file_name(dirname, i, j, op);
+						const auto filename = getStatsFilename(dirname, i, j, op);
 						auto fp = fopen(filename.c_str(), "r");
 						if (!fp) {
 							fmt::print(stderr, "ERROR: fopen({}): {}\n", filename, strerror(errno));
@@ -1989,7 +1989,7 @@ void print_report(Arguments const& args,
 					} else {
 						fmt::fprintf(fp, ",");
 					}
-					fmt::fprintf(fp, "\"%s\": %lu", get_ops_name(op), median);
+					fmt::fprintf(fp, "\"%s\": %lu", getOpName(op), median);
 				}
 			} else {
 				putField("N/A");
@@ -2019,7 +2019,7 @@ void print_report(Arguments const& args,
 				} else {
 					fmt::fprintf(fp, ",");
 				}
-				fmt::fprintf(fp, "\"%s\": %lu", get_ops_name(op), data_points[op][point_95pct]);
+				fmt::fprintf(fp, "\"%s\": %lu", getOpName(op), data_points[op][point_95pct]);
 			}
 		}
 	}
@@ -2046,7 +2046,7 @@ void print_report(Arguments const& args,
 				} else {
 					fmt::fprintf(fp, ",");
 				}
-				fmt::fprintf(fp, "\"%s\": %lu", get_ops_name(op), data_points[op][point_99pct]);
+				fmt::fprintf(fp, "\"%s\": %lu", getOpName(op), data_points[op][point_99pct]);
 			}
 		}
 	}
@@ -2073,7 +2073,7 @@ void print_report(Arguments const& args,
 				} else {
 					fmt::fprintf(fp, ",");
 				}
-				fmt::fprintf(fp, "\"%s\": %lu", get_ops_name(op), data_points[op][point_99_9pct]);
+				fmt::fprintf(fp, "\"%s\": %lu", getOpName(op), data_points[op][point_99_9pct]);
 			}
 		}
 	}
@@ -2086,12 +2086,12 @@ void print_report(Arguments const& args,
 	system(command_remove.c_str());
 }
 
-int stats_process_main(Arguments const& args,
-                       ThreadStatistics const* stats,
-                       std::atomic<double>& throttle_factor,
-                       std::atomic<int> const& signal,
-                       std::atomic<int> const& stopcount,
-                       pid_t pid_main) {
+int statsProcessMain(Arguments const& args,
+                     ThreadStatistics const* stats,
+                     std::atomic<double>& throttle_factor,
+                     std::atomic<int> const& signal,
+                     std::atomic<int> const& stopcount,
+                     pid_t pid_main) {
 	bool first_stats = true;
 
 	/* wait until the signal turn on */
@@ -2100,7 +2100,7 @@ int stats_process_main(Arguments const& args,
 	}
 
 	if (args.verbose >= VERBOSE_DEFAULT)
-		print_stats_header(args, false, true, false);
+		printStatsHeader(args, false, true, false);
 
 	FILE* fp = NULL;
 	if (args.json_output_path[0] != '\0') {
@@ -2190,7 +2190,7 @@ int stats_process_main(Arguments const& args,
 					if (fp)
 						fmt::fprintf(fp, ",");
 				}
-				print_stats(args, stats, to_double_seconds(time_now - time_prev), fp);
+				printStats(args, stats, to_double_seconds(time_now - time_prev), fp);
 			}
 			time_prev = time_now;
 		}
@@ -2206,7 +2206,7 @@ int stats_process_main(Arguments const& args,
 		while (stopcount.load() < args.num_threads * args.num_processes) {
 			usleep(10000); /* 10ms */
 		}
-		print_report(args, stats, to_double_seconds(time_now - time_start), pid_main, fp);
+		printReport(args, stats, to_double_seconds(time_now - time_start), pid_main, fp);
 	}
 
 	if (fp) {
@@ -2222,18 +2222,18 @@ int main(int argc, char* argv[]) {
 
 	auto rc = int{};
 	auto args = Arguments{};
-	rc = init_args(&args);
+	rc = initArguments(&args);
 	if (rc < 0) {
-		fmt::print(stderr, "ERROR: init_args failed\n");
+		fmt::print(stderr, "ERROR: initArguments failed\n");
 		return -1;
 	}
-	rc = parse_args(argc, argv, &args);
+	rc = parseArguments(argc, argv, &args);
 	if (rc < 0) {
 		/* usage printed */
 		return 0;
 	}
 
-	rc = validate_args(&args);
+	rc = validateArguments(&args);
 	if (rc < 0)
 		return -1;
 
@@ -2245,7 +2245,7 @@ int main(int argc, char* argv[]) {
 
 	if (args.mode == MODE_BUILD) {
 		if (args.txnspec.ops[OP_INSERT][OP_COUNT] == 0) {
-			parse_transaction(&args, "i100");
+			parseTransaction(&args, "i100");
 		}
 	}
 
@@ -2331,7 +2331,7 @@ int main(int argc, char* argv[]) {
 
 	if (proc_type == PROC_WORKER) {
 		/* worker process */
-		worker_process_main(args, worker_id, shm_access, pid_main);
+		workerProcessMain(args, worker_id, shm_access, pid_main);
 		/* worker can exit here */
 		exit(0);
 	} else if (proc_type == PROC_STATS) {
@@ -2340,7 +2340,7 @@ int main(int argc, char* argv[]) {
 			/* no stats needed for clean mode */
 			exit(0);
 		}
-		stats_process_main(
+		statsProcessMain(
 		    args, shm_access.statsConstArray(), shm_hdr.throttle_factor, shm_hdr.signal, shm_hdr.stopcount, pid_main);
 		exit(0);
 	}

From 9fc8d9ead85e7df578c8ec0696388c4b8ed57630 Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Mon, 7 Mar 2022 08:52:24 +0100
Subject: [PATCH 12/84] Refine error handling

---
 bindings/c/test/fdb.hpp       |  2 +-
 bindings/c/test/mako/mako.cpp | 32 +++++++++++++++-----------------
 2 files changed, 16 insertions(+), 18 deletions(-)

diff --git a/bindings/c/test/fdb.hpp b/bindings/c/test/fdb.hpp
index fdad6f96f6..6db21a8e07 100644
--- a/bindings/c/test/fdb.hpp
+++ b/bindings/c/test/fdb.hpp
@@ -67,7 +67,7 @@ public:
 
 	explicit operator bool() const noexcept { return err != 0; }
 
-	bool is(CodeType other) const noexcept { return err != other; }
+	bool is(CodeType other) const noexcept { return err == other; }
 
 	CodeType code() const noexcept { return err; }
 
diff --git a/bindings/c/test/mako/mako.cpp b/bindings/c/test/mako/mako.cpp
index ba4db77467..ab9695234b 100644
--- a/bindings/c/test/mako/mako.cpp
+++ b/bindings/c/test/mako/mako.cpp
@@ -58,10 +58,17 @@ FutureRC waitAndHandleForOnError(Transaction tx, FutureType f, std::string_view
 		return FutureRC::ABORT;
 	}
 	if ((err = f.error())) {
-		fmt::print(stderr, "ERROR: Unretryable on_error() error from {}: {}\n", operation, err.what());
-		return FutureRC::ABORT;
+		if (err.is(1020 /*not_committed*/)) {
+			return FutureRC::CONFLICT;
+		} else if (err.retryable()) {
+			fmt::print(debugme, "ERROR: Retryable on_error() error from {}: {}\n", operation, err.what());
+			return FutureRC::RETRY;
+		} else {
+			fmt::print(stderr, "ERROR: Unretryable on_error() error from {}: {}\n", operation, err.what());
+			return FutureRC::ABORT;
+		}
 	} else {
-		return FutureRC::OK;
+		return FutureRC::RETRY;
 	}
 }
 
@@ -83,16 +90,7 @@ FutureRC waitAndHandleError(Transaction tx, FutureType f, std::string_view opera
 	fmt::print(fp, "ERROR: Error in {}: {}\n", operation, err.what());
 	// implicit backoff
 	auto follow_up = tx.onError(err);
-	auto rc = waitAndHandleForOnError(tx, f, operation);
-	if (rc == FutureRC::OK) {
-		if (err.is(1020 /*not_committed*/))
-			return FutureRC::CONFLICT;
-		else
-			return FutureRC::RETRY;
-	} else {
-		tx.reset();
-		return rc;
-	}
+	return waitAndHandleForOnError(tx, f, operation);
 }
 
 /* cleanup database */
@@ -1052,19 +1050,19 @@ int workerProcessMain(Arguments const& args, int worker_id, shared_memory::Acces
 
 	/* wait for everyone to finish */
 	for (auto i = 0; i < args.num_threads; i++) {
-		fmt::print(debugme, "DEBUG: workerThread {} joining\n", i);
+		fmt::print(debugme, "DEBUG: waiting for worker thread {} to join\n", i);
 		worker_threads[i].join();
 	}
 
 	/* stop the network thread */
-	fmt::print(debugme, "DEBUG: fdb_stop_network\n");
+	fmt::print(debugme, "DEBUG: network::stop()\n");
 	err = network::stop();
 	if (err) {
-		fmt::print(stderr, "ERROR: stop_network(): {}\n", err.what());
+		fmt::print(stderr, "ERROR: network::stop(): {}\n", err.what());
 	}
 
 	/* wait for the network thread to join */
-	fmt::print(debugme, "DEBUG: network_thread joining\n");
+	fmt::print(debugme, "DEBUG: waiting for network thread to join\n");
 	network_thread.join();
 
 	return 0;

From cc2b9fad1ec33e9e629923f18b76e1484da4d129 Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Sat, 19 Mar 2022 22:11:09 +0100
Subject: [PATCH 13/84] Simpler logging with thread-local loggers

- No need to repeat parts of the messages: e.g. "ERROR: "
- Thread-specific information prefixed before messages: e.g. "WORKER[  1: 4]"
- Misc. C-to-CPP styling
---
 bindings/c/test/fdb.hpp          |   9 +-
 bindings/c/test/mako/logger.hpp  |  97 +++++
 bindings/c/test/mako/mako.cpp    | 696 +++++++++++++++----------------
 bindings/c/test/mako/mako.hpp    |   8 -
 bindings/c/test/mako/process.hpp |   6 +
 bindings/c/test/mako/shm.hpp     |   1 +
 bindings/c/test/mako/stats.hpp   |  36 +-
 bindings/c/test/mako/time.hpp    |  18 +-
 8 files changed, 465 insertions(+), 406 deletions(-)
 create mode 100644 bindings/c/test/mako/logger.hpp
 create mode 100644 bindings/c/test/mako/process.hpp

diff --git a/bindings/c/test/fdb.hpp b/bindings/c/test/fdb.hpp
index 6db21a8e07..2dbcf98f59 100644
--- a/bindings/c/test/fdb.hpp
+++ b/bindings/c/test/fdb.hpp
@@ -333,7 +333,7 @@ public:
 	}
 };
 
-namespace KeySelect {
+namespace key_select {
 
 struct Inclusive {
 	static constexpr const bool value = true;
@@ -342,7 +342,7 @@ struct Inclusive {
 struct Exclusive {
 	static constexpr const bool value = false;
 };
-} // namespace KeySelect
+} // namespace key_select
 
 class Transaction {
 	friend class Database;
@@ -402,14 +402,11 @@ public:
 		return out;
 	}
 
-	// Func should have signature void(Future f, bool need_retry)
-	// Func should first check that retry == false and f.error() == 0
-	// before attempting to extract value from f
 	TypedFuture<future_var::Value> get(KeyRef key, bool snapshot) {
 		return native::fdb_transaction_get(tr.get(), key.data(), intSize(key), snapshot);
 	}
 
-	// Usage: tx.get_range<KeySelect::inclusive, KeySelect::exclusive>(begin, end, ...);
+	// Usage: tx.getRange<key_select::Inclusive, key_select::Exclusive>(begin, end, ...);
 	// gets key-value pairs in key range [begin, end)
 	template <class FirstInclusive, class LastInclusive>
 	TypedFuture<future_var::KeyValueArray> getRange(KeyRef begin,
diff --git a/bindings/c/test/mako/logger.hpp b/bindings/c/test/mako/logger.hpp
new file mode 100644
index 0000000000..d567b16995
--- /dev/null
+++ b/bindings/c/test/mako/logger.hpp
@@ -0,0 +1,97 @@
+#ifndef MAKO_LOGGER_HPP
+#define MAKO_LOGGER_HPP
+#include <fmt/format.h>
+#include <cassert>
+#include <cstdio>
+#include <iterator>
+#include <string_view>
+#include "process.hpp"
+
+namespace mako {
+
+constexpr const int VERBOSE_NONE = 0; // will still print errors
+constexpr const int VERBOSE_DEFAULT = 1; // will print info and work stats
+constexpr const int VERBOSE_WARN = 2; // will print expected errors
+constexpr const int VERBOSE_DEBUG = 3; // will print everything
+
+template <ProcKind P>
+using ProcKindConstant = std::integral_constant<ProcKind, P>;
+
+using MainProcess = ProcKindConstant<ProcKind::MAIN>;
+using StatsProcess = ProcKindConstant<ProcKind::STATS>;
+using WorkerProcess = ProcKindConstant<ProcKind::WORKER>;
+
+class Logger {
+	ProcKind proc;
+	int verbosity{ VERBOSE_DEFAULT };
+	int process_id{ -1 };
+	int thread_id{ -1 };
+
+	void putHeader(fmt::memory_buffer& buf, std::string_view category) {
+		if (proc == ProcKind::MAIN) {
+			fmt::format_to(std::back_inserter(buf), "[MAIN] {}: ", category);
+		} else if (proc == ProcKind::STATS) {
+			fmt::format_to(std::back_inserter(buf), "[STATS] {}: ", category);
+		} else {
+			if (thread_id == -1) {
+				fmt::format_to(std::back_inserter(buf), "[WORKER{:3d}] {}: ", process_id + 1, category);
+			} else {
+				fmt::format_to(
+				    std::back_inserter(buf), "[WORKER{:3d}:{:3d}] {}: ", process_id + 1, thread_id + 1, category);
+			}
+		}
+	}
+
+public:
+	Logger(MainProcess, int verbosity) noexcept : proc(MainProcess::value), verbosity(verbosity) {}
+
+	Logger(StatsProcess, int verbosity) noexcept : proc(StatsProcess::value), verbosity(verbosity) {}
+
+	Logger(WorkerProcess, int verbosity, int process_id, int thread_id = -1) noexcept
+	  : proc(WorkerProcess::value), verbosity(verbosity), process_id(process_id), thread_id(thread_id) {}
+
+	Logger(const Logger&) noexcept = default;
+	Logger& operator=(const Logger&) noexcept = default;
+
+	void setVerbosity(int value) noexcept {
+		assert(value >= VERBOSE_NONE && value <= VERBOSE_DEBUG);
+		verbosity = value;
+	}
+
+	template <typename... Args>
+	void printWithLogLevel(int log_level, std::string_view header, Args&&... args) {
+		assert(log_level >= VERBOSE_NONE && log_level <= VERBOSE_DEBUG);
+		if (log_level >= verbosity) {
+			const auto fp = log_level == VERBOSE_NONE ? stderr : stdout;
+			// 500B inline buffer
+			auto buf = fmt::memory_buffer{};
+			putHeader(buf, header);
+			fmt::format_to(std::back_inserter(buf), std::forward<Args>(args)...);
+			fmt::print(fp, "{}\n", std::string_view(buf.data(), buf.size()));
+		}
+	}
+
+	template <typename... Args>
+	void error(Args&&... args) {
+		printWithLogLevel(VERBOSE_NONE, "ERROR", std::forward<Args>(args)...);
+	}
+
+	template <typename... Args>
+	void info(Args&&... args) {
+		printWithLogLevel(VERBOSE_DEFAULT, "INFO", std::forward<Args>(args)...);
+	}
+
+	template <typename... Args>
+	void warn(Args&&... args) {
+		printWithLogLevel(VERBOSE_WARN, "WARN", std::forward<Args>(args)...);
+	}
+
+	template <typename... Args>
+	void debug(Args&&... args) {
+		printWithLogLevel(VERBOSE_DEBUG, "DEBUG", std::forward<Args>(args)...);
+	}
+};
+
+} // namespace mako
+
+#endif /*MAKO_LOGGER_HPP*/
diff --git a/bindings/c/test/mako/mako.cpp b/bindings/c/test/mako/mako.cpp
index ab9695234b..d3d04ee0fc 100644
--- a/bindings/c/test/mako/mako.cpp
+++ b/bindings/c/test/mako/mako.cpp
@@ -33,7 +33,9 @@
 #include <fmt/printf.h>
 #include <fdb.hpp>
 #include "fdbclient/zipf.h"
+#include "logger.hpp"
 #include "mako.hpp"
+#include "process.hpp"
 #include "utils.hpp"
 
 using namespace fdb;
@@ -42,29 +44,26 @@ using namespace mako;
 const std::string KEY_PREFIX{ "mako" };
 const std::string TEMP_DATA_STORE{ "/tmp/makoTemp" };
 
-/* global variables */
-FILE* printme; /* descriptor used for default messages */
-FILE* annoyme; /* descriptor used for annoying messages */
-FILE* debugme; /* descriptor used for debug messages */
+thread_local Logger logr = Logger(MainProcess{}, VERBOSE_DEFAULT);
 
 enum class FutureRC { OK, RETRY, CONFLICT, ABORT };
 
 template <class FutureType>
-FutureRC waitAndHandleForOnError(Transaction tx, FutureType f, std::string_view operation) {
+FutureRC waitAndHandleForOnError(Transaction tx, FutureType f, std::string_view step) {
 	assert(f);
 	auto err = Error{};
 	if ((err = f.blockUntilReady())) {
-		fmt::print(stderr, "ERROR: Error while on_error() blocking for {}: {}\n", operation, err.what());
+		logr.error("'{}' found while waiting for on_error() future, step: {}", err.what(), step);
 		return FutureRC::ABORT;
 	}
 	if ((err = f.error())) {
 		if (err.is(1020 /*not_committed*/)) {
 			return FutureRC::CONFLICT;
 		} else if (err.retryable()) {
-			fmt::print(debugme, "ERROR: Retryable on_error() error from {}: {}\n", operation, err.what());
+			logr.warn("Retryable error '{}' found at on_error(), step: {}", err.what(), step);
 			return FutureRC::RETRY;
 		} else {
-			fmt::print(stderr, "ERROR: Unretryable on_error() error from {}: {}\n", operation, err.what());
+			logr.error("Unretryable error '{}' found at on_error(), step: {}", err.what(), step);
 			return FutureRC::ABORT;
 		}
 	} else {
@@ -72,25 +71,27 @@ FutureRC waitAndHandleForOnError(Transaction tx, FutureType f, std::string_view
 	}
 }
 
-// wait on any non-immediate tx-related operation to complete. Follow up with on_error().
+// wait on any non-immediate tx-related step to complete. Follow up with on_error().
 template <class FutureType>
-FutureRC waitAndHandleError(Transaction tx, FutureType f, std::string_view operation) {
+FutureRC waitAndHandleError(Transaction tx, FutureType f, std::string_view step) {
 	assert(f);
 	auto err = Error{};
 	if ((err = f.blockUntilReady())) {
 		const auto retry = err.retryable();
-		auto fp = retry ? annoyme : stderr;
-		fmt::print(fp, "ERROR: {} error in {}: {}\n", (retry ? "Retryable" : "Unretryable"), operation, err.what());
+		logr.error("{} error '{}' found during step: {}", (retry ? "Retryable" : "Unretryable"), err.what(), step);
 		return retry ? FutureRC::RETRY : FutureRC::ABORT;
 	}
 	err = f.error();
 	if (!err)
 		return FutureRC::OK;
-	auto fp = err.retryable() ? annoyme : stderr;
-	fmt::print(fp, "ERROR: Error in {}: {}\n", operation, err.what());
+	if (err.retryable()) {
+		logr.warn("step {} returned '{}'", step, err.what());
+	} else {
+		logr.error("step {} returned '{}'", step, err.what());
+	}
 	// implicit backoff
 	auto follow_up = tx.onError(err);
-	return waitAndHandleForOnError(tx, f, operation);
+	return waitAndHandleForOnError(tx, f, step);
 }
 
 /* cleanup database */
@@ -105,7 +106,7 @@ int cleanup(Transaction tx, Arguments const& args) {
 	genKeyPrefix(endstr, KEY_PREFIX, args);
 	endstr.push_back(0xff);
 
-	auto watch = Stopwatch(start_at_ctor{});
+	auto watch = Stopwatch(StartAtCtor{});
 
 	while (true) {
 		tx.clearRange(beginstr, endstr);
@@ -122,7 +123,7 @@ int cleanup(Transaction tx, Arguments const& args) {
 	}
 
 	tx.reset();
-	fmt::print(printme, "INFO: Clear range: {:6.3f} sec\n", to_double_seconds(watch.stop().diff()));
+	logr.info("Clear range: {:6.3f} sec\n", toDoubleSeconds(watch.stop().diff()));
 	return 0;
 }
 
@@ -144,10 +145,10 @@ int populate(Transaction tx,
 	valstr.reserve(args.value_length);
 	const auto num_commit_every = args.txnspec.ops[OP_INSERT][OP_COUNT];
 	const auto num_seconds_trace_every = args.txntrace;
-	auto watch_total = Stopwatch(start_at_ctor{});
-	auto watch_throttle = Stopwatch(watch_total.get_start());
-	auto watch_tx = Stopwatch(watch_total.get_start());
-	auto watch_trace = Stopwatch(watch_total.get_start());
+	auto watch_total = Stopwatch(StartAtCtor{});
+	auto watch_throttle = Stopwatch(watch_total.getStart());
+	auto watch_tx = Stopwatch(watch_total.getStart());
+	auto watch_trace = Stopwatch(watch_total.getStart());
 	auto key_checkpoint = key_begin; // in case of commit failure, restart from this key
 
 	for (auto i = key_begin; i <= key_end; i++) {
@@ -157,42 +158,42 @@ int populate(Transaction tx,
 		randomString(valstr, args.value_length);
 
 		while (thread_tps > 0 && xacts >= thread_tps /* throttle */) {
-			if (to_integer_seconds(watch_throttle.stop().diff()) >= 1) {
+			if (toIntegerSeconds(watch_throttle.stop().diff()) >= 1) {
 				xacts = 0;
-				watch_throttle.start_from_stop();
+				watch_throttle.startFromStop();
 			} else {
 				usleep(1000);
 			}
 		}
 		if (num_seconds_trace_every) {
-			if (to_integer_seconds(watch_trace.stop().diff()) >= num_seconds_trace_every) {
-				watch_trace.start_from_stop();
-				fmt::print(debugme, "DEBUG: txn tracing {}\n", toCharsRef(keystr));
+			if (toIntegerSeconds(watch_trace.stop().diff()) >= num_seconds_trace_every) {
+				watch_trace.startFromStop();
+				logr.debug("txn tracing {}", toCharsRef(keystr));
 				auto err = Error{};
 				err = tx.setOptionNothrow(FDB_TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER, keystr);
 				if (err) {
-					fmt::print(stderr, "ERROR: setOption(TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER): {}\n", err.what());
+					logr.error("setOption(TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER): {}", err.what());
 				}
 				err = tx.setOptionNothrow(FDB_TR_OPTION_LOG_TRANSACTION, BytesRef());
 				if (err) {
-					fmt::print(stderr, "ERROR: setOption(TR_OPTION_LOG_TRANSACTION): {}\n", err.what());
+					logr.error("setOption(TR_OPTION_LOG_TRANSACTION): {}", err.what());
 				}
 			}
 		}
 
 		/* insert (SET) */
 		tx.set(keystr, valstr);
-		stats.incr_op_count(OP_INSERT);
+		stats.incrOpCount(OP_INSERT);
 
 		/* commit every 100 inserts (default) or if this is the last key */
 		if (i == key_end || (i - key_begin + 1) % num_commit_every == 0) {
-			const auto do_sample = (stats.get_tx_count() % args.sampling) == 0;
-			auto watch_commit = Stopwatch(start_at_ctor{});
+			const auto do_sample = (stats.getTaskCount() % args.sampling) == 0;
+			auto watch_commit = Stopwatch(StartAtCtor{});
 			auto future_commit = tx.commit();
 			const auto rc = waitAndHandleError(tx, future_commit, "COMMIT_POPULATE_INSERT");
 			watch_commit.stop();
-			watch_tx.set_stop(watch_commit.get_stop());
-			auto tx_restarter = ExitGuard([&watch_tx]() { watch_tx.start_from_stop(); });
+			watch_tx.setStop(watch_commit.getStop());
+			auto tx_restarter = ExitGuard([&watch_tx]() { watch_tx.startFromStop(); });
 			if (rc == FutureRC::OK) {
 				key_checkpoint = i + 1; // restart on failures from next key
 				tx.reset();
@@ -206,24 +207,23 @@ int populate(Transaction tx,
 			if (do_sample) {
 				const auto commit_latency = watch_commit.diff();
 				const auto tx_duration = watch_tx.diff();
-				stats.add_latency(OP_COMMIT, commit_latency);
-				stats.add_latency(OP_TRANSACTION, tx_duration);
+				stats.addLatency(OP_COMMIT, commit_latency);
+				stats.addLatency(OP_TRANSACTION, tx_duration);
 				sample_bins[OP_COMMIT].put(commit_latency);
 				sample_bins[OP_TRANSACTION].put(tx_duration);
 			}
-			stats.incr_op_count(OP_COMMIT);
-			stats.incr_op_count(OP_TRANSACTION);
+			stats.incrOpCount(OP_COMMIT);
+			stats.incrOpCount(OP_TRANSACTION);
 
-			stats.incr_tx_count();
+			stats.incrTaskCount();
 			xacts++; /* for throttling */
 		}
 	}
-	fmt::print(debugme,
-	           "DEBUG: Populated {} rows [{}, {}]: {:6.3f} sec\n",
+	logr.debug("Populated {} rows [{}, {}]: {:6.3f} sec\n",
 	           key_end - key_begin + 1,
 	           key_begin,
 	           key_end,
-	           to_double_seconds(watch_total.stop().diff()));
+	           toDoubleSeconds(watch_total.stop().diff()));
 
 	return 0;
 }
@@ -253,27 +253,27 @@ int64_t granule_start_load(const char* filename,
 
 	loadId = context->nextId;
 	if (context->data_by_id[loadId] != 0) {
-		fmt::print(stderr, "ERROR: too many granule file loads at once: {}\n", MAX_BG_IDS);
+		logr.error("too many granule file loads at once: {}", MAX_BG_IDS);
 		return -1;
 	}
 	context->nextId = (context->nextId + 1) % MAX_BG_IDS;
 
 	int ret = snprintf(full_fname, PATH_MAX, "%s%s", context->bgFilePath, filename);
 	if (ret < 0 || ret >= PATH_MAX) {
-		fmt::print(stderr, "ERROR: BG filename too long: {}{}\n", context->bgFilePath, filename);
+		logr.error("BG filename too long: {}{}", context->bgFilePath, filename);
 		return -1;
 	}
 
 	fp = fopen(full_fname, "r");
 	if (!fp) {
-		fmt::print(stderr, "ERROR: BG could not open file: {}\n", full_fname);
+		logr.error("BG could not open file: {}", full_fname);
 		return -1;
 	}
 
 	// don't seek if offset == 0
 	if (offset && fseek(fp, offset, SEEK_SET)) {
 		// if fseek was non-zero, it failed
-		fmt::print(stderr, "ERROR: BG could not seek to %{} in file {}\n", offset, full_fname);
+		logr.error("BG could not seek to %{} in file {}", offset, full_fname);
 		fclose(fp);
 		return -1;
 	}
@@ -283,7 +283,7 @@ int64_t granule_start_load(const char* filename,
 	fclose(fp);
 
 	if (readSize != length) {
-		fmt::print(stderr, "ERROR: BG could not read {} bytes from file: {}\n", length, full_fname);
+		logr.error("BG could not read {} bytes from file: {}", length, full_fname);
 		return -1;
 	}
 
@@ -294,7 +294,7 @@ int64_t granule_start_load(const char* filename,
 uint8_t* granule_get_load(int64_t loadId, void* userContext) {
 	BGLocalFileContext* context = (BGLocalFileContext*)userContext;
 	if (context->data_by_id[loadId] == 0) {
-		fmt::print(stderr, "ERROR: BG loadId invalid for get_load: {}\n", loadId);
+		logr.error("BG loadId invalid for get_load: {}", loadId);
 		return 0;
 	}
 	return context->data_by_id[loadId];
@@ -303,7 +303,7 @@ uint8_t* granule_get_load(int64_t loadId, void* userContext) {
 void granule_free_load(int64_t loadId, void* userContext) {
 	BGLocalFileContext* context = (BGLocalFileContext*)userContext;
 	if (context->data_by_id[loadId] == 0) {
-		fmt::print(stderr, "ERROR: BG loadId invalid for free_load: {}\n", loadId);
+		logr.error("BG loadId invalid for free_load: {}", loadId);
 	}
 	delete[] context->data_by_id[loadId];
 	context->data_by_id[loadId] = 0;
@@ -340,14 +340,14 @@ const std::array<Operation, MAX_OP> opTable{
 		            num_end = args.rows - 1;
 	            genKey(end, KEY_PREFIX, args, num_end);
 	            return tx
-	                .getRange<KeySelect::Inclusive, KeySelect::Inclusive>(begin,
-	                                                                      end,
-	                                                                      0 /*limit*/,
-	                                                                      0 /*target_bytes*/,
-	                                                                      args.streaming_mode,
-	                                                                      0 /*iteration*/,
-	                                                                      false /*snapshot*/,
-	                                                                      args.txnspec.ops[OP_GETRANGE][OP_REVERSE])
+	                .getRange<key_select::Inclusive, key_select::Inclusive>(begin,
+	                                                                        end,
+	                                                                        0 /*limit*/,
+	                                                                        0 /*target_bytes*/,
+	                                                                        args.streaming_mode,
+	                                                                        0 /*iteration*/,
+	                                                                        false /*snapshot*/,
+	                                                                        args.txnspec.ops[OP_GETRANGE][OP_REVERSE])
 	                .eraseType();
 	        } } },
 	    false },
@@ -371,14 +371,14 @@ const std::array<Operation, MAX_OP> opTable{
 		            num_end = args.rows - 1;
 	            genKey(end, KEY_PREFIX, args, num_end);
 	            return tx
-	                .getRange<KeySelect::Inclusive, KeySelect::Inclusive>(begin,
-	                                                                      end,
-	                                                                      0 /*limit*/,
-	                                                                      0 /*target_bytes*/,
-	                                                                      args.streaming_mode,
-	                                                                      0 /*iteration*/,
-	                                                                      true /*snapshot*/,
-	                                                                      args.txnspec.ops[OP_SGETRANGE][OP_REVERSE])
+	                .getRange<key_select::Inclusive, key_select::Inclusive>(begin,
+	                                                                        end,
+	                                                                        0 /*limit*/,
+	                                                                        0 /*target_bytes*/,
+	                                                                        args.streaming_mode,
+	                                                                        0 /*iteration*/,
+	                                                                        true /*snapshot*/,
+	                                                                        args.txnspec.ops[OP_SGETRANGE][OP_REVERSE])
 	                .eraseType();
 	        }
 
@@ -554,11 +554,11 @@ const std::array<Operation, MAX_OP> opTable{
 	            err = r.getKeyValueArrayNothrow(out);
 	            if (!err || err.is(2037 /*blob_granule_not_materialized*/))
 		            return Future();
-	            const auto fp = (err.is(1020 /*not_committed*/) || err.is(1021 /*commit_unknown_result*/) ||
-	                             err.is(1213 /*tag_throttled*/))
-	                                ? annoyme
-	                                : stderr;
-	            fmt::print(fp, "ERROR: get_keyvalue_array() after readBlobGranules(): {}\n", err.what());
+	            const auto level = (err.is(1020 /*not_committed*/) || err.is(1021 /*commit_unknown_result*/) ||
+	                                err.is(1213 /*tag_throttled*/))
+	                                   ? VERBOSE_WARN
+	                                   : VERBOSE_NONE;
+	            logr.printWithLogLevel(level, "ERROR", "get_keyvalue_array() after readBlobGranules(): {}", err.what());
 	            return tx.onError(err).eraseType();
 	        } } },
 	    false } }
@@ -606,19 +606,19 @@ int runOneTransaction(Transaction tx,
 	auto val = ByteString{};
 	val.reserve(args.value_length);
 
-	auto watch_tx = Stopwatch(start_at_ctor{});
+	auto watch_tx = Stopwatch(StartAtCtor{});
 
 	auto op_iter = getOpBegin(args);
 	auto needs_commit = false;
 	auto watch_per_op = std::array<Stopwatch, MAX_OP>{};
-	const auto do_sample = (stats.get_tx_count() % args.sampling) == 0;
+	const auto do_sample = (stats.getTaskCount() % args.sampling) == 0;
 	while (op_iter != OpEnd) {
 		const auto [op, count, step] = op_iter;
 		const auto step_kind = opTable[op].stepKind(step);
 		auto watch_step = Stopwatch{};
 		watch_step.start();
 		if (step == 0 /* first step */)
-			watch_per_op[op] = Stopwatch(watch_step.get_start());
+			watch_per_op[op] = Stopwatch(watch_step.getStart());
 		auto f = opTable[op].stepFunction(step)(tx, args, key1, key2, val);
 		auto future_rc = FutureRC::OK;
 		if (f) {
@@ -634,9 +634,9 @@ int runOneTransaction(Transaction tx,
 		watch_step.stop();
 		if (future_rc != FutureRC::OK) {
 			if (future_rc == FutureRC::CONFLICT) {
-				stats.incr_conflict_count();
+				stats.incrConflictCount();
 			} else if (future_rc == FutureRC::RETRY) {
-				stats.incr_error_count(op);
+				stats.incrErrorCount(op);
 			} else {
 				// abort
 				tx.reset();
@@ -651,18 +651,18 @@ int runOneTransaction(Transaction tx,
 		if (step_kind == StepKind::COMMIT) {
 			// reset transaction boundary
 			const auto step_latency = watch_step.diff();
-			watch_tx.set_stop(watch_step.get_stop());
+			watch_tx.setStop(watch_step.getStop());
 			if (do_sample) {
 				const auto tx_duration = watch_tx.diff();
-				stats.add_latency(OP_COMMIT, step_latency);
-				stats.add_latency(OP_TRANSACTION, tx_duration);
+				stats.addLatency(OP_COMMIT, step_latency);
+				stats.addLatency(OP_TRANSACTION, tx_duration);
 				sample_bins[OP_COMMIT].put(step_latency);
 				sample_bins[OP_TRANSACTION].put(tx_duration);
 			}
 			tx.reset();
-			watch_tx.start_from_stop(); // new tx begins
-			stats.incr_op_count(OP_COMMIT);
-			stats.incr_op_count(OP_TRANSACTION);
+			watch_tx.startFromStop(); // new tx begins
+			stats.incrOpCount(OP_COMMIT);
+			stats.incrOpCount(OP_TRANSACTION);
 			needs_commit = false;
 		}
 
@@ -670,44 +670,44 @@ int runOneTransaction(Transaction tx,
 		if (step + 1 == opTable[op].steps() /* last step */) {
 			if (opTable[op].needsCommit())
 				needs_commit = true;
-			watch_per_op[op].set_stop(watch_step.get_stop());
+			watch_per_op[op].setStop(watch_step.getStop());
 			if (do_sample) {
 				const auto op_latency = watch_per_op[op].diff();
-				stats.add_latency(op, op_latency);
+				stats.addLatency(op, op_latency);
 				sample_bins[op].put(op_latency);
 			}
-			stats.incr_op_count(op);
+			stats.incrOpCount(op);
 		}
 		// move to next op
 		op_iter = getOpNext(args, op_iter);
 
 		// reached the end?
 		if (op_iter == OpEnd && (needs_commit || args.commit_get)) {
-			auto watch_commit = Stopwatch(start_at_ctor{});
+			auto watch_commit = Stopwatch(StartAtCtor{});
 			auto f = tx.commit();
 			const auto rc = waitAndHandleError(tx, f, "COMMIT_AT_TX_END");
 			watch_commit.stop();
-			watch_tx.set_stop(watch_commit.get_stop());
+			watch_tx.setStop(watch_commit.getStop());
 			auto tx_resetter = ExitGuard([&watch_tx, &tx]() {
 					tx.reset();
-					watch_tx.start_from_stop();
+				    watch_tx.startFromStop();
 				});
 			if (rc == FutureRC::OK) {
 				if (do_sample) {
 					const auto commit_latency = watch_commit.diff();
 					const auto tx_duration = watch_tx.diff();
-					stats.add_latency(OP_COMMIT, commit_latency);
-					stats.add_latency(OP_TRANSACTION, tx_duration);
+					stats.addLatency(OP_COMMIT, commit_latency);
+					stats.addLatency(OP_TRANSACTION, tx_duration);
 					sample_bins[OP_COMMIT].put(commit_latency);
 					sample_bins[OP_TRANSACTION].put(tx_duration);
 				}
-				stats.incr_op_count(OP_COMMIT);
-				stats.incr_op_count(OP_TRANSACTION);
+				stats.incrOpCount(OP_COMMIT);
+				stats.incrOpCount(OP_TRANSACTION);
 			} else {
 				if (rc == FutureRC::CONFLICT)
-					stats.incr_conflict_count();
+					stats.incrConflictCount();
 				else
-					stats.incr_error_count(OP_COMMIT);
+					stats.incrErrorCount(OP_COMMIT);
 				if (rc == FutureRC::ABORT) {
 					return -1;
 				}
@@ -717,7 +717,7 @@ int runOneTransaction(Transaction tx,
 			needs_commit = false;
 		}
 	}
-	stats.incr_tx_count();
+	stats.incrTaskCount();
 	/* make sure to reset transaction */
 	tx.reset();
 	return 0;
@@ -758,7 +758,7 @@ int runWorkload(Transaction tx,
 		while ((thread_tps > 0) && (xacts >= current_tps)) {
 			/* throttle on */
 			const auto time_now = steady_clock::now();
-			if (to_double_seconds(time_now - time_prev) >= 1.0) {
+			if (toDoubleSeconds(time_now - time_prev) >= 1.0) {
 				/* more than 1 second passed, no need to throttle */
 				xacts = 0;
 				time_prev = time_now;
@@ -772,19 +772,19 @@ int runWorkload(Transaction tx,
 		/* enable transaction trace */
 		if (dotrace) {
 			const auto time_now = steady_clock::now();
-			if (to_integer_seconds(time_now - time_last_trace) >= 1) {
+			if (toIntegerSeconds(time_now - time_last_trace) >= 1) {
 				time_last_trace = time_now;
 				traceid.clear();
 				fmt::format_to(std::back_inserter(traceid), "makotrace{:0>19d}", total_xacts);
-				fmt::print(debugme, "DEBUG: txn tracing {}\n", traceid);
+				logr.debug("txn tracing {}", traceid);
 				auto err = Error{};
 				err = tx.setOptionNothrow(FDB_TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER, toBytesRef(traceid));
 				if (err) {
-					fmt::print(stderr, "ERROR: TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER: {}\n", err.what());
+					logr.error("TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER: {}", err.what());
 				}
 				err = tx.setOptionNothrow(FDB_TR_OPTION_LOG_TRANSACTION, BytesRef());
 				if (err) {
-					fmt::print(stderr, "ERROR: TR_OPTION_LOG_TRANSACTION: {}\n", err.what());
+					logr.error("TR_OPTION_LOG_TRANSACTION: {}", err.what());
 				}
 			}
 		}
@@ -799,13 +799,13 @@ int runWorkload(Transaction tx,
 			               urand(0, args.txntagging - 1));
 			auto err = tx.setOptionNothrow(FDB_TR_OPTION_AUTO_THROTTLE_TAG, toBytesRef(tagstr));
 			if (err) {
-				fmt::print(stderr, "ERROR: TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER: {}\n", err.what());
+				logr.error("TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER: {}", err.what());
 			}
 		}
 
 		rc = runOneTransaction(tx, args, stats, sample_bins);
 		if (rc) {
-			fmt::print(annoyme, "ERROR: runOneTransaction failed ({})\n", rc);
+			logr.warn("runOneTransaction failed ({})", rc);
 		}
 
 		if (thread_iters > 0) {
@@ -842,17 +842,12 @@ void workerThread(ThreadArgs& thread_args) {
 	auto& readycount = thread_args.shm.header().readycount;
 	auto& stopcount = thread_args.shm.header().stopcount;
 	auto& stats = thread_args.shm.statsSlot(worker_id, thread_id);
+	logr = Logger(WorkerProcess{}, args.verbose, worker_id, thread_id);
 
 	/* init per-thread latency statistics */
 	new (&stats) ThreadStatistics();
 
-	fmt::print(debugme,
-	           "DEBUG: worker_id:{} ({}) thread_id:{} ({}) (tid:{})\n",
-	           worker_id,
-	           args.num_processes,
-	           thread_id,
-	           args.num_threads,
-	           reinterpret_cast<uint64_t>(pthread_self()));
+	logr.debug("started, tid: {}", reinterpret_cast<uint64_t>(pthread_self()));
 
 	const auto thread_tps =
 	    args.tpsmax == 0 ? 0
@@ -878,18 +873,18 @@ void workerThread(ThreadArgs& thread_args) {
 	if (args.mode == MODE_CLEAN) {
 		auto rc = cleanup(tx, args);
 		if (rc < 0) {
-			fmt::print(stderr, "ERROR: cleanup failed\n");
+			logr.error("cleanup failed");
 		}
 	} else if (args.mode == MODE_BUILD) {
 		auto rc = populate(tx, args, worker_id, thread_id, thread_tps, stats, sample_bins);
 		if (rc < 0) {
-			fmt::print(stderr, "ERROR: populate failed\n");
+			logr.error("populate failed");
 		}
 	} else if (args.mode == MODE_RUN) {
 		auto rc = runWorkload(
 		    tx, args, thread_tps, throttle_factor, thread_iters, signal, stats, sample_bins, dotrace, dotagging);
 		if (rc < 0) {
-			fmt::print(stderr, "ERROR: runWorkload failed\n");
+			logr.error("runWorkload failed");
 		}
 	}
 
@@ -897,7 +892,7 @@ void workerThread(ThreadArgs& thread_args) {
 		const auto dirname = fmt::format("{}{}", TEMP_DATA_STORE, parent_id);
 		const auto rc = mkdir(dirname.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
 		if (rc < 0 && errno != EEXIST) {
-			fmt::print(stderr, "ERROR: mkdir {}: {}\n", dirname, strerror(errno));
+			logr.error("mkdir {}: {}", dirname, strerror(errno));
 			return;
 		}
 		for (auto op = 0; op < MAX_OP; op++) {
@@ -905,7 +900,7 @@ void workerThread(ThreadArgs& thread_args) {
 				const auto filename = getStatsFilename(dirname, worker_id, thread_id, op);
 				auto fp = fopen(filename.c_str(), "w");
 				if (!fp) {
-					fmt::print(stderr, "ERROR: fopen({}): {}\n", filename, strerror(errno));
+					logr.error("fopen({}): {}", filename, strerror(errno));
 					continue;
 				}
 				auto fclose_guard = ExitGuard([fp]() { fclose(fp); });
@@ -918,7 +913,7 @@ void workerThread(ThreadArgs& thread_args) {
 
 /* mako worker process */
 int workerProcessMain(Arguments const& args, int worker_id, shared_memory::Access shm, pid_t pid_main) {
-	fmt::print(debugme, "DEBUG: worker {} started\n", worker_id);
+	logr.debug("started");
 
 	auto err = Error{};
 	/* Everything starts from here */
@@ -928,14 +923,14 @@ int workerProcessMain(Arguments const& args, int worker_id, shared_memory::Acces
 	/* enable flatbuffers if specified */
 	if (args.flatbuffers) {
 #ifdef FDB_NET_OPTION_USE_FLATBUFFERS
-		fprintf(debugme, "DEBUG: Using flatbuffers\n");
+		logr.debug("Using flatbuffers");
 		err = network::setOptionNothrow(FDB_NET_OPTION_USE_FLATBUFFERS,
 		                                BytesRef(&args.flatbuffers, sizeof(args.flatbuffers)));
 		if (err) {
-			fmt::print(stderr, "ERROR: network_setOption(USE_FLATBUFFERS): {}\n", err.what());
+			logr.error("network::setOption(USE_FLATBUFFERS): {}", err.what());
 		}
 #else
-		fmt::print(printme, "INFO: flatbuffers is not supported in FDB API version {}\n", FDB_API_VERSION);
+		logr.info("flatbuffers is not supported in FDB API version {}", FDB_API_VERSION);
 #endif
 	}
 
@@ -943,24 +938,23 @@ int workerProcessMain(Arguments const& args, int worker_id, shared_memory::Acces
 	if (args.log_group[0] != '\0') {
 		err = network::setOptionNothrow(FDB_NET_OPTION_TRACE_LOG_GROUP, BytesRef(toBytePtr(args.log_group)));
 		if (err) {
-			fmt::print(stderr, "ERROR: fdb_network_setOption(FDB_NET_OPTION_TRACE_LOG_GROUP): {}\n", err.what());
+			logr.error("network::setOption(FDB_NET_OPTION_TRACE_LOG_GROUP): {}", err.what());
 		}
 	}
 
 	/* enable tracing if specified */
 	if (args.trace) {
-		fmt::print(debugme,
-		           "DEBUG: Enable Tracing in {} ({})\n",
+		logr.debug("Enable Tracing in {} ({})",
 		           (args.traceformat == 0) ? "XML" : "JSON",
 		           (args.tracepath[0] == '\0') ? "current directory" : args.tracepath);
 		err = network::setOptionNothrow(FDB_NET_OPTION_TRACE_ENABLE, BytesRef(toBytePtr(args.tracepath)));
 		if (err) {
-			fmt::print(stderr, "ERROR: network_setOption(TRACE_ENABLE): {}\n", err.what());
+			logr.error("network::setOption(TRACE_ENABLE): {}", err.what());
 		}
 		if (args.traceformat == 1) {
 			err = network::setOptionNothrow(FDB_NET_OPTION_TRACE_FORMAT, BytesRef(toBytePtr("json")));
 			if (err) {
-				fmt::print(stderr, "ERROR: fdb_network_setOption(FDB_NET_OPTION_TRACE_FORMAT): {}\n", err.what());
+				logr.error("network::setOption(FDB_NET_OPTION_TRACE_FORMAT): {}", err.what());
 			}
 		}
 	}
@@ -974,10 +968,10 @@ int workerProcessMain(Arguments const& args, int worker_id, shared_memory::Acces
 			auto knob = knobs.substr(0, knobs.find_first_of(delim));
 			if (knob.empty())
 				break;
-			fmt::print(debugme, "DEBUG: Setting client knob: {}\n", knob);
+			logr.debug("Setting client knob: {}", knob);
 			err = network::setOptionNothrow(FDB_NET_OPTION_KNOB, toBytesRef(knob));
 			if (err) {
-				fmt::print(stderr, "ERROR: fdb_network_setOption({}): {}\n", knob, err.what());
+				logr.error("network::setOption({}): {}", knob, err.what());
 			}
 			knobs.remove_prefix(knob.size());
 		}
@@ -986,8 +980,7 @@ int workerProcessMain(Arguments const& args, int worker_id, shared_memory::Acces
 	if (args.client_threads_per_version > 0) {
 		err = network::setOptionNothrow(FDB_NET_OPTION_CLIENT_THREADS_PER_VERSION, args.client_threads_per_version);
 		if (err) {
-			fmt::print(stderr,
-			           "ERROR: fdb_network_setOption (FDB_NET_OPTION_CLIENT_THREADS_PER_VERSION) ({}): {}\n",
+			logr.error("network::setOption (FDB_NET_OPTION_CLIENT_THREADS_PER_VERSION) ({}): {}\n",
 			           args.client_threads_per_version,
 			           err.what());
 			// let's exit here since we do not want to confuse users
@@ -997,15 +990,15 @@ int workerProcessMain(Arguments const& args, int worker_id, shared_memory::Acces
 	}
 
 	/* Network thread must be setup before doing anything */
-	fprintf(debugme, "DEBUG: fdb_setup_network\n");
+	logr.debug("network::setup()");
 	network::setup();
 
 	/* Each worker process will have its own network thread */
-	fprintf(debugme, "DEBUG: creating network thread\n");
+	logr.debug("creating network thread");
 	auto network_thread = std::thread([]() {
-		fmt::print(debugme, "DEBUG: network thread started\n");
+		logr.debug("network thread started");
 		if (auto err = network::run()) {
-			fmt::print(stderr, "ERROR: fdb_run_network: {}\n", err.what());
+			logr.error("network::run(): {}", err.what());
 		}
 	});
 
@@ -1016,13 +1009,13 @@ int workerProcessMain(Arguments const& args, int worker_id, shared_memory::Acces
 	for (auto i = 0; i < args.num_databases; i++) {
 		size_t cluster_index = args.num_fdb_clusters <= 1 ? 0 : i % args.num_fdb_clusters;
 		databases[i] = Database(args.cluster_files[cluster_index]);
-		fmt::print(debugme, "DEBUG: creating database at cluster {}\n", args.cluster_files[cluster_index]);
+		logr.debug("creating database at cluster {}", args.cluster_files[cluster_index]);
 		if (args.disable_ryw) {
 			databases[i].setOption(FDB_DB_OPTION_SNAPSHOT_RYW_DISABLE, BytesRef{});
 		}
 	}
 
-	fmt::print(debugme, "DEBUG: creating {} worker threads\n", args.num_threads);
+	logr.debug("creating {} worker threads", args.num_threads);
 	auto worker_threads = std::vector<std::thread>(args.num_threads);
 
 	/* spawn worker threads */
@@ -1050,75 +1043,72 @@ int workerProcessMain(Arguments const& args, int worker_id, shared_memory::Acces
 
 	/* wait for everyone to finish */
 	for (auto i = 0; i < args.num_threads; i++) {
-		fmt::print(debugme, "DEBUG: waiting for worker thread {} to join\n", i);
+		logr.debug("waiting for worker thread {} to join", i + 1);
 		worker_threads[i].join();
 	}
 
 	/* stop the network thread */
-	fmt::print(debugme, "DEBUG: network::stop()\n");
+	logr.debug("network::stop()");
 	err = network::stop();
 	if (err) {
-		fmt::print(stderr, "ERROR: network::stop(): {}\n", err.what());
+		logr.error("network::stop(): {}", err.what());
 	}
 
 	/* wait for the network thread to join */
-	fmt::print(debugme, "DEBUG: waiting for network thread to join\n");
+	logr.debug("waiting for network thread to join");
 	network_thread.join();
 
 	return 0;
 }
 
 /* initialize the parameters with default values */
-int initArguments(Arguments* args) {
-	int i;
-	if (!args)
-		return -1;
-	memset(args, 0, sizeof(Arguments)); /* zero-out everything */
-	args->num_fdb_clusters = 0;
-	args->num_databases = 1;
-	args->api_version = maxApiVersion();
-	args->json = 0;
-	args->num_processes = 1;
-	args->num_threads = 1;
-	args->mode = MODE_INVALID;
-	args->rows = 100000;
-	args->row_digits = digits(args->rows);
-	args->seconds = 30;
-	args->iteration = 0;
-	args->tpsmax = 0;
-	args->tpsmin = -1;
-	args->tpsinterval = 10;
-	args->tpschange = TPS_SIN;
-	args->sampling = 1000;
-	args->key_length = 32;
-	args->value_length = 16;
-	args->zipf = 0;
-	args->commit_get = 0;
-	args->verbose = 1;
-	args->flatbuffers = 0; /* internal */
-	args->knobs[0] = '\0';
-	args->log_group[0] = '\0';
-	args->prefixpadding = 0;
-	args->trace = 0;
-	args->tracepath[0] = '\0';
-	args->traceformat = 0; /* default to client's default (XML) */
-	args->streaming_mode = FDB_STREAMING_MODE_WANT_ALL;
-	args->txntrace = 0;
-	args->txntagging = 0;
-	memset(args->txntagging_prefix, 0, TAGPREFIXLENGTH_MAX);
-	for (i = 0; i < MAX_OP; i++) {
-		args->txnspec.ops[i][OP_COUNT] = 0;
+int initArguments(Arguments& args) {
+	memset(&args, 0, sizeof(Arguments)); /* zero-out everything */
+	args.num_fdb_clusters = 0;
+	args.num_databases = 1;
+	args.api_version = maxApiVersion();
+	args.json = 0;
+	args.num_processes = 1;
+	args.num_threads = 1;
+	args.mode = MODE_INVALID;
+	args.rows = 100000;
+	args.row_digits = digits(args.rows);
+	args.seconds = 30;
+	args.iteration = 0;
+	args.tpsmax = 0;
+	args.tpsmin = -1;
+	args.tpsinterval = 10;
+	args.tpschange = TPS_SIN;
+	args.sampling = 1000;
+	args.key_length = 32;
+	args.value_length = 16;
+	args.zipf = 0;
+	args.commit_get = 0;
+	args.verbose = 1;
+	args.flatbuffers = 0; /* internal */
+	args.knobs[0] = '\0';
+	args.log_group[0] = '\0';
+	args.prefixpadding = 0;
+	args.trace = 0;
+	args.tracepath[0] = '\0';
+	args.traceformat = 0; /* default to client's default (XML) */
+	args.streaming_mode = FDB_STREAMING_MODE_WANT_ALL;
+	args.txntrace = 0;
+	args.txntagging = 0;
+	memset(args.txntagging_prefix, 0, TAGPREFIXLENGTH_MAX);
+	for (auto i = 0; i < MAX_OP; i++) {
+		args.txnspec.ops[i][OP_COUNT] = 0;
 	}
-	args->client_threads_per_version = 0;
-	args->disable_ryw = 0;
-	args->json_output_path[0] = '\0';
-	args->bg_materialize_files = false;
-	args->bg_file_path[0] = '\0';
+	args.client_threads_per_version = 0;
+	args.disable_ryw = 0;
+	args.json_output_path[0] = '\0';
+	args.bg_materialize_files = false;
+	args.bg_file_path[0] = '\0';
 	return 0;
 }
 
 /* parse transaction specification */
-int parseTransaction(Arguments* args, char const* optarg) {
+int parseTransaction(Arguments& args, char const* optarg) {
 	char const* ptr = optarg;
 	int op = 0;
 	int rangeop = 0;
@@ -1126,8 +1116,8 @@ int parseTransaction(Arguments* args, char const* optarg) {
 	int error = 0;
 
 	for (op = 0; op < MAX_OP; op++) {
-		args->txnspec.ops[op][OP_COUNT] = 0;
-		args->txnspec.ops[op][OP_RANGE] = 0;
+		args.txnspec.ops[op][OP_COUNT] = 0;
+		args.txnspec.ops[op][OP_RANGE] = 0;
 	}
 
 	op = 0;
@@ -1181,7 +1171,7 @@ int parseTransaction(Arguments* args, char const* optarg) {
 			rangeop = 1;
 			ptr += 2;
 		} else {
-			fprintf(debugme, "Error: Invalid transaction spec: %s\n", ptr);
+			logr.error("Invalid transaction spec: {}", ptr);
 			error = 1;
 			break;
 		}
@@ -1198,7 +1188,7 @@ int parseTransaction(Arguments* args, char const* optarg) {
 			}
 		}
 		/* set count */
-		args->txnspec.ops[op][OP_COUNT] = num;
+		args.txnspec.ops[op][OP_COUNT] = num;
 
 		if (rangeop) {
 			if (*ptr != ':') {
@@ -1208,10 +1198,10 @@ int parseTransaction(Arguments* args, char const* optarg) {
 				ptr++; /* skip ':' */
 				/* check negative '-' sign */
 				if (*ptr == '-') {
-					args->txnspec.ops[op][OP_REVERSE] = 1;
+					args.txnspec.ops[op][OP_REVERSE] = 1;
 					ptr++;
 				} else {
-					args->txnspec.ops[op][OP_REVERSE] = 0;
+					args.txnspec.ops[op][OP_REVERSE] = 0;
 				}
 				num = 0;
 				if ((*ptr < '0') || (*ptr > '9')) {
@@ -1223,20 +1213,20 @@ int parseTransaction(Arguments* args, char const* optarg) {
 					ptr++;
 				}
 				/* set range */
-				args->txnspec.ops[op][OP_RANGE] = num;
+				args.txnspec.ops[op][OP_RANGE] = num;
 			}
 		}
 		rangeop = 0;
 	}
 
 	if (error) {
-		fprintf(stderr, "ERROR: invalid transaction specification %s\n", optarg);
+		logr.error("invalid transaction specification {}", optarg);
 		return -1;
 	}
 
-	if (args->verbose == VERBOSE_DEBUG) {
+	if (args.verbose == VERBOSE_DEBUG) {
 		for (op = 0; op < MAX_OP; op++) {
-			fprintf(debugme, "DEBUG: OP: %d: %d: %d\n", op, args->txnspec.ops[op][0], args->txnspec.ops[op][1]);
+			logr.debug("OP: {}: {}: {}", op, args.txnspec.ops[op][0], args.txnspec.ops[op][1]);
 		}
 	}
 
@@ -1269,7 +1259,7 @@ void usage() {
 	printf("%-24s %s\n", "-m, --mode=MODE", "Specify the mode (build, run, clean)");
 	printf("%-24s %s\n", "-z, --zipf", "Use zipfian distribution instead of uniform distribution");
 	printf("%-24s %s\n", "    --commitget", "Commit GETs");
-	printf("%-24s %s\n", "    --loggroup=LOGGROUP", "Set client log group");
+	printf("%-24s %s\n", "    --loggroup=LOGGROUP", "Set client logr group");
 	printf("%-24s %s\n", "    --prefix_padding", "Pad key by prefixing data (Default: postfix padding)");
 	printf("%-24s %s\n", "    --trace", "Enable tracing");
 	printf("%-24s %s\n", "    --tracepath=PATH", "Set trace file path");
@@ -1291,7 +1281,7 @@ void usage() {
 }
 
 /* parse benchmark paramters */
-int parseArguments(int argc, char* argv[], Arguments* args) {
+int parseArguments(int argc, char* argv[], Arguments& args) {
 	int rc;
 	int c;
 	int idx;
@@ -1351,35 +1341,35 @@ int parseArguments(int argc, char* argv[], Arguments* args) {
 			usage();
 			return -1;
 		case 'a':
-			args->api_version = atoi(optarg);
+			args.api_version = atoi(optarg);
 			break;
 		case 'c': {
 			const char delim[] = ",";
 			char* cluster_file = strtok(optarg, delim);
 			while (cluster_file != NULL) {
-				strcpy(args->cluster_files[args->num_fdb_clusters++], cluster_file);
+				strcpy(args.cluster_files[args.num_fdb_clusters++], cluster_file);
 				cluster_file = strtok(NULL, delim);
 			}
 			break;
 		}
 		case 'd':
-			args->num_databases = atoi(optarg);
+			args.num_databases = atoi(optarg);
 			break;
 		case 'p':
-			args->num_processes = atoi(optarg);
+			args.num_processes = atoi(optarg);
 			break;
 		case 't':
-			args->num_threads = atoi(optarg);
+			args.num_threads = atoi(optarg);
 			break;
 		case 'r':
-			args->rows = atoi(optarg);
-			args->row_digits = digits(args->rows);
+			args.rows = atoi(optarg);
+			args.row_digits = digits(args.rows);
 			break;
 		case 's':
-			args->seconds = atoi(optarg);
+			args.seconds = atoi(optarg);
 			break;
 		case 'i':
-			args->iteration = atoi(optarg);
+			args.iteration = atoi(optarg);
 			break;
 		case 'x':
 			rc = parseTransaction(args, optarg);
@@ -1387,162 +1377,146 @@ int parseArguments(int argc, char* argv[], Arguments* args) {
 				return -1;
 			break;
 		case 'v':
-			args->verbose = atoi(optarg);
+			args.verbose = atoi(optarg);
 			break;
 		case 'z':
-			args->zipf = 1;
+			args.zipf = 1;
 			break;
 		case 'm':
 			if (strcmp(optarg, "clean") == 0) {
-				args->mode = MODE_CLEAN;
+				args.mode = MODE_CLEAN;
 			} else if (strcmp(optarg, "build") == 0) {
-				args->mode = MODE_BUILD;
+				args.mode = MODE_BUILD;
 			} else if (strcmp(optarg, "run") == 0) {
-				args->mode = MODE_RUN;
+				args.mode = MODE_RUN;
 			}
 			break;
 		case ARG_KEYLEN:
-			args->key_length = atoi(optarg);
+			args.key_length = atoi(optarg);
 			break;
 		case ARG_VALLEN:
-			args->value_length = atoi(optarg);
+			args.value_length = atoi(optarg);
 			break;
 		case ARG_TPS:
 		case ARG_TPSMAX:
-			args->tpsmax = atoi(optarg);
+			args.tpsmax = atoi(optarg);
 			break;
 		case ARG_TPSMIN:
-			args->tpsmin = atoi(optarg);
+			args.tpsmin = atoi(optarg);
 			break;
 		case ARG_TPSINTERVAL:
-			args->tpsinterval = atoi(optarg);
+			args.tpsinterval = atoi(optarg);
 			break;
 		case ARG_TPSCHANGE:
 			if (strcmp(optarg, "sin") == 0)
-				args->tpschange = TPS_SIN;
+				args.tpschange = TPS_SIN;
 			else if (strcmp(optarg, "square") == 0)
-				args->tpschange = TPS_SQUARE;
+				args.tpschange = TPS_SQUARE;
 			else if (strcmp(optarg, "pulse") == 0)
-				args->tpschange = TPS_PULSE;
+				args.tpschange = TPS_PULSE;
 			else {
-				fprintf(stderr, "--tpschange must be sin, square or pulse\n");
+				logr.error("--tpschange must be sin, square or pulse");
 				return -1;
 			}
 			break;
 		case ARG_SAMPLING:
-			args->sampling = atoi(optarg);
+			args.sampling = atoi(optarg);
 			break;
 		case ARG_VERSION:
-			fprintf(stderr, "Version: %d\n", FDB_API_VERSION);
+			logr.error("Version: {}\n", FDB_API_VERSION);
 			exit(0);
 			break;
 		case ARG_COMMITGET:
-			args->commit_get = 1;
+			args.commit_get = 1;
 			break;
 		case ARG_FLATBUFFERS:
-			args->flatbuffers = 1;
+			args.flatbuffers = 1;
 			break;
 		case ARG_KNOBS:
-			memcpy(args->knobs, optarg, strlen(optarg) + 1);
+			memcpy(args.knobs, optarg, strlen(optarg) + 1);
 			break;
 		case ARG_LOGGROUP:
-			memcpy(args->log_group, optarg, strlen(optarg) + 1);
+			memcpy(args.log_group, optarg, strlen(optarg) + 1);
 			break;
 		case ARG_PREFIXPADDING:
-			args->prefixpadding = 1;
+			args.prefixpadding = 1;
 			break;
 		case ARG_TRACE:
-			args->trace = 1;
+			args.trace = 1;
 			break;
 		case ARG_TRACEPATH:
-			args->trace = 1;
-			memcpy(args->tracepath, optarg, strlen(optarg) + 1);
+			args.trace = 1;
+			memcpy(args.tracepath, optarg, strlen(optarg) + 1);
 			break;
 		case ARG_TRACEFORMAT:
 			if (strncmp(optarg, "json", 5) == 0) {
-				args->traceformat = 1;
+				args.traceformat = 1;
 			} else if (strncmp(optarg, "xml", 4) == 0) {
-				args->traceformat = 0;
+				args.traceformat = 0;
 			} else {
-				fprintf(stderr, "Error: Invalid trace_format %s\n", optarg);
+				logr.error("Invalid trace_format {}\n", optarg);
 				return -1;
 			}
 			break;
 		case ARG_STREAMING_MODE:
 			if (strncmp(optarg, "all", 3) == 0) {
-				args->streaming_mode = FDB_STREAMING_MODE_WANT_ALL;
+				args.streaming_mode = FDB_STREAMING_MODE_WANT_ALL;
 			} else if (strncmp(optarg, "iterator", 8) == 0) {
-				args->streaming_mode = FDB_STREAMING_MODE_ITERATOR;
+				args.streaming_mode = FDB_STREAMING_MODE_ITERATOR;
 			} else if (strncmp(optarg, "small", 5) == 0) {
-				args->streaming_mode = FDB_STREAMING_MODE_SMALL;
+				args.streaming_mode = FDB_STREAMING_MODE_SMALL;
 			} else if (strncmp(optarg, "medium", 6) == 0) {
-				args->streaming_mode = FDB_STREAMING_MODE_MEDIUM;
+				args.streaming_mode = FDB_STREAMING_MODE_MEDIUM;
 			} else if (strncmp(optarg, "large", 5) == 0) {
-				args->streaming_mode = FDB_STREAMING_MODE_LARGE;
+				args.streaming_mode = FDB_STREAMING_MODE_LARGE;
 			} else if (strncmp(optarg, "serial", 6) == 0) {
-				args->streaming_mode = FDB_STREAMING_MODE_SERIAL;
+				args.streaming_mode = FDB_STREAMING_MODE_SERIAL;
 			} else {
-				fprintf(stderr, "Error: Invalid streaming mode %s\n", optarg);
+				logr.error("Invalid streaming mode {}", optarg);
 				return -1;
 			}
 			break;
 		case ARG_TXNTRACE:
-			args->txntrace = atoi(optarg);
+			args.txntrace = atoi(optarg);
 			break;
 
 		case ARG_TXNTAGGING:
-			args->txntagging = atoi(optarg);
-			if (args->txntagging > 1000) {
-				args->txntagging = 1000;
+			args.txntagging = atoi(optarg);
+			if (args.txntagging > 1000) {
+				args.txntagging = 1000;
 			}
 			break;
 		case ARG_TXNTAGGINGPREFIX:
 			if (strlen(optarg) > TAGPREFIXLENGTH_MAX) {
-				fprintf(stderr, "Error: the length of txntagging_prefix is larger than %d\n", TAGPREFIXLENGTH_MAX);
+				logr.error("the length of txntagging_prefix is larger than {}", TAGPREFIXLENGTH_MAX);
 				exit(0);
 			}
-			memcpy(args->txntagging_prefix, optarg, strlen(optarg));
+			memcpy(args.txntagging_prefix, optarg, strlen(optarg));
 			break;
 		case ARG_CLIENT_THREADS_PER_VERSION:
-			args->client_threads_per_version = atoi(optarg);
+			args.client_threads_per_version = atoi(optarg);
 			break;
 		case ARG_DISABLE_RYW:
-			args->disable_ryw = 1;
+			args.disable_ryw = 1;
 			break;
 		case ARG_JSON_REPORT:
 			if (optarg == NULL && (argv[optind] == NULL || (argv[optind] != NULL && argv[optind][0] == '-'))) {
 				// if --report_json is the last option and no file is specified
 				// or --report_json is followed by another option
 				char default_file[] = "mako.json";
-				strncpy(args->json_output_path, default_file, strlen(default_file));
+				strncpy(args.json_output_path, default_file, strlen(default_file));
 			} else {
-				strncpy(args->json_output_path, optarg, strlen(optarg) + 1);
+				strncpy(args.json_output_path, optarg, strlen(optarg) + 1);
 			}
 			break;
 		case ARG_BG_FILE_PATH:
-			args->bg_materialize_files = true;
-			strncpy(args->bg_file_path, optarg, strlen(optarg) + 1);
+			args.bg_materialize_files = true;
+			strncpy(args.bg_file_path, optarg, strlen(optarg) + 1);
 		}
 	}
 
-	if ((args->tpsmin == -1) || (args->tpsmin > args->tpsmax)) {
-		args->tpsmin = args->tpsmax;
-	}
-
-	if (args->verbose >= VERBOSE_DEFAULT) {
-		printme = stdout;
-	} else {
-		printme = fopen("/dev/null", "w");
-	}
-	if (args->verbose >= VERBOSE_ANNOYING) {
-		annoyme = stdout;
-	} else {
-		annoyme = fopen("/dev/null", "w");
-	}
-	if (args->verbose >= VERBOSE_DEBUG) {
-		debugme = stdout;
-	} else {
-		debugme = fopen("/dev/null", "w");
+	if ((args.tpsmin == -1) || (args.tpsmin > args.tpsmax)) {
+		args.tpsmin = args.tpsmax;
 	}
 
 	return 0;
@@ -1554,63 +1528,60 @@ char const* getOpName(int ops_code) {
 	return "";
 }
 
-int validateArguments(Arguments* args) {
-	if (args->mode == MODE_INVALID) {
-		fprintf(stderr, "ERROR: --mode has to be set\n");
+int validateArguments(Arguments const& args) {
+	if (args.mode == MODE_INVALID) {
+		logr.error("--mode has to be set");
 		return -1;
 	}
-	if (args->rows <= 0) {
-		fprintf(stderr, "ERROR: --rows must be a positive integer\n");
+	if (args.verbose < VERBOSE_NONE || args.verbose > VERBOSE_DEBUG) {
+		logr.error("--verbose must be between 0 and 3");
 		return -1;
 	}
-	if (args->key_length < 0) {
-		fprintf(stderr, "ERROR: --keylen must be a positive integer\n");
+	if (args.rows <= 0) {
+		logr.error("--rows must be a positive integer");
 		return -1;
 	}
-	if (args->value_length < 0) {
-		fprintf(stderr, "ERROR: --vallen must be a positive integer\n");
+	if (args.key_length < 0) {
+		logr.error("--keylen must be a positive integer");
 		return -1;
 	}
-	if (args->num_fdb_clusters > NUM_CLUSTERS_MAX) {
-		fprintf(stderr, "ERROR: Mako is not supported to do work to more than %d clusters\n", NUM_CLUSTERS_MAX);
+	if (args.value_length < 0) {
+		logr.error("--vallen must be a positive integer");
 		return -1;
 	}
-	if (args->num_databases > NUM_DATABASES_MAX) {
-		fprintf(stderr, "ERROR: Mako is not supported to do work to more than %d databases\n", NUM_DATABASES_MAX);
+	if (args.num_fdb_clusters > NUM_CLUSTERS_MAX) {
+		logr.error("Mako is not supported to do work to more than {} clusters", NUM_CLUSTERS_MAX);
 		return -1;
 	}
-	if (args->num_databases < args->num_fdb_clusters) {
-		fprintf(stderr,
-		        "ERROR: --num_databases (%d) must be >= number of clusters(%d)\n",
-		        args->num_databases,
-		        args->num_fdb_clusters);
+	if (args.num_databases > NUM_DATABASES_MAX) {
+		logr.error("Mako is not supported to do work to more than {} databases", NUM_DATABASES_MAX);
 		return -1;
 	}
-	if (args->num_threads < args->num_databases) {
-		fprintf(stderr,
-		        "ERROR: --threads (%d) must be >= number of databases (%d)\n",
-		        args->num_threads,
-		        args->num_databases);
+	if (args.num_databases < args.num_fdb_clusters) {
+		logr.error("--num_databases ({}) must be >= number of clusters({})", args.num_databases, args.num_fdb_clusters);
 		return -1;
 	}
-	if (args->key_length < 4 /* "mako" */ + args->row_digits) {
-		fprintf(stderr,
-		        "ERROR: --keylen must be larger than %d to store \"mako\" prefix "
-		        "and maximum row number\n",
-		        4 + args->row_digits);
+	if (args.num_threads < args.num_databases) {
+		logr.error("--threads ({}) must be >= number of databases ({})", args.num_threads, args.num_databases);
 		return -1;
 	}
-	if (args->mode == MODE_RUN) {
-		if ((args->seconds > 0) && (args->iteration > 0)) {
-			fprintf(stderr, "ERROR: Cannot specify seconds and iteration together\n");
+	if (args.key_length < 4 /* "mako" */ + args.row_digits) {
+		logr.error("--keylen must be larger than {} to store \"mako\" prefix "
+		           "and maximum row number",
+		           4 + args.row_digits);
+		return -1;
+	}
+	if (args.mode == MODE_RUN) {
+		if ((args.seconds > 0) && (args.iteration > 0)) {
+			logr.error("Cannot specify seconds and iteration together");
 			return -1;
 		}
-		if ((args->seconds == 0) && (args->iteration == 0)) {
-			fprintf(stderr, "ERROR: Must specify either seconds or iteration\n");
+		if ((args.seconds == 0) && (args.iteration == 0)) {
+			logr.error("Must specify either seconds or iteration");
 			return -1;
 		}
-		if (args->txntagging < 0) {
-			fprintf(stderr, "ERROR: --txntagging must be a non-negative integer\n");
+		if (args.txntagging < 0) {
+			logr.error("--txntagging must be a non-negative integer");
 			return -1;
 		}
 	}
@@ -1634,23 +1605,23 @@ void printStats(Arguments const& args, ThreadStatistics const* stats, double con
 	auto print_err = false;
 	for (auto op = 0; op < MAX_OP; op++) {
 		if (args.txnspec.ops[op][OP_COUNT] > 0) {
-			const auto ops_total_diff = current.get_op_count(op) - prev.get_op_count(op);
+			const auto ops_total_diff = current.getOpCount(op) - prev.getOpCount(op);
 			putField(ops_total_diff);
 			if (fp) {
 				fmt::print(fp, "\"{}\": {},", getOpName(op), ops_total_diff);
 			}
-			print_err = print_err || (current.get_error_count(op) - prev.get_error_count(op)) > 0;
+			print_err = print_err || (current.getErrorCount(op) - prev.getErrorCount(op)) > 0;
 		}
 	}
 	/* TPS */
-	const auto tps = (current.get_tx_count() - prev.get_tx_count()) / duration_sec;
+	const auto tps = (current.getTaskCount() - prev.getTaskCount()) / duration_sec;
 	putFieldFloat(tps, 2);
 	if (fp) {
 		fprintf(fp, "\"tps\": %.2f,", tps);
 	}
 
 	/* Conflicts */
-	const auto conflicts_diff = (current.get_conflict_count() - prev.get_conflict_count()) / duration_sec;
+	const auto conflicts_diff = (current.getConflictCount() - prev.getConflictCount()) / duration_sec;
 	putFieldFloat(conflicts_diff, 2);
 	fmt::print("\n");
 	if (fp) {
@@ -1661,7 +1632,7 @@ void printStats(Arguments const& args, ThreadStatistics const* stats, double con
 		putTitleRight("Errors");
 		for (auto op = 0; op < MAX_OP; op++) {
 			if (args.txnspec.ops[op][OP_COUNT] > 0) {
-				const auto errors_diff = current.get_error_count(op) - prev.get_error_count(op);
+				const auto errors_diff = current.getErrorCount(op) - prev.getErrorCount(op);
 				putField(errors_diff);
 				if (fp) {
 					fmt::print(fp, ",\"errors\": {}", errors_diff);
@@ -1758,11 +1729,11 @@ void printReport(Arguments const& args,
 			break;
 		}
 	}
-	const auto tps_f = final_stats.get_tx_count() / duration_sec;
+	const auto tps_f = final_stats.getTaskCount() / duration_sec;
 	const auto tps_i = static_cast<uint64_t>(tps_f);
-	fmt::printf("Total Xacts:      %8lu\n", final_stats.get_tx_count());
-	fmt::printf("Total Conflicts:  %8lu\n", final_stats.get_conflict_count());
-	fmt::printf("Total Errors:     %8lu\n", final_stats.get_total_error_count());
+	fmt::printf("Total Xacts:      %8lu\n", final_stats.getTaskCount());
+	fmt::printf("Total Conflicts:  %8lu\n", final_stats.getConflictCount());
+	fmt::printf("Total Errors:     %8lu\n", final_stats.getTotalErrorCount());
 	fmt::printf("Overall TPS:      %8lu\n\n", tps_i);
 
 	if (fp) {
@@ -1771,9 +1742,9 @@ void printReport(Arguments const& args,
 		fmt::fprintf(fp, "\"totalProcesses\": %d,", args.num_processes);
 		fmt::fprintf(fp, "\"totalThreads\": %d,", args.num_threads);
 		fmt::fprintf(fp, "\"targetTPS\": %d,", args.tpsmax);
-		fmt::fprintf(fp, "\"totalXacts\": %lu,", final_stats.get_tx_count());
-		fmt::fprintf(fp, "\"totalConflicts\": %lu,", final_stats.get_conflict_count());
-		fmt::fprintf(fp, "\"totalErrors\": %lu,", final_stats.get_total_error_count());
+		fmt::fprintf(fp, "\"totalXacts\": %lu,", final_stats.getTaskCount());
+		fmt::fprintf(fp, "\"totalConflicts\": %lu,", final_stats.getConflictCount());
+		fmt::fprintf(fp, "\"totalErrors\": %lu,", final_stats.getTotalErrorCount());
 		fmt::fprintf(fp, "\"overallTPS\": %lu,", tps_i);
 	}
 
@@ -1788,24 +1759,24 @@ void printReport(Arguments const& args,
 	auto first_op = true;
 	for (auto op = 0; op < MAX_OP; op++) {
 		if ((args.txnspec.ops[op][OP_COUNT] > 0 && op != OP_TRANSACTION) || op == OP_COMMIT) {
-			putField(final_stats.get_op_count(op));
+			putField(final_stats.getOpCount(op));
 			if (fp) {
 				if (first_op) {
 					first_op = 0;
 				} else {
 					fmt::fprintf(fp, ",");
 				}
-				fmt::fprintf(fp, "\"%s\": %lu", getOpName(op), final_stats.get_op_count(op));
+				fmt::fprintf(fp, "\"%s\": %lu", getOpName(op), final_stats.getOpCount(op));
 			}
 		}
 	}
 
 	/* TPS */
-	const auto tps = final_stats.get_tx_count() / duration_sec;
+	const auto tps = final_stats.getTaskCount() / duration_sec;
 	putFieldFloat(tps, 2);
 
 	/* Conflicts */
-	const auto conflicts_rate = final_stats.get_conflict_count() / duration_sec;
+	const auto conflicts_rate = final_stats.getConflictCount() / duration_sec;
 	putFieldFloat(conflicts_rate, 2);
 	fmt::print("\n");
 
@@ -1818,14 +1789,14 @@ void printReport(Arguments const& args,
 	first_op = 1;
 	for (auto op = 0; op < MAX_OP; op++) {
 		if (args.txnspec.ops[op][OP_COUNT] > 0 && op != OP_TRANSACTION) {
-			putField(final_stats.get_error_count(op));
+			putField(final_stats.getErrorCount(op));
 			if (fp) {
 				if (first_op) {
 					first_op = 0;
 				} else {
 					fmt::fprintf(fp, ",");
 				}
-				fmt::fprintf(fp, "\"%s\": %lu", getOpName(op), final_stats.get_error_count(op));
+				fmt::fprintf(fp, "\"%s\": %lu", getOpName(op), final_stats.getErrorCount(op));
 			}
 		}
 	}
@@ -1842,8 +1813,8 @@ void printReport(Arguments const& args,
 	first_op = 1;
 	for (auto op = 0; op < MAX_OP; op++) {
 		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-			if (final_stats.get_latency_us_total(op)) {
-				putField(final_stats.get_latency_sample_count(op));
+			if (final_stats.getLatencyUsTotal(op)) {
+				putField(final_stats.getLatencySampleCount(op));
 			} else {
 				putField("N/A");
 			}
@@ -1853,7 +1824,7 @@ void printReport(Arguments const& args,
 				} else {
 					fmt::fprintf(fp, ",");
 				}
-				fmt::fprintf(fp, "\"%s\": %lu", getOpName(op), final_stats.get_latency_sample_count(op));
+				fmt::fprintf(fp, "\"%s\": %lu", getOpName(op), final_stats.getLatencySampleCount(op));
 			}
 		}
 	}
@@ -1867,7 +1838,7 @@ void printReport(Arguments const& args,
 	first_op = 1;
 	for (auto op = 0; op < MAX_OP; op++) {
 		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-			const auto lat_min = final_stats.get_latency_us_min(op);
+			const auto lat_min = final_stats.getLatencyUsMin(op);
 			if (lat_min == -1) {
 				putField("N/A");
 			} else {
@@ -1893,8 +1864,8 @@ void printReport(Arguments const& args,
 	first_op = 1;
 	for (auto op = 0; op < MAX_OP; op++) {
 		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-			const auto lat_total = final_stats.get_latency_us_total(op);
-			const auto lat_samples = final_stats.get_latency_sample_count(op);
+			const auto lat_total = final_stats.getLatencyUsTotal(op);
+			const auto lat_samples = final_stats.getLatencySampleCount(op);
 			if (lat_total) {
 				putField(lat_total / lat_samples);
 				if (fp) {
@@ -1920,7 +1891,7 @@ void printReport(Arguments const& args,
 	first_op = 1;
 	for (auto op = 0; op < MAX_OP; op++) {
 		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-			const auto lat_max = final_stats.get_latency_us_max(op);
+			const auto lat_max = final_stats.getLatencyUsMax(op);
 			if (lat_max == 0) {
 				putField("N/A");
 			} else {
@@ -1931,7 +1902,7 @@ void printReport(Arguments const& args,
 					} else {
 						fmt::fprintf(fp, ",");
 					}
-					fmt::fprintf(fp, "\"%s\": %lu", getOpName(op), final_stats.get_latency_us_max(op));
+					fmt::fprintf(fp, "\"%s\": %lu", getOpName(op), final_stats.getLatencyUsMax(op));
 				}
 			}
 		}
@@ -1948,8 +1919,8 @@ void printReport(Arguments const& args,
 	first_op = 1;
 	for (auto op = 0; op < MAX_OP; op++) {
 		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-			const auto lat_total = final_stats.get_latency_us_total(op);
-			const auto lat_samples = final_stats.get_latency_sample_count(op);
+			const auto lat_total = final_stats.getLatencyUsTotal(op);
+			const auto lat_samples = final_stats.getLatencySampleCount(op);
 			if (lat_total && lat_samples) {
 				for (auto i = 0; i < args.num_processes; i++) {
 					for (auto j = 0; j < args.num_threads; j++) {
@@ -1957,7 +1928,7 @@ void printReport(Arguments const& args,
 						const auto filename = getStatsFilename(dirname, i, j, op);
 						auto fp = fopen(filename.c_str(), "r");
 						if (!fp) {
-							fmt::print(stderr, "ERROR: fopen({}): {}\n", filename, strerror(errno));
+							logr.error("fopen({}): {}\n", filename, strerror(errno));
 							continue;
 						}
 						auto fclose_guard = ExitGuard([fp]() { fclose(fp); });
@@ -2004,7 +1975,7 @@ void printReport(Arguments const& args,
 	first_op = 1;
 	for (auto op = 0; op < MAX_OP; op++) {
 		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-			if (data_points[op].empty() || !final_stats.get_latency_us_total(op)) {
+			if (data_points[op].empty() || !final_stats.getLatencyUsTotal(op)) {
 				putField("N/A");
 				continue;
 			}
@@ -2031,7 +2002,7 @@ void printReport(Arguments const& args,
 	first_op = 1;
 	for (auto op = 0; op < MAX_OP; op++) {
 		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-			if (data_points[op].empty() || !final_stats.get_latency_us_total(op)) {
+			if (data_points[op].empty() || !final_stats.getLatencyUsTotal(op)) {
 				putField("N/A");
 				continue;
 			}
@@ -2058,7 +2029,7 @@ void printReport(Arguments const& args,
 	first_op = 1;
 	for (auto op = 0; op < MAX_OP; op++) {
 		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-			if (data_points[op].empty() || !final_stats.get_latency_us_total(op)) {
+			if (data_points[op].empty() || !final_stats.getLatencyUsTotal(op)) {
 				putField("N/A");
 				continue;
 			}
@@ -2145,14 +2116,14 @@ int statsProcessMain(Arguments const& args,
 		auto time_now = steady_clock::now();
 
 		/* print stats every (roughly) 1 sec */
-		if (to_double_seconds(time_now - time_prev) >= 1.0) {
+		if (toDoubleSeconds(time_now - time_prev) >= 1.0) {
 
 			/* adjust throttle rate if needed */
 			if (args.tpsmax != args.tpsmin) {
 				const auto tpsinterval = static_cast<double>(args.tpsinterval);
 				const auto tpsmin = static_cast<double>(args.tpsmin);
 				const auto tpsmax = static_cast<double>(args.tpsmax);
-				const auto pos = fmod(to_double_seconds(time_now - time_start), tpsinterval);
+				const auto pos = fmod(toDoubleSeconds(time_now - time_start), tpsinterval);
 				auto sin_factor = 0.;
 				/* set the throttle factor between 0.0 and 1.0 */
 				switch (args.tpschange) {
@@ -2188,7 +2159,7 @@ int statsProcessMain(Arguments const& args,
 					if (fp)
 						fmt::fprintf(fp, ",");
 				}
-				printStats(args, stats, to_double_seconds(time_now - time_prev), fp);
+				printStats(args, stats, toDoubleSeconds(time_now - time_prev), fp);
 			}
 			time_prev = time_now;
 		}
@@ -2204,7 +2175,7 @@ int statsProcessMain(Arguments const& args,
 		while (stopcount.load() < args.num_threads * args.num_processes) {
 			usleep(10000); /* 10ms */
 		}
-		printReport(args, stats, to_double_seconds(time_now - time_start), pid_main, fp);
+		printReport(args, stats, toDoubleSeconds(time_now - time_start), pid_main, fp);
 	}
 
 	if (fp) {
@@ -2220,20 +2191,21 @@ int main(int argc, char* argv[]) {
 
 	auto rc = int{};
 	auto args = Arguments{};
-	rc = initArguments(&args);
+	rc = initArguments(args);
 	if (rc < 0) {
-		fmt::print(stderr, "ERROR: initArguments failed\n");
+		logr.error("initArguments failed\n");
 		return -1;
 	}
-	rc = parseArguments(argc, argv, &args);
+	rc = parseArguments(argc, argv, args);
 	if (rc < 0) {
 		/* usage printed */
 		return 0;
 	}
 
-	rc = validateArguments(&args);
+	rc = validateArguments(args);
 	if (rc < 0)
 		return -1;
+	logr.setVerbosity(args.verbose);
 
 	if (args.mode == MODE_CLEAN) {
 		/* cleanup will be done from a single thread */
@@ -2243,7 +2215,7 @@ int main(int argc, char* argv[]) {
 
 	if (args.mode == MODE_BUILD) {
 		if (args.txnspec.ops[OP_INSERT][OP_COUNT] == 0) {
-			parseTransaction(&args, "i100");
+			parseTransaction(args, "i100");
 		}
 	}
 
@@ -2252,7 +2224,7 @@ int main(int argc, char* argv[]) {
 	const auto shmpath = fmt::format("mako{}", pid_main);
 	auto shmfd = shm_open(shmpath.c_str(), O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
 	if (shmfd < 0) {
-		fmt::print(stderr, "ERROR: shm_open failed\n");
+		logr.error("shm_open failed: {}", strerror(errno));
 		return -1;
 	}
 	auto shmfd_guard = ExitGuard([shmfd, &shmpath]() {
@@ -2266,14 +2238,14 @@ int main(int argc, char* argv[]) {
 	auto shm = std::add_pointer_t<void>{};
 	if (ftruncate(shmfd, shmsize) < 0) {
 		shm = MAP_FAILED;
-		fmt::print(stderr, "ERROR: ftruncate (fd:{} size:{}) failed\n", shmfd, shmsize);
+		logr.error("ftruncate (fd:{} size:{}) failed", shmfd, shmsize);
 		return -1;
 	}
 
 	/* map it */
 	shm = mmap(NULL, shmsize, PROT_READ | PROT_WRITE, MAP_SHARED, shmfd, 0);
 	if (shm == MAP_FAILED) {
-		fmt::print(stderr, "ERROR: mmap (fd:{} size:{}) failed\n", shmfd, shmsize);
+		logr.error("mmap (fd:{} size:{}) failed", shmfd, shmsize);
 		return -1;
 	}
 	auto munmap_guard = ExitGuard([=]() { munmap(shm, shmsize); });
@@ -2290,7 +2262,7 @@ int main(int argc, char* argv[]) {
 	shm_hdr.stopcount = 0;
 	shm_hdr.throttle_factor = 1.0;
 
-	auto proc_type = PROC_MASTER;
+	auto proc_type = ProcKind::MAIN;
 	/* fork worker processes + 1 stats process */
 	auto worker_pids = std::vector<pid_t>(args.num_processes + 1);
 
@@ -2304,16 +2276,18 @@ int main(int argc, char* argv[]) {
 			/* master */
 			worker_pids[p] = pid;
 			if (args.verbose == VERBOSE_DEBUG) {
-				printf("DEBUG: worker %d (PID:%d) forked\n", p, worker_pids[p]);
+				logr.debug("worker {} (PID:{}) forked", p + 1, worker_pids[p]);
 			}
 		} else {
 			if (p < args.num_processes) {
 				/* worker process */
-				proc_type = PROC_WORKER;
+				logr = Logger(WorkerProcess{}, args.verbose, p);
+				proc_type = ProcKind::WORKER;
 				worker_id = p;
 			} else {
 				/* stats */
-				proc_type = PROC_STATS;
+				logr = Logger(StatsProcess{}, args.verbose);
+				proc_type = ProcKind::STATS;
 			}
 			break;
 		}
@@ -2327,12 +2301,12 @@ int main(int argc, char* argv[]) {
 		zipfian_generator(args.rows);
 	}
 
-	if (proc_type == PROC_WORKER) {
+	if (proc_type == ProcKind::WORKER) {
 		/* worker process */
 		workerProcessMain(args, worker_id, shm_access, pid_main);
 		/* worker can exit here */
 		exit(0);
-	} else if (proc_type == PROC_STATS) {
+	} else if (proc_type == ProcKind::STATS) {
 		/* stats */
 		if (args.mode == MODE_CLEAN) {
 			/* no stats needed for clean mode */
@@ -2356,19 +2330,15 @@ int main(int argc, char* argv[]) {
 		/* if seconds is specified, stop child processes after the specified
 		 * duration */
 		if (args.seconds > 0) {
-			if (args.verbose == VERBOSE_DEBUG) {
-				printf("DEBUG: master sleeping for %d seconds\n", args.seconds);
-			}
+			logr.debug("master sleeping for {} seconds", args.seconds);
 
 			auto time_start = steady_clock::now();
 			while (1) {
 				usleep(100000); /* sleep for 100ms */
 				auto time_now = steady_clock::now();
 				/* doesn't have to be precise */
-				if (to_double_seconds(time_now - time_start) > args.seconds) {
-					if (args.verbose == VERBOSE_DEBUG) {
-						printf("DEBUG: time's up (%d seconds)\n", args.seconds);
-					}
+				if (toDoubleSeconds(time_now - time_start) > args.seconds) {
+					logr.debug("time's up ({} seconds)", args.seconds);
 					break;
 				}
 			}
@@ -2381,16 +2351,12 @@ int main(int argc, char* argv[]) {
 	auto status = int{};
 	/* wait for worker processes to exit */
 	for (auto p = 0; p < args.num_processes; p++) {
-		if (args.verbose == VERBOSE_DEBUG) {
-			fmt::print("DEBUG: waiting worker {} (PID:{}) to exit\n", p, worker_pids[p]);
-		}
+		logr.debug("waiting for worker process {} (PID:{}) to exit", p + 1, worker_pids[p]);
 		auto pid = waitpid(worker_pids[p], &status, 0 /* or what? */);
 		if (pid < 0) {
-			fmt::print(stderr, "ERROR: waitpid failed for worker process PID {}\n", worker_pids[p]);
-		}
-		if (args.verbose == VERBOSE_DEBUG) {
-			fmt::print("DEBUG: worker {} (PID:{}) exited\n", p, worker_pids[p]);
+			logr.error("waitpid failed for worker process PID {}", worker_pids[p]);
 		}
+		logr.debug("worker {} (PID:{}) exited", p + 1, worker_pids[p]);
 	}
 
 	/* all worker threads finished, stop the stats */
@@ -2401,7 +2367,7 @@ int main(int argc, char* argv[]) {
 	/* wait for stats to stop */
 	auto pid = waitpid(worker_pids[args.num_processes], &status, 0 /* or what? */);
 	if (pid < 0) {
-		fmt::print(stderr, "ERROR: waitpid failed for stats process PID {}\n", worker_pids[args.num_processes]);
+		logr.error("waitpid failed for stats process PID {}", worker_pids[args.num_processes]);
 	}
 
 	return 0;
diff --git a/bindings/c/test/mako/mako.hpp b/bindings/c/test/mako/mako.hpp
index 9c2700ed5b..6a6f4bf0e0 100644
--- a/bindings/c/test/mako/mako.hpp
+++ b/bindings/c/test/mako/mako.hpp
@@ -30,11 +30,6 @@
 
 namespace mako {
 
-constexpr const int VERBOSE_NONE = 0;
-constexpr const int VERBOSE_DEFAULT = 1;
-constexpr const int VERBOSE_ANNOYING = 2;
-constexpr const int VERBOSE_DEBUG = 3;
-
 constexpr const int MODE_INVALID = -1;
 constexpr const int MODE_CLEAN = 0;
 constexpr const int MODE_BUILD = 1;
@@ -152,9 +147,6 @@ using StepFunction = fdb::Future (*)(fdb::Transaction tx,
                                      fdb::ByteString& /*key2*/,
                                      fdb::ByteString& /*value*/);
 
-/* process type */
-typedef enum { PROC_MASTER = 0, PROC_WORKER, PROC_STATS } ProcKind;
-
 class Operation {
 	using Step = std::pair<StepKind, StepFunction>;
 	std::string_view name_;
diff --git a/bindings/c/test/mako/process.hpp b/bindings/c/test/mako/process.hpp
new file mode 100644
index 0000000000..174fc0e427
--- /dev/null
+++ b/bindings/c/test/mako/process.hpp
@@ -0,0 +1,6 @@
+#ifndef MAKO_PROCESS_HPP
+#define MAKO_PROCESS_HPP
+
+enum class ProcKind { MAIN, WORKER, STATS };
+
+#endif /*MAKO_PROCESS_HPP*/
diff --git a/bindings/c/test/mako/shm.hpp b/bindings/c/test/mako/shm.hpp
index 87d2ee3a47..32ae0c2056 100644
--- a/bindings/c/test/mako/shm.hpp
+++ b/bindings/c/test/mako/shm.hpp
@@ -6,6 +6,7 @@
 #include <cstdint>
 #include "stats.hpp"
 
+// controlled, safer access to shared memory
 namespace mako::shared_memory {
 
 struct Header {
diff --git a/bindings/c/test/mako/stats.hpp b/bindings/c/test/mako/stats.hpp
index 442a84451c..2ebb908c9f 100644
--- a/bindings/c/test/mako/stats.hpp
+++ b/bindings/c/test/mako/stats.hpp
@@ -26,7 +26,7 @@ public:
 	bool full() const noexcept { return index >= LAT_BLOCK_SIZE; }
 	void put(timediff_t td) {
 		assert(!full());
-		samples[index++] = to_integer_microseconds(td);
+		samples[index++] = toIntegerMicroseconds(td);
 	}
 	// return {data block, number of samples}
 	std::pair<uint64_t const*, size_t> data() const noexcept { return { samples, index }; }
@@ -59,7 +59,7 @@ public:
 };
 
 class alignas(64) ThreadStatistics {
-	uint64_t xacts;
+	uint64_t tasks;
 	uint64_t conflicts;
 	uint64_t total_errors;
 	uint64_t ops[MAX_OP];
@@ -78,27 +78,27 @@ public:
 	ThreadStatistics(const ThreadStatistics& other) noexcept = default;
 	ThreadStatistics& operator=(const ThreadStatistics& other) noexcept = default;
 
-	uint64_t get_tx_count() const noexcept { return xacts; }
+	uint64_t getTaskCount() const noexcept { return tasks; }
 
-	uint64_t get_conflict_count() const noexcept { return conflicts; }
+	uint64_t getConflictCount() const noexcept { return conflicts; }
 
-	uint64_t get_op_count(int op) const noexcept { return ops[op]; }
+	uint64_t getOpCount(int op) const noexcept { return ops[op]; }
 
-	uint64_t get_error_count(int op) const noexcept { return errors[op]; }
+	uint64_t getErrorCount(int op) const noexcept { return errors[op]; }
 
-	uint64_t get_total_error_count() const noexcept { return total_errors; }
+	uint64_t getTotalErrorCount() const noexcept { return total_errors; }
 
-	uint64_t get_latency_sample_count(int op) const noexcept { return latency_samples[op]; }
+	uint64_t getLatencySampleCount(int op) const noexcept { return latency_samples[op]; }
 
-	uint64_t get_latency_us_total(int op) const noexcept { return latency_us_total[op]; }
+	uint64_t getLatencyUsTotal(int op) const noexcept { return latency_us_total[op]; }
 
-	uint64_t get_latency_us_min(int op) const noexcept { return latency_us_min[op]; }
+	uint64_t getLatencyUsMin(int op) const noexcept { return latency_us_min[op]; }
 
-	uint64_t get_latency_us_max(int op) const noexcept { return latency_us_max[op]; }
+	uint64_t getLatencyUsMax(int op) const noexcept { return latency_us_max[op]; }
 
 	// with 'this' as final aggregation, factor in 'other'
 	void combine(const ThreadStatistics& other) {
-		xacts += other.xacts;
+		tasks += other.tasks;
 		conflicts += other.conflicts;
 		for (auto op = 0; op < MAX_OP; op++) {
 			ops[op] += other.ops[op];
@@ -113,19 +113,19 @@ public:
 		}
 	}
 
-	void incr_tx_count() noexcept { xacts++; }
-	void incr_conflict_count() noexcept { conflicts++; }
+	void incrTaskCount() noexcept { tasks++; }
+	void incrConflictCount() noexcept { conflicts++; }
 
 	// non-commit write operations aren't measured for time.
-	void incr_op_count(int op) noexcept { ops[op]++; }
+	void incrOpCount(int op) noexcept { ops[op]++; }
 
-	void incr_error_count(int op) noexcept {
+	void incrErrorCount(int op) noexcept {
 		total_errors++;
 		errors[op]++;
 	}
 
-	void add_latency(int op, timediff_t diff) noexcept {
-		const auto latency_us = to_integer_microseconds(diff);
+	void addLatency(int op, timediff_t diff) noexcept {
+		const auto latency_us = toIntegerMicroseconds(diff);
 		latency_samples[op]++;
 		latency_us_total[op] += latency_us;
 		if (latency_us_min[op] > latency_us)
diff --git a/bindings/c/test/mako/time.hpp b/bindings/c/test/mako/time.hpp
index 835d4b4f51..eda1efc30c 100644
--- a/bindings/c/test/mako/time.hpp
+++ b/bindings/c/test/mako/time.hpp
@@ -11,44 +11,44 @@ using timepoint_t = decltype(steady_clock::now());
 using timediff_t = decltype(std::declval<timepoint_t>() - std::declval<timepoint_t>());
 
 template <typename Duration>
-double to_double_seconds(Duration duration) {
+double toDoubleSeconds(Duration duration) {
 	return std::chrono::duration_cast<std::chrono::duration<double>>(duration).count();
 }
 
 template <typename Duration>
-uint64_t to_integer_seconds(Duration duration) {
+uint64_t toIntegerSeconds(Duration duration) {
 	return std::chrono::duration_cast<std::chrono::duration<uint64_t>>(duration).count();
 }
 
 template <typename Duration>
-uint64_t to_integer_microseconds(Duration duration) {
+uint64_t toIntegerMicroseconds(Duration duration) {
 	return std::chrono::duration_cast<std::chrono::duration<uint64_t, std::micro>>(duration).count();
 }
 
 // timing helpers
-struct start_at_ctor {};
+struct StartAtCtor {};
 
 class Stopwatch {
 	timepoint_t p1, p2;
 
 public:
 	Stopwatch() noexcept = default;
-	Stopwatch(start_at_ctor) noexcept { start(); }
+	Stopwatch(StartAtCtor) noexcept { start(); }
 	Stopwatch(timepoint_t start_time) noexcept : p1(start_time), p2() {}
 	Stopwatch(const Stopwatch&) noexcept = default;
 	Stopwatch& operator=(const Stopwatch&) noexcept = default;
-	timepoint_t get_start() const noexcept { return p1; }
-	timepoint_t get_stop() const noexcept { return p2; }
+	timepoint_t getStart() const noexcept { return p1; }
+	timepoint_t getStop() const noexcept { return p2; }
 	void start() noexcept { p1 = steady_clock::now(); }
 	Stopwatch& stop() noexcept {
 		p2 = steady_clock::now();
 		return *this;
 	}
-	Stopwatch& set_stop(timepoint_t p_stop) noexcept {
+	Stopwatch& setStop(timepoint_t p_stop) noexcept {
 		p2 = p_stop;
 		return *this;
 	}
-	void start_from_stop() noexcept { p1 = p2; }
+	void startFromStop() noexcept { p1 = p2; }
 	auto diff() const noexcept { return p2 - p1; }
 };
 

From 00ce4f6248980ef37771fa3a70a5a48d72ab37ee Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Mon, 21 Mar 2022 22:34:10 +0100
Subject: [PATCH 14/84] Add asynchronous execution mode

- option -t (or --threads) determines the number of worker threads
  running asio job scheduler (io_context).
- value of --async_xacts indicates how many concurrent transactions should be running
  (only applies to '-m build' or '-m run')
- concurrent transactions whose count is specified in --async_xacts
  walks through the workload sequence (-x) as worker threads would in
  synchronous execution mode: i.e. --async_xacts=0.
- concurrent transactions in async mode, as would worker threads in sync mode,
  divide up the insertion range in build mode,
  and iteration limit in 'run' mode.
---
 bindings/c/CMakeLists.txt           |   6 +-
 bindings/c/test/fdb.hpp             |   5 +-
 bindings/c/test/mako/logger.hpp     |   4 +-
 bindings/c/test/mako/mako.cpp       | 757 +++++++++++++++++++++++-----
 bindings/c/test/mako/mako.hpp       |   4 +
 bindings/c/test/mako/operations.hpp |   6 +
 bindings/c/test/mako/stats.hpp      |   5 -
 bindings/c/test/mako/utils.cpp      |   5 +-
 8 files changed, 653 insertions(+), 139 deletions(-)

diff --git a/bindings/c/CMakeLists.txt b/bindings/c/CMakeLists.txt
index 0058fd5354..294746a5aa 100644
--- a/bindings/c/CMakeLists.txt
+++ b/bindings/c/CMakeLists.txt
@@ -147,7 +147,11 @@ if(NOT WIN32 AND NOT IS_ARM_MAC)
 
   # do not set RPATH for mako
   set_property(TARGET mako PROPERTY SKIP_BUILD_RPATH TRUE)
-  target_link_libraries(mako PRIVATE fdb_c fdbclient fmt::fmt Threads::Threads fdb_cpp)
+  if (USE_SANITIZER)
+	target_link_libraries(mako PRIVATE fdb_c fdbclient fmt::fmt Threads::Threads fdb_cpp boost_asan)
+  else()
+	target_link_libraries(mako PRIVATE fdb_c fdbclient fmt::fmt Threads::Threads fdb_cpp boost_target)
+  endif()
 
   if(NOT OPEN_FOR_IDE)
     # Make sure that fdb_c.h is compatible with c90
diff --git a/bindings/c/test/fdb.hpp b/bindings/c/test/fdb.hpp
index 2dbcf98f59..f5ffde486f 100644
--- a/bindings/c/test/fdb.hpp
+++ b/bindings/c/test/fdb.hpp
@@ -253,7 +253,9 @@ protected:
 		auto cb = [fut = FutureType(*this), fn = std::forward<UserFunc>(fn)]() { fn(fut); };
 		using cb_type = std::decay_t<decltype(cb)>;
 		auto fp = new cb_type(std::move(cb));
-		native::fdb_future_set_callback(f.get(), &callback<cb_type>, fp);
+		if (auto err = Error(native::fdb_future_set_callback(f.get(), &callback<cb_type>, fp))) {
+			throwError("ERROR: future_set_callback: ", err);
+		}
 	}
 
 public:
@@ -309,6 +311,7 @@ public:
 
 template <typename VarTraits>
 class TypedFuture : public Future {
+	friend class Future;
 	friend class Transaction;
 	using SelfType = TypedFuture<VarTraits>;
 	using Future::Future;
diff --git a/bindings/c/test/mako/logger.hpp b/bindings/c/test/mako/logger.hpp
index d567b16995..45cab8347a 100644
--- a/bindings/c/test/mako/logger.hpp
+++ b/bindings/c/test/mako/logger.hpp
@@ -61,7 +61,7 @@ public:
 	template <typename... Args>
 	void printWithLogLevel(int log_level, std::string_view header, Args&&... args) {
 		assert(log_level >= VERBOSE_NONE && log_level <= VERBOSE_DEBUG);
-		if (log_level >= verbosity) {
+		if (log_level <= verbosity) {
 			const auto fp = log_level == VERBOSE_NONE ? stderr : stdout;
 			// 500B inline buffer
 			auto buf = fmt::memory_buffer{};
@@ -83,7 +83,7 @@ public:
 
 	template <typename... Args>
 	void warn(Args&&... args) {
-		printWithLogLevel(VERBOSE_WARN, "WARN", std::forward<Args>(args)...);
+		printWithLogLevel(VERBOSE_WARN, "WARNING", std::forward<Args>(args)...);
 	}
 
 	template <typename... Args>
diff --git a/bindings/c/test/mako/mako.cpp b/bindings/c/test/mako/mako.cpp
index d3d04ee0fc..653e8dab22 100644
--- a/bindings/c/test/mako/mako.cpp
+++ b/bindings/c/test/mako/mako.cpp
@@ -1,5 +1,6 @@
-#include <cmath>
+
 #include <cassert>
+#include <cmath>
 #include <cstdint>
 #include <cstdio>
 #include <cstdlib>
@@ -29,6 +30,7 @@
 #include <limits.h>
 #endif
 
+#include <boost/asio.hpp>
 #include <fmt/format.h>
 #include <fmt/printf.h>
 #include <fdb.hpp>
@@ -41,13 +43,28 @@
 using namespace fdb;
 using namespace mako;
 
-const std::string KEY_PREFIX{ "mako" };
-const std::string TEMP_DATA_STORE{ "/tmp/makoTemp" };
-
 thread_local Logger logr = Logger(MainProcess{}, VERBOSE_DEFAULT);
 
 enum class FutureRC { OK, RETRY, CONFLICT, ABORT };
 
+template <class FutureType>
+FutureRC handleForOnError(Transaction tx, FutureType f, std::string_view step) {
+	if (auto err = f.error()) {
+		if (err.is(1020 /*not_committed*/)) {
+			return FutureRC::CONFLICT;
+		} else if (err.retryable()) {
+			logr.warn("Retryable error '{}' found at on_error(), step: {}", err.what(), step);
+			return FutureRC::RETRY;
+		} else {
+			logr.error("Unretryable error '{}' found at on_error(), step: {}", err.what(), step);
+			tx.reset();
+			return FutureRC::ABORT;
+		}
+	} else {
+		return FutureRC::RETRY;
+	}
+}
+
 template <class FutureType>
 FutureRC waitAndHandleForOnError(Transaction tx, FutureType f, std::string_view step) {
 	assert(f);
@@ -56,19 +73,7 @@ FutureRC waitAndHandleForOnError(Transaction tx, FutureType f, std::string_view
 		logr.error("'{}' found while waiting for on_error() future, step: {}", err.what(), step);
 		return FutureRC::ABORT;
 	}
-	if ((err = f.error())) {
-		if (err.is(1020 /*not_committed*/)) {
-			return FutureRC::CONFLICT;
-		} else if (err.retryable()) {
-			logr.warn("Retryable error '{}' found at on_error(), step: {}", err.what(), step);
-			return FutureRC::RETRY;
-		} else {
-			logr.error("Unretryable error '{}' found at on_error(), step: {}", err.what(), step);
-			return FutureRC::ABORT;
-		}
-	} else {
-		return FutureRC::RETRY;
-	}
+	return handleForOnError(tx, f, step);
 }
 
 // wait on any non-immediate tx-related step to complete. Follow up with on_error().
@@ -123,7 +128,7 @@ int cleanup(Transaction tx, Arguments const& args) {
 	}
 
 	tx.reset();
-	logr.info("Clear range: {:6.3f} sec\n", toDoubleSeconds(watch.stop().diff()));
+	logr.info("Clear range: {:6.3f} sec", toDoubleSeconds(watch.stop().diff()));
 	return 0;
 }
 
@@ -187,7 +192,7 @@ int populate(Transaction tx,
 
 		/* commit every 100 inserts (default) or if this is the last key */
 		if (i == key_end || (i - key_begin + 1) % num_commit_every == 0) {
-			const auto do_sample = (stats.getTaskCount() % args.sampling) == 0;
+			const auto do_sample = (stats.getOpCount(OP_TASK) % args.sampling) == 0;
 			auto watch_commit = Stopwatch(StartAtCtor{});
 			auto future_commit = tx.commit();
 			const auto rc = waitAndHandleError(tx, future_commit, "COMMIT_POPULATE_INSERT");
@@ -215,11 +220,11 @@ int populate(Transaction tx,
 			stats.incrOpCount(OP_COMMIT);
 			stats.incrOpCount(OP_TRANSACTION);
 
-			stats.incrTaskCount();
+			stats.incrOpCount(OP_TASK);
 			xacts++; /* for throttling */
 		}
 	}
-	logr.debug("Populated {} rows [{}, {}]: {:6.3f} sec\n",
+	logr.debug("Populated {} rows [{}, {}]: {:6.3f} sec",
 	           key_end - key_begin + 1,
 	           key_begin,
 	           key_end,
@@ -511,6 +516,7 @@ const std::array<Operation, MAX_OP> opTable{
 	    true },
 	  { "COMMIT", { { StepKind::NONE, nullptr } }, false },
 	  { "TRANSACTION", { { StepKind::NONE, nullptr } }, false },
+	  { "TASK", { { StepKind::NONE, nullptr } }, false },
 	  { "READBLOBGRANULE",
 	    { { StepKind::ON_ERROR,
 	        [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
@@ -564,13 +570,19 @@ const std::array<Operation, MAX_OP> opTable{
 	    false } }
 };
 
+char const* getOpName(int ops_code) {
+	if (ops_code >= 0 && ops_code < MAX_OP)
+		return opTable[ops_code].name().data();
+	return "";
+}
+
 using OpIterator = std::tuple<int /*op*/, int /*count*/, int /*step*/>;
 
 constexpr const OpIterator OpEnd = OpIterator(MAX_OP, -1, -1);
 
 OpIterator getOpBegin(Arguments const& args) noexcept {
 	for (auto op = 0; op < MAX_OP; op++) {
-		if (op == OP_COMMIT || op == OP_TRANSACTION || args.txnspec.ops[op][OP_COUNT] == 0)
+		if (isAbstractOp(op) || args.txnspec.ops[op][OP_COUNT] == 0)
 			continue;
 		return OpIterator(op, 0, 0);
 	}
@@ -581,12 +593,12 @@ OpIterator getOpNext(Arguments const& args, OpIterator current) noexcept {
 	if (OpEnd == current)
 		return OpEnd;
 	auto [op, count, step] = current;
-	assert(op < MAX_OP && op != OP_TRANSACTION && op != OP_COMMIT);
+	assert(op < MAX_OP && !isAbstractOp(op));
 	if (opTable[op].steps() > step + 1)
 		return OpIterator(op, count, step + 1);
 	count++;
 	for (; op < MAX_OP; op++, count = 0) {
-		if (op == OP_COMMIT || op == OP_TRANSACTION || args.txnspec.ops[op][OP_COUNT] <= count)
+		if (isAbstractOp(op) || args.txnspec.ops[op][OP_COUNT] <= count)
 			continue;
 		return OpIterator(op, count, 0);
 	}
@@ -594,10 +606,7 @@ OpIterator getOpNext(Arguments const& args, OpIterator current) noexcept {
 }
 
 /* run one transaction */
-int runOneTransaction(Transaction tx,
-                      Arguments const& args,
-                      ThreadStatistics& stats,
-                      LatencySampleBinArray& sample_bins) {
+int runOneTask(Transaction tx, Arguments const& args, ThreadStatistics& stats, LatencySampleBinArray& sample_bins) {
 	// reuse memory for keys to avoid realloc overhead
 	auto key1 = ByteString{};
 	key1.reserve(args.key_length);
@@ -607,11 +616,12 @@ int runOneTransaction(Transaction tx,
 	val.reserve(args.value_length);
 
 	auto watch_tx = Stopwatch(StartAtCtor{});
+	auto watch_task = Stopwatch(watch_tx.getStart());
 
 	auto op_iter = getOpBegin(args);
 	auto needs_commit = false;
 	auto watch_per_op = std::array<Stopwatch, MAX_OP>{};
-	const auto do_sample = (stats.getTaskCount() % args.sampling) == 0;
+	const auto do_sample = (stats.getOpCount(OP_TASK) % args.sampling) == 0;
 	while (op_iter != OpEnd) {
 		const auto [op, count, step] = op_iter;
 		const auto step_kind = opTable[op].stepKind(step);
@@ -625,10 +635,7 @@ int runOneTransaction(Transaction tx,
 			if (step_kind != StepKind::ON_ERROR) {
 				future_rc = waitAndHandleError(tx, f, opTable[op].name());
 			} else {
-				auto followup_rc = waitAndHandleForOnError(tx, f, opTable[op].name());
-				if (followup_rc == FutureRC::OK) {
-					future_rc = FutureRC::RETRY;
-				}
+				future_rc = waitAndHandleForOnError(tx, f, opTable[op].name());
 			}
 		}
 		watch_step.stop();
@@ -717,7 +724,13 @@ int runOneTransaction(Transaction tx,
 			needs_commit = false;
 		}
 	}
-	stats.incrTaskCount();
+	// one task iteration has completed successfully
+	const auto task_duration = watch_task.stop().diff();
+	if (stats.getOpCount(OP_TASK) % args.sampling == 0) {
+		sample_bins[OP_TASK].put(task_duration);
+		stats.addLatency(OP_TASK, task_duration);
+	}
+	stats.incrOpCount(OP_TASK);
 	/* make sure to reset transaction */
 	tx.reset();
 	return 0;
@@ -803,13 +816,13 @@ int runWorkload(Transaction tx,
 			}
 		}
 
-		rc = runOneTransaction(tx, args, stats, sample_bins);
+		rc = runOneTask(tx, args, stats, sample_bins);
 		if (rc) {
-			logr.warn("runOneTransaction failed ({})", rc);
+			logr.warn("runOneTask failed ({})", rc);
 		}
 
-		if (thread_iters > 0) {
-			if (thread_iters == xacts) {
+		if (thread_iters != -1) {
+			if (thread_iters >= xacts) {
 				/* xact limit reached */
 				break;
 			}
@@ -828,6 +841,474 @@ std::string getStatsFilename(std::string_view dirname, int worker_id, int thread
 	return fmt::format("{}/{}_{}_{}", dirname, worker_id + 1, thread_id + 1, opTable[op].name());
 }
 
+void dumpThreadSamples(Arguments const& args,
+                       pid_t parent_id,
+                       int worker_id,
+                       int thread_id,
+                       const LatencySampleBinArray& sample_bins,
+                       bool overwrite = true) {
+	const auto dirname = fmt::format("{}{}", TEMP_DATA_STORE, parent_id);
+	const auto rc = mkdir(dirname.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
+	if (rc < 0 && errno != EEXIST) {
+		logr.error("mkdir {}: {}", dirname, strerror(errno));
+		return;
+	}
+	for (auto op = 0; op < MAX_OP; op++) {
+		if (args.txnspec.ops[op][OP_COUNT] > 0 || isAbstractOp(op)) {
+			const auto filename = getStatsFilename(dirname, worker_id, thread_id, op);
+			auto fp = fopen(filename.c_str(), overwrite ? "w" : "a");
+			if (!fp) {
+				logr.error("fopen({}): {}", filename, strerror(errno));
+				continue;
+			}
+			auto fclose_guard = ExitGuard([fp]() { fclose(fp); });
+			sample_bins[op].forEachBlock([fp](auto ptr, auto count) { fwrite(ptr, sizeof(*ptr) * count, 1, fp); });
+		}
+	}
+}
+
+// as we don't have coroutines yet, we need to store in heap the complete state of execution,
+// such that we can reconstruct and resume exactly where we were from last database op.
+struct ResumableStateForPopulate {
+	Logger logr;
+	Database db;
+	Transaction tx;
+	boost::asio::io_context& io_context;
+	Arguments const& args;
+	ThreadStatistics& stats;
+	std::atomic<int>& stopcount;
+	LatencySampleBinArray sample_bins;
+	int key_begin;
+	int key_end;
+	int key_checkpoint;
+	ByteString keystr;
+	ByteString valstr;
+	Stopwatch watch_tx;
+	Stopwatch watch_commit;
+	Stopwatch watch_total;
+};
+
+using PopulateStateHandle = std::shared_ptr<ResumableStateForPopulate>;
+
+// avoid redeclaring each variable for each continuation after async op
+#define UNPACK_RESUMABLE_STATE_FOR_POPULATE(p_state)                                                                   \
+	[[maybe_unused]] auto& [logr,                                                                                      \
+	                        db,                                                                                        \
+	                        tx,                                                                                        \
+	                        io_context,                                                                                \
+	                        args,                                                                                      \
+	                        stats,                                                                                     \
+	                        stopcount,                                                                                 \
+	                        sample_bins,                                                                               \
+	                        key_begin,                                                                                 \
+	                        key_end,                                                                                   \
+	                        key_checkpoint,                                                                            \
+	                        keystr,                                                                                    \
+	                        valstr,                                                                                    \
+	                        watch_tx,                                                                                  \
+	                        watch_commit,                                                                              \
+	                        watch_total] = *p_state
+
+void resumablePopulate(PopulateStateHandle state) {
+	UNPACK_RESUMABLE_STATE_FOR_POPULATE(state);
+	const auto num_commit_every = args.txnspec.ops[OP_INSERT][OP_COUNT];
+	for (auto i = key_checkpoint; i <= key_end; i++) {
+		genKey(keystr, KEY_PREFIX, args, i);
+		randomString(valstr, args.value_length);
+		tx.set(keystr, valstr);
+		stats.incrOpCount(OP_INSERT);
+		if (i == key_end || (i - key_begin + 1) % num_commit_every == 0) {
+			watch_commit.start();
+			auto f = tx.commit();
+			f.then([state, i](Future f) {
+				UNPACK_RESUMABLE_STATE_FOR_POPULATE(state);
+				if (auto err = f.error()) {
+					logr.printWithLogLevel(err.retryable() ? VERBOSE_WARN : VERBOSE_NONE,
+					                       "ERROR",
+					                       "commit for populate returned '{}'",
+					                       err.what());
+					auto err_f = tx.onError(err);
+					err_f.then([state](Future f) {
+						UNPACK_RESUMABLE_STATE_FOR_POPULATE(state);
+						const auto f_rc = handleForOnError(tx, f, "ON_ERROR_FOR_POPULATE");
+						if (f_rc == FutureRC::ABORT) {
+							stopcount.fetch_add(1);
+							return;
+						} else {
+							boost::asio::post(io_context, [state]() { resumablePopulate(state); });
+						}
+					});
+				} else {
+					// successfully committed
+					watch_commit.stop();
+					watch_tx.setStop(watch_commit.getStop());
+					if (stats.getOpCount(OP_TASK) % args.sampling == 0) {
+						const auto commit_latency = watch_commit.diff();
+						const auto tx_duration = watch_tx.diff();
+						stats.addLatency(OP_COMMIT, commit_latency);
+						stats.addLatency(OP_TRANSACTION, tx_duration);
+						stats.addLatency(OP_TASK, tx_duration);
+						sample_bins[OP_COMMIT].put(commit_latency);
+						sample_bins[OP_TRANSACTION].put(tx_duration);
+						sample_bins[OP_TASK].put(tx_duration);
+					}
+					stats.incrOpCount(OP_COMMIT);
+					stats.incrOpCount(OP_TRANSACTION);
+					stats.incrOpCount(OP_TASK);
+					tx.reset();
+					watch_tx.startFromStop();
+					key_checkpoint = i + 1;
+					if (i != key_end) {
+						boost::asio::post(io_context, [state]() { resumablePopulate(state); });
+					} else {
+						logr.debug("Populated {} rows [{}, {}]: {:6.3f} sec",
+						           key_end - key_begin + 1,
+						           key_begin,
+						           key_end,
+						           toDoubleSeconds(watch_total.stop().diff()));
+						stopcount.fetch_add(1);
+						return;
+					}
+				}
+			});
+			break;
+		}
+	}
+}
+
+struct ResumableStateForRunWorkload {
+	Logger logr;
+	Database db;
+	Transaction tx;
+	boost::asio::io_context& io_context;
+	Arguments const& args;
+	ThreadStatistics& stats;
+	std::atomic<int>& stopcount;
+	std::atomic<int> const& signal;
+	int max_iters;
+	OpIterator op_iter;
+	LatencySampleBinArray sample_bins;
+	ByteString key1;
+	ByteString key2;
+	ByteString val;
+	std::array<Stopwatch, MAX_OP> watch_per_op;
+	Stopwatch watch_step;
+	Stopwatch watch_commit;
+	Stopwatch watch_tx;
+	Stopwatch watch_task;
+	bool needs_commit;
+	void signalEnd() noexcept { stopcount.fetch_add(1); }
+	bool ended() noexcept {
+		return (max_iters != -1 && max_iters >= stats.getOpCount(OP_TASK)) || signal.load() == SIGNAL_RED;
+	}
+};
+
+using RunWorkloadStateHandle = std::shared_ptr<ResumableStateForRunWorkload>;
+
+#define UNPACK_RESUMABLE_STATE_FOR_RUN_WORKLOAD(p_state)                                                               \
+	[[maybe_unused]] auto& [logr,                                                                                      \
+	                        db,                                                                                        \
+	                        tx,                                                                                        \
+	                        io_context,                                                                                \
+	                        args,                                                                                      \
+	                        stats,                                                                                     \
+	                        stopcount,                                                                                 \
+	                        signal,                                                                                    \
+	                        max_iters,                                                                                 \
+	                        op_iter,                                                                                   \
+	                        sample_bins,                                                                               \
+	                        key1,                                                                                      \
+	                        key2,                                                                                      \
+	                        val,                                                                                       \
+	                        watch_per_op,                                                                              \
+	                        watch_step,                                                                                \
+	                        watch_commit,                                                                              \
+	                        watch_tx,                                                                                  \
+	                        watch_task,                                                                                \
+	                        needs_commit] = *p_state;                                                                  \
+	[[maybe_unused]] auto& [op, count, step] = op_iter;                                                                \
+	[[maybe_unused]] const auto step_kind = opTable[op].stepKind(step)
+
+void resumableRunWorkload(RunWorkloadStateHandle state);
+
+void onStepSuccess(RunWorkloadStateHandle state) {
+	UNPACK_RESUMABLE_STATE_FOR_RUN_WORKLOAD(state);
+	logr.debug("Step {}:{} succeeded", getOpName(op), step);
+	// step successful
+	watch_step.stop();
+	const auto do_sample = stats.getOpCount(OP_TASK) % args.sampling == 0;
+	if (step_kind == StepKind::COMMIT) {
+		// reset transaction boundary
+		const auto step_latency = watch_step.diff();
+		watch_tx.setStop(watch_step.getStop());
+		if (do_sample) {
+			const auto tx_duration = watch_tx.diff();
+			stats.addLatency(OP_COMMIT, step_latency);
+			stats.addLatency(OP_TRANSACTION, tx_duration);
+			sample_bins[OP_COMMIT].put(step_latency);
+			sample_bins[OP_TRANSACTION].put(tx_duration);
+		}
+		tx.reset();
+		watch_tx.startFromStop();
+		stats.incrOpCount(OP_COMMIT);
+		stats.incrOpCount(OP_TRANSACTION);
+		needs_commit = false;
+	}
+	// op completed successfully
+	if (step + 1 == opTable[op].steps()) {
+		if (opTable[op].needsCommit())
+			needs_commit = true;
+		watch_per_op[op].setStop(watch_step.getStop());
+		if (do_sample) {
+			const auto op_latency = watch_per_op[op].diff();
+			stats.addLatency(op, op_latency);
+			sample_bins[op].put(op_latency);
+		}
+		stats.incrOpCount(op);
+	}
+	op_iter = getOpNext(args, op_iter);
+	if (op_iter == OpEnd) {
+		if (needs_commit || args.commit_get) {
+			// task completed, need to commit before finish
+			watch_commit.start();
+			auto f = tx.commit().eraseType();
+			f.then([state](Future f) {
+				UNPACK_RESUMABLE_STATE_FOR_RUN_WORKLOAD(state);
+				if (auto err = f.error()) {
+					// commit had errors
+					logr.printWithLogLevel(err.retryable() ? VERBOSE_WARN : VERBOSE_NONE,
+					                       "ERROR",
+					                       "Post-iteration commit returned error: {}",
+					                       err.what());
+					tx.onError(err).then([state](Future f) {
+						UNPACK_RESUMABLE_STATE_FOR_RUN_WORKLOAD(state);
+						const auto rc = handleForOnError(tx, f, "ON_ERROR");
+						if (rc == FutureRC::CONFLICT)
+							stats.incrConflictCount();
+						else
+							stats.incrErrorCount(OP_COMMIT);
+						if (rc == FutureRC::ABORT) {
+							state->signalEnd();
+							return;
+						}
+						op_iter = getOpBegin(args);
+						needs_commit = false;
+						boost::asio::post(io_context, [state]() { resumableRunWorkload(state); });
+					});
+				} else {
+					// commit successful
+					watch_commit.stop();
+					watch_tx.setStop(watch_commit.getStop());
+					watch_task.setStop(watch_commit.getStop());
+					if (stats.getOpCount(OP_TASK) % args.sampling == 0) {
+						const auto commit_latency = watch_commit.diff();
+						const auto tx_duration = watch_tx.diff();
+						const auto task_duration = watch_task.diff();
+						stats.addLatency(OP_COMMIT, commit_latency);
+						stats.addLatency(OP_TRANSACTION, commit_latency);
+						stats.addLatency(OP_TASK, task_duration);
+						sample_bins[OP_COMMIT].put(commit_latency);
+						sample_bins[OP_TRANSACTION].put(tx_duration);
+						sample_bins[OP_TASK].put(task_duration);
+					}
+					stats.incrOpCount(OP_COMMIT);
+					stats.incrOpCount(OP_TRANSACTION);
+					stats.incrOpCount(OP_TASK);
+					tx.reset();
+					watch_tx.startFromStop();
+					watch_task.startFromStop();
+					if (state->ended()) {
+						state->signalEnd();
+						return;
+					}
+					// start next iteration
+					op_iter = getOpBegin(args);
+					boost::asio::post(io_context, [state]() { resumableRunWorkload(state); });
+				}
+			});
+		} else {
+			// task completed but no need to commit
+			watch_task.stop();
+			if (stats.getOpCount(OP_TASK) % args.sampling == 0) {
+				const auto task_duration = watch_task.diff();
+				stats.addLatency(OP_TASK, task_duration);
+				sample_bins[OP_TASK].put(task_duration);
+			}
+			stats.incrOpCount(OP_TASK);
+			watch_tx.startFromStop();
+			watch_task.startFromStop();
+			tx.reset();
+			if (state->ended()) {
+				state->signalEnd();
+				return;
+			}
+			op_iter = getOpBegin(args);
+			// run next iteration
+			boost::asio::post(io_context, [state]() { resumableRunWorkload(state); });
+		}
+	} else {
+		boost::asio::post(io_context, [state]() { resumableRunWorkload(state); });
+	}
+}
+
+void resumableRunWorkload(RunWorkloadStateHandle state) {
+	UNPACK_RESUMABLE_STATE_FOR_RUN_WORKLOAD(state);
+	assert(op_iter != OpEnd);
+	watch_step.start();
+	if (step == 0 /* first step */) {
+		watch_per_op[op] = Stopwatch(watch_step.getStart());
+	}
+	auto f = opTable[op].stepFunction(step)(tx, args, key1, key2, val);
+	if (!f) {
+		// immediately completed client-side ops: e.g. set, setrange, clear, clearrange, ...
+		onStepSuccess(state);
+	} else {
+		f.then([state](Future f) {
+			UNPACK_RESUMABLE_STATE_FOR_RUN_WORKLOAD(state);
+			if (step_kind != StepKind::ON_ERROR) {
+				if (auto err = f.error()) {
+					logr.printWithLogLevel(err.retryable() ? VERBOSE_WARN : VERBOSE_NONE,
+					                       "ERROR",
+					                       "step {} of op {} returned '{}'",
+					                       step,
+					                       opTable[op].name(),
+					                       err.what());
+					tx.onError(err).then([state](Future f) {
+						UNPACK_RESUMABLE_STATE_FOR_RUN_WORKLOAD(state);
+						const auto rc = handleForOnError(tx, f, fmt::format("{}_STEP_{}", opTable[op].name(), step));
+						if (rc == FutureRC::RETRY) {
+							stats.incrErrorCount(op);
+						} else if (rc == FutureRC::CONFLICT) {
+							stats.incrConflictCount();
+						} else if (rc == FutureRC::ABORT) {
+							tx.reset();
+							stopcount.fetch_add(1);
+							return;
+						}
+						op_iter = getOpBegin(args);
+						needs_commit = false;
+						// restart this iteration from beginning
+						boost::asio::post(io_context, [state]() { resumableRunWorkload(state); });
+					});
+					return;
+				}
+			} else {
+				auto rc = handleForOnError(tx, f, "BG_ON_ERROR");
+				if (rc == FutureRC::RETRY) {
+					stats.incrErrorCount(op);
+				} else if (rc == FutureRC::CONFLICT) {
+					stats.incrConflictCount();
+				} else if (rc == FutureRC::ABORT) {
+					tx.reset();
+					stopcount.fetch_add(1);
+					return;
+				}
+				op_iter = getOpBegin(args);
+				needs_commit = false;
+				// restart this iteration from beginning
+				boost::asio::post(io_context, [state]() { resumableRunWorkload(state); });
+				return;
+			}
+			onStepSuccess(state);
+		});
+	}
+}
+
+void runAsyncWorkload(Arguments const& args,
+                      pid_t pid_main,
+                      int worker_id,
+                      shared_memory::Access shm,
+                      boost::asio::io_context& io_context,
+                      std::vector<Database>& databases) {
+	auto dump_samples = [&args, pid_main, worker_id](auto&& states) {
+		auto overwrite = true; /* overwrite or append */
+		for (const auto& state : states) {
+			dumpThreadSamples(args, pid_main, worker_id, 0 /*thread_id*/, state->sample_bins, overwrite);
+			overwrite = false;
+		}
+	};
+	std::atomic<int> stopcount = ATOMIC_VAR_INIT(0);
+	if (args.mode == MODE_BUILD) {
+		auto states = std::vector<PopulateStateHandle>(args.async_xacts);
+		for (auto i = 0; i < args.async_xacts; i++) {
+			const auto key_begin = insertBegin(args.rows, worker_id, i, args.num_processes, args.async_xacts);
+			const auto key_end = insertEnd(args.rows, worker_id, i, args.num_processes, args.async_xacts);
+			auto db = databases[i % args.num_databases];
+			auto state =
+			    PopulateStateHandle(new ResumableStateForPopulate{ Logger(WorkerProcess{}, args.verbose, worker_id, i),
+			                                                       db,
+			                                                       db.createTransaction(),
+			                                                       io_context,
+			                                                       args,
+			                                                       shm.statsSlot(worker_id, i),
+			                                                       stopcount,
+			                                                       LatencySampleBinArray(),
+			                                                       key_begin,
+			                                                       key_end,
+			                                                       key_begin,
+			                                                       ByteString{},
+			                                                       ByteString{},
+			                                                       Stopwatch(StartAtCtor{}),
+			                                                       Stopwatch(),
+			                                                       Stopwatch(StartAtCtor{}) });
+			states[i] = state;
+			state->keystr.reserve(args.key_length);
+			state->valstr.reserve(args.value_length);
+		}
+		while (shm.headerConst().signal.load() != SIGNAL_GREEN)
+			usleep(1000);
+		// launch [async_xacts] concurrent transactions
+		for (auto state : states)
+			boost::asio::post(io_context, [state]() { resumablePopulate(state); });
+		while (stopcount.load() != args.async_xacts)
+			usleep(1000);
+		dump_samples(states);
+	} else if (args.mode == MODE_RUN) {
+		auto states = std::vector<RunWorkloadStateHandle>(args.async_xacts);
+		for (auto i = 0; i < args.async_xacts; i++) {
+			auto db = databases[i % args.num_databases];
+			const auto max_iters =
+			    args.iteration == 0
+			        ? -1
+			        : computeThreadIters(args.iteration, worker_id, i, args.num_processes, args.async_xacts);
+			auto state = RunWorkloadStateHandle(
+			    new ResumableStateForRunWorkload{ Logger(WorkerProcess{}, args.verbose, worker_id, i),
+			                                      db,
+			                                      db.createTransaction(),
+			                                      io_context,
+			                                      args,
+			                                      shm.statsSlot(worker_id, i),
+			                                      stopcount,
+			                                      shm.headerConst().signal,
+			                                      max_iters,
+			                                      getOpBegin(args),
+			                                      LatencySampleBinArray(),
+			                                      ByteString{},
+			                                      ByteString{},
+			                                      ByteString{},
+			                                      std::array<Stopwatch, MAX_OP>{},
+			                                      Stopwatch() /*watch_step*/,
+			                                      Stopwatch() /*watch_commit*/,
+			                                      Stopwatch(StartAtCtor{}) /*watch_tx*/,
+			                                      Stopwatch(StartAtCtor{}) /*watch_task*/,
+			                                      false /*needs_commit*/ });
+			states[i] = state;
+			state->key1.reserve(args.key_length);
+			state->key2.reserve(args.key_length);
+			state->val.reserve(args.value_length);
+		}
+		while (shm.headerConst().signal.load() != SIGNAL_GREEN)
+			usleep(1000);
+		for (auto state : states)
+			boost::asio::post(io_context, [state]() { resumableRunWorkload(state); });
+		logr.debug("Launched {} concurrent transactions", states.size());
+		while (stopcount.load() != args.async_xacts)
+			usleep(1000);
+		logr.debug("All transactions completed");
+		dump_samples(states);
+	}
+}
+
 /* mako worker thread */
 void workerThread(ThreadArgs& thread_args) {
 	const auto& args = *thread_args.args;
@@ -855,7 +1336,7 @@ void workerThread(ThreadArgs& thread_args) {
 
 	const auto thread_iters =
 	    args.iteration == 0
-	        ? 0
+	        ? -1
 	        : computeThreadIters(args.iteration, worker_id, thread_id, args.num_processes, args.num_threads);
 
 	/* create my own transaction object */
@@ -889,25 +1370,7 @@ void workerThread(ThreadArgs& thread_args) {
 	}
 
 	if (args.mode == MODE_BUILD || args.mode == MODE_RUN) {
-		const auto dirname = fmt::format("{}{}", TEMP_DATA_STORE, parent_id);
-		const auto rc = mkdir(dirname.c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
-		if (rc < 0 && errno != EEXIST) {
-			logr.error("mkdir {}: {}", dirname, strerror(errno));
-			return;
-		}
-		for (auto op = 0; op < MAX_OP; op++) {
-			if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_COMMIT || op == OP_TRANSACTION) {
-				const auto filename = getStatsFilename(dirname, worker_id, thread_id, op);
-				auto fp = fopen(filename.c_str(), "w");
-				if (!fp) {
-					logr.error("fopen({}): {}", filename, strerror(errno));
-					continue;
-				}
-				auto fclose_guard = ExitGuard([fp]() { fclose(fp); });
-				thread_args.sample_bins[op].forEachBlock(
-				    [fp](auto ptr, auto count) { fwrite(ptr, sizeof(*ptr) * count, 1, fp); });
-			}
-		}
+		dumpThreadSamples(args, parent_id, worker_id, thread_id, sample_bins);
 	}
 }
 
@@ -934,7 +1397,7 @@ int workerProcessMain(Arguments const& args, int worker_id, shared_memory::Acces
 #endif
 	}
 
-	/* Set client Log group */
+	/* Set client logr group */
 	if (args.log_group[0] != '\0') {
 		err = network::setOptionNothrow(FDB_NET_OPTION_TRACE_LOG_GROUP, BytesRef(toBytePtr(args.log_group)));
 		if (err) {
@@ -980,7 +1443,7 @@ int workerProcessMain(Arguments const& args, int worker_id, shared_memory::Acces
 	if (args.client_threads_per_version > 0) {
 		err = network::setOptionNothrow(FDB_NET_OPTION_CLIENT_THREADS_PER_VERSION, args.client_threads_per_version);
 		if (err) {
-			logr.error("network::setOption (FDB_NET_OPTION_CLIENT_THREADS_PER_VERSION) ({}): {}\n",
+			logr.error("network::setOption (FDB_NET_OPTION_CLIENT_THREADS_PER_VERSION) ({}): {}",
 			           args.client_threads_per_version,
 			           err.what());
 			// let's exit here since we do not want to confuse users
@@ -995,7 +1458,8 @@ int workerProcessMain(Arguments const& args, int worker_id, shared_memory::Acces
 
 	/* Each worker process will have its own network thread */
 	logr.debug("creating network thread");
-	auto network_thread = std::thread([]() {
+	auto network_thread = std::thread([parent_logr = logr]() {
+		logr = parent_logr;
 		logr.debug("network thread started");
 		if (auto err = network::run()) {
 			logr.error("network::run(): {}", err.what());
@@ -1015,36 +1479,55 @@ int workerProcessMain(Arguments const& args, int worker_id, shared_memory::Acces
 		}
 	}
 
-	logr.debug("creating {} worker threads", args.num_threads);
-	auto worker_threads = std::vector<std::thread>(args.num_threads);
+	if (!args.async_xacts) {
+		logr.debug("creating {} worker threads", args.num_threads);
+		auto worker_threads = std::vector<std::thread>(args.num_threads);
 
-	/* spawn worker threads */
-	auto thread_args = std::vector<ThreadArgs>(args.num_threads);
+		/* spawn worker threads */
+		auto thread_args = std::vector<ThreadArgs>(args.num_threads);
 
-	for (auto i = 0; i < args.num_threads; i++) {
-		auto& this_args = thread_args[i];
-		this_args.worker_id = worker_id;
-		this_args.thread_id = i;
-		this_args.parent_id = pid_main;
-		this_args.args = &args;
-		this_args.shm = shm;
-		this_args.database = databases[i % args.num_databases];
+		for (auto i = 0; i < args.num_threads; i++) {
+			auto& this_args = thread_args[i];
+			this_args.worker_id = worker_id;
+			this_args.thread_id = i;
+			this_args.parent_id = pid_main;
+			this_args.args = &args;
+			this_args.shm = shm;
+			this_args.database = databases[i % args.num_databases];
 
-		/* for ops to run, pre-allocate one latency sample block */
-		for (auto op = 0; op < MAX_OP; op++) {
-			if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-				this_args.sample_bins[op].reserveOneBlock();
+			/* for ops to run, pre-allocate one latency sample block */
+			for (auto op = 0; op < MAX_OP; op++) {
+				if (args.txnspec.ops[op][OP_COUNT] > 0 || isAbstractOp(op)) {
+					this_args.sample_bins[op].reserveOneBlock();
+				}
 			}
+			worker_threads[i] = std::thread(workerThread, std::ref(this_args));
 		}
-		worker_threads[i] = std::thread(workerThread, std::ref(this_args));
-	}
-
-	/*** party is over ***/
-
-	/* wait for everyone to finish */
-	for (auto i = 0; i < args.num_threads; i++) {
-		logr.debug("waiting for worker thread {} to join", i + 1);
-		worker_threads[i].join();
+		/* wait for everyone to finish */
+		for (auto i = 0; i < args.num_threads; i++) {
+			logr.debug("waiting for worker thread {} to join", i + 1);
+			worker_threads[i].join();
+		}
+	} else {
+		logr.debug("running async mode with {} concurrent transactions", args.async_xacts);
+		boost::asio::io_context ctx;
+		using WorkGuard = boost::asio::executor_work_guard<boost::asio::io_context::executor_type>;
+		auto wg = WorkGuard(ctx.get_executor());
+		auto worker_threads = std::vector<std::thread>(args.num_threads);
+		for (auto i = 0; i < args.num_threads; i++) {
+			worker_threads[i] = std::thread([&ctx, &args, worker_id, i]() {
+				logr = Logger(WorkerProcess{}, args.verbose, worker_id);
+				logr.debug("Async-mode worker thread {} started", i + 1);
+				ctx.run();
+				logr.debug("Async-mode worker thread {} finished", i + 1);
+			});
+		}
+		shm.header().readycount.fetch_add(args.num_threads);
+		runAsyncWorkload(args, pid_main, worker_id, shm, ctx, databases);
+		wg.reset();
+		for (auto& thread : worker_threads)
+			thread.join();
+		shm.header().stopcount.fetch_add(args.num_threads);
 	}
 
 	/* stop the network thread */
@@ -1070,6 +1553,7 @@ int initArguments(Arguments& args) {
 	args.json = 0;
 	args.num_processes = 1;
 	args.num_threads = 1;
+	args.async_xacts = 0;
 	args.mode = MODE_INVALID;
 	args.rows = 100000;
 	args.row_digits = digits(args.rows);
@@ -1243,6 +1727,7 @@ void usage() {
 	printf("%-24s %s\n", "-d, --num_databases=NUM_DATABASES", "Specify number of databases");
 	printf("%-24s %s\n", "-p, --procs=PROCS", "Specify number of worker processes");
 	printf("%-24s %s\n", "-t, --threads=THREADS", "Specify number of worker threads");
+	printf("%-24s %s\n", "    --async_xacts", "Specify number of concurrent transactions to be run in async mode");
 	printf("%-24s %s\n", "-r, --rows=ROWS", "Specify number of records");
 	printf("%-24s %s\n", "-s, --seconds=SECONDS", "Specify the test duration in seconds\n");
 	printf("%-24s %s\n", "", "This option cannot be specified with --iteration.");
@@ -1294,6 +1779,7 @@ int parseArguments(int argc, char* argv[], Arguments& args) {
 			{ "num_databases", optional_argument, NULL, 'd' },
 			{ "procs", required_argument, NULL, 'p' },
 			{ "threads", required_argument, NULL, 't' },
+			{ "async_xacts", required_argument, NULL, ARG_ASYNC },
 			{ "rows", required_argument, NULL, 'r' },
 			{ "seconds", required_argument, NULL, 's' },
 			{ "iteration", required_argument, NULL, 'i' },
@@ -1391,6 +1877,9 @@ int parseArguments(int argc, char* argv[], Arguments& args) {
 				args.mode = MODE_RUN;
 			}
 			break;
+		case ARG_ASYNC:
+			args.async_xacts = atoi(optarg);
+			break;
 		case ARG_KEYLEN:
 			args.key_length = atoi(optarg);
 			break;
@@ -1423,7 +1912,7 @@ int parseArguments(int argc, char* argv[], Arguments& args) {
 			args.sampling = atoi(optarg);
 			break;
 		case ARG_VERSION:
-			logr.error("Version: {}\n", FDB_API_VERSION);
+			logr.error("Version: {}", FDB_API_VERSION);
 			exit(0);
 			break;
 		case ARG_COMMITGET:
@@ -1454,7 +1943,7 @@ int parseArguments(int argc, char* argv[], Arguments& args) {
 			} else if (strncmp(optarg, "xml", 4) == 0) {
 				args.traceformat = 0;
 			} else {
-				logr.error("Invalid trace_format {}\n", optarg);
+				logr.error("Invalid trace_format {}", optarg);
 				return -1;
 			}
 			break;
@@ -1522,12 +2011,6 @@ int parseArguments(int argc, char* argv[], Arguments& args) {
 	return 0;
 }
 
-char const* getOpName(int ops_code) {
-	if (ops_code >= 0 && ops_code < MAX_OP)
-		return opTable[ops_code].name().data();
-	return "";
-}
-
 int validateArguments(Arguments const& args) {
 	if (args.mode == MODE_INVALID) {
 		logr.error("--mode has to be set");
@@ -1591,10 +2074,11 @@ int validateArguments(Arguments const& args) {
 void printStats(Arguments const& args, ThreadStatistics const* stats, double const duration_sec, FILE* fp) {
 	static ThreadStatistics prev;
 
+	const auto num_effective_threads = args.async_xacts > 0 ? args.async_xacts : args.num_threads;
 	auto current = ThreadStatistics{};
 	for (auto i = 0; i < args.num_processes; i++) {
 		for (auto j = 0; j < args.num_threads; j++) {
-			current.combine(stats[(i * args.num_threads) + j]);
+			current.combine(stats[(i * num_effective_threads) + j]);
 		}
 	}
 
@@ -1614,7 +2098,7 @@ void printStats(Arguments const& args, ThreadStatistics const* stats, double con
 		}
 	}
 	/* TPS */
-	const auto tps = (current.getTaskCount() - prev.getTaskCount()) / duration_sec;
+	const auto tps = (current.getOpCount(OP_TASK) - prev.getOpCount(OP_TASK)) / duration_sec;
 	putFieldFloat(tps, 2);
 	if (fp) {
 		fprintf(fp, "\"tps\": %.2f,", tps);
@@ -1699,24 +2183,26 @@ void printReport(Arguments const& args,
                  FILE* fp) {
 
 	auto final_stats = ThreadStatistics{};
+	const auto num_effective_threads = args.async_xacts > 0 ? args.async_xacts : args.num_threads;
 	for (auto i = 0; i < args.num_processes; i++) {
-		for (auto j = 0; j < args.num_threads; j++) {
-			const auto idx = i * args.num_threads + j;
+		for (auto j = 0; j < num_effective_threads; j++) {
+			const auto idx = i * num_effective_threads + j;
 			final_stats.combine(stats[idx]);
 		}
 	}
 
 	/* overall stats */
 	fmt::printf("\n====== Total Duration %6.3f sec ======\n\n", duration_sec);
-	fmt::printf("Total Processes:  %8d\n", args.num_processes);
-	fmt::printf("Total Threads:    %8d\n", args.num_threads);
+	fmt::printf("Total Processes:   %8d\n", args.num_processes);
+	fmt::printf("Total Threads:     %8d\n", args.num_threads);
+	fmt::printf("Total Async Xacts: %8d\n", args.async_xacts);
 	if (args.tpsmax == args.tpsmin)
-		fmt::printf("Target TPS:       %8d\n", args.tpsmax);
+		fmt::printf("Target TPS:        %8d\n", args.tpsmax);
 	else {
-		fmt::printf("Target TPS (MAX): %8d\n", args.tpsmax);
-		fmt::printf("Target TPS (MIN): %8d\n", args.tpsmin);
-		fmt::printf("TPS Interval:     %8d\n", args.tpsinterval);
-		fmt::printf("TPS Change:       ");
+		fmt::printf("Target TPS (MAX):  %8d\n", args.tpsmax);
+		fmt::printf("Target TPS (MIN):  %8d\n", args.tpsmin);
+		fmt::printf("TPS Interval:      %8d\n", args.tpsinterval);
+		fmt::printf("TPS Change:        ");
 		switch (args.tpschange) {
 		case TPS_SIN:
 			fmt::printf("%8s\n", "SIN");
@@ -1729,20 +2215,21 @@ void printReport(Arguments const& args,
 			break;
 		}
 	}
-	const auto tps_f = final_stats.getTaskCount() / duration_sec;
+	const auto tps_f = final_stats.getOpCount(OP_TASK) / duration_sec;
 	const auto tps_i = static_cast<uint64_t>(tps_f);
-	fmt::printf("Total Xacts:      %8lu\n", final_stats.getTaskCount());
-	fmt::printf("Total Conflicts:  %8lu\n", final_stats.getConflictCount());
-	fmt::printf("Total Errors:     %8lu\n", final_stats.getTotalErrorCount());
-	fmt::printf("Overall TPS:      %8lu\n\n", tps_i);
+	fmt::printf("Total Xacts:       %8lu\n", final_stats.getOpCount(OP_TASK));
+	fmt::printf("Total Conflicts:   %8lu\n", final_stats.getConflictCount());
+	fmt::printf("Total Errors:      %8lu\n", final_stats.getTotalErrorCount());
+	fmt::printf("Overall TPS:       %8lu\n\n", tps_i);
 
 	if (fp) {
 		fmt::fprintf(fp, "\"results\": {");
 		fmt::fprintf(fp, "\"totalDuration\": %6.3f,", duration_sec);
 		fmt::fprintf(fp, "\"totalProcesses\": %d,", args.num_processes);
 		fmt::fprintf(fp, "\"totalThreads\": %d,", args.num_threads);
+		fmt::fprintf(fp, "\"totalAsyncXacts\": %d,", args.async_xacts);
 		fmt::fprintf(fp, "\"targetTPS\": %d,", args.tpsmax);
-		fmt::fprintf(fp, "\"totalXacts\": %lu,", final_stats.getTaskCount());
+		fmt::fprintf(fp, "\"totalXacts\": %lu,", final_stats.getOpCount(OP_TASK));
 		fmt::fprintf(fp, "\"totalConflicts\": %lu,", final_stats.getConflictCount());
 		fmt::fprintf(fp, "\"totalErrors\": %lu,", final_stats.getTotalErrorCount());
 		fmt::fprintf(fp, "\"overallTPS\": %lu,", tps_i);
@@ -1758,7 +2245,7 @@ void printReport(Arguments const& args,
 	}
 	auto first_op = true;
 	for (auto op = 0; op < MAX_OP; op++) {
-		if ((args.txnspec.ops[op][OP_COUNT] > 0 && op != OP_TRANSACTION) || op == OP_COMMIT) {
+		if ((args.txnspec.ops[op][OP_COUNT] > 0 && op != OP_TASK && op != OP_TRANSACTION) || op == OP_COMMIT) {
 			putField(final_stats.getOpCount(op));
 			if (fp) {
 				if (first_op) {
@@ -1772,7 +2259,7 @@ void printReport(Arguments const& args,
 	}
 
 	/* TPS */
-	const auto tps = final_stats.getTaskCount() / duration_sec;
+	const auto tps = final_stats.getOpCount(OP_TASK) / duration_sec;
 	putFieldFloat(tps, 2);
 
 	/* Conflicts */
@@ -1812,7 +2299,7 @@ void printReport(Arguments const& args,
 	putTitle("Samples");
 	first_op = 1;
 	for (auto op = 0; op < MAX_OP; op++) {
-		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
+		if (args.txnspec.ops[op][OP_COUNT] > 0 || isAbstractOp(op)) {
 			if (final_stats.getLatencyUsTotal(op)) {
 				putField(final_stats.getLatencySampleCount(op));
 			} else {
@@ -1837,7 +2324,7 @@ void printReport(Arguments const& args,
 	putTitle("Min");
 	first_op = 1;
 	for (auto op = 0; op < MAX_OP; op++) {
-		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
+		if (args.txnspec.ops[op][OP_COUNT] > 0 || isAbstractOp(op)) {
 			const auto lat_min = final_stats.getLatencyUsMin(op);
 			if (lat_min == -1) {
 				putField("N/A");
@@ -1863,7 +2350,7 @@ void printReport(Arguments const& args,
 	putTitle("Avg");
 	first_op = 1;
 	for (auto op = 0; op < MAX_OP; op++) {
-		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
+		if (args.txnspec.ops[op][OP_COUNT] > 0 || isAbstractOp(op)) {
 			const auto lat_total = final_stats.getLatencyUsTotal(op);
 			const auto lat_samples = final_stats.getLatencySampleCount(op);
 			if (lat_total) {
@@ -1890,7 +2377,7 @@ void printReport(Arguments const& args,
 	putTitle("Max");
 	first_op = 1;
 	for (auto op = 0; op < MAX_OP; op++) {
-		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
+		if (args.txnspec.ops[op][OP_COUNT] > 0 || isAbstractOp(op)) {
 			const auto lat_max = final_stats.getLatencyUsMax(op);
 			if (lat_max == 0) {
 				putField("N/A");
@@ -1918,29 +2405,37 @@ void printReport(Arguments const& args,
 	putTitle("Median");
 	first_op = 1;
 	for (auto op = 0; op < MAX_OP; op++) {
-		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
+		if (args.txnspec.ops[op][OP_COUNT] > 0 || isAbstractOp(op)) {
 			const auto lat_total = final_stats.getLatencyUsTotal(op);
 			const auto lat_samples = final_stats.getLatencySampleCount(op);
+			data_points[op].reserve(lat_samples);
 			if (lat_total && lat_samples) {
 				for (auto i = 0; i < args.num_processes; i++) {
-					for (auto j = 0; j < args.num_threads; j++) {
+					auto load_sample = [pid_main, op, &data_points](int process_id, int thread_id) {
 						const auto dirname = fmt::format("{}{}", TEMP_DATA_STORE, pid_main);
-						const auto filename = getStatsFilename(dirname, i, j, op);
+						const auto filename = getStatsFilename(dirname, process_id, thread_id, op);
 						auto fp = fopen(filename.c_str(), "r");
 						if (!fp) {
-							logr.error("fopen({}): {}\n", filename, strerror(errno));
-							continue;
+							logr.error("fopen({}): {}", filename, strerror(errno));
+							return;
 						}
 						auto fclose_guard = ExitGuard([fp]() { fclose(fp); });
 						fseek(fp, 0, SEEK_END);
 						const auto num_points = ftell(fp) / sizeof(uint64_t);
-						data_points[op].reserve(num_points);
 						fseek(fp, 0, 0);
 						for (auto index = 0u; index < num_points; index++) {
 							auto value = uint64_t{};
 							fread(&value, sizeof(uint64_t), 1, fp);
 							data_points[op].push_back(value);
 						}
+					};
+					if (args.async_xacts == 0) {
+						for (auto j = 0; j < args.num_threads; j++) {
+							load_sample(i, j);
+						}
+					} else {
+						// async mode uses only one file per process
+						load_sample(i, 0);
 					}
 				}
 				std::sort(data_points[op].begin(), data_points[op].end());
@@ -1974,7 +2469,7 @@ void printReport(Arguments const& args,
 	putTitle("95.0 pctile");
 	first_op = 1;
 	for (auto op = 0; op < MAX_OP; op++) {
-		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
+		if (args.txnspec.ops[op][OP_COUNT] > 0 || isAbstractOp(op)) {
 			if (data_points[op].empty() || !final_stats.getLatencyUsTotal(op)) {
 				putField("N/A");
 				continue;
@@ -2001,7 +2496,7 @@ void printReport(Arguments const& args,
 	putTitle("99.0 pctile");
 	first_op = 1;
 	for (auto op = 0; op < MAX_OP; op++) {
-		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
+		if (args.txnspec.ops[op][OP_COUNT] > 0 || isAbstractOp(op)) {
 			if (data_points[op].empty() || !final_stats.getLatencyUsTotal(op)) {
 				putField("N/A");
 				continue;
@@ -2028,7 +2523,7 @@ void printReport(Arguments const& args,
 	putTitle("99.9 pctile");
 	first_op = 1;
 	for (auto op = 0; op < MAX_OP; op++) {
-		if (args.txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
+		if (args.txnspec.ops[op][OP_COUNT] > 0 || isAbstractOp(op)) {
 			if (data_points[op].empty() || !final_stats.getLatencyUsTotal(op)) {
 				putField("N/A");
 				continue;
@@ -2079,6 +2574,7 @@ int statsProcessMain(Arguments const& args,
 		fmt::fprintf(fp, "\"json\": %d,", args.json);
 		fmt::fprintf(fp, "\"num_processes\": %d,", args.num_processes);
 		fmt::fprintf(fp, "\"num_threads\": %d,", args.num_threads);
+		fmt::fprintf(fp, "\"async_xacts\": %d,", args.async_xacts);
 		fmt::fprintf(fp, "\"mode\": %d,", args.mode);
 		fmt::fprintf(fp, "\"rows\": %d,", args.rows);
 		fmt::fprintf(fp, "\"seconds\": %d,", args.seconds);
@@ -2193,7 +2689,7 @@ int main(int argc, char* argv[]) {
 	auto args = Arguments{};
 	rc = initArguments(args);
 	if (rc < 0) {
-		logr.error("initArguments failed\n");
+		logr.error("initArguments failed");
 		return -1;
 	}
 	rc = parseArguments(argc, argv, args);
@@ -2233,8 +2729,11 @@ int main(int argc, char* argv[]) {
 		unlink(shmpath.c_str());
 	});
 
+	const auto async_mode = args.async_xacts > 0;
+	const auto nthreads_for_shm = async_mode ? args.async_xacts : args.num_threads;
 	/* allocate */
-	const auto shmsize = shared_memory::storageSize(args.num_processes, args.num_threads);
+	const auto shmsize = shared_memory::storageSize(args.num_processes, nthreads_for_shm);
+
 	auto shm = std::add_pointer_t<void>{};
 	if (ftruncate(shmfd, shmsize) < 0) {
 		shm = MAP_FAILED;
@@ -2250,7 +2749,7 @@ int main(int argc, char* argv[]) {
 	}
 	auto munmap_guard = ExitGuard([=]() { munmap(shm, shmsize); });
 
-	auto shm_access = shared_memory::Access(shm, args.num_processes, args.num_threads);
+	auto shm_access = shared_memory::Access(shm, args.num_processes, nthreads_for_shm);
 
 	/* initialize the shared memory */
 	shm_access.reset();
diff --git a/bindings/c/test/mako/mako.hpp b/bindings/c/test/mako/mako.hpp
index 6a6f4bf0e0..6f3dfe6987 100644
--- a/bindings/c/test/mako/mako.hpp
+++ b/bindings/c/test/mako/mako.hpp
@@ -40,6 +40,7 @@ enum ArgKind {
 	ARG_KEYLEN,
 	ARG_VALLEN,
 	ARG_TPS,
+	ARG_ASYNC,
 	ARG_COMMITGET,
 	ARG_SAMPLING,
 	ARG_VERSION,
@@ -81,6 +82,8 @@ constexpr const int TAGPREFIXLENGTH_MAX = 8;
 constexpr const int NUM_CLUSTERS_MAX = 3;
 constexpr const int NUM_DATABASES_MAX = 10;
 constexpr const int MAX_BG_IDS = 1000;
+constexpr const std::string_view KEY_PREFIX{ "mako" };
+constexpr const std::string_view TEMP_DATA_STORE{ "/tmp/makoTemp" };
 
 /* benchmark parameters */
 struct Arguments {
@@ -88,6 +91,7 @@ struct Arguments {
 	int json;
 	int num_processes;
 	int num_threads;
+	int async_xacts;
 	int mode;
 	int rows; /* is 2 billion enough? */
 	int row_digits;
diff --git a/bindings/c/test/mako/operations.hpp b/bindings/c/test/mako/operations.hpp
index d69c6f9f7e..9ecf6cb901 100644
--- a/bindings/c/test/mako/operations.hpp
+++ b/bindings/c/test/mako/operations.hpp
@@ -23,6 +23,7 @@ enum OpKind {
 	OP_SETCLEARRANGE,
 	OP_COMMIT,
 	OP_TRANSACTION, /* pseudo-operation - cumulative time for the operation + commit */
+	OP_TASK, /* pseudo-operation - cumulative time for each iteraton in run_workload */
 	OP_READ_BG,
 	MAX_OP /* must be the last item */
 };
@@ -40,6 +41,11 @@ enum class StepKind {
 	ON_ERROR ///< future is a result of tx.on_error()
 };
 
+// Ops that doesn't have concrete steps to execute and are there for measurements only
+inline bool isAbstractOp(int op) noexcept {
+	return op == OP_COMMIT || op == OP_TRANSACTION; // || op == OP_TASK;
+}
+
 } // namespace mako
 
 #endif /* MAKO_OPERATIONS_HPP */
diff --git a/bindings/c/test/mako/stats.hpp b/bindings/c/test/mako/stats.hpp
index 2ebb908c9f..0fe8dfb2b6 100644
--- a/bindings/c/test/mako/stats.hpp
+++ b/bindings/c/test/mako/stats.hpp
@@ -59,7 +59,6 @@ public:
 };
 
 class alignas(64) ThreadStatistics {
-	uint64_t tasks;
 	uint64_t conflicts;
 	uint64_t total_errors;
 	uint64_t ops[MAX_OP];
@@ -78,8 +77,6 @@ public:
 	ThreadStatistics(const ThreadStatistics& other) noexcept = default;
 	ThreadStatistics& operator=(const ThreadStatistics& other) noexcept = default;
 
-	uint64_t getTaskCount() const noexcept { return tasks; }
-
 	uint64_t getConflictCount() const noexcept { return conflicts; }
 
 	uint64_t getOpCount(int op) const noexcept { return ops[op]; }
@@ -98,7 +95,6 @@ public:
 
 	// with 'this' as final aggregation, factor in 'other'
 	void combine(const ThreadStatistics& other) {
-		tasks += other.tasks;
 		conflicts += other.conflicts;
 		for (auto op = 0; op < MAX_OP; op++) {
 			ops[op] += other.ops[op];
@@ -113,7 +109,6 @@ public:
 		}
 	}
 
-	void incrTaskCount() noexcept { tasks++; }
 	void incrConflictCount() noexcept { conflicts++; }
 
 	// non-commit write operations aren't measured for time.
diff --git a/bindings/c/test/mako/utils.cpp b/bindings/c/test/mako/utils.cpp
index c41abf84e8..e4d2a71565 100644
--- a/bindings/c/test/mako/utils.cpp
+++ b/bindings/c/test/mako/utils.cpp
@@ -1,11 +1,14 @@
 #include "utils.hpp"
 #include "mako.hpp"
-#include <cmath>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <fmt/format.h>
 
+namespace math {
+#include <cmath>
+}
+
 namespace mako {
 
 /* uniform-distribution random */

From 1c8edc92f986ea49790af994d23539c18bff5e1a Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Wed, 23 Mar 2022 14:15:24 +0100
Subject: [PATCH 15/84] Apply clang-format to earlier mako changes

---
 bindings/c/test/mako/mako.cpp  | 6 +++---
 bindings/c/test/mako/utils.hpp | 5 ++---
 2 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/bindings/c/test/mako/mako.cpp b/bindings/c/test/mako/mako.cpp
index 653e8dab22..2bcaa6a7d0 100644
--- a/bindings/c/test/mako/mako.cpp
+++ b/bindings/c/test/mako/mako.cpp
@@ -696,9 +696,9 @@ int runOneTask(Transaction tx, Arguments const& args, ThreadStatistics& stats, L
 			watch_commit.stop();
 			watch_tx.setStop(watch_commit.getStop());
 			auto tx_resetter = ExitGuard([&watch_tx, &tx]() {
-					tx.reset();
-				    watch_tx.startFromStop();
-				});
+				tx.reset();
+				watch_tx.startFromStop();
+			});
 			if (rc == FutureRC::OK) {
 				if (do_sample) {
 					const auto commit_latency = watch_commit.diff();
diff --git a/bindings/c/test/mako/utils.hpp b/bindings/c/test/mako/utils.hpp
index dd1ea097a9..73ee0e0fc1 100644
--- a/bindings/c/test/mako/utils.hpp
+++ b/bindings/c/test/mako/utils.hpp
@@ -56,13 +56,12 @@ int computeThreadPortion(int val, int p_idx, int t_idx, int total_p, int total_t
 /* similar to insertBegin/end, computeThreadTps computes
  * the per-thread target TPS for given configuration.
  */
-#define computeThreadTps(val, p_idx, t_idx, total_p, total_t)                                                        \
-	computeThreadPortion(val, p_idx, t_idx, total_p, total_t)
+#define computeThreadTps(val, p_idx, t_idx, total_p, total_t) computeThreadPortion(val, p_idx, t_idx, total_p, total_t)
 
 /* similar to computeThreadTps,
  * computeThreadIters computs the number of iterations.
  */
-#define computeThreadIters(val, p_idx, t_idx, total_p, total_t)                                                      \
+#define computeThreadIters(val, p_idx, t_idx, total_p, total_t)                                                        \
 	computeThreadPortion(val, p_idx, t_idx, total_p, total_t)
 
 /* get the number of digits */

From d450a8ee264d1b9aeb226174c3ae483ffcfd6c9f Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Wed, 23 Mar 2022 17:32:41 +0100
Subject: [PATCH 16/84] Fix	Linux build error

---
 bindings/c/test/mako/time.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bindings/c/test/mako/time.hpp b/bindings/c/test/mako/time.hpp
index eda1efc30c..c1684b02e5 100644
--- a/bindings/c/test/mako/time.hpp
+++ b/bindings/c/test/mako/time.hpp
@@ -32,7 +32,7 @@ class Stopwatch {
 	timepoint_t p1, p2;
 
 public:
-	Stopwatch() noexcept = default;
+	Stopwatch() noexcept : p1(), p2() {}
 	Stopwatch(StartAtCtor) noexcept { start(); }
 	Stopwatch(timepoint_t start_time) noexcept : p1(start_time), p2() {}
 	Stopwatch(const Stopwatch&) noexcept = default;

From 077d82c01c9bc1928d5d016f28bba27cabf2f212 Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Wed, 23 Mar 2022 19:28:06 +0100
Subject: [PATCH 17/84] Fix g++ warnings (as errors)

---
 bindings/c/test/mako/mako.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/bindings/c/test/mako/mako.cpp b/bindings/c/test/mako/mako.cpp
index 2bcaa6a7d0..a5f847dbce 100644
--- a/bindings/c/test/mako/mako.cpp
+++ b/bindings/c/test/mako/mako.cpp
@@ -1993,14 +1993,14 @@ int parseArguments(int argc, char* argv[], Arguments& args) {
 				// if --report_json is the last option and no file is specified
 				// or --report_json is followed by another option
 				char default_file[] = "mako.json";
-				strncpy(args.json_output_path, default_file, strlen(default_file));
+				strncpy(args.json_output_path, default_file, sizeof(default_file));
 			} else {
-				strncpy(args.json_output_path, optarg, strlen(optarg) + 1);
+				strncpy(args.json_output_path, optarg, std::min(sizeof(args.json_output_path), strlen(optarg) + 1));
 			}
 			break;
 		case ARG_BG_FILE_PATH:
 			args.bg_materialize_files = true;
-			strncpy(args.bg_file_path, optarg, strlen(optarg) + 1);
+			strncpy(args.bg_file_path, optarg, std::min(sizeof(args.bg_file_path), strlen(optarg) + 1));
 		}
 	}
 

From d0b7eddbcc05ee0f175792f7b6cab80ebc405780 Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Fri, 1 Apr 2022 09:25:43 -0700
Subject: [PATCH 18/84] Break mako.cpp into separate files

- future wait and common error handling
- operations and sub-op steps
- blob granules API invocation prep
- asynchronous benchmark execution
---
 bindings/c/CMakeLists.txt              |  12 +
 bindings/c/test/mako/async.cpp         | 274 ++++++++
 bindings/c/test/mako/async.hpp         | 105 ++++
 bindings/c/test/mako/blob_granules.cpp |  93 +++
 bindings/c/test/mako/blob_granules.hpp |  29 +
 bindings/c/test/mako/future.hpp        |  68 ++
 bindings/c/test/mako/mako.cpp          | 835 +------------------------
 bindings/c/test/mako/mako.hpp          |  32 -
 bindings/c/test/mako/operations.cpp    | 292 +++++++++
 bindings/c/test/mako/operations.hpp    |  52 +-
 10 files changed, 946 insertions(+), 846 deletions(-)
 create mode 100644 bindings/c/test/mako/async.cpp
 create mode 100644 bindings/c/test/mako/async.hpp
 create mode 100644 bindings/c/test/mako/blob_granules.cpp
 create mode 100644 bindings/c/test/mako/blob_granules.hpp
 create mode 100644 bindings/c/test/mako/future.hpp
 create mode 100644 bindings/c/test/mako/operations.cpp

diff --git a/bindings/c/CMakeLists.txt b/bindings/c/CMakeLists.txt
index 294746a5aa..93fcbbee0a 100644
--- a/bindings/c/CMakeLists.txt
+++ b/bindings/c/CMakeLists.txt
@@ -81,8 +81,20 @@ endif()
 # check later whether this works
 if(NOT WIN32 AND NOT IS_ARM_MAC)
   set(MAKO_SRCS
+    test/mako/async.hpp
+    test/mako/async.cpp
+    test/mako/blob_granules.hpp
+    test/mako/blob_granules.cpp
+    test/mako/future.hpp
+    test/mako/logger.hpp
     test/mako/mako.cpp
     test/mako/mako.hpp
+    test/mako/operations.hpp
+    test/mako/operations.cpp
+    test/mako/process.hpp
+    test/mako/shm.hpp
+    test/mako/stats.hpp
+    test/mako/time.hpp
     test/mako/utils.cpp
     test/mako/utils.hpp)
   add_subdirectory(test/unit/third_party)
diff --git a/bindings/c/test/mako/async.cpp b/bindings/c/test/mako/async.cpp
new file mode 100644
index 0000000000..2e98e3fc7b
--- /dev/null
+++ b/bindings/c/test/mako/async.cpp
@@ -0,0 +1,274 @@
+#include <boost/asio.hpp>
+#include "async.hpp"
+#include "future.hpp"
+#include "logger.hpp"
+#include "operations.hpp"
+#include "stats.hpp"
+#include "time.hpp"
+#include "utils.hpp"
+
+extern thread_local mako::Logger logr;
+
+using namespace fdb;
+
+namespace mako {
+
+void ResumableStateForPopulate::postNextTick() {
+	boost::asio::post(io_context, [this, state=shared_from_this()]() { runOneTick(); });
+}
+
+void ResumableStateForPopulate::runOneTick() {
+	const auto num_commit_every = args.txnspec.ops[OP_INSERT][OP_COUNT];
+	for (auto i = key_checkpoint; i <= key_end; i++) {
+		genKey(keystr, KEY_PREFIX, args, i);
+		randomString(valstr, args.value_length);
+		tx.set(keystr, valstr);
+		stats.incrOpCount(OP_INSERT);
+		if (i == key_end || (i - key_begin + 1) % num_commit_every == 0) {
+			watch_commit.start();
+			auto f = tx.commit();
+			f.then([this, state=shared_from_this(), i](Future f) {
+				if (auto err = f.error()) {
+					logr.printWithLogLevel(err.retryable() ? VERBOSE_WARN : VERBOSE_NONE,
+					                       "ERROR",
+					                       "commit for populate returned '{}'",
+					                       err.what());
+					auto err_f = tx.onError(err);
+					err_f.then([this, state=shared_from_this()](Future f) {
+						const auto f_rc = handleForOnError(tx, f, "ON_ERROR_FOR_POPULATE");
+						if (f_rc == FutureRC::ABORT) {
+							signalEnd();
+							return;
+						} else {
+							postNextTick();
+						}
+					});
+				} else {
+					// successfully committed
+					watch_commit.stop();
+					watch_tx.setStop(watch_commit.getStop());
+					if (stats.getOpCount(OP_TASK) % args.sampling == 0) {
+						const auto commit_latency = watch_commit.diff();
+						const auto tx_duration = watch_tx.diff();
+						stats.addLatency(OP_COMMIT, commit_latency);
+						stats.addLatency(OP_TRANSACTION, tx_duration);
+						stats.addLatency(OP_TASK, tx_duration);
+						sample_bins[OP_COMMIT].put(commit_latency);
+						sample_bins[OP_TRANSACTION].put(tx_duration);
+						sample_bins[OP_TASK].put(tx_duration);
+					}
+					stats.incrOpCount(OP_COMMIT);
+					stats.incrOpCount(OP_TRANSACTION);
+					stats.incrOpCount(OP_TASK);
+					tx.reset();
+					watch_tx.startFromStop();
+					key_checkpoint = i + 1;
+					if (i != key_end) {
+						postNextTick();
+					} else {
+						logr.debug("Populated {} rows [{}, {}]: {:6.3f} sec",
+						           key_end - key_begin + 1,
+						           key_begin,
+						           key_end,
+						           toDoubleSeconds(watch_total.stop().diff()));
+						signalEnd();
+						return;
+					}
+				}
+			});
+			break;
+		}
+	}
+}
+
+void ResumableStateForRunWorkload::postNextTick() {
+	boost::asio::post(io_context, [this, state=shared_from_this()]() { runOneTick(); });
+}
+
+#define UNPACK_OP_INFO() \
+	[[maybe_unused]] auto& [op, count, step] = op_iter; \
+	[[maybe_unused]] const auto step_kind = opTable[op].stepKind(step)
+
+void ResumableStateForRunWorkload::runOneTick() {
+	UNPACK_OP_INFO();
+	assert(op_iter != OpEnd);
+	watch_step.start();
+	if (step == 0 /* first step */) {
+		watch_per_op[op] = Stopwatch(watch_step.getStart());
+	}
+	auto f = opTable[op].stepFunction(step)(tx, args, key1, key2, val);
+	if (!f) {
+		// immediately completed client-side ops: e.g. set, setrange, clear, clearrange, ...
+		onStepSuccess();
+	} else {
+		f.then([this, state=shared_from_this()](Future f) {
+			UNPACK_OP_INFO();
+			if (step_kind != StepKind::ON_ERROR) {
+				if (auto err = f.error()) {
+					logr.printWithLogLevel(err.retryable() ? VERBOSE_WARN : VERBOSE_NONE,
+					                       "ERROR",
+					                       "step {} of op {} returned '{}'",
+					                       step,
+					                       opTable[op].name(),
+					                       err.what());
+					tx.onError(err).then([this, state=shared_from_this()](Future f) {
+						UNPACK_OP_INFO();
+						const auto rc = handleForOnError(tx, f, fmt::format("{}_STEP_{}", opTable[op].name(), step));
+						if (rc == FutureRC::RETRY) {
+							stats.incrErrorCount(op);
+						} else if (rc == FutureRC::CONFLICT) {
+							stats.incrConflictCount();
+						} else if (rc == FutureRC::ABORT) {
+							tx.reset();
+							stopcount.fetch_add(1);
+							return;
+						}
+						op_iter = getOpBegin(args);
+						needs_commit = false;
+						// restart this iteration from beginning
+						postNextTick();
+					});
+					return;
+				}
+			} else {
+				auto rc = handleForOnError(tx, f, "BG_ON_ERROR");
+				if (rc == FutureRC::RETRY) {
+					stats.incrErrorCount(op);
+				} else if (rc == FutureRC::CONFLICT) {
+					stats.incrConflictCount();
+				} else if (rc == FutureRC::ABORT) {
+					tx.reset();
+					stopcount.fetch_add(1);
+					return;
+				}
+				op_iter = getOpBegin(args);
+				needs_commit = false;
+				// restart this iteration from beginning
+				postNextTick();
+				return;
+			}
+			onStepSuccess();
+		});
+	}
+}
+
+void ResumableStateForRunWorkload::onStepSuccess() {
+	UNPACK_OP_INFO();
+	logr.debug("Step {}:{} succeeded", getOpName(op), step);
+	// step successful
+	watch_step.stop();
+	const auto do_sample = stats.getOpCount(OP_TASK) % args.sampling == 0;
+	if (step_kind == StepKind::COMMIT) {
+		// reset transaction boundary
+		const auto step_latency = watch_step.diff();
+		watch_tx.setStop(watch_step.getStop());
+		if (do_sample) {
+			const auto tx_duration = watch_tx.diff();
+			stats.addLatency(OP_COMMIT, step_latency);
+			stats.addLatency(OP_TRANSACTION, tx_duration);
+			sample_bins[OP_COMMIT].put(step_latency);
+			sample_bins[OP_TRANSACTION].put(tx_duration);
+		}
+		tx.reset();
+		watch_tx.startFromStop();
+		stats.incrOpCount(OP_COMMIT);
+		stats.incrOpCount(OP_TRANSACTION);
+		needs_commit = false;
+	}
+	// op completed successfully
+	if (step + 1 == opTable[op].steps()) {
+		if (opTable[op].needsCommit())
+			needs_commit = true;
+		watch_per_op[op].setStop(watch_step.getStop());
+		if (do_sample) {
+			const auto op_latency = watch_per_op[op].diff();
+			stats.addLatency(op, op_latency);
+			sample_bins[op].put(op_latency);
+		}
+		stats.incrOpCount(op);
+	}
+	op_iter = getOpNext(args, op_iter);
+	if (op_iter == OpEnd) {
+		if (needs_commit || args.commit_get) {
+			// task completed, need to commit before finish
+			watch_commit.start();
+			auto f = tx.commit().eraseType();
+			f.then([this, state=shared_from_this()](Future f) {
+				UNPACK_OP_INFO();
+				if (auto err = f.error()) {
+					// commit had errors
+					logr.printWithLogLevel(err.retryable() ? VERBOSE_WARN : VERBOSE_NONE,
+					                       "ERROR",
+					                       "Post-iteration commit returned error: {}",
+					                       err.what());
+					tx.onError(err).then([this, state=shared_from_this()](Future f) {
+						const auto rc = handleForOnError(tx, f, "ON_ERROR");
+						if (rc == FutureRC::CONFLICT)
+							stats.incrConflictCount();
+						else
+							stats.incrErrorCount(OP_COMMIT);
+						if (rc == FutureRC::ABORT) {
+							signalEnd();
+							return;
+						}
+						op_iter = getOpBegin(args);
+						needs_commit = false;
+						postNextTick();
+					});
+				} else {
+					// commit successful
+					watch_commit.stop();
+					watch_tx.setStop(watch_commit.getStop());
+					watch_task.setStop(watch_commit.getStop());
+					if (stats.getOpCount(OP_TASK) % args.sampling == 0) {
+						const auto commit_latency = watch_commit.diff();
+						const auto tx_duration = watch_tx.diff();
+						const auto task_duration = watch_task.diff();
+						stats.addLatency(OP_COMMIT, commit_latency);
+						stats.addLatency(OP_TRANSACTION, commit_latency);
+						stats.addLatency(OP_TASK, task_duration);
+						sample_bins[OP_COMMIT].put(commit_latency);
+						sample_bins[OP_TRANSACTION].put(tx_duration);
+						sample_bins[OP_TASK].put(task_duration);
+					}
+					stats.incrOpCount(OP_COMMIT);
+					stats.incrOpCount(OP_TRANSACTION);
+					stats.incrOpCount(OP_TASK);
+					tx.reset();
+					watch_tx.startFromStop();
+					watch_task.startFromStop();
+					if (ended()) {
+						signalEnd();
+						return;
+					}
+					// start next iteration
+					op_iter = getOpBegin(args);
+					postNextTick();
+				}
+			});
+		} else {
+			// task completed but no need to commit
+			watch_task.stop();
+			if (stats.getOpCount(OP_TASK) % args.sampling == 0) {
+				const auto task_duration = watch_task.diff();
+				stats.addLatency(OP_TASK, task_duration);
+				sample_bins[OP_TASK].put(task_duration);
+			}
+			stats.incrOpCount(OP_TASK);
+			watch_tx.startFromStop();
+			watch_task.startFromStop();
+			tx.reset();
+			if (ended()) {
+				signalEnd();
+				return;
+			}
+			op_iter = getOpBegin(args);
+			// run next iteration
+			postNextTick();
+		}
+	} else {
+		postNextTick();
+	}
+}
+
+} // namespace mako
diff --git a/bindings/c/test/mako/async.hpp b/bindings/c/test/mako/async.hpp
new file mode 100644
index 0000000000..da32e4afb8
--- /dev/null
+++ b/bindings/c/test/mako/async.hpp
@@ -0,0 +1,105 @@
+#ifndef MAKO_ASYNC_HPP
+#define MAKO_ASYNC_HPP
+
+#include <atomic>
+#include <memory>
+#include <boost/asio.hpp>
+#include "logger.hpp"
+#include "mako.hpp"
+#include "stats.hpp"
+#include "time.hpp"
+
+namespace mako {
+
+// as we don't have coroutines yet, we need to store in heap the complete state of execution,
+// such that we can resume exactly where we were from last database op.
+struct ResumableStateForPopulate : std::enable_shared_from_this<ResumableStateForPopulate> {
+	Logger logr;
+	fdb::Database db;
+	fdb::Transaction tx;
+	boost::asio::io_context& io_context;
+	Arguments const& args;
+	ThreadStatistics& stats;
+	std::atomic<int>& stopcount;
+	LatencySampleBinArray sample_bins;
+	int key_begin;
+	int key_end;
+	int key_checkpoint;
+	fdb::ByteString keystr;
+	fdb::ByteString valstr;
+	Stopwatch watch_tx;
+	Stopwatch watch_commit;
+	Stopwatch watch_total;
+
+	ResumableStateForPopulate(
+			Logger logr,
+			fdb::Database db, fdb::Transaction tx,
+			boost::asio::io_context& io_context,
+			Arguments const& args,
+			ThreadStatistics& stats,
+			std::atomic<int>& stopcount, int key_begin, int key_end) :
+		logr(logr), db(db), tx(tx),
+		io_context(io_context), args(args), stats(stats), stopcount(stopcount),
+		key_begin(key_begin), key_end(key_end), key_checkpoint(key_begin)
+	{
+		keystr.reserve(args.key_length);
+		valstr.reserve(args.value_length);
+	}
+	void runOneTick();
+	void postNextTick();
+	void signalEnd() { stopcount.fetch_add(1); }
+};
+
+using PopulateStateHandle = std::shared_ptr<ResumableStateForPopulate>;
+
+struct ResumableStateForRunWorkload : std::enable_shared_from_this<ResumableStateForRunWorkload> {
+	Logger logr;
+	fdb::Database db;
+	fdb::Transaction tx;
+	boost::asio::io_context& io_context;
+	Arguments const& args;
+	ThreadStatistics& stats;
+	std::atomic<int>& stopcount;
+	std::atomic<int> const& signal;
+	int max_iters;
+	OpIterator op_iter;
+	LatencySampleBinArray sample_bins;
+	fdb::ByteString key1;
+	fdb::ByteString key2;
+	fdb::ByteString val;
+	std::array<Stopwatch, MAX_OP> watch_per_op;
+	Stopwatch watch_step;
+	Stopwatch watch_commit;
+	Stopwatch watch_tx;
+	Stopwatch watch_task;
+	bool needs_commit;
+
+	ResumableStateForRunWorkload(
+			Logger logr,
+			fdb::Database db, fdb::Transaction tx,
+			boost::asio::io_context& io_context,
+			Arguments const& args,
+			ThreadStatistics& stats,
+			std::atomic<int>& stopcount, std::atomic<int> const& signal,
+			int max_iters, OpIterator op_iter) :
+		logr(logr), db(db), tx(tx), io_context(io_context), args(args), stats(stats),
+		stopcount(stopcount), signal(signal), max_iters(max_iters), op_iter(op_iter), needs_commit(false)
+	{
+		key1.reserve(args.key_length);
+		key2.reserve(args.key_length);
+		val.reserve(args.value_length);
+	}
+	void signalEnd() noexcept { stopcount.fetch_add(1); }
+	bool ended() noexcept {
+		return (max_iters != -1 && max_iters >= stats.getOpCount(OP_TASK)) || signal.load() == SIGNAL_RED;
+	}
+	void postNextTick();
+	void runOneTick();
+	void onStepSuccess();
+};
+
+using RunWorkloadStateHandle = std::shared_ptr<ResumableStateForRunWorkload>;
+
+} // namespace mako
+
+#endif /*MAKO_ASYNC_HPP*/
diff --git a/bindings/c/test/mako/blob_granules.cpp b/bindings/c/test/mako/blob_granules.cpp
new file mode 100644
index 0000000000..84c8584ea4
--- /dev/null
+++ b/bindings/c/test/mako/blob_granules.cpp
@@ -0,0 +1,93 @@
+#include "blob_granules.hpp"
+#include "logger.hpp"
+#include <cstdio>
+#include <fdb.hpp>
+
+extern thread_local mako::Logger logr;
+
+namespace mako::blob_granules::local_file {
+
+int64_t startLoad(const char* filename,
+                  int filenameLength,
+                  int64_t offset,
+                  int64_t length,
+                  void* userContext) {
+	FILE* fp;
+	char full_fname[PATH_MAX]{
+		0,
+	};
+	int loadId;
+	uint8_t* data;
+	size_t readSize;
+
+	auto context = static_cast<UserContext*>(userContext);
+
+	loadId = context->nextId;
+	if (context->dataById[loadId] != 0) {
+		logr.error("too many granule file loads at once: {}", MAX_BG_IDS);
+		return -1;
+	}
+	context->nextId = (context->nextId + 1) % MAX_BG_IDS;
+
+	int ret = snprintf(full_fname, PATH_MAX, "%s%s", context->bgFilePath, filename);
+	if (ret < 0 || ret >= PATH_MAX) {
+		logr.error("BG filename too long: {}{}", context->bgFilePath, filename);
+		return -1;
+	}
+
+	fp = fopen(full_fname, "r");
+	if (!fp) {
+		logr.error("BG could not open file: {}", full_fname);
+		return -1;
+	}
+
+	// don't seek if offset == 0
+	if (offset && fseek(fp, offset, SEEK_SET)) {
+		// if fseek was non-zero, it failed
+		logr.error("BG could not seek to %{} in file {}", offset, full_fname);
+		fclose(fp);
+		return -1;
+	}
+
+	data = new uint8_t[length];
+	readSize = fread(data, sizeof(uint8_t), length, fp);
+	fclose(fp);
+
+	if (readSize != length) {
+		logr.error("BG could not read {} bytes from file: {}", length, full_fname);
+		return -1;
+	}
+
+	context->dataById[loadId] = data;
+	return loadId;
+}
+
+uint8_t* getLoad(int64_t loadId, void* userContext) {
+	auto context = static_cast<UserContext*>(userContext);
+	if (context->dataById[loadId] == 0) {
+		logr.error("BG loadId invalid for get_load: {}", loadId);
+		return 0;
+	}
+	return context->dataById[loadId];
+}
+
+void freeLoad(int64_t loadId, void* userContext) {
+	auto context = static_cast<UserContext*>(userContext);
+	if (context->dataById[loadId] == 0) {
+		logr.error("BG loadId invalid for free_load: {}", loadId);
+	}
+	delete[] context->dataById[loadId];
+	context->dataById[loadId] = 0;
+}
+
+fdb::native::FDBReadBlobGranuleContext createApiContext(UserContext& ctx, bool materialize_files) {
+	auto ret = fdb::native::FDBReadBlobGranuleContext{};
+	ret.userContext = &ctx;
+	ret.start_load_f = &startLoad;
+	ret.get_load_f = &getLoad;
+	ret.free_load_f = &freeLoad;
+	ret.debugNoMaterialize = !materialize_files;
+	return ret;
+}
+
+} // namespace mako::blob_granules::local_file
diff --git a/bindings/c/test/mako/blob_granules.hpp b/bindings/c/test/mako/blob_granules.hpp
new file mode 100644
index 0000000000..8aec305705
--- /dev/null
+++ b/bindings/c/test/mako/blob_granules.hpp
@@ -0,0 +1,29 @@
+#ifndef MAKO_BLOB_GRANULES_HPP
+#define MAKO_BLOB_GRANULES_HPP
+
+#include <cstdint>
+#include <memory>
+#include <fdb.hpp>
+
+namespace mako::blob_granules::local_file {
+
+constexpr const int MAX_BG_IDS = 1000;
+
+// TODO: could always abstract this into something more generically usable by something other than mako.
+// But outside of testing there are likely few use cases for local granules
+struct UserContext {
+	char const* bgFilePath;
+	int nextId;
+	std::unique_ptr<uint8_t*[]> dataByIdMem;
+	uint8_t** dataById;
+
+	UserContext(char const* filePath) : bgFilePath(filePath), nextId(0), dataByIdMem(new uint8_t*[MAX_BG_IDS]()), dataById(dataByIdMem.get()) {}
+
+	void clear() { dataByIdMem.reset(); }
+};
+
+fdb::native::FDBReadBlobGranuleContext createApiContext(UserContext& ctx, bool materialize_files);
+
+} // namespace mako::blob_granules::local_file
+
+#endif /*MAKO_BLOB_GRANULES_HPP*/
diff --git a/bindings/c/test/mako/future.hpp b/bindings/c/test/mako/future.hpp
new file mode 100644
index 0000000000..7c7cd6fe6b
--- /dev/null
+++ b/bindings/c/test/mako/future.hpp
@@ -0,0 +1,68 @@
+#ifndef MAKO_FUTURE_HPP
+#define MAKO_FUTURE_HPP
+
+#include <fdb.hpp>
+#include <cassert>
+#include <string_view>
+#include "logger.hpp"
+
+extern thread_local mako::Logger logr;
+
+namespace mako {
+
+enum class FutureRC { OK, RETRY, CONFLICT, ABORT };
+
+template <class FutureType>
+FutureRC handleForOnError(fdb::Transaction tx, FutureType f, std::string_view step) {
+	if (auto err = f.error()) {
+		if (err.is(1020 /*not_committed*/)) {
+			return FutureRC::CONFLICT;
+		} else if (err.retryable()) {
+			logr.warn("Retryable error '{}' found at on_error(), step: {}", err.what(), step);
+			return FutureRC::RETRY;
+		} else {
+			logr.error("Unretryable error '{}' found at on_error(), step: {}", err.what(), step);
+			tx.reset();
+			return FutureRC::ABORT;
+		}
+	} else {
+		return FutureRC::RETRY;
+	}
+}
+
+template <class FutureType>
+FutureRC waitAndHandleForOnError(fdb::Transaction tx, FutureType f, std::string_view step) {
+	assert(f);
+	if (auto err = f.blockUntilReady()) {
+		logr.error("'{}' found while waiting for on_error() future, step: {}", err.what(), step);
+		return FutureRC::ABORT;
+	}
+	return handleForOnError(tx, f, step);
+}
+
+// wait on any non-immediate tx-related step to complete. Follow up with on_error().
+template <class FutureType>
+FutureRC waitAndHandleError(fdb::Transaction tx, FutureType f, std::string_view step) {
+	assert(f);
+	auto err = fdb::Error{};
+	if ((err = f.blockUntilReady())) {
+		const auto retry = err.retryable();
+		logr.error("{} error '{}' found during step: {}", (retry ? "Retryable" : "Unretryable"), err.what(), step);
+		return retry ? FutureRC::RETRY : FutureRC::ABORT;
+	}
+	err = f.error();
+	if (!err)
+		return FutureRC::OK;
+	if (err.retryable()) {
+		logr.warn("step {} returned '{}'", step, err.what());
+	} else {
+		logr.error("step {} returned '{}'", step, err.what());
+	}
+	// implicit backoff
+	auto follow_up = tx.onError(err);
+	return waitAndHandleForOnError(tx, f, step);
+}
+
+} // namespace mako
+
+#endif /*MAKO_FUTURE_HPP*/
diff --git a/bindings/c/test/mako/mako.cpp b/bindings/c/test/mako/mako.cpp
index a5f847dbce..5a1e06f085 100644
--- a/bindings/c/test/mako/mako.cpp
+++ b/bindings/c/test/mako/mako.cpp
@@ -39,66 +39,14 @@
 #include "mako.hpp"
 #include "process.hpp"
 #include "utils.hpp"
+#include "future.hpp"
+#include "async.hpp"
 
 using namespace fdb;
 using namespace mako;
 
 thread_local Logger logr = Logger(MainProcess{}, VERBOSE_DEFAULT);
 
-enum class FutureRC { OK, RETRY, CONFLICT, ABORT };
-
-template <class FutureType>
-FutureRC handleForOnError(Transaction tx, FutureType f, std::string_view step) {
-	if (auto err = f.error()) {
-		if (err.is(1020 /*not_committed*/)) {
-			return FutureRC::CONFLICT;
-		} else if (err.retryable()) {
-			logr.warn("Retryable error '{}' found at on_error(), step: {}", err.what(), step);
-			return FutureRC::RETRY;
-		} else {
-			logr.error("Unretryable error '{}' found at on_error(), step: {}", err.what(), step);
-			tx.reset();
-			return FutureRC::ABORT;
-		}
-	} else {
-		return FutureRC::RETRY;
-	}
-}
-
-template <class FutureType>
-FutureRC waitAndHandleForOnError(Transaction tx, FutureType f, std::string_view step) {
-	assert(f);
-	auto err = Error{};
-	if ((err = f.blockUntilReady())) {
-		logr.error("'{}' found while waiting for on_error() future, step: {}", err.what(), step);
-		return FutureRC::ABORT;
-	}
-	return handleForOnError(tx, f, step);
-}
-
-// wait on any non-immediate tx-related step to complete. Follow up with on_error().
-template <class FutureType>
-FutureRC waitAndHandleError(Transaction tx, FutureType f, std::string_view step) {
-	assert(f);
-	auto err = Error{};
-	if ((err = f.blockUntilReady())) {
-		const auto retry = err.retryable();
-		logr.error("{} error '{}' found during step: {}", (retry ? "Retryable" : "Unretryable"), err.what(), step);
-		return retry ? FutureRC::RETRY : FutureRC::ABORT;
-	}
-	err = f.error();
-	if (!err)
-		return FutureRC::OK;
-	if (err.retryable()) {
-		logr.warn("step {} returned '{}'", step, err.what());
-	} else {
-		logr.error("step {} returned '{}'", step, err.what());
-	}
-	// implicit backoff
-	auto follow_up = tx.onError(err);
-	return waitAndHandleForOnError(tx, f, step);
-}
-
 /* cleanup database */
 int cleanup(Transaction tx, Arguments const& args) {
 	auto beginstr = ByteString{};
@@ -233,378 +181,6 @@ int populate(Transaction tx,
 	return 0;
 }
 
-// TODO: could always abstract this into something more generically usable by something other than mako.
-// But outside of testing there are likely few use cases for local granules
-typedef struct {
-	char const* bgFilePath;
-	int nextId;
-	uint8_t** data_by_id;
-} BGLocalFileContext;
-
-int64_t granule_start_load(const char* filename,
-                           int filenameLength,
-                           int64_t offset,
-                           int64_t length,
-                           void* userContext) {
-	FILE* fp;
-	char full_fname[PATH_MAX]{
-		0,
-	};
-	int loadId;
-	uint8_t* data;
-	size_t readSize;
-
-	BGLocalFileContext* context = (BGLocalFileContext*)userContext;
-
-	loadId = context->nextId;
-	if (context->data_by_id[loadId] != 0) {
-		logr.error("too many granule file loads at once: {}", MAX_BG_IDS);
-		return -1;
-	}
-	context->nextId = (context->nextId + 1) % MAX_BG_IDS;
-
-	int ret = snprintf(full_fname, PATH_MAX, "%s%s", context->bgFilePath, filename);
-	if (ret < 0 || ret >= PATH_MAX) {
-		logr.error("BG filename too long: {}{}", context->bgFilePath, filename);
-		return -1;
-	}
-
-	fp = fopen(full_fname, "r");
-	if (!fp) {
-		logr.error("BG could not open file: {}", full_fname);
-		return -1;
-	}
-
-	// don't seek if offset == 0
-	if (offset && fseek(fp, offset, SEEK_SET)) {
-		// if fseek was non-zero, it failed
-		logr.error("BG could not seek to %{} in file {}", offset, full_fname);
-		fclose(fp);
-		return -1;
-	}
-
-	data = new uint8_t[length];
-	readSize = fread(data, sizeof(uint8_t), length, fp);
-	fclose(fp);
-
-	if (readSize != length) {
-		logr.error("BG could not read {} bytes from file: {}", length, full_fname);
-		return -1;
-	}
-
-	context->data_by_id[loadId] = data;
-	return loadId;
-}
-
-uint8_t* granule_get_load(int64_t loadId, void* userContext) {
-	BGLocalFileContext* context = (BGLocalFileContext*)userContext;
-	if (context->data_by_id[loadId] == 0) {
-		logr.error("BG loadId invalid for get_load: {}", loadId);
-		return 0;
-	}
-	return context->data_by_id[loadId];
-}
-
-void granule_free_load(int64_t loadId, void* userContext) {
-	BGLocalFileContext* context = (BGLocalFileContext*)userContext;
-	if (context->data_by_id[loadId] == 0) {
-		logr.error("BG loadId invalid for free_load: {}", loadId);
-	}
-	delete[] context->data_by_id[loadId];
-	context->data_by_id[loadId] = 0;
-}
-
-inline int nextKey(Arguments const& args) {
-	if (args.zipf)
-		return zipfian_next();
-	return urand(0, args.rows - 1);
-}
-
-const std::array<Operation, MAX_OP> opTable{
-	{ { "GRV",
-	    { { StepKind::READ,
-	        [](Transaction tx, Arguments const&, ByteString&, ByteString&, ByteString&) {
-	            return tx.getReadVersion().eraseType();
-	        } } },
-	    false },
-	  { "GET",
-	    { { StepKind::READ,
-	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
-	            const auto num = nextKey(args);
-	            genKey(key, KEY_PREFIX, args, num);
-	            return tx.get(key, false /*snapshot*/).eraseType();
-	        } } },
-	    false },
-	  { "GETRANGE",
-	    { { StepKind::READ,
-	        [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
-	            const auto num_begin = nextKey(args);
-	            genKey(begin, KEY_PREFIX, args, num_begin);
-	            auto num_end = num_begin + args.txnspec.ops[OP_GETRANGE][OP_RANGE] - 1;
-	            if (num_end > args.rows - 1)
-		            num_end = args.rows - 1;
-	            genKey(end, KEY_PREFIX, args, num_end);
-	            return tx
-	                .getRange<key_select::Inclusive, key_select::Inclusive>(begin,
-	                                                                        end,
-	                                                                        0 /*limit*/,
-	                                                                        0 /*target_bytes*/,
-	                                                                        args.streaming_mode,
-	                                                                        0 /*iteration*/,
-	                                                                        false /*snapshot*/,
-	                                                                        args.txnspec.ops[OP_GETRANGE][OP_REVERSE])
-	                .eraseType();
-	        } } },
-	    false },
-	  { "SGET",
-	    { { StepKind::READ,
-	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
-	            const auto num = nextKey(args);
-	            genKey(key, KEY_PREFIX, args, num);
-	            return tx.get(key, true /*snapshot*/).eraseType();
-	        } } },
-	    false },
-	  { "SGETRANGE",
-	    { {
-
-	        StepKind::READ,
-	        [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
-	            const auto num_begin = nextKey(args);
-	            genKey(begin, KEY_PREFIX, args, num_begin);
-	            auto num_end = num_begin + args.txnspec.ops[OP_SGETRANGE][OP_RANGE] - 1;
-	            if (num_end > args.rows - 1)
-		            num_end = args.rows - 1;
-	            genKey(end, KEY_PREFIX, args, num_end);
-	            return tx
-	                .getRange<key_select::Inclusive, key_select::Inclusive>(begin,
-	                                                                        end,
-	                                                                        0 /*limit*/,
-	                                                                        0 /*target_bytes*/,
-	                                                                        args.streaming_mode,
-	                                                                        0 /*iteration*/,
-	                                                                        true /*snapshot*/,
-	                                                                        args.txnspec.ops[OP_SGETRANGE][OP_REVERSE])
-	                .eraseType();
-	        }
-
-	    } },
-	    false },
-	  { "UPDATE",
-	    { { StepKind::READ,
-	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
-	            const auto num = nextKey(args);
-	            genKey(key, KEY_PREFIX, args, num);
-	            return tx.get(key, false /*snapshot*/).eraseType();
-	        } },
-	      { StepKind::IMM,
-	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
-	            randomString(value, args.value_length);
-	            tx.set(key, value);
-	            return Future();
-	        } } },
-	    true },
-	  { "INSERT",
-	    { { StepKind::IMM,
-	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
-	            genKeyPrefix(key, KEY_PREFIX, args);
-	            // concat([padding], key_prefix, random_string): reasonably unique
-	            randomString<false /*clear-before-append*/>(key, args.key_length - static_cast<int>(key.size()));
-	            randomString(value, args.value_length);
-	            tx.set(key, value);
-	            return Future();
-	        } } },
-	    true },
-	  { "INSERTRANGE",
-	    { { StepKind::IMM,
-	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
-	            genKeyPrefix(key, KEY_PREFIX, args);
-	            const auto prefix_len = static_cast<int>(key.size());
-	            const auto range = args.txnspec.ops[OP_INSERTRANGE][OP_RANGE];
-	            assert(range > 0);
-	            const auto range_digits = digits(range);
-	            assert(args.key_length - prefix_len >= range_digits);
-	            const auto rand_len = args.key_length - prefix_len - range_digits;
-	            // concat([padding], prefix, random_string, range_digits)
-	            randomString<false /*clear-before-append*/>(key, rand_len);
-	            randomString(value, args.value_length);
-	            for (auto i = 0; i < range; i++) {
-		            fmt::format_to(std::back_inserter(key), "{0:0{1}d}", i, range_digits);
-		            tx.set(key, value);
-		            key.resize(key.size() - static_cast<size_t>(range_digits));
-	            }
-	            return Future();
-	        } } },
-	    true },
-	  { "OVERWRITE",
-	    { { StepKind::IMM,
-	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
-	            genKey(key, KEY_PREFIX, args, nextKey(args));
-	            randomString(value, args.value_length);
-	            tx.set(key, value);
-	            return Future();
-	        } } },
-	    true },
-	  { "CLEAR",
-	    { { StepKind::IMM,
-	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
-	            genKey(key, KEY_PREFIX, args, nextKey(args));
-	            tx.clear(key);
-	            return Future();
-	        } } },
-	    true },
-	  { "SETCLEAR",
-	    { { StepKind::COMMIT,
-	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
-	            genKeyPrefix(key, KEY_PREFIX, args);
-	            const auto prefix_len = static_cast<int>(key.size());
-	            randomString<false /*append-after-clear*/>(key, args.key_length - prefix_len);
-	            randomString(value, args.value_length);
-	            tx.set(key, value);
-	            return tx.commit().eraseType();
-	        } },
-	      { StepKind::IMM,
-	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
-	            tx.reset(); // assuming commit from step 0 worked.
-	            tx.clear(key); // key should forward unchanged from step 0
-	            return Future();
-	        } } },
-	    true },
-	  { "CLEARRANGE",
-	    { { StepKind::IMM,
-	        [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
-	            const auto num_begin = nextKey(args);
-	            genKey(begin, KEY_PREFIX, args, num_begin);
-	            const auto range = args.txnspec.ops[OP_CLEARRANGE][OP_RANGE];
-	            assert(range > 0);
-	            genKey(end, KEY_PREFIX, args, std::min(args.rows - 1, num_begin + range - 1));
-	            tx.clearRange(begin, end);
-	            return Future();
-	        } } },
-	    true },
-	  { "SETCLEARRANGE",
-	    { { StepKind::COMMIT,
-	        [](Transaction tx, Arguments const& args, ByteString& key_begin, ByteString& key, ByteString& value) {
-	            genKeyPrefix(key, KEY_PREFIX, args);
-	            const auto prefix_len = static_cast<int>(key.size());
-	            const auto range = args.txnspec.ops[OP_SETCLEARRANGE][OP_RANGE];
-	            assert(range > 0);
-	            const auto range_digits = digits(range);
-	            assert(args.key_length - prefix_len >= range_digits);
-	            const auto rand_len = args.key_length - prefix_len - range_digits;
-	            // concat([padding], prefix, random_string, range_digits)
-	            randomString<false /*clear-before-append*/>(key, rand_len);
-	            randomString(value, args.value_length);
-	            for (auto i = 0; i <= range; i++) {
-		            fmt::format_to(std::back_inserter(key), "{0:0{1}d}", i, range_digits);
-		            if (i == range)
-			            break; // preserve "exclusive last"
-		            // preserve first key for step 1
-		            if (i == 0)
-			            key_begin = key;
-		            tx.set(key, value);
-		            // preserve last key for step 1
-		            key.resize(key.size() - static_cast<size_t>(range_digits));
-	            }
-	            return tx.commit().eraseType();
-	        } },
-	      { StepKind::IMM,
-	        [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
-	            tx.reset();
-	            tx.clearRange(begin, end);
-	            return Future();
-	        } } },
-	    true },
-	  { "COMMIT", { { StepKind::NONE, nullptr } }, false },
-	  { "TRANSACTION", { { StepKind::NONE, nullptr } }, false },
-	  { "TASK", { { StepKind::NONE, nullptr } }, false },
-	  { "READBLOBGRANULE",
-	    { { StepKind::ON_ERROR,
-	        [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
-	            const auto num_begin = nextKey(args);
-	            genKey(begin, KEY_PREFIX, args, num_begin);
-	            const auto range = args.txnspec.ops[OP_READ_BG][OP_RANGE];
-	            assert(range > 0);
-	            genKey(end, KEY_PREFIX, args, std::min(args.rows - 1, num_begin + range - 1));
-	            auto err = Error{};
-
-	            err = tx.setOptionNothrow(FDB_TR_OPTION_READ_YOUR_WRITES_DISABLE, BytesRef());
-	            if (err) {
-		            // Issuing read/writes before disabling RYW results in error.
-		            // Possible malformed workload?
-		            // As workloads execute in sequence, retrying would likely repeat this error.
-		            fmt::print(stderr, "ERROR: TR_OPTION_READ_YOUR_WRITES_DISABLE: {}", err.what());
-		            return Future();
-	            }
-
-	            auto mem = std::unique_ptr<uint8_t*[]>(new uint8_t*[MAX_BG_IDS]);
-	            // Allocate a separate context per call to avoid multiple threads accessing
-	            BGLocalFileContext fileContext;
-	            fileContext.bgFilePath = args.bg_file_path;
-	            fileContext.nextId = 0;
-	            fileContext.data_by_id = mem.get();
-	            memset(fileContext.data_by_id, 0, MAX_BG_IDS * sizeof(uint8_t*));
-
-	            native::FDBReadBlobGranuleContext granuleContext;
-	            granuleContext.userContext = &fileContext;
-	            granuleContext.start_load_f = &granule_start_load;
-	            granuleContext.get_load_f = &granule_get_load;
-	            granuleContext.free_load_f = &granule_free_load;
-	            granuleContext.debugNoMaterialize = !args.bg_materialize_files;
-
-	            auto r =
-	                tx.readBlobGranules(begin, end, 0 /*begin_version*/, -1 /*end_version, use txn's*/, granuleContext);
-
-	            mem.reset();
-
-	            auto out = Result::KeyValueArray{};
-	            err = r.getKeyValueArrayNothrow(out);
-	            if (!err || err.is(2037 /*blob_granule_not_materialized*/))
-		            return Future();
-	            const auto level = (err.is(1020 /*not_committed*/) || err.is(1021 /*commit_unknown_result*/) ||
-	                                err.is(1213 /*tag_throttled*/))
-	                                   ? VERBOSE_WARN
-	                                   : VERBOSE_NONE;
-	            logr.printWithLogLevel(level, "ERROR", "get_keyvalue_array() after readBlobGranules(): {}", err.what());
-	            return tx.onError(err).eraseType();
-	        } } },
-	    false } }
-};
-
-char const* getOpName(int ops_code) {
-	if (ops_code >= 0 && ops_code < MAX_OP)
-		return opTable[ops_code].name().data();
-	return "";
-}
-
-using OpIterator = std::tuple<int /*op*/, int /*count*/, int /*step*/>;
-
-constexpr const OpIterator OpEnd = OpIterator(MAX_OP, -1, -1);
-
-OpIterator getOpBegin(Arguments const& args) noexcept {
-	for (auto op = 0; op < MAX_OP; op++) {
-		if (isAbstractOp(op) || args.txnspec.ops[op][OP_COUNT] == 0)
-			continue;
-		return OpIterator(op, 0, 0);
-	}
-	return OpEnd;
-}
-
-OpIterator getOpNext(Arguments const& args, OpIterator current) noexcept {
-	if (OpEnd == current)
-		return OpEnd;
-	auto [op, count, step] = current;
-	assert(op < MAX_OP && !isAbstractOp(op));
-	if (opTable[op].steps() > step + 1)
-		return OpIterator(op, count, step + 1);
-	count++;
-	for (; op < MAX_OP; op++, count = 0) {
-		if (isAbstractOp(op) || args.txnspec.ops[op][OP_COUNT] <= count)
-			continue;
-		return OpIterator(op, count, 0);
-	}
-	return OpEnd;
-}
-
 /* run one transaction */
 int runOneTask(Transaction tx, Arguments const& args, ThreadStatistics& stats, LatencySampleBinArray& sample_bins) {
 	// reuse memory for keys to avoid realloc overhead
@@ -867,353 +443,6 @@ void dumpThreadSamples(Arguments const& args,
 	}
 }
 
-// as we don't have coroutines yet, we need to store in heap the complete state of execution,
-// such that we can reconstruct and resume exactly where we were from last database op.
-struct ResumableStateForPopulate {
-	Logger logr;
-	Database db;
-	Transaction tx;
-	boost::asio::io_context& io_context;
-	Arguments const& args;
-	ThreadStatistics& stats;
-	std::atomic<int>& stopcount;
-	LatencySampleBinArray sample_bins;
-	int key_begin;
-	int key_end;
-	int key_checkpoint;
-	ByteString keystr;
-	ByteString valstr;
-	Stopwatch watch_tx;
-	Stopwatch watch_commit;
-	Stopwatch watch_total;
-};
-
-using PopulateStateHandle = std::shared_ptr<ResumableStateForPopulate>;
-
-// avoid redeclaring each variable for each continuation after async op
-#define UNPACK_RESUMABLE_STATE_FOR_POPULATE(p_state)                                                                   \
-	[[maybe_unused]] auto& [logr,                                                                                      \
-	                        db,                                                                                        \
-	                        tx,                                                                                        \
-	                        io_context,                                                                                \
-	                        args,                                                                                      \
-	                        stats,                                                                                     \
-	                        stopcount,                                                                                 \
-	                        sample_bins,                                                                               \
-	                        key_begin,                                                                                 \
-	                        key_end,                                                                                   \
-	                        key_checkpoint,                                                                            \
-	                        keystr,                                                                                    \
-	                        valstr,                                                                                    \
-	                        watch_tx,                                                                                  \
-	                        watch_commit,                                                                              \
-	                        watch_total] = *p_state
-
-void resumablePopulate(PopulateStateHandle state) {
-	UNPACK_RESUMABLE_STATE_FOR_POPULATE(state);
-	const auto num_commit_every = args.txnspec.ops[OP_INSERT][OP_COUNT];
-	for (auto i = key_checkpoint; i <= key_end; i++) {
-		genKey(keystr, KEY_PREFIX, args, i);
-		randomString(valstr, args.value_length);
-		tx.set(keystr, valstr);
-		stats.incrOpCount(OP_INSERT);
-		if (i == key_end || (i - key_begin + 1) % num_commit_every == 0) {
-			watch_commit.start();
-			auto f = tx.commit();
-			f.then([state, i](Future f) {
-				UNPACK_RESUMABLE_STATE_FOR_POPULATE(state);
-				if (auto err = f.error()) {
-					logr.printWithLogLevel(err.retryable() ? VERBOSE_WARN : VERBOSE_NONE,
-					                       "ERROR",
-					                       "commit for populate returned '{}'",
-					                       err.what());
-					auto err_f = tx.onError(err);
-					err_f.then([state](Future f) {
-						UNPACK_RESUMABLE_STATE_FOR_POPULATE(state);
-						const auto f_rc = handleForOnError(tx, f, "ON_ERROR_FOR_POPULATE");
-						if (f_rc == FutureRC::ABORT) {
-							stopcount.fetch_add(1);
-							return;
-						} else {
-							boost::asio::post(io_context, [state]() { resumablePopulate(state); });
-						}
-					});
-				} else {
-					// successfully committed
-					watch_commit.stop();
-					watch_tx.setStop(watch_commit.getStop());
-					if (stats.getOpCount(OP_TASK) % args.sampling == 0) {
-						const auto commit_latency = watch_commit.diff();
-						const auto tx_duration = watch_tx.diff();
-						stats.addLatency(OP_COMMIT, commit_latency);
-						stats.addLatency(OP_TRANSACTION, tx_duration);
-						stats.addLatency(OP_TASK, tx_duration);
-						sample_bins[OP_COMMIT].put(commit_latency);
-						sample_bins[OP_TRANSACTION].put(tx_duration);
-						sample_bins[OP_TASK].put(tx_duration);
-					}
-					stats.incrOpCount(OP_COMMIT);
-					stats.incrOpCount(OP_TRANSACTION);
-					stats.incrOpCount(OP_TASK);
-					tx.reset();
-					watch_tx.startFromStop();
-					key_checkpoint = i + 1;
-					if (i != key_end) {
-						boost::asio::post(io_context, [state]() { resumablePopulate(state); });
-					} else {
-						logr.debug("Populated {} rows [{}, {}]: {:6.3f} sec",
-						           key_end - key_begin + 1,
-						           key_begin,
-						           key_end,
-						           toDoubleSeconds(watch_total.stop().diff()));
-						stopcount.fetch_add(1);
-						return;
-					}
-				}
-			});
-			break;
-		}
-	}
-}
-
-struct ResumableStateForRunWorkload {
-	Logger logr;
-	Database db;
-	Transaction tx;
-	boost::asio::io_context& io_context;
-	Arguments const& args;
-	ThreadStatistics& stats;
-	std::atomic<int>& stopcount;
-	std::atomic<int> const& signal;
-	int max_iters;
-	OpIterator op_iter;
-	LatencySampleBinArray sample_bins;
-	ByteString key1;
-	ByteString key2;
-	ByteString val;
-	std::array<Stopwatch, MAX_OP> watch_per_op;
-	Stopwatch watch_step;
-	Stopwatch watch_commit;
-	Stopwatch watch_tx;
-	Stopwatch watch_task;
-	bool needs_commit;
-	void signalEnd() noexcept { stopcount.fetch_add(1); }
-	bool ended() noexcept {
-		return (max_iters != -1 && max_iters >= stats.getOpCount(OP_TASK)) || signal.load() == SIGNAL_RED;
-	}
-};
-
-using RunWorkloadStateHandle = std::shared_ptr<ResumableStateForRunWorkload>;
-
-#define UNPACK_RESUMABLE_STATE_FOR_RUN_WORKLOAD(p_state)                                                               \
-	[[maybe_unused]] auto& [logr,                                                                                      \
-	                        db,                                                                                        \
-	                        tx,                                                                                        \
-	                        io_context,                                                                                \
-	                        args,                                                                                      \
-	                        stats,                                                                                     \
-	                        stopcount,                                                                                 \
-	                        signal,                                                                                    \
-	                        max_iters,                                                                                 \
-	                        op_iter,                                                                                   \
-	                        sample_bins,                                                                               \
-	                        key1,                                                                                      \
-	                        key2,                                                                                      \
-	                        val,                                                                                       \
-	                        watch_per_op,                                                                              \
-	                        watch_step,                                                                                \
-	                        watch_commit,                                                                              \
-	                        watch_tx,                                                                                  \
-	                        watch_task,                                                                                \
-	                        needs_commit] = *p_state;                                                                  \
-	[[maybe_unused]] auto& [op, count, step] = op_iter;                                                                \
-	[[maybe_unused]] const auto step_kind = opTable[op].stepKind(step)
-
-void resumableRunWorkload(RunWorkloadStateHandle state);
-
-void onStepSuccess(RunWorkloadStateHandle state) {
-	UNPACK_RESUMABLE_STATE_FOR_RUN_WORKLOAD(state);
-	logr.debug("Step {}:{} succeeded", getOpName(op), step);
-	// step successful
-	watch_step.stop();
-	const auto do_sample = stats.getOpCount(OP_TASK) % args.sampling == 0;
-	if (step_kind == StepKind::COMMIT) {
-		// reset transaction boundary
-		const auto step_latency = watch_step.diff();
-		watch_tx.setStop(watch_step.getStop());
-		if (do_sample) {
-			const auto tx_duration = watch_tx.diff();
-			stats.addLatency(OP_COMMIT, step_latency);
-			stats.addLatency(OP_TRANSACTION, tx_duration);
-			sample_bins[OP_COMMIT].put(step_latency);
-			sample_bins[OP_TRANSACTION].put(tx_duration);
-		}
-		tx.reset();
-		watch_tx.startFromStop();
-		stats.incrOpCount(OP_COMMIT);
-		stats.incrOpCount(OP_TRANSACTION);
-		needs_commit = false;
-	}
-	// op completed successfully
-	if (step + 1 == opTable[op].steps()) {
-		if (opTable[op].needsCommit())
-			needs_commit = true;
-		watch_per_op[op].setStop(watch_step.getStop());
-		if (do_sample) {
-			const auto op_latency = watch_per_op[op].diff();
-			stats.addLatency(op, op_latency);
-			sample_bins[op].put(op_latency);
-		}
-		stats.incrOpCount(op);
-	}
-	op_iter = getOpNext(args, op_iter);
-	if (op_iter == OpEnd) {
-		if (needs_commit || args.commit_get) {
-			// task completed, need to commit before finish
-			watch_commit.start();
-			auto f = tx.commit().eraseType();
-			f.then([state](Future f) {
-				UNPACK_RESUMABLE_STATE_FOR_RUN_WORKLOAD(state);
-				if (auto err = f.error()) {
-					// commit had errors
-					logr.printWithLogLevel(err.retryable() ? VERBOSE_WARN : VERBOSE_NONE,
-					                       "ERROR",
-					                       "Post-iteration commit returned error: {}",
-					                       err.what());
-					tx.onError(err).then([state](Future f) {
-						UNPACK_RESUMABLE_STATE_FOR_RUN_WORKLOAD(state);
-						const auto rc = handleForOnError(tx, f, "ON_ERROR");
-						if (rc == FutureRC::CONFLICT)
-							stats.incrConflictCount();
-						else
-							stats.incrErrorCount(OP_COMMIT);
-						if (rc == FutureRC::ABORT) {
-							state->signalEnd();
-							return;
-						}
-						op_iter = getOpBegin(args);
-						needs_commit = false;
-						boost::asio::post(io_context, [state]() { resumableRunWorkload(state); });
-					});
-				} else {
-					// commit successful
-					watch_commit.stop();
-					watch_tx.setStop(watch_commit.getStop());
-					watch_task.setStop(watch_commit.getStop());
-					if (stats.getOpCount(OP_TASK) % args.sampling == 0) {
-						const auto commit_latency = watch_commit.diff();
-						const auto tx_duration = watch_tx.diff();
-						const auto task_duration = watch_task.diff();
-						stats.addLatency(OP_COMMIT, commit_latency);
-						stats.addLatency(OP_TRANSACTION, commit_latency);
-						stats.addLatency(OP_TASK, task_duration);
-						sample_bins[OP_COMMIT].put(commit_latency);
-						sample_bins[OP_TRANSACTION].put(tx_duration);
-						sample_bins[OP_TASK].put(task_duration);
-					}
-					stats.incrOpCount(OP_COMMIT);
-					stats.incrOpCount(OP_TRANSACTION);
-					stats.incrOpCount(OP_TASK);
-					tx.reset();
-					watch_tx.startFromStop();
-					watch_task.startFromStop();
-					if (state->ended()) {
-						state->signalEnd();
-						return;
-					}
-					// start next iteration
-					op_iter = getOpBegin(args);
-					boost::asio::post(io_context, [state]() { resumableRunWorkload(state); });
-				}
-			});
-		} else {
-			// task completed but no need to commit
-			watch_task.stop();
-			if (stats.getOpCount(OP_TASK) % args.sampling == 0) {
-				const auto task_duration = watch_task.diff();
-				stats.addLatency(OP_TASK, task_duration);
-				sample_bins[OP_TASK].put(task_duration);
-			}
-			stats.incrOpCount(OP_TASK);
-			watch_tx.startFromStop();
-			watch_task.startFromStop();
-			tx.reset();
-			if (state->ended()) {
-				state->signalEnd();
-				return;
-			}
-			op_iter = getOpBegin(args);
-			// run next iteration
-			boost::asio::post(io_context, [state]() { resumableRunWorkload(state); });
-		}
-	} else {
-		boost::asio::post(io_context, [state]() { resumableRunWorkload(state); });
-	}
-}
-
-void resumableRunWorkload(RunWorkloadStateHandle state) {
-	UNPACK_RESUMABLE_STATE_FOR_RUN_WORKLOAD(state);
-	assert(op_iter != OpEnd);
-	watch_step.start();
-	if (step == 0 /* first step */) {
-		watch_per_op[op] = Stopwatch(watch_step.getStart());
-	}
-	auto f = opTable[op].stepFunction(step)(tx, args, key1, key2, val);
-	if (!f) {
-		// immediately completed client-side ops: e.g. set, setrange, clear, clearrange, ...
-		onStepSuccess(state);
-	} else {
-		f.then([state](Future f) {
-			UNPACK_RESUMABLE_STATE_FOR_RUN_WORKLOAD(state);
-			if (step_kind != StepKind::ON_ERROR) {
-				if (auto err = f.error()) {
-					logr.printWithLogLevel(err.retryable() ? VERBOSE_WARN : VERBOSE_NONE,
-					                       "ERROR",
-					                       "step {} of op {} returned '{}'",
-					                       step,
-					                       opTable[op].name(),
-					                       err.what());
-					tx.onError(err).then([state](Future f) {
-						UNPACK_RESUMABLE_STATE_FOR_RUN_WORKLOAD(state);
-						const auto rc = handleForOnError(tx, f, fmt::format("{}_STEP_{}", opTable[op].name(), step));
-						if (rc == FutureRC::RETRY) {
-							stats.incrErrorCount(op);
-						} else if (rc == FutureRC::CONFLICT) {
-							stats.incrConflictCount();
-						} else if (rc == FutureRC::ABORT) {
-							tx.reset();
-							stopcount.fetch_add(1);
-							return;
-						}
-						op_iter = getOpBegin(args);
-						needs_commit = false;
-						// restart this iteration from beginning
-						boost::asio::post(io_context, [state]() { resumableRunWorkload(state); });
-					});
-					return;
-				}
-			} else {
-				auto rc = handleForOnError(tx, f, "BG_ON_ERROR");
-				if (rc == FutureRC::RETRY) {
-					stats.incrErrorCount(op);
-				} else if (rc == FutureRC::CONFLICT) {
-					stats.incrConflictCount();
-				} else if (rc == FutureRC::ABORT) {
-					tx.reset();
-					stopcount.fetch_add(1);
-					return;
-				}
-				op_iter = getOpBegin(args);
-				needs_commit = false;
-				// restart this iteration from beginning
-				boost::asio::post(io_context, [state]() { resumableRunWorkload(state); });
-				return;
-			}
-			onStepSuccess(state);
-		});
-	}
-}
-
 void runAsyncWorkload(Arguments const& args,
                       pid_t pid_main,
                       int worker_id,
@@ -1227,39 +456,31 @@ void runAsyncWorkload(Arguments const& args,
 			overwrite = false;
 		}
 	};
-	std::atomic<int> stopcount = ATOMIC_VAR_INIT(0);
+	auto stopcount = std::atomic<int>{};
 	if (args.mode == MODE_BUILD) {
 		auto states = std::vector<PopulateStateHandle>(args.async_xacts);
 		for (auto i = 0; i < args.async_xacts; i++) {
 			const auto key_begin = insertBegin(args.rows, worker_id, i, args.num_processes, args.async_xacts);
 			const auto key_end = insertEnd(args.rows, worker_id, i, args.num_processes, args.async_xacts);
 			auto db = databases[i % args.num_databases];
-			auto state =
-			    PopulateStateHandle(new ResumableStateForPopulate{ Logger(WorkerProcess{}, args.verbose, worker_id, i),
-			                                                       db,
-			                                                       db.createTransaction(),
-			                                                       io_context,
-			                                                       args,
-			                                                       shm.statsSlot(worker_id, i),
-			                                                       stopcount,
-			                                                       LatencySampleBinArray(),
-			                                                       key_begin,
-			                                                       key_end,
-			                                                       key_begin,
-			                                                       ByteString{},
-			                                                       ByteString{},
-			                                                       Stopwatch(StartAtCtor{}),
-			                                                       Stopwatch(),
-			                                                       Stopwatch(StartAtCtor{}) });
+			auto state = std::make_shared<ResumableStateForPopulate>(
+											   Logger(WorkerProcess{}, args.verbose, worker_id, i),
+											   db,
+											   db.createTransaction(),
+											   io_context,
+											   args,
+											   shm.statsSlot(worker_id, i),
+											   stopcount,
+											   key_begin,
+											   key_end);
+			state->watch_tx.start();
+			state->watch_total.start();
 			states[i] = state;
-			state->keystr.reserve(args.key_length);
-			state->valstr.reserve(args.value_length);
 		}
 		while (shm.headerConst().signal.load() != SIGNAL_GREEN)
 			usleep(1000);
 		// launch [async_xacts] concurrent transactions
-		for (auto state : states)
-			boost::asio::post(io_context, [state]() { resumablePopulate(state); });
+		for (auto state : states) state->postNextTick();
 		while (stopcount.load() != args.async_xacts)
 			usleep(1000);
 		dump_samples(states);
@@ -1271,8 +492,8 @@ void runAsyncWorkload(Arguments const& args,
 			    args.iteration == 0
 			        ? -1
 			        : computeThreadIters(args.iteration, worker_id, i, args.num_processes, args.async_xacts);
-			auto state = RunWorkloadStateHandle(
-			    new ResumableStateForRunWorkload{ Logger(WorkerProcess{}, args.verbose, worker_id, i),
+			auto state = std::make_shared<ResumableStateForRunWorkload>(
+												  Logger(WorkerProcess{}, args.verbose, worker_id, i),
 			                                      db,
 			                                      db.createTransaction(),
 			                                      io_context,
@@ -1281,26 +502,14 @@ void runAsyncWorkload(Arguments const& args,
 			                                      stopcount,
 			                                      shm.headerConst().signal,
 			                                      max_iters,
-			                                      getOpBegin(args),
-			                                      LatencySampleBinArray(),
-			                                      ByteString{},
-			                                      ByteString{},
-			                                      ByteString{},
-			                                      std::array<Stopwatch, MAX_OP>{},
-			                                      Stopwatch() /*watch_step*/,
-			                                      Stopwatch() /*watch_commit*/,
-			                                      Stopwatch(StartAtCtor{}) /*watch_tx*/,
-			                                      Stopwatch(StartAtCtor{}) /*watch_task*/,
-			                                      false /*needs_commit*/ });
+			                                      getOpBegin(args));
 			states[i] = state;
-			state->key1.reserve(args.key_length);
-			state->key2.reserve(args.key_length);
-			state->val.reserve(args.value_length);
+			state->watch_task.start();
+			state->watch_tx.start();
 		}
 		while (shm.headerConst().signal.load() != SIGNAL_GREEN)
 			usleep(1000);
-		for (auto state : states)
-			boost::asio::post(io_context, [state]() { resumableRunWorkload(state); });
+		for (auto state : states) state->postNextTick();
 		logr.debug("Launched {} concurrent transactions", states.size());
 		while (stopcount.load() != args.async_xacts)
 			usleep(1000);
diff --git a/bindings/c/test/mako/mako.hpp b/bindings/c/test/mako/mako.hpp
index 6f3dfe6987..b4b1182ca7 100644
--- a/bindings/c/test/mako/mako.hpp
+++ b/bindings/c/test/mako/mako.hpp
@@ -81,7 +81,6 @@ constexpr const int KNOB_MAX = 256;
 constexpr const int TAGPREFIXLENGTH_MAX = 8;
 constexpr const int NUM_CLUSTERS_MAX = 3;
 constexpr const int NUM_DATABASES_MAX = 10;
-constexpr const int MAX_BG_IDS = 1000;
 constexpr const std::string_view KEY_PREFIX{ "mako" };
 constexpr const std::string_view TEMP_DATA_STORE{ "/tmp/makoTemp" };
 
@@ -145,37 +144,6 @@ struct alignas(64) ThreadArgs {
 	fdb::Database database; // database to work with
 };
 
-using StepFunction = fdb::Future (*)(fdb::Transaction tx,
-                                     Arguments const&,
-                                     fdb::ByteString& /*key1*/,
-                                     fdb::ByteString& /*key2*/,
-                                     fdb::ByteString& /*value*/);
-
-class Operation {
-	using Step = std::pair<StepKind, StepFunction>;
-	std::string_view name_;
-	std::vector<Step> steps_;
-	bool needs_commit_;
-
-public:
-	Operation(std::string_view name, std::vector<Step>&& steps, bool needs_commit)
-	  : name_(name), steps_(std::move(steps)), needs_commit_(needs_commit) {}
-
-	std::string_view name() const noexcept { return name_; }
-
-	StepKind stepKind(int step) const noexcept {
-		assert(step < steps());
-		return steps_[step].first;
-	}
-
-	StepFunction stepFunction(int step) const noexcept { return steps_[step].second; }
-
-	// how many steps in this op?
-	int steps() const noexcept { return static_cast<int>(steps_.size()); }
-	// does the op needs to commit some time after its final step?
-	bool needsCommit() const noexcept { return needs_commit_; }
-};
-
 } // namespace mako
 
 #endif /* MAKO_HPP */
diff --git a/bindings/c/test/mako/operations.cpp b/bindings/c/test/mako/operations.cpp
new file mode 100644
index 0000000000..f7228aef99
--- /dev/null
+++ b/bindings/c/test/mako/operations.cpp
@@ -0,0 +1,292 @@
+#include "blob_granules.hpp"
+#include "operations.hpp"
+#include "mako.hpp"
+#include "logger.hpp"
+#include "utils.hpp"
+#include "fdbclient/zipf.h"
+#include <array>
+
+extern thread_local mako::Logger logr;
+
+namespace mako {
+
+OpIterator getOpBegin(Arguments const& args) noexcept {
+	for (auto op = 0; op < MAX_OP; op++) {
+		if (isAbstractOp(op) || args.txnspec.ops[op][OP_COUNT] == 0)
+			continue;
+		return OpIterator(op, 0, 0);
+	}
+	return OpEnd;
+}
+
+OpIterator getOpNext(Arguments const& args, OpIterator current) noexcept {
+	if (OpEnd == current)
+		return OpEnd;
+	auto [op, count, step] = current;
+	assert(op < MAX_OP && !isAbstractOp(op));
+	if (opTable[op].steps() > step + 1)
+		return OpIterator(op, count, step + 1);
+	count++;
+	for (; op < MAX_OP; op++, count = 0) {
+		if (isAbstractOp(op) || args.txnspec.ops[op][OP_COUNT] <= count)
+			continue;
+		return OpIterator(op, count, 0);
+	}
+	return OpEnd;
+}
+
+using namespace fdb;
+
+inline int nextKey(Arguments const& args) {
+	if (args.zipf)
+		return zipfian_next();
+	return urand(0, args.rows - 1);
+}
+
+char const* getOpName(int ops_code) {
+	if (ops_code >= 0 && ops_code < MAX_OP)
+		return opTable[ops_code].name().data();
+	return "";
+}
+
+const std::array<Operation, MAX_OP> opTable{
+	{ { "GRV",
+	    { { StepKind::READ,
+	        [](Transaction tx, Arguments const&, ByteString&, ByteString&, ByteString&) {
+	            return tx.getReadVersion().eraseType();
+	        } } },
+	    false },
+	  { "GET",
+	    { { StepKind::READ,
+	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
+	            const auto num = nextKey(args);
+	            genKey(key, KEY_PREFIX, args, num);
+	            return tx.get(key, false /*snapshot*/).eraseType();
+	        } } },
+	    false },
+	  { "GETRANGE",
+	    { { StepKind::READ,
+	        [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
+	            const auto num_begin = nextKey(args);
+	            genKey(begin, KEY_PREFIX, args, num_begin);
+	            auto num_end = num_begin + args.txnspec.ops[OP_GETRANGE][OP_RANGE] - 1;
+	            if (num_end > args.rows - 1)
+		            num_end = args.rows - 1;
+	            genKey(end, KEY_PREFIX, args, num_end);
+	            return tx
+	                .getRange<key_select::Inclusive, key_select::Inclusive>(begin,
+	                                                                        end,
+	                                                                        0 /*limit*/,
+	                                                                        0 /*target_bytes*/,
+	                                                                        args.streaming_mode,
+	                                                                        0 /*iteration*/,
+	                                                                        false /*snapshot*/,
+	                                                                        args.txnspec.ops[OP_GETRANGE][OP_REVERSE])
+	                .eraseType();
+	        } } },
+	    false },
+	  { "SGET",
+	    { { StepKind::READ,
+	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
+	            const auto num = nextKey(args);
+	            genKey(key, KEY_PREFIX, args, num);
+	            return tx.get(key, true /*snapshot*/).eraseType();
+	        } } },
+	    false },
+	  { "SGETRANGE",
+	    { {
+
+	        StepKind::READ,
+	        [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
+	            const auto num_begin = nextKey(args);
+	            genKey(begin, KEY_PREFIX, args, num_begin);
+	            auto num_end = num_begin + args.txnspec.ops[OP_SGETRANGE][OP_RANGE] - 1;
+	            if (num_end > args.rows - 1)
+		            num_end = args.rows - 1;
+	            genKey(end, KEY_PREFIX, args, num_end);
+	            return tx
+	                .getRange<key_select::Inclusive, key_select::Inclusive>(begin,
+	                                                                        end,
+	                                                                        0 /*limit*/,
+	                                                                        0 /*target_bytes*/,
+	                                                                        args.streaming_mode,
+	                                                                        0 /*iteration*/,
+	                                                                        true /*snapshot*/,
+	                                                                        args.txnspec.ops[OP_SGETRANGE][OP_REVERSE])
+	                .eraseType();
+	        }
+
+	    } },
+	    false },
+	  { "UPDATE",
+	    { { StepKind::READ,
+	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
+	            const auto num = nextKey(args);
+	            genKey(key, KEY_PREFIX, args, num);
+	            return tx.get(key, false /*snapshot*/).eraseType();
+	        } },
+	      { StepKind::IMM,
+	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
+	            randomString(value, args.value_length);
+	            tx.set(key, value);
+	            return Future();
+	        } } },
+	    true },
+	  { "INSERT",
+	    { { StepKind::IMM,
+	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
+	            genKeyPrefix(key, KEY_PREFIX, args);
+	            // concat([padding], key_prefix, random_string): reasonably unique
+	            randomString<false /*clear-before-append*/>(key, args.key_length - static_cast<int>(key.size()));
+	            randomString(value, args.value_length);
+	            tx.set(key, value);
+	            return Future();
+	        } } },
+	    true },
+	  { "INSERTRANGE",
+	    { { StepKind::IMM,
+	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
+	            genKeyPrefix(key, KEY_PREFIX, args);
+	            const auto prefix_len = static_cast<int>(key.size());
+	            const auto range = args.txnspec.ops[OP_INSERTRANGE][OP_RANGE];
+	            assert(range > 0);
+	            const auto range_digits = digits(range);
+	            assert(args.key_length - prefix_len >= range_digits);
+	            const auto rand_len = args.key_length - prefix_len - range_digits;
+	            // concat([padding], prefix, random_string, range_digits)
+	            randomString<false /*clear-before-append*/>(key, rand_len);
+	            randomString(value, args.value_length);
+	            for (auto i = 0; i < range; i++) {
+		            fmt::format_to(std::back_inserter(key), "{0:0{1}d}", i, range_digits);
+		            tx.set(key, value);
+		            key.resize(key.size() - static_cast<size_t>(range_digits));
+	            }
+	            return Future();
+	        } } },
+	    true },
+	  { "OVERWRITE",
+	    { { StepKind::IMM,
+	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
+	            genKey(key, KEY_PREFIX, args, nextKey(args));
+	            randomString(value, args.value_length);
+	            tx.set(key, value);
+	            return Future();
+	        } } },
+	    true },
+	  { "CLEAR",
+	    { { StepKind::IMM,
+	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
+	            genKey(key, KEY_PREFIX, args, nextKey(args));
+	            tx.clear(key);
+	            return Future();
+	        } } },
+	    true },
+	  { "SETCLEAR",
+	    { { StepKind::COMMIT,
+	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
+	            genKeyPrefix(key, KEY_PREFIX, args);
+	            const auto prefix_len = static_cast<int>(key.size());
+	            randomString<false /*append-after-clear*/>(key, args.key_length - prefix_len);
+	            randomString(value, args.value_length);
+	            tx.set(key, value);
+	            return tx.commit().eraseType();
+	        } },
+	      { StepKind::IMM,
+	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
+	            tx.reset(); // assuming commit from step 0 worked.
+	            tx.clear(key); // key should forward unchanged from step 0
+	            return Future();
+	        } } },
+	    true },
+	  { "CLEARRANGE",
+	    { { StepKind::IMM,
+	        [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
+	            const auto num_begin = nextKey(args);
+	            genKey(begin, KEY_PREFIX, args, num_begin);
+	            const auto range = args.txnspec.ops[OP_CLEARRANGE][OP_RANGE];
+	            assert(range > 0);
+	            genKey(end, KEY_PREFIX, args, std::min(args.rows - 1, num_begin + range - 1));
+	            tx.clearRange(begin, end);
+	            return Future();
+	        } } },
+	    true },
+	  { "SETCLEARRANGE",
+	    { { StepKind::COMMIT,
+	        [](Transaction tx, Arguments const& args, ByteString& key_begin, ByteString& key, ByteString& value) {
+	            genKeyPrefix(key, KEY_PREFIX, args);
+	            const auto prefix_len = static_cast<int>(key.size());
+	            const auto range = args.txnspec.ops[OP_SETCLEARRANGE][OP_RANGE];
+	            assert(range > 0);
+	            const auto range_digits = digits(range);
+	            assert(args.key_length - prefix_len >= range_digits);
+	            const auto rand_len = args.key_length - prefix_len - range_digits;
+	            // concat([padding], prefix, random_string, range_digits)
+	            randomString<false /*clear-before-append*/>(key, rand_len);
+	            randomString(value, args.value_length);
+	            for (auto i = 0; i <= range; i++) {
+		            fmt::format_to(std::back_inserter(key), "{0:0{1}d}", i, range_digits);
+		            if (i == range)
+			            break; // preserve "exclusive last"
+		            // preserve first key for step 1
+		            if (i == 0)
+			            key_begin = key;
+		            tx.set(key, value);
+		            // preserve last key for step 1
+		            key.resize(key.size() - static_cast<size_t>(range_digits));
+	            }
+	            return tx.commit().eraseType();
+	        } },
+	      { StepKind::IMM,
+	        [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
+	            tx.reset();
+	            tx.clearRange(begin, end);
+	            return Future();
+	        } } },
+	    true },
+	  { "COMMIT", { { StepKind::NONE, nullptr } }, false },
+	  { "TRANSACTION", { { StepKind::NONE, nullptr } }, false },
+	  { "TASK", { { StepKind::NONE, nullptr } }, false },
+	  { "READBLOBGRANULE",
+	    { { StepKind::ON_ERROR,
+	        [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
+	            const auto num_begin = nextKey(args);
+	            genKey(begin, KEY_PREFIX, args, num_begin);
+	            const auto range = args.txnspec.ops[OP_READ_BG][OP_RANGE];
+	            assert(range > 0);
+	            genKey(end, KEY_PREFIX, args, std::min(args.rows - 1, num_begin + range - 1));
+	            auto err = Error{};
+
+	            err = tx.setOptionNothrow(FDB_TR_OPTION_READ_YOUR_WRITES_DISABLE, BytesRef());
+	            if (err) {
+		            // Issuing read/writes before disabling RYW results in error.
+		            // Possible malformed workload?
+		            // As workloads execute in sequence, retrying would likely repeat this error.
+		            fmt::print(stderr, "ERROR: TR_OPTION_READ_YOUR_WRITES_DISABLE: {}", err.what());
+		            return Future();
+	            }
+
+	            // Allocate a separate context per call to avoid multiple threads accessing
+				auto user_context = blob_granules::local_file::UserContext(args.bg_file_path);
+
+	            auto api_context = blob_granules::local_file::createApiContext(user_context, args.bg_materialize_files);
+
+	            auto r =
+	                tx.readBlobGranules(begin, end, 0 /*begin_version*/, -1 /*end_version, use txn's*/, api_context);
+
+	            user_context.clear();
+
+	            auto out = Result::KeyValueArray{};
+	            err = r.getKeyValueArrayNothrow(out);
+	            if (!err || err.is(2037 /*blob_granule_not_materialized*/))
+		            return Future();
+	            const auto level = (err.is(1020 /*not_committed*/) || err.is(1021 /*commit_unknown_result*/) ||
+	                                err.is(1213 /*tag_throttled*/))
+	                                   ? VERBOSE_WARN
+	                                   : VERBOSE_NONE;
+	            logr.printWithLogLevel(level, "ERROR", "get_keyvalue_array() after readBlobGranules(): {}", err.what());
+	            return tx.onError(err).eraseType();
+	        } } },
+	    false } }
+};
+
+} // namespace mako
diff --git a/bindings/c/test/mako/operations.hpp b/bindings/c/test/mako/operations.hpp
index 9ecf6cb901..98a1770b87 100644
--- a/bindings/c/test/mako/operations.hpp
+++ b/bindings/c/test/mako/operations.hpp
@@ -1,11 +1,18 @@
 #ifndef MAKO_OPERATIONS_HPP
 #define MAKO_OPERATIONS_HPP
 
-#include <vector>
+#include <fdb.hpp>
+#include <array>
+#include <cassert>
 #include <string_view>
+#include <tuple>
+#include <utility>
+#include <vector>
 
 namespace mako {
 
+struct Arguments;
+
 /* transaction specification */
 enum OpKind {
 	OP_GETREADVERSION,
@@ -46,6 +53,49 @@ inline bool isAbstractOp(int op) noexcept {
 	return op == OP_COMMIT || op == OP_TRANSACTION; // || op == OP_TASK;
 }
 
+using StepFunction = fdb::Future (*)(fdb::Transaction tx,
+                                     Arguments const&,
+                                     fdb::ByteString& /*key1*/,
+                                     fdb::ByteString& /*key2*/,
+                                     fdb::ByteString& /*value*/);
+
+class Operation {
+	using Step = std::pair<StepKind, StepFunction>;
+	std::string_view name_;
+	std::vector<Step> steps_;
+	bool needs_commit_;
+
+public:
+	Operation(std::string_view name, std::vector<Step>&& steps, bool needs_commit)
+	  : name_(name), steps_(std::move(steps)), needs_commit_(needs_commit) {}
+
+	std::string_view name() const noexcept { return name_; }
+
+	StepKind stepKind(int step) const noexcept {
+		assert(step < steps());
+		return steps_[step].first;
+	}
+
+	StepFunction stepFunction(int step) const noexcept { return steps_[step].second; }
+
+	// how many steps in this op?
+	int steps() const noexcept { return static_cast<int>(steps_.size()); }
+	// does the op needs to commit some time after its final step?
+	bool needsCommit() const noexcept { return needs_commit_; }
+};
+
+char const* getOpName(int ops_code);
+
+extern const std::array<Operation, MAX_OP> opTable;
+
+using OpIterator = std::tuple<int /*op*/, int /*count*/, int /*step*/>;
+
+constexpr const OpIterator OpEnd = OpIterator(MAX_OP, -1, -1);
+
+OpIterator getOpBegin(Arguments const& args) noexcept;
+
+OpIterator getOpNext(Arguments const& args, OpIterator current) noexcept;
+
 } // namespace mako
 
 #endif /* MAKO_OPERATIONS_HPP */

From ebf86f9cff71e853afa200af4c335fd847bdd78f Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Fri, 1 Apr 2022 14:07:17 -0700
Subject: [PATCH 19/84] Fix incorrect stats collection

---
 bindings/c/test/mako/async.cpp | 3 +--
 bindings/c/test/mako/mako.cpp  | 7 ++-----
 bindings/c/test/mako/shm.hpp   | 7 ++++++-
 3 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/bindings/c/test/mako/async.cpp b/bindings/c/test/mako/async.cpp
index 2e98e3fc7b..e642a440ca 100644
--- a/bindings/c/test/mako/async.cpp
+++ b/bindings/c/test/mako/async.cpp
@@ -192,8 +192,7 @@ void ResumableStateForRunWorkload::onStepSuccess() {
 		if (needs_commit || args.commit_get) {
 			// task completed, need to commit before finish
 			watch_commit.start();
-			auto f = tx.commit().eraseType();
-			f.then([this, state=shared_from_this()](Future f) {
+			tx.commit().then([this, state=shared_from_this()](Future f) {
 				UNPACK_OP_INFO();
 				if (auto err = f.error()) {
 					// commit had errors
diff --git a/bindings/c/test/mako/mako.cpp b/bindings/c/test/mako/mako.cpp
index 5a1e06f085..355771e386 100644
--- a/bindings/c/test/mako/mako.cpp
+++ b/bindings/c/test/mako/mako.cpp
@@ -534,9 +534,6 @@ void workerThread(ThreadArgs& thread_args) {
 	auto& stats = thread_args.shm.statsSlot(worker_id, thread_id);
 	logr = Logger(WorkerProcess{}, args.verbose, worker_id, thread_id);
 
-	/* init per-thread latency statistics */
-	new (&stats) ThreadStatistics();
-
 	logr.debug("started, tid: {}", reinterpret_cast<uint64_t>(pthread_self()));
 
 	const auto thread_tps =
@@ -1286,7 +1283,7 @@ void printStats(Arguments const& args, ThreadStatistics const* stats, double con
 	const auto num_effective_threads = args.async_xacts > 0 ? args.async_xacts : args.num_threads;
 	auto current = ThreadStatistics{};
 	for (auto i = 0; i < args.num_processes; i++) {
-		for (auto j = 0; j < args.num_threads; j++) {
+		for (auto j = 0; j < num_effective_threads; j++) {
 			current.combine(stats[(i * num_effective_threads) + j]);
 		}
 	}
@@ -1961,7 +1958,7 @@ int main(int argc, char* argv[]) {
 	auto shm_access = shared_memory::Access(shm, args.num_processes, nthreads_for_shm);
 
 	/* initialize the shared memory */
-	shm_access.reset();
+	shm_access.initMemory();
 
 	/* get ready */
 	auto& shm_hdr = shm_access.header();
diff --git a/bindings/c/test/mako/shm.hpp b/bindings/c/test/mako/shm.hpp
index 32ae0c2056..06460293fa 100644
--- a/bindings/c/test/mako/shm.hpp
+++ b/bindings/c/test/mako/shm.hpp
@@ -50,7 +50,12 @@ public:
 
 	size_t size() const noexcept { return storageSize(num_processes, num_threads); }
 
-	void reset() noexcept { memset(base, 0, size()); }
+	void initMemory() noexcept {
+		memset(&header(), 0, sizeof(Header));
+		for (auto i = 0; i < num_processes; i++)
+			for (auto j = 0; j < num_threads; j++)
+				new (&statsSlot(i, j)) ThreadStatistics();
+	}
 
 	Header const& headerConst() const noexcept { return *static_cast<Header const*>(base); }
 

From 61e950e06519975addc160a3c3bd3e8d8af58757 Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Fri, 1 Apr 2022 15:18:10 -0700
Subject: [PATCH 20/84] Run clang format

---
 bindings/c/test/mako/async.cpp         | 20 +++++------
 bindings/c/test/mako/async.hpp         | 45 ++++++++++++------------
 bindings/c/test/mako/blob_granules.cpp |  6 +---
 bindings/c/test/mako/blob_granules.hpp |  3 +-
 bindings/c/test/mako/mako.cpp          | 48 ++++++++++++++------------
 bindings/c/test/mako/operations.cpp    |  2 +-
 6 files changed, 62 insertions(+), 62 deletions(-)

diff --git a/bindings/c/test/mako/async.cpp b/bindings/c/test/mako/async.cpp
index e642a440ca..9cdbab1703 100644
--- a/bindings/c/test/mako/async.cpp
+++ b/bindings/c/test/mako/async.cpp
@@ -14,7 +14,7 @@ using namespace fdb;
 namespace mako {
 
 void ResumableStateForPopulate::postNextTick() {
-	boost::asio::post(io_context, [this, state=shared_from_this()]() { runOneTick(); });
+	boost::asio::post(io_context, [this, state = shared_from_this()]() { runOneTick(); });
 }
 
 void ResumableStateForPopulate::runOneTick() {
@@ -27,14 +27,14 @@ void ResumableStateForPopulate::runOneTick() {
 		if (i == key_end || (i - key_begin + 1) % num_commit_every == 0) {
 			watch_commit.start();
 			auto f = tx.commit();
-			f.then([this, state=shared_from_this(), i](Future f) {
+			f.then([this, state = shared_from_this(), i](Future f) {
 				if (auto err = f.error()) {
 					logr.printWithLogLevel(err.retryable() ? VERBOSE_WARN : VERBOSE_NONE,
 					                       "ERROR",
 					                       "commit for populate returned '{}'",
 					                       err.what());
 					auto err_f = tx.onError(err);
-					err_f.then([this, state=shared_from_this()](Future f) {
+					err_f.then([this, state = shared_from_this()](Future f) {
 						const auto f_rc = handleForOnError(tx, f, "ON_ERROR_FOR_POPULATE");
 						if (f_rc == FutureRC::ABORT) {
 							signalEnd();
@@ -82,11 +82,11 @@ void ResumableStateForPopulate::runOneTick() {
 }
 
 void ResumableStateForRunWorkload::postNextTick() {
-	boost::asio::post(io_context, [this, state=shared_from_this()]() { runOneTick(); });
+	boost::asio::post(io_context, [this, state = shared_from_this()]() { runOneTick(); });
 }
 
-#define UNPACK_OP_INFO() \
-	[[maybe_unused]] auto& [op, count, step] = op_iter; \
+#define UNPACK_OP_INFO()                                                                                               \
+	[[maybe_unused]] auto& [op, count, step] = op_iter;                                                                \
 	[[maybe_unused]] const auto step_kind = opTable[op].stepKind(step)
 
 void ResumableStateForRunWorkload::runOneTick() {
@@ -101,7 +101,7 @@ void ResumableStateForRunWorkload::runOneTick() {
 		// immediately completed client-side ops: e.g. set, setrange, clear, clearrange, ...
 		onStepSuccess();
 	} else {
-		f.then([this, state=shared_from_this()](Future f) {
+		f.then([this, state = shared_from_this()](Future f) {
 			UNPACK_OP_INFO();
 			if (step_kind != StepKind::ON_ERROR) {
 				if (auto err = f.error()) {
@@ -111,7 +111,7 @@ void ResumableStateForRunWorkload::runOneTick() {
 					                       step,
 					                       opTable[op].name(),
 					                       err.what());
-					tx.onError(err).then([this, state=shared_from_this()](Future f) {
+					tx.onError(err).then([this, state = shared_from_this()](Future f) {
 						UNPACK_OP_INFO();
 						const auto rc = handleForOnError(tx, f, fmt::format("{}_STEP_{}", opTable[op].name(), step));
 						if (rc == FutureRC::RETRY) {
@@ -192,7 +192,7 @@ void ResumableStateForRunWorkload::onStepSuccess() {
 		if (needs_commit || args.commit_get) {
 			// task completed, need to commit before finish
 			watch_commit.start();
-			tx.commit().then([this, state=shared_from_this()](Future f) {
+			tx.commit().then([this, state = shared_from_this()](Future f) {
 				UNPACK_OP_INFO();
 				if (auto err = f.error()) {
 					// commit had errors
@@ -200,7 +200,7 @@ void ResumableStateForRunWorkload::onStepSuccess() {
 					                       "ERROR",
 					                       "Post-iteration commit returned error: {}",
 					                       err.what());
-					tx.onError(err).then([this, state=shared_from_this()](Future f) {
+					tx.onError(err).then([this, state = shared_from_this()](Future f) {
 						const auto rc = handleForOnError(tx, f, "ON_ERROR");
 						if (rc == FutureRC::CONFLICT)
 							stats.incrConflictCount();
diff --git a/bindings/c/test/mako/async.hpp b/bindings/c/test/mako/async.hpp
index da32e4afb8..f73f05b3c3 100644
--- a/bindings/c/test/mako/async.hpp
+++ b/bindings/c/test/mako/async.hpp
@@ -31,17 +31,17 @@ struct ResumableStateForPopulate : std::enable_shared_from_this<ResumableStateFo
 	Stopwatch watch_commit;
 	Stopwatch watch_total;
 
-	ResumableStateForPopulate(
-			Logger logr,
-			fdb::Database db, fdb::Transaction tx,
-			boost::asio::io_context& io_context,
-			Arguments const& args,
-			ThreadStatistics& stats,
-			std::atomic<int>& stopcount, int key_begin, int key_end) :
-		logr(logr), db(db), tx(tx),
-		io_context(io_context), args(args), stats(stats), stopcount(stopcount),
-		key_begin(key_begin), key_end(key_end), key_checkpoint(key_begin)
-	{
+	ResumableStateForPopulate(Logger logr,
+	                          fdb::Database db,
+	                          fdb::Transaction tx,
+	                          boost::asio::io_context& io_context,
+	                          Arguments const& args,
+	                          ThreadStatistics& stats,
+	                          std::atomic<int>& stopcount,
+	                          int key_begin,
+	                          int key_end)
+	  : logr(logr), db(db), tx(tx), io_context(io_context), args(args), stats(stats), stopcount(stopcount),
+	    key_begin(key_begin), key_end(key_end), key_checkpoint(key_begin) {
 		keystr.reserve(args.key_length);
 		valstr.reserve(args.value_length);
 	}
@@ -74,17 +74,18 @@ struct ResumableStateForRunWorkload : std::enable_shared_from_this<ResumableStat
 	Stopwatch watch_task;
 	bool needs_commit;
 
-	ResumableStateForRunWorkload(
-			Logger logr,
-			fdb::Database db, fdb::Transaction tx,
-			boost::asio::io_context& io_context,
-			Arguments const& args,
-			ThreadStatistics& stats,
-			std::atomic<int>& stopcount, std::atomic<int> const& signal,
-			int max_iters, OpIterator op_iter) :
-		logr(logr), db(db), tx(tx), io_context(io_context), args(args), stats(stats),
-		stopcount(stopcount), signal(signal), max_iters(max_iters), op_iter(op_iter), needs_commit(false)
-	{
+	ResumableStateForRunWorkload(Logger logr,
+	                             fdb::Database db,
+	                             fdb::Transaction tx,
+	                             boost::asio::io_context& io_context,
+	                             Arguments const& args,
+	                             ThreadStatistics& stats,
+	                             std::atomic<int>& stopcount,
+	                             std::atomic<int> const& signal,
+	                             int max_iters,
+	                             OpIterator op_iter)
+	  : logr(logr), db(db), tx(tx), io_context(io_context), args(args), stats(stats), stopcount(stopcount),
+	    signal(signal), max_iters(max_iters), op_iter(op_iter), needs_commit(false) {
 		key1.reserve(args.key_length);
 		key2.reserve(args.key_length);
 		val.reserve(args.value_length);
diff --git a/bindings/c/test/mako/blob_granules.cpp b/bindings/c/test/mako/blob_granules.cpp
index 84c8584ea4..98f8d92fc0 100644
--- a/bindings/c/test/mako/blob_granules.cpp
+++ b/bindings/c/test/mako/blob_granules.cpp
@@ -7,11 +7,7 @@ extern thread_local mako::Logger logr;
 
 namespace mako::blob_granules::local_file {
 
-int64_t startLoad(const char* filename,
-                  int filenameLength,
-                  int64_t offset,
-                  int64_t length,
-                  void* userContext) {
+int64_t startLoad(const char* filename, int filenameLength, int64_t offset, int64_t length, void* userContext) {
 	FILE* fp;
 	char full_fname[PATH_MAX]{
 		0,
diff --git a/bindings/c/test/mako/blob_granules.hpp b/bindings/c/test/mako/blob_granules.hpp
index 8aec305705..2bbb8fb7b8 100644
--- a/bindings/c/test/mako/blob_granules.hpp
+++ b/bindings/c/test/mako/blob_granules.hpp
@@ -17,7 +17,8 @@ struct UserContext {
 	std::unique_ptr<uint8_t*[]> dataByIdMem;
 	uint8_t** dataById;
 
-	UserContext(char const* filePath) : bgFilePath(filePath), nextId(0), dataByIdMem(new uint8_t*[MAX_BG_IDS]()), dataById(dataByIdMem.get()) {}
+	UserContext(char const* filePath)
+	  : bgFilePath(filePath), nextId(0), dataByIdMem(new uint8_t*[MAX_BG_IDS]()), dataById(dataByIdMem.get()) {}
 
 	void clear() { dataByIdMem.reset(); }
 };
diff --git a/bindings/c/test/mako/mako.cpp b/bindings/c/test/mako/mako.cpp
index 355771e386..f8a172ec5f 100644
--- a/bindings/c/test/mako/mako.cpp
+++ b/bindings/c/test/mako/mako.cpp
@@ -463,16 +463,16 @@ void runAsyncWorkload(Arguments const& args,
 			const auto key_begin = insertBegin(args.rows, worker_id, i, args.num_processes, args.async_xacts);
 			const auto key_end = insertEnd(args.rows, worker_id, i, args.num_processes, args.async_xacts);
 			auto db = databases[i % args.num_databases];
-			auto state = std::make_shared<ResumableStateForPopulate>(
-											   Logger(WorkerProcess{}, args.verbose, worker_id, i),
-											   db,
-											   db.createTransaction(),
-											   io_context,
-											   args,
-											   shm.statsSlot(worker_id, i),
-											   stopcount,
-											   key_begin,
-											   key_end);
+			auto state =
+			    std::make_shared<ResumableStateForPopulate>(Logger(WorkerProcess{}, args.verbose, worker_id, i),
+			                                                db,
+			                                                db.createTransaction(),
+			                                                io_context,
+			                                                args,
+			                                                shm.statsSlot(worker_id, i),
+			                                                stopcount,
+			                                                key_begin,
+			                                                key_end);
 			state->watch_tx.start();
 			state->watch_total.start();
 			states[i] = state;
@@ -480,7 +480,8 @@ void runAsyncWorkload(Arguments const& args,
 		while (shm.headerConst().signal.load() != SIGNAL_GREEN)
 			usleep(1000);
 		// launch [async_xacts] concurrent transactions
-		for (auto state : states) state->postNextTick();
+		for (auto state : states)
+			state->postNextTick();
 		while (stopcount.load() != args.async_xacts)
 			usleep(1000);
 		dump_samples(states);
@@ -492,24 +493,25 @@ void runAsyncWorkload(Arguments const& args,
 			    args.iteration == 0
 			        ? -1
 			        : computeThreadIters(args.iteration, worker_id, i, args.num_processes, args.async_xacts);
-			auto state = std::make_shared<ResumableStateForRunWorkload>(
-												  Logger(WorkerProcess{}, args.verbose, worker_id, i),
-			                                      db,
-			                                      db.createTransaction(),
-			                                      io_context,
-			                                      args,
-			                                      shm.statsSlot(worker_id, i),
-			                                      stopcount,
-			                                      shm.headerConst().signal,
-			                                      max_iters,
-			                                      getOpBegin(args));
+			auto state =
+			    std::make_shared<ResumableStateForRunWorkload>(Logger(WorkerProcess{}, args.verbose, worker_id, i),
+			                                                   db,
+			                                                   db.createTransaction(),
+			                                                   io_context,
+			                                                   args,
+			                                                   shm.statsSlot(worker_id, i),
+			                                                   stopcount,
+			                                                   shm.headerConst().signal,
+			                                                   max_iters,
+			                                                   getOpBegin(args));
 			states[i] = state;
 			state->watch_task.start();
 			state->watch_tx.start();
 		}
 		while (shm.headerConst().signal.load() != SIGNAL_GREEN)
 			usleep(1000);
-		for (auto state : states) state->postNextTick();
+		for (auto state : states)
+			state->postNextTick();
 		logr.debug("Launched {} concurrent transactions", states.size());
 		while (stopcount.load() != args.async_xacts)
 			usleep(1000);
diff --git a/bindings/c/test/mako/operations.cpp b/bindings/c/test/mako/operations.cpp
index f7228aef99..998e813ec5 100644
--- a/bindings/c/test/mako/operations.cpp
+++ b/bindings/c/test/mako/operations.cpp
@@ -266,7 +266,7 @@ const std::array<Operation, MAX_OP> opTable{
 	            }
 
 	            // Allocate a separate context per call to avoid multiple threads accessing
-				auto user_context = blob_granules::local_file::UserContext(args.bg_file_path);
+	            auto user_context = blob_granules::local_file::UserContext(args.bg_file_path);
 
 	            auto api_context = blob_granules::local_file::createApiContext(user_context, args.bg_materialize_files);
 

From 1de56eabf0c9676dbea2063c603e571cbead0025 Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Wed, 13 Apr 2022 10:23:53 +0200
Subject: [PATCH 21/84] Avoid async queueing for immediately completed steps

---
 bindings/c/test/mako/async.cpp      | 235 ++++++++++++++--------------
 bindings/c/test/mako/async.hpp      |   9 +-
 bindings/c/test/mako/mako.cpp       |   2 +-
 bindings/c/test/mako/operations.cpp |   6 +-
 bindings/c/test/mako/operations.hpp |  22 ++-
 5 files changed, 150 insertions(+), 124 deletions(-)

diff --git a/bindings/c/test/mako/async.cpp b/bindings/c/test/mako/async.cpp
index 9cdbab1703..08e0934d91 100644
--- a/bindings/c/test/mako/async.cpp
+++ b/bindings/c/test/mako/async.cpp
@@ -26,15 +26,13 @@ void ResumableStateForPopulate::runOneTick() {
 		stats.incrOpCount(OP_INSERT);
 		if (i == key_end || (i - key_begin + 1) % num_commit_every == 0) {
 			watch_commit.start();
-			auto f = tx.commit();
-			f.then([this, state = shared_from_this(), i](Future f) {
+			tx.commit().then([this, state = shared_from_this(), i](Future f) {
 				if (auto err = f.error()) {
 					logr.printWithLogLevel(err.retryable() ? VERBOSE_WARN : VERBOSE_NONE,
 					                       "ERROR",
 					                       "commit for populate returned '{}'",
 					                       err.what());
-					auto err_f = tx.onError(err);
-					err_f.then([this, state = shared_from_this()](Future f) {
+					tx.onError(err).then([this, state = shared_from_this()](Future f) {
 						const auto f_rc = handleForOnError(tx, f, "ON_ERROR_FOR_POPULATE");
 						if (f_rc == FutureRC::ABORT) {
 							signalEnd();
@@ -85,55 +83,67 @@ void ResumableStateForRunWorkload::postNextTick() {
 	boost::asio::post(io_context, [this, state = shared_from_this()]() { runOneTick(); });
 }
 
-#define UNPACK_OP_INFO()                                                                                               \
-	[[maybe_unused]] auto& [op, count, step] = op_iter;                                                                \
-	[[maybe_unused]] const auto step_kind = opTable[op].stepKind(step)
-
 void ResumableStateForRunWorkload::runOneTick() {
-	UNPACK_OP_INFO();
-	assert(op_iter != OpEnd);
+	assert(iter != OpEnd);
 	watch_step.start();
-	if (step == 0 /* first step */) {
-		watch_per_op[op] = Stopwatch(watch_step.getStart());
+	if (iter.step == 0 /* first step */) {
+		watch_per_op[iter.op] = Stopwatch(watch_step.getStart());
 	}
-	auto f = opTable[op].stepFunction(step)(tx, args, key1, key2, val);
+	auto f = Future{};
+	// to minimize context switch overhead, repeat immediately completed ops
+	// in a loop, not async continuation.
+repeat_immediate_steps:
+	f = opTable[iter.op].stepFunction(iter.step)(tx, args, key1, key2, val);
 	if (!f) {
 		// immediately completed client-side ops: e.g. set, setrange, clear, clearrange, ...
-		onStepSuccess();
+		updateStepStats();
+		iter = getOpNext(args, iter);
+		if (iter == OpEnd)
+			onTaskSuccess();
+		else
+			goto repeat_immediate_steps;
 	} else {
+		// step is blocking. register a continuation and return
 		f.then([this, state = shared_from_this()](Future f) {
-			UNPACK_OP_INFO();
-			if (step_kind != StepKind::ON_ERROR) {
+			if (iter.stepKind() != StepKind::ON_ERROR) {
 				if (auto err = f.error()) {
 					logr.printWithLogLevel(err.retryable() ? VERBOSE_WARN : VERBOSE_NONE,
-					                       "ERROR",
-					                       "step {} of op {} returned '{}'",
-					                       step,
-					                       opTable[op].name(),
-					                       err.what());
+										   "ERROR",
+										   "{}:{} returned '{}'",
+										   iter.opName(),
+										   iter.step,
+										   err.what());
 					tx.onError(err).then([this, state = shared_from_this()](Future f) {
-						UNPACK_OP_INFO();
-						const auto rc = handleForOnError(tx, f, fmt::format("{}_STEP_{}", opTable[op].name(), step));
+						const auto rc = handleForOnError(tx, f, fmt::format("{}:{}", iter.opName(), iter.step));
 						if (rc == FutureRC::RETRY) {
-							stats.incrErrorCount(op);
+							stats.incrErrorCount(iter.op);
 						} else if (rc == FutureRC::CONFLICT) {
 							stats.incrConflictCount();
 						} else if (rc == FutureRC::ABORT) {
 							tx.reset();
-							stopcount.fetch_add(1);
+							signalEnd();
 							return;
 						}
-						op_iter = getOpBegin(args);
-						needs_commit = false;
 						// restart this iteration from beginning
+						iter = getOpBegin(args);
+						needs_commit = false;
 						postNextTick();
 					});
-					return;
+				} else {
+					// async step succeeded
+					updateStepStats();
+					iter = getOpNext(args, iter);
+					if (iter == OpEnd) {
+						onTaskSuccess();
+					} else {
+						postNextTick();
+					}
 				}
 			} else {
+				// blob granules op error
 				auto rc = handleForOnError(tx, f, "BG_ON_ERROR");
 				if (rc == FutureRC::RETRY) {
-					stats.incrErrorCount(op);
+					stats.incrErrorCount(iter.op);
 				} else if (rc == FutureRC::CONFLICT) {
 					stats.incrConflictCount();
 				} else if (rc == FutureRC::ABORT) {
@@ -141,24 +151,21 @@ void ResumableStateForRunWorkload::runOneTick() {
 					stopcount.fetch_add(1);
 					return;
 				}
-				op_iter = getOpBegin(args);
+				iter = getOpBegin(args);
 				needs_commit = false;
 				// restart this iteration from beginning
 				postNextTick();
-				return;
 			}
-			onStepSuccess();
 		});
 	}
 }
 
-void ResumableStateForRunWorkload::onStepSuccess() {
-	UNPACK_OP_INFO();
-	logr.debug("Step {}:{} succeeded", getOpName(op), step);
+void ResumableStateForRunWorkload::updateStepStats() {
+	logr.debug("Step {}:{} succeeded", iter.opName(), iter.step);
 	// step successful
 	watch_step.stop();
 	const auto do_sample = stats.getOpCount(OP_TASK) % args.sampling == 0;
-	if (step_kind == StepKind::COMMIT) {
+	if (iter.stepKind() == StepKind::COMMIT) {
 		// reset transaction boundary
 		const auto step_latency = watch_step.diff();
 		watch_tx.setStop(watch_step.getStop());
@@ -176,97 +183,97 @@ void ResumableStateForRunWorkload::onStepSuccess() {
 		needs_commit = false;
 	}
 	// op completed successfully
-	if (step + 1 == opTable[op].steps()) {
-		if (opTable[op].needsCommit())
+	if (iter.step + 1 == opTable[iter.op].steps()) {
+		if (opTable[iter.op].needsCommit())
 			needs_commit = true;
-		watch_per_op[op].setStop(watch_step.getStop());
+		watch_per_op[iter.op].setStop(watch_step.getStop());
 		if (do_sample) {
-			const auto op_latency = watch_per_op[op].diff();
-			stats.addLatency(op, op_latency);
-			sample_bins[op].put(op_latency);
+			const auto op_latency = watch_per_op[iter.op].diff();
+			stats.addLatency(iter.op, op_latency);
+			sample_bins[iter.op].put(op_latency);
 		}
-		stats.incrOpCount(op);
+		stats.incrOpCount(iter.op);
 	}
-	op_iter = getOpNext(args, op_iter);
-	if (op_iter == OpEnd) {
-		if (needs_commit || args.commit_get) {
-			// task completed, need to commit before finish
-			watch_commit.start();
-			tx.commit().then([this, state = shared_from_this()](Future f) {
-				UNPACK_OP_INFO();
-				if (auto err = f.error()) {
-					// commit had errors
-					logr.printWithLogLevel(err.retryable() ? VERBOSE_WARN : VERBOSE_NONE,
-					                       "ERROR",
-					                       "Post-iteration commit returned error: {}",
-					                       err.what());
-					tx.onError(err).then([this, state = shared_from_this()](Future f) {
-						const auto rc = handleForOnError(tx, f, "ON_ERROR");
-						if (rc == FutureRC::CONFLICT)
-							stats.incrConflictCount();
-						else
-							stats.incrErrorCount(OP_COMMIT);
-						if (rc == FutureRC::ABORT) {
-							signalEnd();
-							return;
-						}
-						op_iter = getOpBegin(args);
-						needs_commit = false;
-						postNextTick();
-					});
-				} else {
-					// commit successful
-					watch_commit.stop();
-					watch_tx.setStop(watch_commit.getStop());
-					watch_task.setStop(watch_commit.getStop());
-					if (stats.getOpCount(OP_TASK) % args.sampling == 0) {
-						const auto commit_latency = watch_commit.diff();
-						const auto tx_duration = watch_tx.diff();
-						const auto task_duration = watch_task.diff();
-						stats.addLatency(OP_COMMIT, commit_latency);
-						stats.addLatency(OP_TRANSACTION, commit_latency);
-						stats.addLatency(OP_TASK, task_duration);
-						sample_bins[OP_COMMIT].put(commit_latency);
-						sample_bins[OP_TRANSACTION].put(tx_duration);
-						sample_bins[OP_TASK].put(task_duration);
-					}
-					stats.incrOpCount(OP_COMMIT);
-					stats.incrOpCount(OP_TRANSACTION);
-					stats.incrOpCount(OP_TASK);
-					tx.reset();
-					watch_tx.startFromStop();
-					watch_task.startFromStop();
-					if (ended()) {
+}
+
+void ResumableStateForRunWorkload::onTaskSuccess() {
+	if (needs_commit || args.commit_get) {
+		// task completed, need to commit before finish
+		watch_commit.start();
+		tx.commit().then([this, state = shared_from_this()](Future f) {
+			if (auto err = f.error()) {
+				// commit had errors
+				logr.printWithLogLevel(err.retryable() ? VERBOSE_WARN : VERBOSE_NONE,
+									   "ERROR",
+									   "Post-iteration commit returned error: {}",
+									   err.what());
+				tx.onError(err).then([this, state = shared_from_this()](Future f) {
+					const auto rc = handleForOnError(tx, f, "ON_ERROR");
+					if (rc == FutureRC::CONFLICT)
+						stats.incrConflictCount();
+					else
+						stats.incrErrorCount(OP_COMMIT);
+					if (rc == FutureRC::ABORT) {
 						signalEnd();
 						return;
 					}
+					if (ended()) {
+						signalEnd();
+					} else {
+						iter = getOpBegin(args);
+						needs_commit = false;
+						postNextTick();
+					}
+				});
+			} else {
+				// commit successful
+				watch_commit.stop();
+				watch_tx.setStop(watch_commit.getStop());
+				watch_task.setStop(watch_commit.getStop());
+				if (stats.getOpCount(OP_TASK) % args.sampling == 0) {
+					const auto commit_latency = watch_commit.diff();
+					const auto tx_duration = watch_tx.diff();
+					const auto task_duration = watch_task.diff();
+					stats.addLatency(OP_COMMIT, commit_latency);
+					stats.addLatency(OP_TRANSACTION, commit_latency);
+					stats.addLatency(OP_TASK, task_duration);
+					sample_bins[OP_COMMIT].put(commit_latency);
+					sample_bins[OP_TRANSACTION].put(tx_duration);
+					sample_bins[OP_TASK].put(task_duration);
+				}
+				stats.incrOpCount(OP_COMMIT);
+				stats.incrOpCount(OP_TRANSACTION);
+				stats.incrOpCount(OP_TASK);
+				tx.reset();
+				watch_tx.startFromStop();
+				watch_task.startFromStop();
+				if (ended()) {
+					signalEnd();
+				} else {
 					// start next iteration
-					op_iter = getOpBegin(args);
+					iter = getOpBegin(args);
 					postNextTick();
 				}
-			});
+			}
+		});
+	} else {
+		// task completed but no need to commit
+		watch_task.stop();
+		if (stats.getOpCount(OP_TASK) % args.sampling == 0) {
+			const auto task_duration = watch_task.diff();
+			stats.addLatency(OP_TASK, task_duration);
+			sample_bins[OP_TASK].put(task_duration);
+		}
+		stats.incrOpCount(OP_TASK);
+		watch_task.startFromStop();
+		tx.reset();
+		if (ended()) {
+			signalEnd();
 		} else {
-			// task completed but no need to commit
-			watch_task.stop();
-			if (stats.getOpCount(OP_TASK) % args.sampling == 0) {
-				const auto task_duration = watch_task.diff();
-				stats.addLatency(OP_TASK, task_duration);
-				sample_bins[OP_TASK].put(task_duration);
-			}
-			stats.incrOpCount(OP_TASK);
-			watch_tx.startFromStop();
-			watch_task.startFromStop();
-			tx.reset();
-			if (ended()) {
-				signalEnd();
-				return;
-			}
-			op_iter = getOpBegin(args);
-			// run next iteration
+			iter = getOpBegin(args);
+			// start next iteration
 			postNextTick();
 		}
-	} else {
-		postNextTick();
 	}
 }
 
diff --git a/bindings/c/test/mako/async.hpp b/bindings/c/test/mako/async.hpp
index f73f05b3c3..4a683d512d 100644
--- a/bindings/c/test/mako/async.hpp
+++ b/bindings/c/test/mako/async.hpp
@@ -62,7 +62,7 @@ struct ResumableStateForRunWorkload : std::enable_shared_from_this<ResumableStat
 	std::atomic<int>& stopcount;
 	std::atomic<int> const& signal;
 	int max_iters;
-	OpIterator op_iter;
+	OpIterator iter;
 	LatencySampleBinArray sample_bins;
 	fdb::ByteString key1;
 	fdb::ByteString key2;
@@ -83,9 +83,9 @@ struct ResumableStateForRunWorkload : std::enable_shared_from_this<ResumableStat
 	                             std::atomic<int>& stopcount,
 	                             std::atomic<int> const& signal,
 	                             int max_iters,
-	                             OpIterator op_iter)
+	                             OpIterator iter)
 	  : logr(logr), db(db), tx(tx), io_context(io_context), args(args), stats(stats), stopcount(stopcount),
-	    signal(signal), max_iters(max_iters), op_iter(op_iter), needs_commit(false) {
+	    signal(signal), max_iters(max_iters), iter(iter), needs_commit(false) {
 		key1.reserve(args.key_length);
 		key2.reserve(args.key_length);
 		val.reserve(args.value_length);
@@ -96,7 +96,8 @@ struct ResumableStateForRunWorkload : std::enable_shared_from_this<ResumableStat
 	}
 	void postNextTick();
 	void runOneTick();
-	void onStepSuccess();
+	void updateStepStats();
+	void onTaskSuccess();
 };
 
 using RunWorkloadStateHandle = std::shared_ptr<ResumableStateForRunWorkload>;
diff --git a/bindings/c/test/mako/mako.cpp b/bindings/c/test/mako/mako.cpp
index f8a172ec5f..deebd04423 100644
--- a/bindings/c/test/mako/mako.cpp
+++ b/bindings/c/test/mako/mako.cpp
@@ -718,7 +718,7 @@ int workerProcessMain(Arguments const& args, int worker_id, shared_memory::Acces
 		}
 	} else {
 		logr.debug("running async mode with {} concurrent transactions", args.async_xacts);
-		boost::asio::io_context ctx;
+		auto ctx = boost::asio::io_context{};
 		using WorkGuard = boost::asio::executor_work_guard<boost::asio::io_context::executor_type>;
 		auto wg = WorkGuard(ctx.get_executor());
 		auto worker_threads = std::vector<std::thread>(args.num_threads);
diff --git a/bindings/c/test/mako/operations.cpp b/bindings/c/test/mako/operations.cpp
index 998e813ec5..6e44fba909 100644
--- a/bindings/c/test/mako/operations.cpp
+++ b/bindings/c/test/mako/operations.cpp
@@ -14,7 +14,7 @@ OpIterator getOpBegin(Arguments const& args) noexcept {
 	for (auto op = 0; op < MAX_OP; op++) {
 		if (isAbstractOp(op) || args.txnspec.ops[op][OP_COUNT] == 0)
 			continue;
-		return OpIterator(op, 0, 0);
+		return OpIterator{op, 0, 0};
 	}
 	return OpEnd;
 }
@@ -25,12 +25,12 @@ OpIterator getOpNext(Arguments const& args, OpIterator current) noexcept {
 	auto [op, count, step] = current;
 	assert(op < MAX_OP && !isAbstractOp(op));
 	if (opTable[op].steps() > step + 1)
-		return OpIterator(op, count, step + 1);
+		return OpIterator{op, count, step + 1};
 	count++;
 	for (; op < MAX_OP; op++, count = 0) {
 		if (isAbstractOp(op) || args.txnspec.ops[op][OP_COUNT] <= count)
 			continue;
-		return OpIterator(op, count, 0);
+		return OpIterator{op, count, 0};
 	}
 	return OpEnd;
 }
diff --git a/bindings/c/test/mako/operations.hpp b/bindings/c/test/mako/operations.hpp
index 98a1770b87..9bb20bb667 100644
--- a/bindings/c/test/mako/operations.hpp
+++ b/bindings/c/test/mako/operations.hpp
@@ -88,9 +88,27 @@ char const* getOpName(int ops_code);
 
 extern const std::array<Operation, MAX_OP> opTable;
 
-using OpIterator = std::tuple<int /*op*/, int /*count*/, int /*step*/>;
+struct OpIterator {
+	int op, count, step;
 
-constexpr const OpIterator OpEnd = OpIterator(MAX_OP, -1, -1);
+	bool operator==(const OpIterator& other) const noexcept {
+		return op == other.op && count == other.count && step == other.step;
+	}
+
+	bool operator!=(const OpIterator& other) const noexcept {
+		return !(*this == other);
+	}
+
+	StepKind stepKind() const noexcept {
+		return opTable[op].stepKind(step);
+	}
+
+	char const* opName() const noexcept {
+		return getOpName(op);
+	}
+};
+
+constexpr const OpIterator OpEnd = OpIterator{MAX_OP, -1, -1};
 
 OpIterator getOpBegin(Arguments const& args) noexcept;
 

From 0256c08cabf115bab6df86d5de7dff9d07afc5e1 Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Wed, 13 Apr 2022 10:56:02 +0200
Subject: [PATCH 22/84] Apply clang format

---
 bindings/c/test/mako/async.cpp      | 18 +++++++++---------
 bindings/c/test/mako/operations.cpp |  6 +++---
 bindings/c/test/mako/operations.hpp | 14 ++++----------
 3 files changed, 16 insertions(+), 22 deletions(-)

diff --git a/bindings/c/test/mako/async.cpp b/bindings/c/test/mako/async.cpp
index 08e0934d91..d447370262 100644
--- a/bindings/c/test/mako/async.cpp
+++ b/bindings/c/test/mako/async.cpp
@@ -91,7 +91,7 @@ void ResumableStateForRunWorkload::runOneTick() {
 	}
 	auto f = Future{};
 	// to minimize context switch overhead, repeat immediately completed ops
-	// in a loop, not async continuation.
+	// in a loop, not an async continuation.
 repeat_immediate_steps:
 	f = opTable[iter.op].stepFunction(iter.step)(tx, args, key1, key2, val);
 	if (!f) {
@@ -108,11 +108,11 @@ repeat_immediate_steps:
 			if (iter.stepKind() != StepKind::ON_ERROR) {
 				if (auto err = f.error()) {
 					logr.printWithLogLevel(err.retryable() ? VERBOSE_WARN : VERBOSE_NONE,
-										   "ERROR",
-										   "{}:{} returned '{}'",
-										   iter.opName(),
-										   iter.step,
-										   err.what());
+					                       "ERROR",
+					                       "{}:{} returned '{}'",
+					                       iter.opName(),
+					                       iter.step,
+					                       err.what());
 					tx.onError(err).then([this, state = shared_from_this()](Future f) {
 						const auto rc = handleForOnError(tx, f, fmt::format("{}:{}", iter.opName(), iter.step));
 						if (rc == FutureRC::RETRY) {
@@ -204,9 +204,9 @@ void ResumableStateForRunWorkload::onTaskSuccess() {
 			if (auto err = f.error()) {
 				// commit had errors
 				logr.printWithLogLevel(err.retryable() ? VERBOSE_WARN : VERBOSE_NONE,
-									   "ERROR",
-									   "Post-iteration commit returned error: {}",
-									   err.what());
+				                       "ERROR",
+				                       "Post-iteration commit returned error: {}",
+				                       err.what());
 				tx.onError(err).then([this, state = shared_from_this()](Future f) {
 					const auto rc = handleForOnError(tx, f, "ON_ERROR");
 					if (rc == FutureRC::CONFLICT)
diff --git a/bindings/c/test/mako/operations.cpp b/bindings/c/test/mako/operations.cpp
index 6e44fba909..72f5ef71c2 100644
--- a/bindings/c/test/mako/operations.cpp
+++ b/bindings/c/test/mako/operations.cpp
@@ -14,7 +14,7 @@ OpIterator getOpBegin(Arguments const& args) noexcept {
 	for (auto op = 0; op < MAX_OP; op++) {
 		if (isAbstractOp(op) || args.txnspec.ops[op][OP_COUNT] == 0)
 			continue;
-		return OpIterator{op, 0, 0};
+		return OpIterator{ op, 0, 0 };
 	}
 	return OpEnd;
 }
@@ -25,12 +25,12 @@ OpIterator getOpNext(Arguments const& args, OpIterator current) noexcept {
 	auto [op, count, step] = current;
 	assert(op < MAX_OP && !isAbstractOp(op));
 	if (opTable[op].steps() > step + 1)
-		return OpIterator{op, count, step + 1};
+		return OpIterator{ op, count, step + 1 };
 	count++;
 	for (; op < MAX_OP; op++, count = 0) {
 		if (isAbstractOp(op) || args.txnspec.ops[op][OP_COUNT] <= count)
 			continue;
-		return OpIterator{op, count, 0};
+		return OpIterator{ op, count, 0 };
 	}
 	return OpEnd;
 }
diff --git a/bindings/c/test/mako/operations.hpp b/bindings/c/test/mako/operations.hpp
index 9bb20bb667..131740ca33 100644
--- a/bindings/c/test/mako/operations.hpp
+++ b/bindings/c/test/mako/operations.hpp
@@ -95,20 +95,14 @@ struct OpIterator {
 		return op == other.op && count == other.count && step == other.step;
 	}
 
-	bool operator!=(const OpIterator& other) const noexcept {
-		return !(*this == other);
-	}
+	bool operator!=(const OpIterator& other) const noexcept { return !(*this == other); }
 
-	StepKind stepKind() const noexcept {
-		return opTable[op].stepKind(step);
-	}
+	StepKind stepKind() const noexcept { return opTable[op].stepKind(step); }
 
-	char const* opName() const noexcept {
-		return getOpName(op);
-	}
+	char const* opName() const noexcept { return getOpName(op); }
 };
 
-constexpr const OpIterator OpEnd = OpIterator{MAX_OP, -1, -1};
+constexpr const OpIterator OpEnd = OpIterator{ MAX_OP, -1, -1 };
 
 OpIterator getOpBegin(Arguments const& args) noexcept;
 

From b756e8b1e73cf7cb5afc822009da28c9afa85392 Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Wed, 13 Apr 2022 11:35:52 +0200
Subject: [PATCH 23/84] Update Mako documentation

---
 bindings/c/test/mako/mako.rst | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/bindings/c/test/mako/mako.rst b/bindings/c/test/mako/mako.rst
index ea9603c234..1efaf562ed 100644
--- a/bindings/c/test/mako/mako.rst
+++ b/bindings/c/test/mako/mako.rst
@@ -53,6 +53,12 @@ Arguments
 
 - | ``-t | --threads <threads>``
   | Number of threads per worker process (Default: 1)
+  | With ``--async_xacts <xacts>`` == 0 (Default), each of the ``<threads>`` operates on a transaction object with blocking API calls
+  | Otherwise, all of the ``<threads>`` run an asynchronous job scheduler, serving ``<xacts>`` transactions
+
+- | ``--async_xacts <xacts>``
+  | Number of transactions per worker process to run asynchronously (Default: 0)
+  | ``<xacts>`` > 0 switches the execution mode to non-blocking (See ``-t | --threads``)
 
 - | ``-r | --rows <rows>``
   | Number of rows initially populated (Default: 100000)

From 194e3dafea787cfa53082d66f976c04a0f8d68be Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Wed, 13 Apr 2022 15:27:05 +0200
Subject: [PATCH 24/84] Add TX Parser for OP_OVERWRITE

---
 bindings/c/test/mako/mako.cpp | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/bindings/c/test/mako/mako.cpp b/bindings/c/test/mako/mako.cpp
index deebd04423..125148c4a6 100644
--- a/bindings/c/test/mako/mako.cpp
+++ b/bindings/c/test/mako/mako.cpp
@@ -844,6 +844,9 @@ int parseTransaction(Arguments& args, char const* optarg) {
 		} else if (strncmp(ptr, "i", 1) == 0) {
 			op = OP_INSERT;
 			ptr++;
+		} else if (strncmp(ptr, "o", 1) == 0) {
+			op = OP_OVERWRITE;
+			ptr++;
 		} else if (strncmp(ptr, "cr", 2) == 0) {
 			op = OP_CLEARRANGE;
 			rangeop = 1;

From 18787da562c48f6cbabc060902f8644c2d5efebb Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Wed, 13 Apr 2022 19:09:12 +0200
Subject: [PATCH 25/84] Change fdb.hpp > fdb_api.hpp

---
 bindings/c/CMakeLists.txt                | 2 +-
 bindings/c/test/{fdb.hpp => fdb_api.hpp} | 0
 bindings/c/test/mako/blob_granules.cpp   | 2 +-
 bindings/c/test/mako/blob_granules.hpp   | 2 +-
 bindings/c/test/mako/future.hpp          | 2 +-
 bindings/c/test/mako/mako.cpp            | 2 +-
 bindings/c/test/mako/mako.hpp            | 2 +-
 bindings/c/test/mako/operations.hpp      | 2 +-
 8 files changed, 7 insertions(+), 7 deletions(-)
 rename bindings/c/test/{fdb.hpp => fdb_api.hpp} (100%)

diff --git a/bindings/c/CMakeLists.txt b/bindings/c/CMakeLists.txt
index 93fcbbee0a..8318dcb448 100644
--- a/bindings/c/CMakeLists.txt
+++ b/bindings/c/CMakeLists.txt
@@ -112,7 +112,7 @@ if(NOT WIN32 AND NOT IS_ARM_MAC)
     test/unit/fdb_api.hpp)
 
   add_library(fdb_cpp INTERFACE)
-  target_sources(fdb_cpp INTERFACE test/fdb.hpp)
+  target_sources(fdb_cpp INTERFACE test/fdb_api.hpp)
   target_include_directories(fdb_cpp INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}/test)
   target_link_libraries(fdb_cpp INTERFACE fmt::fmt)
   if(OPEN_FOR_IDE)
diff --git a/bindings/c/test/fdb.hpp b/bindings/c/test/fdb_api.hpp
similarity index 100%
rename from bindings/c/test/fdb.hpp
rename to bindings/c/test/fdb_api.hpp
diff --git a/bindings/c/test/mako/blob_granules.cpp b/bindings/c/test/mako/blob_granules.cpp
index 98f8d92fc0..967679d35f 100644
--- a/bindings/c/test/mako/blob_granules.cpp
+++ b/bindings/c/test/mako/blob_granules.cpp
@@ -1,7 +1,7 @@
 #include "blob_granules.hpp"
 #include "logger.hpp"
 #include <cstdio>
-#include <fdb.hpp>
+#include <fdb_api.hpp>
 
 extern thread_local mako::Logger logr;
 
diff --git a/bindings/c/test/mako/blob_granules.hpp b/bindings/c/test/mako/blob_granules.hpp
index 2bbb8fb7b8..a0d05b35f5 100644
--- a/bindings/c/test/mako/blob_granules.hpp
+++ b/bindings/c/test/mako/blob_granules.hpp
@@ -3,7 +3,7 @@
 
 #include <cstdint>
 #include <memory>
-#include <fdb.hpp>
+#include <fdb_api.hpp>
 
 namespace mako::blob_granules::local_file {
 
diff --git a/bindings/c/test/mako/future.hpp b/bindings/c/test/mako/future.hpp
index 7c7cd6fe6b..82f9b93a2a 100644
--- a/bindings/c/test/mako/future.hpp
+++ b/bindings/c/test/mako/future.hpp
@@ -1,7 +1,7 @@
 #ifndef MAKO_FUTURE_HPP
 #define MAKO_FUTURE_HPP
 
-#include <fdb.hpp>
+#include <fdb_api.hpp>
 #include <cassert>
 #include <string_view>
 #include "logger.hpp"
diff --git a/bindings/c/test/mako/mako.cpp b/bindings/c/test/mako/mako.cpp
index 125148c4a6..d8dd71dd38 100644
--- a/bindings/c/test/mako/mako.cpp
+++ b/bindings/c/test/mako/mako.cpp
@@ -33,7 +33,7 @@
 #include <boost/asio.hpp>
 #include <fmt/format.h>
 #include <fmt/printf.h>
-#include <fdb.hpp>
+#include <fdb_api.hpp>
 #include "fdbclient/zipf.h"
 #include "logger.hpp"
 #include "mako.hpp"
diff --git a/bindings/c/test/mako/mako.hpp b/bindings/c/test/mako/mako.hpp
index b4b1182ca7..95c115fa67 100644
--- a/bindings/c/test/mako/mako.hpp
+++ b/bindings/c/test/mako/mako.hpp
@@ -12,7 +12,7 @@
 #include <list>
 #include <vector>
 #include <string_view>
-#include <fdb.hpp>
+#include <fdb_api.hpp>
 #include <pthread.h>
 #include <sys/types.h>
 #include <stdbool.h>
diff --git a/bindings/c/test/mako/operations.hpp b/bindings/c/test/mako/operations.hpp
index 131740ca33..af619d9c2d 100644
--- a/bindings/c/test/mako/operations.hpp
+++ b/bindings/c/test/mako/operations.hpp
@@ -1,7 +1,7 @@
 #ifndef MAKO_OPERATIONS_HPP
 #define MAKO_OPERATIONS_HPP
 
-#include <fdb.hpp>
+#include <fdb_api.hpp>
 #include <array>
 #include <cassert>
 #include <string_view>

From c650d5366f9fa1904b0310f232a86e2aad1703ae Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Wed, 13 Apr 2022 19:17:23 +0200
Subject: [PATCH 26/84] Prefix sources and headers with license comment

Add include guards
---
 bindings/c/test/fdb_api.hpp            | 24 ++++++++++++++++++++++++
 bindings/c/test/mako/async.cpp         | 20 ++++++++++++++++++++
 bindings/c/test/mako/async.hpp         | 20 ++++++++++++++++++++
 bindings/c/test/mako/blob_granules.cpp | 20 ++++++++++++++++++++
 bindings/c/test/mako/blob_granules.hpp | 20 ++++++++++++++++++++
 bindings/c/test/mako/future.hpp        | 20 ++++++++++++++++++++
 bindings/c/test/mako/logger.hpp        | 20 ++++++++++++++++++++
 bindings/c/test/mako/mako.cpp          | 19 +++++++++++++++++++
 bindings/c/test/mako/mako.hpp          | 20 ++++++++++++++++++++
 bindings/c/test/mako/operations.cpp    | 20 ++++++++++++++++++++
 bindings/c/test/mako/operations.hpp    | 20 ++++++++++++++++++++
 bindings/c/test/mako/process.hpp       | 20 ++++++++++++++++++++
 bindings/c/test/mako/shm.hpp           | 20 ++++++++++++++++++++
 bindings/c/test/mako/stats.hpp         | 20 ++++++++++++++++++++
 bindings/c/test/mako/time.hpp          | 20 ++++++++++++++++++++
 bindings/c/test/mako/utils.cpp         | 24 ++++++++++++++++++++----
 bindings/c/test/mako/utils.hpp         | 20 ++++++++++++++++++++
 17 files changed, 343 insertions(+), 4 deletions(-)

diff --git a/bindings/c/test/fdb_api.hpp b/bindings/c/test/fdb_api.hpp
index f5ffde486f..24b206a22b 100644
--- a/bindings/c/test/fdb_api.hpp
+++ b/bindings/c/test/fdb_api.hpp
@@ -1,3 +1,25 @@
+/*
+ * fdb_api.hpp
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2013-2022 Apple Inc. and the FoundationDB project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FDB_API_HPP
+#define FDB_API_HPP
 #pragma once
 
 #ifndef FDB_API_VERSION
@@ -541,3 +563,5 @@ public:
 };
 
 } // namespace fdb
+
+#endif /*FDB_API_HPP*/
diff --git a/bindings/c/test/mako/async.cpp b/bindings/c/test/mako/async.cpp
index d447370262..09932bd10a 100644
--- a/bindings/c/test/mako/async.cpp
+++ b/bindings/c/test/mako/async.cpp
@@ -1,3 +1,23 @@
+/*
+ * async.cpp
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2013-2022 Apple Inc. and the FoundationDB project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 #include <boost/asio.hpp>
 #include "async.hpp"
 #include "future.hpp"
diff --git a/bindings/c/test/mako/async.hpp b/bindings/c/test/mako/async.hpp
index 4a683d512d..717e81fc22 100644
--- a/bindings/c/test/mako/async.hpp
+++ b/bindings/c/test/mako/async.hpp
@@ -1,3 +1,23 @@
+/*
+ * async.hpp
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2013-2022 Apple Inc. and the FoundationDB project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 #ifndef MAKO_ASYNC_HPP
 #define MAKO_ASYNC_HPP
 
diff --git a/bindings/c/test/mako/blob_granules.cpp b/bindings/c/test/mako/blob_granules.cpp
index 967679d35f..16b440a726 100644
--- a/bindings/c/test/mako/blob_granules.cpp
+++ b/bindings/c/test/mako/blob_granules.cpp
@@ -1,3 +1,23 @@
+/*
+ * blob_granules.cpp
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2013-2022 Apple Inc. and the FoundationDB project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 #include "blob_granules.hpp"
 #include "logger.hpp"
 #include <cstdio>
diff --git a/bindings/c/test/mako/blob_granules.hpp b/bindings/c/test/mako/blob_granules.hpp
index a0d05b35f5..67ef8952c1 100644
--- a/bindings/c/test/mako/blob_granules.hpp
+++ b/bindings/c/test/mako/blob_granules.hpp
@@ -1,3 +1,23 @@
+/*
+ * blob_granules.hpp
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2013-2022 Apple Inc. and the FoundationDB project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 #ifndef MAKO_BLOB_GRANULES_HPP
 #define MAKO_BLOB_GRANULES_HPP
 
diff --git a/bindings/c/test/mako/future.hpp b/bindings/c/test/mako/future.hpp
index 82f9b93a2a..ba25cfbcfa 100644
--- a/bindings/c/test/mako/future.hpp
+++ b/bindings/c/test/mako/future.hpp
@@ -1,3 +1,23 @@
+/*
+ * future.hpp
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2013-2022 Apple Inc. and the FoundationDB project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 #ifndef MAKO_FUTURE_HPP
 #define MAKO_FUTURE_HPP
 
diff --git a/bindings/c/test/mako/logger.hpp b/bindings/c/test/mako/logger.hpp
index 45cab8347a..184062b560 100644
--- a/bindings/c/test/mako/logger.hpp
+++ b/bindings/c/test/mako/logger.hpp
@@ -1,3 +1,23 @@
+/*
+ * logger.hpp
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2013-2022 Apple Inc. and the FoundationDB project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 #ifndef MAKO_LOGGER_HPP
 #define MAKO_LOGGER_HPP
 #include <fmt/format.h>
diff --git a/bindings/c/test/mako/mako.cpp b/bindings/c/test/mako/mako.cpp
index d8dd71dd38..35096620dc 100644
--- a/bindings/c/test/mako/mako.cpp
+++ b/bindings/c/test/mako/mako.cpp
@@ -1,3 +1,22 @@
+/*
+ * mako.cpp
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2013-2022 Apple Inc. and the FoundationDB project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 #include <cassert>
 #include <cmath>
diff --git a/bindings/c/test/mako/mako.hpp b/bindings/c/test/mako/mako.hpp
index 95c115fa67..6c1862e6d2 100644
--- a/bindings/c/test/mako/mako.hpp
+++ b/bindings/c/test/mako/mako.hpp
@@ -1,3 +1,23 @@
+/*
+ * mako.hpp
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2013-2022 Apple Inc. and the FoundationDB project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 #ifndef MAKO_HPP
 #define MAKO_HPP
 
diff --git a/bindings/c/test/mako/operations.cpp b/bindings/c/test/mako/operations.cpp
index 72f5ef71c2..8667747c4c 100644
--- a/bindings/c/test/mako/operations.cpp
+++ b/bindings/c/test/mako/operations.cpp
@@ -1,3 +1,23 @@
+/*
+ * operations.cpp
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2013-2022 Apple Inc. and the FoundationDB project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 #include "blob_granules.hpp"
 #include "operations.hpp"
 #include "mako.hpp"
diff --git a/bindings/c/test/mako/operations.hpp b/bindings/c/test/mako/operations.hpp
index af619d9c2d..d454132126 100644
--- a/bindings/c/test/mako/operations.hpp
+++ b/bindings/c/test/mako/operations.hpp
@@ -1,3 +1,23 @@
+/*
+ * operations.hpp
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2013-2022 Apple Inc. and the FoundationDB project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 #ifndef MAKO_OPERATIONS_HPP
 #define MAKO_OPERATIONS_HPP
 
diff --git a/bindings/c/test/mako/process.hpp b/bindings/c/test/mako/process.hpp
index 174fc0e427..bbf460b934 100644
--- a/bindings/c/test/mako/process.hpp
+++ b/bindings/c/test/mako/process.hpp
@@ -1,3 +1,23 @@
+/*
+ * process.hpp
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2013-2022 Apple Inc. and the FoundationDB project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 #ifndef MAKO_PROCESS_HPP
 #define MAKO_PROCESS_HPP
 
diff --git a/bindings/c/test/mako/shm.hpp b/bindings/c/test/mako/shm.hpp
index 06460293fa..67adde6f24 100644
--- a/bindings/c/test/mako/shm.hpp
+++ b/bindings/c/test/mako/shm.hpp
@@ -1,3 +1,23 @@
+/*
+ * shm.hpp
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2013-2022 Apple Inc. and the FoundationDB project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 #ifndef MAKO_SHM_HPP
 #define MAKO_SHM_HPP
 
diff --git a/bindings/c/test/mako/stats.hpp b/bindings/c/test/mako/stats.hpp
index 0fe8dfb2b6..5cea6707f3 100644
--- a/bindings/c/test/mako/stats.hpp
+++ b/bindings/c/test/mako/stats.hpp
@@ -1,3 +1,23 @@
+/*
+ * stats.hpp
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2013-2022 Apple Inc. and the FoundationDB project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 #ifndef MAKO_STATS_HPP
 #define MAKO_STATS_HPP
 
diff --git a/bindings/c/test/mako/time.hpp b/bindings/c/test/mako/time.hpp
index c1684b02e5..4093dbe982 100644
--- a/bindings/c/test/mako/time.hpp
+++ b/bindings/c/test/mako/time.hpp
@@ -1,3 +1,23 @@
+/*
+ * time.hpp
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2013-2022 Apple Inc. and the FoundationDB project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 #ifndef MAKO_TIME_HPP
 #define MAKO_TIME_HPP
 
diff --git a/bindings/c/test/mako/utils.cpp b/bindings/c/test/mako/utils.cpp
index e4d2a71565..e267385336 100644
--- a/bindings/c/test/mako/utils.cpp
+++ b/bindings/c/test/mako/utils.cpp
@@ -1,3 +1,23 @@
+/*
+ * utils.cpp
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2013-2022 Apple Inc. and the FoundationDB project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 #include "utils.hpp"
 #include "mako.hpp"
 #include <cstdio>
@@ -5,10 +25,6 @@
 #include <cstring>
 #include <fmt/format.h>
 
-namespace math {
-#include <cmath>
-}
-
 namespace mako {
 
 /* uniform-distribution random */
diff --git a/bindings/c/test/mako/utils.hpp b/bindings/c/test/mako/utils.hpp
index 73ee0e0fc1..4ed10183b2 100644
--- a/bindings/c/test/mako/utils.hpp
+++ b/bindings/c/test/mako/utils.hpp
@@ -1,3 +1,23 @@
+/*
+ * utils.hpp
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2013-2022 Apple Inc. and the FoundationDB project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 #ifndef UTILS_HPP
 #define UTILS_HPP
 #pragma once

From 4b3f6cbd0b3c4e2abdc3abca37ad568d48fd5148 Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Thu, 14 Apr 2022 14:38:55 +0200
Subject: [PATCH 27/84] Introduce post-step functions

- To try accessing data from ready future for get* APIs,
simulating real workload.
- Adapt to modified blob granules API
---
 bindings/c/test/fdb_api.hpp            |    2 +-
 bindings/c/test/mako/async.cpp         |    2 +
 bindings/c/test/mako/blob_granules.cpp |    8 +-
 bindings/c/test/mako/mako.c            | 3113 ------------------------
 bindings/c/test/mako/mako.cpp          |    2 +
 bindings/c/test/mako/mako.h            |  209 --
 bindings/c/test/mako/operations.cpp    |   41 +-
 bindings/c/test/mako/operations.hpp    |   19 +-
 8 files changed, 64 insertions(+), 3332 deletions(-)
 delete mode 100644 bindings/c/test/mako/mako.c
 delete mode 100644 bindings/c/test/mako/mako.h

diff --git a/bindings/c/test/fdb_api.hpp b/bindings/c/test/fdb_api.hpp
index 24b206a22b..9f7090da07 100644
--- a/bindings/c/test/fdb_api.hpp
+++ b/bindings/c/test/fdb_api.hpp
@@ -23,7 +23,7 @@
 #pragma once
 
 #ifndef FDB_API_VERSION
-#define FDB_API_VERSION 710
+#define FDB_API_VERSION 720
 #endif
 
 #include <cstdint>
diff --git a/bindings/c/test/mako/async.cpp b/bindings/c/test/mako/async.cpp
index 09932bd10a..0d5b254d19 100644
--- a/bindings/c/test/mako/async.cpp
+++ b/bindings/c/test/mako/async.cpp
@@ -125,6 +125,8 @@ repeat_immediate_steps:
 	} else {
 		// step is blocking. register a continuation and return
 		f.then([this, state = shared_from_this()](Future f) {
+			if (auto postStepFn = opTable[iter.op].postStepFunction(iter.step))
+				postStepFn(f, tx, args, key1, key2, val);
 			if (iter.stepKind() != StepKind::ON_ERROR) {
 				if (auto err = f.error()) {
 					logr.printWithLogLevel(err.retryable() ? VERBOSE_WARN : VERBOSE_NONE,
diff --git a/bindings/c/test/mako/blob_granules.cpp b/bindings/c/test/mako/blob_granules.cpp
index 16b440a726..750152e19c 100644
--- a/bindings/c/test/mako/blob_granules.cpp
+++ b/bindings/c/test/mako/blob_granules.cpp
@@ -27,7 +27,12 @@ extern thread_local mako::Logger logr;
 
 namespace mako::blob_granules::local_file {
 
-int64_t startLoad(const char* filename, int filenameLength, int64_t offset, int64_t length, void* userContext) {
+int64_t startLoad(const char* filename,
+                  int filenameLength,
+                  int64_t offset,
+                  int64_t length,
+                  int64_t fullFileLength,
+                  void* userContext) {
 	FILE* fp;
 	char full_fname[PATH_MAX]{
 		0,
@@ -103,6 +108,7 @@ fdb::native::FDBReadBlobGranuleContext createApiContext(UserContext& ctx, bool m
 	ret.get_load_f = &getLoad;
 	ret.free_load_f = &freeLoad;
 	ret.debugNoMaterialize = !materialize_files;
+	ret.granuleParallelism = 2; // TODO make knob or setting for changing this?
 	return ret;
 }
 
diff --git a/bindings/c/test/mako/mako.c b/bindings/c/test/mako/mako.c
deleted file mode 100644
index 46a75ba387..0000000000
--- a/bindings/c/test/mako/mako.c
+++ /dev/null
@@ -1,3113 +0,0 @@
-#include <assert.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <getopt.h>
-#include <inttypes.h>
-#include <math.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <time.h>
-#include <unistd.h>
-
-#if defined(__linux__)
-#include <linux/limits.h>
-#elif defined(__FreeBSD__)
-#include <sys/stat.h>
-#define CLOCK_MONOTONIC_COARSE CLOCK_MONOTONIC_FAST
-#elif defined(__APPLE__)
-#include <sys/syslimits.h>
-#define CLOCK_MONOTONIC_COARSE CLOCK_MONOTONIC
-#else
-#include <limits.h>
-#endif
-
-#include "fdbclient/zipf.h"
-#include "mako.h"
-#include "utils.h"
-
-/* global variables */
-FILE* printme; /* descriptor used for default messages */
-FILE* annoyme; /* descriptor used for annoying messages */
-FILE* debugme; /* descriptor used for debug messages */
-
-#define check_fdb_error(_e)                                                                                            \
-	do {                                                                                                               \
-		if (_e) {                                                                                                      \
-			fprintf(stderr, "ERROR: Failed at %s:%d (%s)\n", __FILE__, __LINE__, fdb_get_error(_e));                   \
-			goto failExit;                                                                                             \
-		}                                                                                                              \
-	} while (0)
-
-#define fdb_block_wait(_f)                                                                                             \
-	do {                                                                                                               \
-		if ((fdb_future_block_until_ready(_f)) != 0) {                                                                 \
-			fprintf(stderr, "ERROR: fdb_future_block_until_ready failed at %s:%d\n", __FILE__, __LINE__);              \
-			goto failExit;                                                                                             \
-		}                                                                                                              \
-	} while (0)
-
-#define fdb_wait_and_handle_error(_func, _f, _t)                                                                       \
-	do {                                                                                                               \
-		int err = wait_future(_f);                                                                                     \
-		if (err) {                                                                                                     \
-			int err2;                                                                                                  \
-			if ((err != 1020 /* not_committed */) && (err != 1021 /* commit_unknown_result */) &&                      \
-			    (err != 1213 /* tag_throttled */)) {                                                                   \
-				fprintf(stderr, "ERROR: Error %s (%d) occured at %s\n", #_func, err, fdb_get_error(err));              \
-			} else {                                                                                                   \
-				fprintf(annoyme, "ERROR: Error %s (%d) occured at %s\n", #_func, err, fdb_get_error(err));             \
-			}                                                                                                          \
-			fdb_future_destroy(_f);                                                                                    \
-			_f = fdb_transaction_on_error(_t, err);                                                                    \
-			/* this will return the original error for non-retryable errors */                                         \
-			err2 = wait_future(_f);                                                                                    \
-			fdb_future_destroy(_f);                                                                                    \
-			if (err2) {                                                                                                \
-				/* unretryable error */                                                                                \
-				fprintf(stderr, "ERROR: fdb_transaction_on_error returned %d at %s:%d\n", err2, __FILE__, __LINE__);   \
-				fdb_transaction_reset(_t);                                                                             \
-				/* TODO: if we add a retry limit in the future,                                                        \
-				 *       handle the conflict stats properly.                                                           \
-				 */                                                                                                    \
-				return FDB_ERROR_ABORT;                                                                                \
-			}                                                                                                          \
-			if (err == 1020 /* not_committed */) {                                                                     \
-				return FDB_ERROR_CONFLICT;                                                                             \
-			}                                                                                                          \
-			return FDB_ERROR_RETRY;                                                                                    \
-		}                                                                                                              \
-	} while (0)
-
-#define fdb_handle_result_error(_func, err, _t)                                                                        \
-	do {                                                                                                               \
-		if (err) {                                                                                                     \
-			int err2;                                                                                                  \
-			FDBFuture* fErr;                                                                                           \
-			if ((err != 1020 /* not_committed */) && (err != 1021 /* commit_unknown_result */) &&                      \
-			    (err != 1213 /* tag_throttled */)) {                                                                   \
-				fprintf(stderr, "ERROR: Error %s (%d) occured at %s\n", #_func, err, fdb_get_error(err));              \
-			} else {                                                                                                   \
-				fprintf(annoyme, "ERROR: Error %s (%d) occured at %s\n", #_func, err, fdb_get_error(err));             \
-			}                                                                                                          \
-			fErr = fdb_transaction_on_error(_t, err);                                                                  \
-			/* this will return the original error for non-retryable errors */                                         \
-			err2 = wait_future(fErr);                                                                                  \
-			fdb_future_destroy(fErr);                                                                                  \
-			if (err2) {                                                                                                \
-				/* unretryable error */                                                                                \
-				fprintf(stderr, "ERROR: fdb_transaction_on_error returned %d at %s:%d\n", err2, __FILE__, __LINE__);   \
-				fdb_transaction_reset(_t);                                                                             \
-				/* TODO: if we add a retry limit in the future,                                                        \
-				 *       handle the conflict stats properly.                                                           \
-				 */                                                                                                    \
-				return FDB_ERROR_ABORT;                                                                                \
-			}                                                                                                          \
-			if (err == 1020 /* not_committed */) {                                                                     \
-				return FDB_ERROR_CONFLICT;                                                                             \
-			}                                                                                                          \
-			return FDB_ERROR_RETRY;                                                                                    \
-		}                                                                                                              \
-	} while (0)
-
-fdb_error_t wait_future(FDBFuture* f) {
-	fdb_error_t err;
-
-	err = fdb_future_block_until_ready(f);
-	if (err) {
-		return err; /* error from fdb_future_block_until_ready() */
-	}
-	return fdb_future_get_error(f);
-}
-
-int commit_transaction(FDBTransaction* transaction) {
-	FDBFuture* f;
-
-	f = fdb_transaction_commit(transaction);
-	fdb_wait_and_handle_error(commit_transaction, f, transaction);
-	fdb_future_destroy(f);
-
-	return FDB_SUCCESS;
-}
-
-void update_op_lat_stats(struct timespec* start,
-                         struct timespec* end,
-                         int op,
-                         mako_stats_t* stats,
-                         lat_block_t* block[],
-                         int* elem_size,
-                         bool* is_memory_allocated) {
-	uint64_t latencyus;
-
-	latencyus = (((uint64_t)end->tv_sec * 1000000000 + end->tv_nsec) -
-	             ((uint64_t)start->tv_sec * 1000000000 + start->tv_nsec)) /
-	            1000;
-	stats->latency_samples[op]++;
-	stats->latency_us_total[op] += latencyus;
-	if (latencyus < stats->latency_us_min[op]) {
-		stats->latency_us_min[op] = latencyus;
-	}
-	if (latencyus > stats->latency_us_max[op]) {
-		stats->latency_us_max[op] = latencyus;
-	}
-	if (!is_memory_allocated[op])
-		return;
-	if (elem_size[op] < stats->latency_samples[op]) {
-		elem_size[op] = elem_size[op] + LAT_BLOCK_SIZE;
-		lat_block_t* temp_block = (lat_block_t*)malloc(sizeof(lat_block_t));
-		if (temp_block == NULL) {
-			is_memory_allocated[op] = false;
-			return;
-		}
-		temp_block->next_block = NULL;
-		block[op]->next_block = (lat_block_t*)temp_block;
-		block[op] = temp_block;
-	}
-	block[op]->data[(stats->latency_samples[op] - 1) % LAT_BLOCK_SIZE] = latencyus;
-}
-
-/* FDB network thread */
-void* fdb_network_thread(void* args) {
-	fdb_error_t err;
-
-	fprintf(debugme, "DEBUG: fdb_network_thread started\n");
-
-	err = fdb_run_network();
-	if (err) {
-		fprintf(stderr, "ERROR: fdb_run_network: %s\n", fdb_get_error(err));
-	}
-
-	return 0;
-}
-
-int genprefix(char* str, char* prefix, int prefixlen, int prefixpadding, int rows, int len) {
-	const int rowdigit = digits(rows);
-	const int paddinglen = len - (prefixlen + rowdigit) - 1;
-	int offset = 0;
-	if (prefixpadding) {
-		memset(str, 'x', paddinglen);
-		offset += paddinglen;
-	}
-	memcpy(str + offset, prefix, prefixlen);
-	str[len - 1] = '\0';
-	return offset + prefixlen;
-}
-
-/* cleanup database */
-int cleanup(FDBTransaction* transaction, mako_args_t* args) {
-	struct timespec timer_start, timer_end;
-	char* prefixstr = (char*)malloc(sizeof(char) * args->key_length + 1);
-	if (!prefixstr)
-		return -1;
-	char* beginstr = (char*)malloc(sizeof(char) * args->key_length + 1);
-	if (!beginstr) {
-		free(prefixstr);
-		return -1;
-	}
-	char* endstr = (char*)malloc(sizeof(char) * args->key_length + 1);
-	if (!endstr) {
-		free(prefixstr);
-		free(beginstr);
-		return -1;
-	}
-
-	int len = genprefix(prefixstr, KEYPREFIX, KEYPREFIXLEN, args->prefixpadding, args->rows, args->key_length + 1);
-	snprintf(beginstr, len + 2, "%s%c", prefixstr, 0x00);
-	snprintf(endstr, len + 2, "%s%c", prefixstr, 0xff);
-	free(prefixstr);
-	len += 1;
-
-retryTxn:
-	clock_gettime(CLOCK_MONOTONIC_COARSE, &timer_start);
-
-	fdb_transaction_clear_range(transaction, (uint8_t*)beginstr, len + 1, (uint8_t*)endstr, len + 1);
-	switch (commit_transaction(transaction)) {
-	case (FDB_SUCCESS):
-		break;
-	case (FDB_ERROR_RETRY):
-		fdb_transaction_reset(transaction);
-		goto retryTxn;
-	default:
-		goto failExit;
-	}
-
-	fdb_transaction_reset(transaction);
-	clock_gettime(CLOCK_MONOTONIC_COARSE, &timer_end);
-	fprintf(printme,
-	        "INFO: Clear range: %6.3f sec\n",
-	        ((timer_end.tv_sec - timer_start.tv_sec) * 1000000000.0 + timer_end.tv_nsec - timer_start.tv_nsec) /
-	            1000000000);
-
-	free(beginstr);
-	free(endstr);
-
-	return 0;
-
-failExit:
-	free(beginstr);
-	free(endstr);
-
-	fprintf(stderr, "ERROR: FDB failure in cleanup()\n");
-	return -1;
-}
-
-/* populate database */
-int populate(FDBTransaction* transaction,
-             mako_args_t* args,
-             int worker_id,
-             int thread_id,
-             int thread_tps,
-             mako_stats_t* stats,
-             lat_block_t* block[],
-             int* elem_size,
-             bool* is_memory_allocated) {
-	int i;
-	struct timespec timer_start, timer_end;
-	struct timespec timer_prev, timer_now; /* for throttling */
-	struct timespec timer_per_xact_start, timer_per_xact_end;
-	struct timespec timer_start_commit;
-	char* keystr;
-	char* valstr;
-
-	int begin = insert_begin(args->rows, worker_id, thread_id, args->num_processes, args->num_threads);
-	int end = insert_end(args->rows, worker_id, thread_id, args->num_processes, args->num_threads);
-	int xacts = 0;
-	int tracetimer = 0;
-
-	keystr = (char*)malloc(sizeof(char) * args->key_length + 1);
-	if (!keystr)
-		return -1;
-	valstr = (char*)malloc(sizeof(char) * args->value_length + 1);
-	if (!valstr) {
-		free(keystr);
-		return -1;
-	}
-
-	clock_gettime(CLOCK_MONOTONIC, &timer_start);
-	timer_prev.tv_sec = timer_start.tv_sec;
-	timer_prev.tv_nsec = timer_start.tv_nsec;
-	timer_per_xact_start.tv_sec = timer_start.tv_sec;
-	timer_per_xact_start.tv_nsec = timer_start.tv_nsec;
-
-	for (i = begin; i <= end; i++) {
-
-		/* sequential keys */
-		genkey(keystr, KEYPREFIX, KEYPREFIXLEN, args->prefixpadding, i, args->rows, args->key_length + 1);
-		/* random values */
-		randstr(valstr, args->value_length + 1);
-
-		if (((thread_tps > 0) && (xacts >= thread_tps)) /* throttle */ || (args->txntrace) /* txn tracing */) {
-
-		throttle:
-			clock_gettime(CLOCK_MONOTONIC_COARSE, &timer_now);
-			if ((timer_now.tv_sec > timer_prev.tv_sec + 1) ||
-			    ((timer_now.tv_sec == timer_prev.tv_sec + 1) && (timer_now.tv_nsec > timer_prev.tv_nsec))) {
-				/* more than 1 second passed, no need to throttle */
-				xacts = 0;
-				timer_prev.tv_sec = timer_now.tv_sec;
-				timer_prev.tv_nsec = timer_now.tv_nsec;
-
-				/* enable transaction tracing */
-				if (args->txntrace) {
-					tracetimer++;
-					if (tracetimer == args->txntrace) {
-						fdb_error_t err;
-						tracetimer = 0;
-						fprintf(debugme, "DEBUG: txn tracing %s\n", keystr);
-						err = fdb_transaction_set_option(
-						    transaction, FDB_TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER, (uint8_t*)keystr, strlen(keystr));
-						if (err) {
-							fprintf(
-							    stderr,
-							    "ERROR: fdb_transaction_set_option(FDB_TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER): %s\n",
-							    fdb_get_error(err));
-						}
-						err = fdb_transaction_set_option(transaction, FDB_TR_OPTION_LOG_TRANSACTION, (uint8_t*)NULL, 0);
-						if (err) {
-							fprintf(stderr,
-							        "ERROR: fdb_transaction_set_option(FDB_TR_OPTION_LOG_TRANSACTION): %s\n",
-							        fdb_get_error(err));
-						}
-					}
-				}
-			} else {
-				if (thread_tps > 0) {
-					/* 1 second not passed, throttle */
-					usleep(1000); /* sleep for 1ms */
-					goto throttle;
-				}
-			}
-		} /* throttle or txntrace */
-
-		/* insert (SET) */
-		fdb_transaction_set(transaction, (uint8_t*)keystr, strlen(keystr), (uint8_t*)valstr, strlen(valstr));
-		stats->ops[OP_INSERT]++;
-
-		/* commit every 100 inserts (default) */
-		if (i % args->txnspec.ops[OP_INSERT][OP_COUNT] == 0) {
-		retryTxn:
-			if (stats->xacts % args->sampling == 0) {
-				clock_gettime(CLOCK_MONOTONIC, &timer_start_commit);
-			}
-
-			switch (commit_transaction(transaction)) {
-			case (FDB_SUCCESS):
-				break;
-			case (FDB_ERROR_RETRY):
-				goto retryTxn;
-			default:
-				goto failExit;
-			}
-
-			/* xact latency stats */
-			if (stats->xacts % args->sampling == 0) {
-				clock_gettime(CLOCK_MONOTONIC, &timer_per_xact_end);
-				update_op_lat_stats(
-				    &timer_start_commit, &timer_per_xact_end, OP_COMMIT, stats, block, elem_size, is_memory_allocated);
-				update_op_lat_stats(&timer_per_xact_start,
-				                    &timer_per_xact_end,
-				                    OP_TRANSACTION,
-				                    stats,
-				                    block,
-				                    elem_size,
-				                    is_memory_allocated);
-			}
-
-			stats->ops[OP_COMMIT]++;
-			stats->ops[OP_TRANSACTION]++;
-			clock_gettime(CLOCK_MONOTONIC, &timer_per_xact_start);
-
-			fdb_transaction_reset(transaction);
-			stats->xacts++;
-			xacts++; /* for throttling */
-		}
-	}
-	time_t start_time_sec, current_time_sec;
-	time(&start_time_sec);
-	int is_committed = false;
-	// will hit FDB_ERROR_RETRY if running mako with multi-version client
-	while (!is_committed) {
-		if (stats->xacts % args->sampling == 0) {
-			clock_gettime(CLOCK_MONOTONIC, &timer_start_commit);
-		}
-		int rc;
-		if ((rc = commit_transaction(transaction) != FDB_SUCCESS)) {
-			if (rc == FDB_ERROR_RETRY) {
-				time(&current_time_sec);
-				if (difftime(current_time_sec, start_time_sec) > 5) {
-					goto failExit;
-				} else {
-					continue;
-				}
-			} else {
-				goto failExit;
-			}
-		}
-		is_committed = true;
-		/* xact latency stats */
-		if (stats->xacts % args->sampling == 0) {
-			clock_gettime(CLOCK_MONOTONIC, &timer_per_xact_end);
-			update_op_lat_stats(
-			    &timer_start_commit, &timer_per_xact_end, OP_COMMIT, stats, block, elem_size, is_memory_allocated);
-			update_op_lat_stats(&timer_per_xact_start,
-			                    &timer_per_xact_end,
-			                    OP_TRANSACTION,
-			                    stats,
-			                    block,
-			                    elem_size,
-			                    is_memory_allocated);
-		}
-	}
-
-	clock_gettime(CLOCK_MONOTONIC, &timer_end);
-	stats->xacts++;
-
-	fprintf(debugme,
-	        "DEBUG: Populated %d rows (%d-%d): %6.3f sec\n",
-	        end - begin,
-	        begin,
-	        end,
-	        ((timer_end.tv_sec - timer_start.tv_sec) * 1000000000.0 + timer_end.tv_nsec - timer_start.tv_nsec) /
-	            1000000000);
-
-	free(keystr);
-	free(valstr);
-	return 0;
-
-failExit:
-	if (keystr)
-		free(keystr);
-	if (valstr)
-		free(valstr);
-	fprintf(stderr, "ERROR: FDB failure in populate()\n");
-	return -1;
-}
-
-int64_t run_op_getreadversion(FDBTransaction* transaction, int64_t* rv) {
-	FDBFuture* f;
-	fdb_error_t err;
-
-	*rv = 0;
-
-	f = fdb_transaction_get_read_version(transaction);
-	fdb_wait_and_handle_error(fdb_transaction_get_read_version, f, transaction);
-
-#if FDB_API_VERSION < 620
-	err = fdb_future_get_version(f, rv);
-#else
-	err = fdb_future_get_int64(f, rv);
-#endif
-
-	fdb_future_destroy(f);
-	if (err) {
-#if FDB_API_VERSION < 620
-		fprintf(stderr, "ERROR: fdb_future_get_version: %s\n", fdb_get_error(err));
-#else
-		fprintf(stderr, "ERROR: fdb_future_get_int64: %s\n", fdb_get_error(err));
-#endif
-		return FDB_ERROR_RETRY;
-	}
-
-	/* fail if rv not properly set */
-	if (!*rv) {
-		return FDB_ERROR_RETRY;
-	}
-	return FDB_SUCCESS;
-}
-
-int run_op_get(FDBTransaction* transaction, char* keystr, char* valstr, int snapshot) {
-	FDBFuture* f;
-	int out_present;
-	char* val;
-	int vallen;
-	fdb_error_t err;
-
-	f = fdb_transaction_get(transaction, (uint8_t*)keystr, strlen(keystr), snapshot);
-	fdb_wait_and_handle_error(fdb_transaction_get, f, transaction);
-
-	err = fdb_future_get_value(f, &out_present, (const uint8_t**)&val, &vallen);
-	fdb_future_destroy(f);
-	if (err || !out_present) {
-		/* error or value not present */
-		return FDB_ERROR_RETRY;
-	}
-	strncpy(valstr, val, vallen);
-	valstr[vallen] = '\0';
-	return FDB_SUCCESS;
-}
-
-int run_op_getrange(FDBTransaction* transaction,
-                    char* keystr,
-                    char* keystr2,
-                    char* valstr,
-                    int snapshot,
-                    int reverse,
-                    FDBStreamingMode streaming_mode) {
-	FDBFuture* f;
-	fdb_error_t err;
-	FDBKeyValue const* out_kv;
-	int out_count;
-	int out_more;
-
-	f = fdb_transaction_get_range(transaction,
-	                              FDB_KEYSEL_FIRST_GREATER_OR_EQUAL((uint8_t*)keystr, strlen(keystr)),
-	                              FDB_KEYSEL_LAST_LESS_OR_EQUAL((uint8_t*)keystr2, strlen(keystr2)) + 1,
-	                              0 /* limit */,
-	                              0 /* target_bytes */,
-	                              streaming_mode /* FDBStreamingMode */,
-	                              0 /* iteration */,
-	                              snapshot,
-	                              reverse /* reverse */);
-	fdb_wait_and_handle_error(fdb_transaction_get_range, f, transaction);
-
-	err = fdb_future_get_keyvalue_array(f, &out_kv, &out_count, &out_more);
-	if (err) {
-		fprintf(stderr, "ERROR: fdb_future_get_keyvalue_array: %s\n", fdb_get_error(err));
-		fdb_future_destroy(f);
-		return FDB_ERROR_RETRY;
-	}
-	fdb_future_destroy(f);
-	return FDB_SUCCESS;
-}
-
-/* Update -- GET and SET the same key */
-int run_op_update(FDBTransaction* transaction, char* keystr, char* valstr) {
-	FDBFuture* f;
-	int out_present;
-	char* val;
-	int vallen;
-	fdb_error_t err;
-
-	/* GET first */
-	f = fdb_transaction_get(transaction, (uint8_t*)keystr, strlen(keystr), 0);
-	fdb_wait_and_handle_error(fdb_transaction_get, f, transaction);
-
-	err = fdb_future_get_value(f, &out_present, (const uint8_t**)&val, &vallen);
-	fdb_future_destroy(f);
-	if (err || !out_present) {
-		/* error or value not present */
-		return FDB_ERROR_RETRY;
-	}
-
-	/* Update Value (SET) */
-	fdb_transaction_set(transaction, (uint8_t*)keystr, strlen(keystr), (uint8_t*)valstr, strlen(valstr));
-	return FDB_SUCCESS;
-}
-
-int run_op_insert(FDBTransaction* transaction, char* keystr, char* valstr) {
-	fdb_transaction_set(transaction, (uint8_t*)keystr, strlen(keystr), (uint8_t*)valstr, strlen(valstr));
-	return FDB_SUCCESS;
-}
-
-int run_op_clear(FDBTransaction* transaction, char* keystr) {
-	fdb_transaction_clear(transaction, (uint8_t*)keystr, strlen(keystr));
-	return FDB_SUCCESS;
-}
-
-int run_op_clearrange(FDBTransaction* transaction, char* keystr, char* keystr2) {
-	fdb_transaction_clear_range(transaction, (uint8_t*)keystr, strlen(keystr), (uint8_t*)keystr2, strlen(keystr2));
-	return FDB_SUCCESS;
-}
-
-// TODO: could always abstract this into something more generically usable by something other than mako.
-// But outside of testing there are likely few use cases for local granules
-typedef struct {
-	char* bgFilePath;
-	int nextId;
-	uint8_t** data_by_id;
-} BGLocalFileContext;
-
-int64_t granule_start_load(const char* filename,
-                           int filenameLength,
-                           int64_t offset,
-                           int64_t length,
-                           int64_t fullFileLength,
-                           void* userContext) {
-	FILE* fp;
-	char full_fname[PATH_MAX];
-	int loadId;
-	uint8_t* data;
-	size_t readSize;
-
-	BGLocalFileContext* context = (BGLocalFileContext*)userContext;
-
-	loadId = context->nextId;
-	if (context->data_by_id[loadId] != 0) {
-		fprintf(stderr, "ERROR: too many granule file loads at once: %d\n", MAX_BG_IDS);
-		return -1;
-	}
-	context->nextId = (context->nextId + 1) % MAX_BG_IDS;
-
-	int ret = snprintf(full_fname, PATH_MAX, "%s%s", context->bgFilePath, filename);
-	if (ret < 0 || ret >= PATH_MAX) {
-		fprintf(stderr, "ERROR: BG filename too long: %s%s\n", context->bgFilePath, filename);
-		return -1;
-	}
-
-	fp = fopen(full_fname, "r");
-	if (!fp) {
-		fprintf(stderr, "ERROR: BG could not open file: %s\n", full_fname);
-		return -1;
-	}
-
-	// don't seek if offset == 0
-	if (offset && fseek(fp, offset, SEEK_SET)) {
-		// if fseek was non-zero, it failed
-		fprintf(stderr, "ERROR: BG could not seek to %" PRId64 " in file %s\n", offset, full_fname);
-		fclose(fp);
-		return -1;
-	}
-
-	data = (uint8_t*)malloc(length);
-	readSize = fread(data, sizeof(uint8_t), length, fp);
-	fclose(fp);
-
-	if (readSize != length) {
-		fprintf(stderr, "ERROR: BG could not read %" PRId64 " bytes from file: %s\n", length, full_fname);
-		return -1;
-	}
-
-	context->data_by_id[loadId] = data;
-	return loadId;
-}
-
-uint8_t* granule_get_load(int64_t loadId, void* userContext) {
-	BGLocalFileContext* context = (BGLocalFileContext*)userContext;
-	if (context->data_by_id[loadId] == 0) {
-		fprintf(stderr, "ERROR: BG loadId invalid for get_load: %" PRId64 "\n", loadId);
-		return 0;
-	}
-	return context->data_by_id[loadId];
-}
-
-void granule_free_load(int64_t loadId, void* userContext) {
-	BGLocalFileContext* context = (BGLocalFileContext*)userContext;
-	if (context->data_by_id[loadId] == 0) {
-		fprintf(stderr, "ERROR: BG loadId invalid for free_load: %" PRId64 "\n", loadId);
-	}
-	free(context->data_by_id[loadId]);
-	context->data_by_id[loadId] = 0;
-}
-
-int run_op_read_blob_granules(FDBTransaction* transaction,
-                              char* keystr,
-                              char* keystr2,
-                              bool doMaterialize,
-                              char* bgFilePath) {
-	FDBResult* r;
-	fdb_error_t err;
-	FDBKeyValue const* out_kv;
-	int out_count;
-	int out_more;
-
-	err = fdb_transaction_set_option(transaction, FDB_TR_OPTION_READ_YOUR_WRITES_DISABLE, (uint8_t*)NULL, 0);
-	if (err) {
-		fprintf(stderr, "ERROR: FDB_TR_OPTION_READ_YOUR_WRITES_DISABLE: %s\n", fdb_get_error(err));
-		return FDB_ERROR_RETRY;
-	}
-
-	// Allocate a separate context per call to avoid multiple threads accessing
-	BGLocalFileContext fileContext;
-	fileContext.bgFilePath = bgFilePath;
-	fileContext.nextId = 0;
-	fileContext.data_by_id = (uint8_t**)malloc(MAX_BG_IDS * sizeof(uint8_t*));
-	memset(fileContext.data_by_id, 0, MAX_BG_IDS * sizeof(uint8_t*));
-
-	FDBReadBlobGranuleContext granuleContext;
-	granuleContext.userContext = &fileContext;
-	granuleContext.start_load_f = &granule_start_load;
-	granuleContext.get_load_f = &granule_get_load;
-	granuleContext.free_load_f = &granule_free_load;
-	granuleContext.debugNoMaterialize = !doMaterialize;
-	granuleContext.granuleParallelism = 2; // TODO make knob or setting for changing this?
-
-	r = fdb_transaction_read_blob_granules(transaction,
-	                                       (uint8_t*)keystr,
-	                                       strlen(keystr),
-	                                       (uint8_t*)keystr2,
-	                                       strlen(keystr2),
-	                                       0 /* beginVersion*/,
-	                                       -2, /* endVersion. -2 (latestVersion) is use txn read version */
-	                                       granuleContext);
-
-	free(fileContext.data_by_id);
-
-	err = fdb_result_get_keyvalue_array(r, &out_kv, &out_count, &out_more);
-
-	if (err) {
-		if (err != 2037 /* blob_granule_not_materialized */) {
-			fdb_handle_result_error(fdb_transaction_read_blob_granules, err, transaction);
-		} else {
-			fdb_result_destroy(r);
-			return FDB_SUCCESS;
-		}
-	}
-
-	fdb_result_destroy(r);
-
-	return FDB_SUCCESS;
-}
-
-/* run one transaction */
-int run_one_transaction(FDBTransaction* transaction,
-                        mako_args_t* args,
-                        mako_stats_t* stats,
-                        char* keystr,
-                        char* keystr2,
-                        char* valstr,
-                        lat_block_t* block[],
-                        int* elem_size,
-                        bool* is_memory_allocated) {
-	int i;
-	int count;
-	int rc;
-	struct timespec timer_start, timer_end;
-	struct timespec timer_per_xact_start, timer_per_xact_end;
-	struct timespec timer_start_commit;
-	int docommit = 0;
-	int keynum;
-	int keyend;
-	int64_t readversion;
-	int randstrlen;
-	int rangei;
-
-#if 0 /* this call conflicts with debug transaction */
-  /* make sure that the transaction object is clean */
-  fdb_transaction_reset(transaction);
-#endif
-
-	clock_gettime(CLOCK_MONOTONIC, &timer_per_xact_start);
-
-retryTxn:
-	for (i = 0; i < MAX_OP; i++) {
-
-		if ((args->txnspec.ops[i][OP_COUNT] > 0) && (i != OP_TRANSACTION) && (i != OP_COMMIT)) {
-			for (count = 0; count < args->txnspec.ops[i][OP_COUNT]; count++) {
-
-				/* note: for simplicity, always generate a new key(s) even when retrying */
-
-				/* pick a random key(s) */
-				if (args->zipf) {
-					keynum = zipfian_next();
-				} else {
-					keynum = urand(0, args->rows - 1);
-				}
-				genkey(keystr, KEYPREFIX, KEYPREFIXLEN, args->prefixpadding, keynum, args->rows, args->key_length + 1);
-
-				/* range */
-				if (args->txnspec.ops[i][OP_RANGE] > 0) {
-					keyend = keynum + args->txnspec.ops[i][OP_RANGE] - 1; /* inclusive */
-					if (keyend > args->rows - 1) {
-						keyend = args->rows - 1;
-					}
-					genkey(keystr2,
-					       KEYPREFIX,
-					       KEYPREFIXLEN,
-					       args->prefixpadding,
-					       keyend,
-					       args->rows,
-					       args->key_length + 1);
-				}
-
-				if (stats->xacts % args->sampling == 0) {
-					/* per op latency */
-					clock_gettime(CLOCK_MONOTONIC, &timer_start);
-				}
-
-				switch (i) {
-				case OP_GETREADVERSION:
-					rc = run_op_getreadversion(transaction, &readversion);
-					break;
-				case OP_GET:
-					rc = run_op_get(transaction, keystr, valstr, 0);
-					break;
-				case OP_GETRANGE:
-					rc = run_op_getrange(transaction,
-					                     keystr,
-					                     keystr2,
-					                     valstr,
-					                     0,
-					                     args->txnspec.ops[i][OP_REVERSE],
-					                     args->streaming_mode);
-					break;
-				case OP_SGET:
-					rc = run_op_get(transaction, keystr, valstr, 1);
-					break;
-				case OP_SGETRANGE:
-					rc = run_op_getrange(transaction,
-					                     keystr,
-					                     keystr2,
-					                     valstr,
-					                     1,
-					                     args->txnspec.ops[i][OP_REVERSE],
-					                     args->streaming_mode);
-					break;
-				case OP_UPDATE:
-					randstr(valstr, args->value_length + 1);
-					rc = run_op_update(transaction, keystr, valstr);
-					docommit = 1;
-					break;
-				case OP_INSERT:
-					randstr(keystr + KEYPREFIXLEN, args->key_length - KEYPREFIXLEN + 1); /* make it (almost) unique */
-					randstr(valstr, args->value_length + 1);
-					rc = run_op_insert(transaction, keystr, valstr);
-					docommit = 1;
-					break;
-				case OP_INSERTRANGE:
-					randstrlen = args->key_length - KEYPREFIXLEN - digits(args->txnspec.ops[i][OP_RANGE]);
-					randstr(keystr + KEYPREFIXLEN, randstrlen + 1); /* make it (almost) unique */
-					randstr(valstr, args->value_length + 1);
-					for (rangei = 0; rangei < args->txnspec.ops[i][OP_RANGE]; rangei++) {
-						sprintf(keystr + KEYPREFIXLEN + randstrlen,
-						        "%0.*d",
-						        digits(args->txnspec.ops[i][OP_RANGE]),
-						        rangei);
-						rc = run_op_insert(transaction, keystr, valstr);
-						if (rc != FDB_SUCCESS)
-							break;
-					}
-					docommit = 1;
-					break;
-				case OP_OVERWRITE:
-					rc = run_op_insert(transaction, keystr, valstr);
-					docommit = 1;
-					break;
-				case OP_CLEAR:
-					rc = run_op_clear(transaction, keystr);
-					docommit = 1;
-					break;
-				case OP_SETCLEAR:
-					randstr(keystr + KEYPREFIXLEN, args->key_length - KEYPREFIXLEN + 1); /* make it (almost) unique */
-					randstr(valstr, args->value_length + 1);
-					rc = run_op_insert(transaction, keystr, valstr);
-					if (rc == FDB_SUCCESS) {
-						/* commit insert so mutation goes to storage */
-						/* to measure commit latency */
-						if (stats->xacts % args->sampling == 0) {
-							clock_gettime(CLOCK_MONOTONIC, &timer_start_commit);
-						}
-						rc = commit_transaction(transaction);
-						if (rc == FDB_SUCCESS) {
-							stats->ops[OP_COMMIT]++;
-							stats->ops[OP_TRANSACTION]++;
-							if (stats->xacts % args->sampling == 0) {
-								clock_gettime(CLOCK_MONOTONIC, &timer_per_xact_end);
-								update_op_lat_stats(&timer_start_commit,
-								                    &timer_per_xact_end,
-								                    OP_COMMIT,
-								                    stats,
-								                    block,
-								                    elem_size,
-								                    is_memory_allocated);
-								update_op_lat_stats(&timer_per_xact_start,
-								                    &timer_per_xact_end,
-								                    OP_TRANSACTION,
-								                    stats,
-								                    block,
-								                    elem_size,
-								                    is_memory_allocated);
-							}
-						} else {
-							/* error */
-							if (rc == FDB_ERROR_CONFLICT) {
-								stats->conflicts++;
-							} else {
-								stats->errors[OP_COMMIT]++;
-							}
-							if (rc == FDB_ERROR_ABORT) {
-								/* make sure to reset transaction */
-								fdb_transaction_reset(transaction);
-								return rc; /* abort */
-							}
-							goto retryTxn;
-						}
-						fdb_transaction_reset(transaction);
-						rc = run_op_clear(transaction, keystr);
-					}
-					docommit = 1;
-					break;
-				case OP_CLEARRANGE:
-					rc = run_op_clearrange(transaction, keystr, keystr2);
-					docommit = 1;
-					break;
-				case OP_SETCLEARRANGE:
-					randstrlen = args->key_length - KEYPREFIXLEN - digits(args->txnspec.ops[i][OP_RANGE]);
-					randstr(keystr + KEYPREFIXLEN, randstrlen + 1); /* make it (almost) unique */
-					randstr(valstr, args->value_length + 1);
-					for (rangei = 0; rangei < args->txnspec.ops[i][OP_RANGE]; rangei++) {
-						sprintf(keystr + KEYPREFIXLEN + randstrlen,
-						        "%0.*d",
-						        digits(args->txnspec.ops[i][OP_RANGE]),
-						        rangei);
-						if (rangei == 0) {
-							strcpy(keystr2, keystr);
-							keystr2[strlen(keystr)] = '\0';
-						}
-						rc = run_op_insert(transaction, keystr, valstr);
-						/* rollback not necessary, move on */
-						if (rc == FDB_ERROR_RETRY) {
-							goto retryTxn;
-						} else if (rc == FDB_ERROR_ABORT) {
-							/* make sure to reset transaction */
-							fdb_transaction_reset(transaction);
-							return rc; /* abort */
-						}
-					}
-					/* commit insert so mutation goes to storage */
-					if (stats->xacts % args->sampling == 0) {
-						clock_gettime(CLOCK_MONOTONIC, &timer_start_commit);
-					}
-					rc = commit_transaction(transaction);
-					if (rc == FDB_SUCCESS) {
-						stats->ops[OP_COMMIT]++;
-						stats->ops[OP_TRANSACTION]++;
-						if (stats->xacts % args->sampling == 0) {
-							clock_gettime(CLOCK_MONOTONIC, &timer_per_xact_end);
-							update_op_lat_stats(&timer_start_commit,
-							                    &timer_per_xact_end,
-							                    OP_COMMIT,
-							                    stats,
-							                    block,
-							                    elem_size,
-							                    is_memory_allocated);
-							update_op_lat_stats(&timer_per_xact_start,
-							                    &timer_per_xact_end,
-							                    OP_TRANSACTION,
-							                    stats,
-							                    block,
-							                    elem_size,
-							                    is_memory_allocated);
-						}
-					} else {
-						/* error */
-						if (rc == FDB_ERROR_CONFLICT) {
-							stats->conflicts++;
-						} else {
-							stats->errors[OP_TRANSACTION]++;
-						}
-						if (rc == FDB_ERROR_ABORT) {
-							/* make sure to reset transaction */
-							fdb_transaction_reset(transaction);
-							return rc; /* abort */
-						}
-						goto retryTxn;
-					}
-					fdb_transaction_reset(transaction);
-					rc = run_op_clearrange(transaction, keystr2, keystr);
-					docommit = 1;
-					break;
-				case OP_READ_BG:
-					rc = run_op_read_blob_granules(
-					    transaction, keystr, keystr2, args->bg_materialize_files, args->bg_file_path);
-					break;
-				default:
-					fprintf(stderr, "ERROR: Unknown Operation %d\n", i);
-					break;
-				}
-
-				if (stats->xacts % args->sampling == 0) {
-					clock_gettime(CLOCK_MONOTONIC, &timer_end);
-					if (rc == FDB_SUCCESS) {
-						/* per op latency, record successful transactions */
-						update_op_lat_stats(&timer_start, &timer_end, i, stats, block, elem_size, is_memory_allocated);
-					}
-				}
-
-				/* check rc and update stats */
-				if (rc == FDB_SUCCESS) {
-					stats->ops[i]++;
-				} else {
-					/* error */
-					if (rc == FDB_ERROR_CONFLICT) {
-						stats->conflicts++;
-					} else {
-						stats->errors[OP_TRANSACTION]++;
-					}
-					if (rc == FDB_ERROR_ABORT) {
-						/* make sure to reset transaction */
-						fdb_transaction_reset(transaction);
-						return rc; /* abort */
-					}
-					goto retryTxn;
-				}
-			}
-		}
-	}
-
-	/* commit only successful transaction */
-	if (docommit | args->commit_get) {
-		if (stats->xacts % args->sampling == 0) {
-			clock_gettime(CLOCK_MONOTONIC, &timer_start_commit);
-		}
-		rc = commit_transaction(transaction);
-		if (rc == FDB_SUCCESS) {
-			/* success */
-			stats->ops[OP_COMMIT]++;
-			if (stats->xacts % args->sampling == 0) {
-				clock_gettime(CLOCK_MONOTONIC, &timer_per_xact_end);
-				update_op_lat_stats(
-				    &timer_start_commit, &timer_per_xact_end, OP_COMMIT, stats, block, elem_size, is_memory_allocated);
-			}
-		} else {
-			/* error */
-			if (rc == FDB_ERROR_CONFLICT) {
-				stats->conflicts++;
-			} else {
-				stats->errors[OP_TRANSACTION]++;
-			}
-			if (rc == FDB_ERROR_ABORT) {
-				/* make sure to reset transaction */
-				fdb_transaction_reset(transaction);
-				return rc; /* abort */
-			}
-			goto retryTxn;
-		}
-	}
-
-	stats->ops[OP_TRANSACTION]++;
-	if (stats->xacts % args->sampling == 0) {
-		clock_gettime(CLOCK_MONOTONIC, &timer_per_xact_end);
-		update_op_lat_stats(
-		    &timer_per_xact_start, &timer_per_xact_end, OP_TRANSACTION, stats, block, elem_size, is_memory_allocated);
-	}
-
-	stats->xacts++;
-
-	/* make sure to reset transaction */
-	fdb_transaction_reset(transaction);
-	return 0;
-}
-
-int run_workload(FDBTransaction* transaction,
-                 mako_args_t* args,
-                 int thread_tps,
-                 volatile double* throttle_factor,
-                 int thread_iters,
-                 volatile int* signal,
-                 mako_stats_t* stats,
-                 int dotrace,
-                 int dotagging,
-                 lat_block_t* block[],
-                 int* elem_size,
-                 bool* is_memory_allocated) {
-	int xacts = 0;
-	int64_t total_xacts = 0;
-	int rc = 0;
-	struct timespec timer_prev, timer_now;
-	char* keystr;
-	char* keystr2;
-	char* valstr;
-	int current_tps;
-	char* traceid;
-	int tracetimer = 0;
-	char* tagstr;
-
-	if (thread_tps < 0)
-		return 0;
-
-	if (dotrace) {
-		traceid = (char*)malloc(32);
-	}
-
-	if (dotagging) {
-		tagstr = (char*)calloc(16, 1);
-		memcpy(tagstr, KEYPREFIX, KEYPREFIXLEN);
-		memcpy(tagstr + KEYPREFIXLEN, args->txntagging_prefix, TAGPREFIXLENGTH_MAX);
-	}
-
-	current_tps = (int)((double)thread_tps * *throttle_factor);
-
-	keystr = (char*)malloc(sizeof(char) * args->key_length + 1);
-	if (!keystr)
-		return -1;
-	keystr2 = (char*)malloc(sizeof(char) * args->key_length + 1);
-	if (!keystr2) {
-		free(keystr);
-		return -1;
-	}
-	valstr = (char*)malloc(sizeof(char) * args->value_length + 1);
-	if (!valstr) {
-		free(keystr);
-		free(keystr2);
-		return -1;
-	}
-
-	clock_gettime(CLOCK_MONOTONIC_COARSE, &timer_prev);
-
-	/* main transaction loop */
-	while (1) {
-
-		if (((thread_tps > 0) && (xacts >= current_tps)) /* throttle on */ || dotrace /* transaction tracing on */) {
-
-			clock_gettime(CLOCK_MONOTONIC_COARSE, &timer_now);
-			if ((timer_now.tv_sec > timer_prev.tv_sec + 1) ||
-			    ((timer_now.tv_sec == timer_prev.tv_sec + 1) && (timer_now.tv_nsec > timer_prev.tv_nsec))) {
-				/* more than 1 second passed, no need to throttle */
-				xacts = 0;
-				timer_prev.tv_sec = timer_now.tv_sec;
-				timer_prev.tv_nsec = timer_now.tv_nsec;
-
-				/* update throttle rate */
-				if (thread_tps > 0) {
-					current_tps = (int)((double)thread_tps * *throttle_factor);
-				}
-
-				/* enable transaction trace */
-				if (dotrace) {
-					tracetimer++;
-					if (tracetimer == dotrace) {
-						fdb_error_t err;
-						tracetimer = 0;
-						snprintf(traceid, 32, "makotrace%019" PRId64, total_xacts);
-						fprintf(debugme, "DEBUG: txn tracing %s\n", traceid);
-						err = fdb_transaction_set_option(transaction,
-						                                 FDB_TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER,
-						                                 (uint8_t*)traceid,
-						                                 strlen(traceid));
-						if (err) {
-							fprintf(
-							    stderr, "ERROR: FDB_TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER: %s\n", fdb_get_error(err));
-						}
-						err = fdb_transaction_set_option(transaction, FDB_TR_OPTION_LOG_TRANSACTION, (uint8_t*)NULL, 0);
-						if (err) {
-							fprintf(stderr, "ERROR: FDB_TR_OPTION_LOG_TRANSACTION: %s\n", fdb_get_error(err));
-						}
-					}
-				}
-
-			} else {
-				if (thread_tps > 0) {
-					/* 1 second not passed, throttle */
-					usleep(1000);
-					continue;
-				}
-			}
-		} /* throttle or txntrace */
-
-		/* enable transaction tagging */
-		if (dotagging > 0) {
-			sprintf(tagstr + KEYPREFIXLEN + TAGPREFIXLENGTH_MAX, "%03d", urand(0, args->txntagging - 1));
-			fdb_error_t err =
-			    fdb_transaction_set_option(transaction, FDB_TR_OPTION_AUTO_THROTTLE_TAG, (uint8_t*)tagstr, 16);
-			if (err) {
-				fprintf(stderr, "ERROR: FDB_TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER: %s\n", fdb_get_error(err));
-			}
-		}
-
-		rc = run_one_transaction(
-		    transaction, args, stats, keystr, keystr2, valstr, block, elem_size, is_memory_allocated);
-		if (rc) {
-			/* FIXME: run_one_transaction should return something meaningful */
-			fprintf(annoyme, "ERROR: run_one_transaction failed (%d)\n", rc);
-		}
-
-		if (thread_iters > 0) {
-			if (thread_iters == xacts) {
-				/* xact limit reached */
-				break;
-			}
-		} else if (*signal == SIGNAL_RED) {
-			/* signal turned red, target duration reached */
-			break;
-		}
-		xacts++;
-		total_xacts++;
-	}
-	free(keystr);
-	free(keystr2);
-	free(valstr);
-	if (dotrace) {
-		free(traceid);
-	}
-	if (dotagging) {
-		free(tagstr);
-	}
-
-	return rc;
-}
-
-void get_stats_file_name(char filename[], int worker_id, int thread_id, int op) {
-	char str1[256];
-	sprintf(str1, "/%d_%d_", worker_id + 1, thread_id + 1);
-	strcat(filename, str1);
-	switch (op) {
-	case OP_GETREADVERSION:
-		strcat(filename, "GRV");
-		break;
-	case OP_GET:
-		strcat(filename, "GET");
-		break;
-	case OP_GETRANGE:
-		strcat(filename, "GETRANGE");
-		break;
-	case OP_SGET:
-		strcat(filename, "SGET");
-		break;
-	case OP_SGETRANGE:
-		strcat(filename, "SGETRANGE");
-		break;
-	case OP_UPDATE:
-		strcat(filename, "UPDATE");
-		break;
-	case OP_INSERT:
-		strcat(filename, "INSERT");
-		break;
-	case OP_INSERTRANGE:
-		strcat(filename, "INSERTRANGE");
-		break;
-	case OP_OVERWRITE:
-		strcat(filename, "OVERWRITE");
-		break;
-	case OP_CLEAR:
-		strcat(filename, "CLEAR");
-		break;
-	case OP_SETCLEAR:
-		strcat(filename, "SETCLEAR");
-		break;
-	case OP_CLEARRANGE:
-		strcat(filename, "CLEARRANGE");
-		break;
-	case OP_SETCLEARRANGE:
-		strcat(filename, "SETCLRRANGE");
-		break;
-	case OP_COMMIT:
-		strcat(filename, "COMMIT");
-		break;
-	case OP_TRANSACTION:
-		strcat(filename, "TRANSACTION");
-		break;
-	case OP_READ_BG:
-		strcat(filename, "READBLOBGRANULES");
-		break;
-	}
-}
-
-/* mako worker thread */
-void* worker_thread(void* thread_args) {
-	int worker_id = ((thread_args_t*)thread_args)->process->worker_id;
-	int thread_id = ((thread_args_t*)thread_args)->thread_id;
-	mako_args_t* args = ((thread_args_t*)thread_args)->process->args;
-	size_t database_index = ((thread_args_t*)thread_args)->database_index;
-	FDBDatabase* database = ((thread_args_t*)thread_args)->process->databases[database_index];
-	fdb_error_t err;
-	int rc;
-	FDBTransaction* transaction;
-	int thread_tps = 0;
-	int thread_iters = 0;
-	int op;
-	int i, size;
-	int dotrace = (worker_id == 0 && thread_id == 0 && args->txntrace) ? args->txntrace : 0;
-	int dotagging = args->txntagging;
-	volatile int* signal = &((thread_args_t*)thread_args)->process->shm->signal;
-	volatile double* throttle_factor = &((thread_args_t*)thread_args)->process->shm->throttle_factor;
-	volatile int* readycount = &((thread_args_t*)thread_args)->process->shm->readycount;
-	volatile int* stopcount = &((thread_args_t*)thread_args)->process->shm->stopcount;
-	mako_stats_t* stats = (void*)((thread_args_t*)thread_args)->process->shm + sizeof(mako_shmhdr_t) /* skip header */
-	                      + (sizeof(mako_stats_t) * (worker_id * args->num_threads + thread_id));
-
-	lat_block_t* block[MAX_OP];
-	for (int i = 0; i < MAX_OP; i++) {
-		block[i] = ((thread_args_t*)thread_args)->block[i];
-	}
-	int* elem_size = &((thread_args_t*)thread_args)->elem_size[0];
-	pid_t* parent_id = &((thread_args_t*)thread_args)->process->parent_id;
-	bool* is_memory_allocated = &((thread_args_t*)thread_args)->is_memory_allocated[0];
-
-	/* init latency */
-	for (op = 0; op < MAX_OP; op++) {
-		stats->latency_us_min[op] = 0xFFFFFFFFFFFFFFFF; /* uint64_t */
-		stats->latency_us_max[op] = 0;
-		stats->latency_us_total[op] = 0;
-		stats->latency_samples[op] = 0;
-	}
-
-	fprintf(debugme,
-	        "DEBUG: worker_id:%d (%d) thread_id:%d (%d) database_index:%lu (tid:%" PRIu64 ")\n",
-	        worker_id,
-	        args->num_processes,
-	        thread_id,
-	        args->num_threads,
-	        database_index,
-	        (uint64_t)pthread_self());
-
-	if (args->tpsmax) {
-		thread_tps = compute_thread_tps(args->tpsmax, worker_id, thread_id, args->num_processes, args->num_threads);
-	}
-
-	if (args->iteration) {
-		thread_iters =
-		    compute_thread_iters(args->iteration, worker_id, thread_id, args->num_processes, args->num_threads);
-	}
-
-	/* create my own transaction object */
-	err = fdb_database_create_transaction(database, &transaction);
-	check_fdb_error(err);
-
-	/* i'm ready */
-	__sync_fetch_and_add(readycount, 1);
-	while (*signal == SIGNAL_OFF) {
-		usleep(10000); /* 10ms */
-	}
-
-	/* clean */
-	if (args->mode == MODE_CLEAN) {
-		rc = cleanup(transaction, args);
-		if (rc < 0) {
-			fprintf(stderr, "ERROR: cleanup failed\n");
-		}
-	}
-
-	/* build/popualte */
-	else if (args->mode == MODE_BUILD) {
-		rc =
-		    populate(transaction, args, worker_id, thread_id, thread_tps, stats, block, elem_size, is_memory_allocated);
-		if (rc < 0) {
-			fprintf(stderr, "ERROR: populate failed\n");
-		}
-	}
-
-	/* run the workload */
-	else if (args->mode == MODE_RUN) {
-		rc = run_workload(transaction,
-		                  args,
-		                  thread_tps,
-		                  throttle_factor,
-		                  thread_iters,
-		                  signal,
-		                  stats,
-		                  dotrace,
-		                  dotagging,
-		                  block,
-		                  elem_size,
-		                  is_memory_allocated);
-		if (rc < 0) {
-			fprintf(stderr, "ERROR: run_workload failed\n");
-		}
-	}
-
-	if (args->mode == MODE_BUILD || args->mode == MODE_RUN) {
-		char str2[1000];
-		sprintf(str2, "%s%d", TEMP_DATA_STORE, *parent_id);
-		rc = mkdir(str2, S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH);
-		if (rc < 0 && errno != EEXIST) {
-			int ec = errno;
-			fprintf(stderr, "Failed to make directory: %s because %s\n", str2, strerror(ec));
-			goto failExit;
-		}
-		for (op = 0; op < MAX_OP; op++) {
-			if (args->txnspec.ops[op][OP_COUNT] > 0 || op == OP_COMMIT || op == OP_TRANSACTION) {
-				FILE* fp;
-				char file_name[NAME_MAX] = { '\0' };
-				strcat(file_name, str2);
-				get_stats_file_name(file_name, worker_id, thread_id, op);
-				fp = fopen(file_name, "w");
-				if (!fp) {
-					int ec = errno;
-					fprintf(stderr, "Failed to open file: %s because %s\n", file_name, strerror(ec));
-					goto failExit;
-				}
-				lat_block_t* temp_block = ((thread_args_t*)thread_args)->block[op];
-				if (is_memory_allocated[op]) {
-					size = stats->latency_samples[op] / LAT_BLOCK_SIZE;
-					for (i = 0; i < size && temp_block != NULL; i++) {
-						fwrite(&temp_block->data, sizeof(uint64_t) * LAT_BLOCK_SIZE, 1, fp);
-						temp_block = temp_block->next_block;
-					}
-					size = stats->latency_samples[op] % LAT_BLOCK_SIZE;
-					if (size != 0)
-						fwrite(&temp_block->data, sizeof(uint64_t) * size, 1, fp);
-				} else {
-					while (temp_block) {
-						fwrite(&temp_block->data, sizeof(uint64_t) * LAT_BLOCK_SIZE, 1, fp);
-						temp_block = temp_block->next_block;
-					}
-				}
-				fclose(fp);
-			}
-		}
-	}
-
-	/* fall through */
-failExit:
-	__sync_fetch_and_add(stopcount, 1);
-	for (op = 0; op < MAX_OP; op++) {
-		lat_block_t* curr = ((thread_args_t*)thread_args)->block[op];
-		lat_block_t* prev = NULL;
-		size = elem_size[op] / LAT_BLOCK_SIZE;
-		while (size--) {
-			prev = curr;
-			curr = curr->next_block;
-			free(prev);
-		}
-	}
-	fdb_transaction_destroy(transaction);
-	pthread_exit(0);
-}
-
-/* mako worker process */
-int worker_process_main(mako_args_t* args, int worker_id, mako_shmhdr_t* shm, pid_t* pid_main) {
-	int i;
-	pthread_t network_thread; /* handle for thread which invoked fdb_run_network() */
-	pthread_t* worker_threads = NULL;
-#if FDB_API_VERSION < 610
-	FDBCluster* cluster;
-#endif
-	process_info_t process;
-	thread_args_t* thread_args = NULL;
-	int rc;
-	fdb_error_t err;
-
-	process.worker_id = worker_id;
-	process.parent_id = *pid_main;
-	process.args = args;
-	process.shm = (mako_shmhdr_t*)shm;
-
-	fprintf(debugme, "DEBUG: worker %d started\n", worker_id);
-
-	/* Everything starts from here */
-
-	err = fdb_select_api_version(args->api_version);
-	if (err) {
-		fprintf(stderr, "ERROR: Failed at %s:%d (%s)\n", __FILE__, __LINE__, fdb_get_error(err));
-		return -1;
-	}
-
-	/* enable flatbuffers if specified */
-	if (args->flatbuffers) {
-#ifdef FDB_NET_OPTION_USE_FLATBUFFERS
-		fprintf(debugme, "DEBUG: Using flatbuffers\n");
-		err = fdb_network_set_option(FDB_NET_OPTION_USE_FLATBUFFERS, (uint8_t*)&args->flatbuffers, sizeof(uint8_t));
-		if (err) {
-			fprintf(stderr, "ERROR: fdb_network_set_option(FDB_NET_OPTION_USE_FLATBUFFERS): %s\n", fdb_get_error(err));
-		}
-#else
-		fprintf(printme, "INFO: flatbuffers is not supported in FDB API version %d\n", FDB_API_VERSION);
-#endif
-	}
-
-	/* Set client Log group */
-	if (strlen(args->log_group) != 0) {
-		err =
-		    fdb_network_set_option(FDB_NET_OPTION_TRACE_LOG_GROUP, (uint8_t*)args->log_group, strlen(args->log_group));
-		if (err) {
-			fprintf(stderr, "ERROR: fdb_network_set_option(FDB_NET_OPTION_TRACE_LOG_GROUP): %s\n", fdb_get_error(err));
-		}
-	}
-
-	/* enable tracing if specified */
-	if (args->trace) {
-		fprintf(debugme,
-		        "DEBUG: Enable Tracing in %s (%s)\n",
-		        (args->traceformat == 0) ? "XML" : "JSON",
-		        (args->tracepath[0] == '\0') ? "current directory" : args->tracepath);
-		err = fdb_network_set_option(FDB_NET_OPTION_TRACE_ENABLE, (uint8_t*)args->tracepath, strlen(args->tracepath));
-		if (err) {
-			fprintf(stderr, "ERROR: fdb_network_set_option(FDB_NET_OPTION_TRACE_ENABLE): %s\n", fdb_get_error(err));
-		}
-		if (args->traceformat == 1) {
-			err = fdb_network_set_option(FDB_NET_OPTION_TRACE_FORMAT, (uint8_t*)"json", 4);
-			if (err) {
-				fprintf(stderr, "ERROR: fdb_network_set_option(FDB_NET_OPTION_TRACE_FORMAT): %s\n", fdb_get_error(err));
-			}
-		}
-	}
-
-	/* enable knobs if specified */
-	if (args->knobs[0] != '\0') {
-		char delim[] = ", ";
-		char* knob = strtok(args->knobs, delim);
-		while (knob != NULL) {
-			fprintf(debugme, "DEBUG: Setting client knobs: %s\n", knob);
-			err = fdb_network_set_option(FDB_NET_OPTION_KNOB, (uint8_t*)knob, strlen(knob));
-			if (err) {
-				fprintf(stderr, "ERROR: fdb_network_set_option: %s\n", fdb_get_error(err));
-			}
-			knob = strtok(NULL, delim);
-		}
-	}
-
-	if (args->client_threads_per_version > 0) {
-		err = fdb_network_set_option(
-		    FDB_NET_OPTION_CLIENT_THREADS_PER_VERSION, (uint8_t*)&args->client_threads_per_version, sizeof(int64_t));
-		if (err) {
-			fprintf(stderr,
-			        "ERROR: fdb_network_set_option (FDB_NET_OPTION_CLIENT_THREADS_PER_VERSION) (%d): %s\n",
-			        args->client_threads_per_version,
-			        fdb_get_error(err));
-			// let's exit here since we do not want to confuse users
-			// that mako is running with multi-threaded client enabled
-			return -1;
-		}
-	}
-
-	/* Network thread must be setup before doing anything */
-	fprintf(debugme, "DEBUG: fdb_setup_network\n");
-	err = fdb_setup_network();
-	if (err) {
-		fprintf(stderr, "ERROR: Failed at %s:%d (%s)\n", __FILE__, __LINE__, fdb_get_error(err));
-		return -1;
-	}
-
-	/* Each worker process will have its own network thread */
-	fprintf(debugme, "DEBUG: creating network thread\n");
-	rc = pthread_create(&network_thread, NULL, fdb_network_thread, (void*)args);
-	if (rc != 0) {
-		fprintf(stderr, "ERROR: Cannot create a network thread\n");
-		return -1;
-	}
-
-	/*** let's party! ***/
-
-	/* set up cluster and datbase for worker threads */
-
-#if FDB_API_VERSION < 610
-	/* cluster */
-	f = fdb_create_cluster(args->cluster_file);
-	fdb_block_wait(f);
-	err = fdb_future_get_cluster(f, &cluster);
-	check_fdb_error(err);
-	fdb_future_destroy(f);
-
-	/* database */
-	/* big mystery -- do we ever have a database named other than "DB"? */
-	f = fdb_cluster_create_database(cluster, (uint8_t*)"DB", 2);
-	fdb_block_wait(f);
-	err = fdb_future_get_database(f, &process.database);
-	check_fdb_error(err);
-	fdb_future_destroy(f);
-
-#else /* >= 610 */
-	for (size_t i = 0; i < args->num_databases; i++) {
-		size_t cluster_index = args->num_fdb_clusters <= 1 ? 0 : i % args->num_fdb_clusters;
-		fdb_create_database(args->cluster_files[cluster_index], &process.databases[i]);
-		fprintf(debugme, "DEBUG: creating database at cluster %s\n", args->cluster_files[cluster_index]);
-		if (args->disable_ryw) {
-			fdb_database_set_option(process.databases[i], FDB_DB_OPTION_SNAPSHOT_RYW_DISABLE, (uint8_t*)NULL, 0);
-		}
-	}
-#endif
-
-	fprintf(debugme, "DEBUG: creating %d worker threads\n", args->num_threads);
-	worker_threads = (pthread_t*)calloc(sizeof(pthread_t), args->num_threads);
-	if (!worker_threads) {
-		fprintf(stderr, "ERROR: cannot allocate worker_threads\n");
-		goto failExit;
-	}
-
-	/* spawn worker threads */
-	thread_args = (thread_args_t*)calloc(sizeof(thread_args_t), args->num_threads);
-	if (!thread_args) {
-		fprintf(stderr, "ERROR: cannot allocate thread_args\n");
-		goto failExit;
-	}
-
-	for (i = 0; i < args->num_threads; i++) {
-		thread_args[i].thread_id = i;
-		thread_args[i].database_index = i % args->num_databases;
-
-		for (int op = 0; op < MAX_OP; op++) {
-			if (args->txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-				thread_args[i].block[op] = (lat_block_t*)malloc(sizeof(lat_block_t));
-				if (thread_args[i].block[op] == NULL) {
-					thread_args[i].is_memory_allocated[op] = false;
-					thread_args[i].elem_size[op] = 0;
-				} else {
-					thread_args[i].is_memory_allocated[op] = true;
-					thread_args[i].block[op]->next_block = NULL;
-					thread_args[i].elem_size[op] = LAT_BLOCK_SIZE;
-				}
-			}
-		}
-		thread_args[i].process = &process;
-		rc = pthread_create(&worker_threads[i], NULL, worker_thread, (void*)&thread_args[i]);
-		if (rc != 0) {
-			fprintf(stderr, "ERROR: cannot create a new worker thread %d\n", i);
-			/* ignore this thread? */
-		}
-	}
-
-	/*** party is over ***/
-
-	/* wait for everyone to finish */
-	for (i = 0; i < args->num_threads; i++) {
-		fprintf(debugme, "DEBUG: worker_thread %d joining\n", i);
-		rc = pthread_join(worker_threads[i], NULL);
-		if (rc != 0) {
-			fprintf(stderr, "ERROR: threads %d failed to join\n", i);
-		}
-	}
-
-failExit:
-	if (worker_threads)
-		free(worker_threads);
-	if (thread_args)
-		free(thread_args);
-
-	/* clean up database and cluster */
-	for (size_t i = 0; i < args->num_databases; i++) {
-		fdb_database_destroy(process.databases[i]);
-	}
-
-#if FDB_API_VERSION < 610
-	fdb_cluster_destroy(cluster);
-#endif
-
-	/* stop the network thread */
-	fprintf(debugme, "DEBUG: fdb_stop_network\n");
-	err = fdb_stop_network();
-	check_fdb_error(err);
-
-	/* wait for the network thread to join */
-	fprintf(debugme, "DEBUG: network_thread joining\n");
-	rc = pthread_join(network_thread, NULL);
-	if (rc != 0) {
-		fprintf(stderr, "ERROR: network thread failed to join\n");
-	}
-
-	return 0;
-}
-
-/* initialize the parameters with default values */
-int init_args(mako_args_t* args) {
-	int i;
-	if (!args)
-		return -1;
-	memset(args, 0, sizeof(mako_args_t)); /* zero-out everything */
-	args->num_fdb_clusters = 0;
-	args->num_databases = 1;
-	args->api_version = fdb_get_max_api_version();
-	args->json = 0;
-	args->num_processes = 1;
-	args->num_threads = 1;
-	args->mode = MODE_INVALID;
-	args->rows = 100000;
-	args->seconds = 30;
-	args->iteration = 0;
-	args->tpsmax = 0;
-	args->tpsmin = -1;
-	args->tpsinterval = 10;
-	args->tpschange = TPS_SIN;
-	args->sampling = 1000;
-	args->key_length = 32;
-	args->value_length = 16;
-	args->zipf = 0;
-	args->commit_get = 0;
-	args->verbose = 1;
-	args->flatbuffers = 0; /* internal */
-	args->knobs[0] = '\0';
-	args->log_group[0] = '\0';
-	args->prefixpadding = 0;
-	args->trace = 0;
-	args->tracepath[0] = '\0';
-	args->traceformat = 0; /* default to client's default (XML) */
-	args->streaming_mode = FDB_STREAMING_MODE_WANT_ALL;
-	args->txntrace = 0;
-	args->txntagging = 0;
-	memset(args->txntagging_prefix, 0, TAGPREFIXLENGTH_MAX);
-	for (i = 0; i < MAX_OP; i++) {
-		args->txnspec.ops[i][OP_COUNT] = 0;
-	}
-	args->client_threads_per_version = 0;
-	args->disable_ryw = 0;
-	args->json_output_path[0] = '\0';
-	args->bg_materialize_files = false;
-	args->bg_file_path[0] = '\0';
-	return 0;
-}
-
-/* parse transaction specification */
-int parse_transaction(mako_args_t* args, char* optarg) {
-	char* ptr = optarg;
-	int op = 0;
-	int rangeop = 0;
-	int num;
-	int error = 0;
-
-	for (op = 0; op < MAX_OP; op++) {
-		args->txnspec.ops[op][OP_COUNT] = 0;
-		args->txnspec.ops[op][OP_RANGE] = 0;
-	}
-
-	op = 0;
-	while (*ptr) {
-// Clang gives false positive array bounds warning, which must be ignored:
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Warray-bounds"
-		if (strncmp(ptr, "grv", 3) == 0) {
-			op = OP_GETREADVERSION;
-			ptr += 3;
-		} else if (strncmp(ptr, "gr", 2) == 0) {
-			op = OP_GETRANGE;
-			rangeop = 1;
-			ptr += 2;
-		} else if (strncmp(ptr, "g", 1) == 0) {
-			op = OP_GET;
-			ptr++;
-		} else if (strncmp(ptr, "sgr", 3) == 0) {
-			op = OP_SGETRANGE;
-			rangeop = 1;
-			ptr += 3;
-		} else if (strncmp(ptr, "sg", 2) == 0) {
-			op = OP_SGET;
-			ptr += 2;
-		} else if (strncmp(ptr, "u", 1) == 0) {
-			op = OP_UPDATE;
-			ptr++;
-		} else if (strncmp(ptr, "ir", 2) == 0) {
-			op = OP_INSERTRANGE;
-			rangeop = 1;
-			ptr += 2;
-		} else if (strncmp(ptr, "i", 1) == 0) {
-			op = OP_INSERT;
-			ptr++;
-		} else if (strncmp(ptr, "o", 1) == 0) {
-			op = OP_OVERWRITE;
-			ptr++;
-		} else if (strncmp(ptr, "cr", 2) == 0) {
-			op = OP_CLEARRANGE;
-			rangeop = 1;
-			ptr += 2;
-		} else if (strncmp(ptr, "c", 1) == 0) {
-			op = OP_CLEAR;
-			ptr++;
-		} else if (strncmp(ptr, "scr", 3) == 0) {
-			op = OP_SETCLEARRANGE;
-			rangeop = 1;
-			ptr += 3;
-		} else if (strncmp(ptr, "sc", 2) == 0) {
-			op = OP_SETCLEAR;
-			ptr += 2;
-		} else if (strncmp(ptr, "bg", 2) == 0) {
-			op = OP_READ_BG;
-			rangeop = 1;
-			ptr += 2;
-		} else {
-			fprintf(debugme, "Error: Invalid transaction spec: %s\n", ptr);
-			error = 1;
-			break;
-		}
-#pragma clang diagnostic pop
-
-		/* count */
-		num = 0;
-		if ((*ptr < '0') || (*ptr > '9')) {
-			num = 1; /* if omitted, set it to 1 */
-		} else {
-			while ((*ptr >= '0') && (*ptr <= '9')) {
-				num = num * 10 + *ptr - '0';
-				ptr++;
-			}
-		}
-		/* set count */
-		args->txnspec.ops[op][OP_COUNT] = num;
-
-		if (rangeop) {
-			if (*ptr != ':') {
-				error = 1;
-				break;
-			} else {
-				ptr++; /* skip ':' */
-				/* check negative '-' sign */
-				if (*ptr == '-') {
-					args->txnspec.ops[op][OP_REVERSE] = 1;
-					ptr++;
-				} else {
-					args->txnspec.ops[op][OP_REVERSE] = 0;
-				}
-				num = 0;
-				if ((*ptr < '0') || (*ptr > '9')) {
-					error = 1;
-					break;
-				}
-				while ((*ptr >= '0') && (*ptr <= '9')) {
-					num = num * 10 + *ptr - '0';
-					ptr++;
-				}
-				/* set range */
-				args->txnspec.ops[op][OP_RANGE] = num;
-			}
-		}
-		rangeop = 0;
-	}
-
-	if (error) {
-		fprintf(stderr, "ERROR: invalid transaction specification %s\n", optarg);
-		return -1;
-	}
-
-	if (args->verbose == VERBOSE_DEBUG) {
-		for (op = 0; op < MAX_OP; op++) {
-			fprintf(debugme, "DEBUG: OP: %d: %d: %d\n", op, args->txnspec.ops[op][0], args->txnspec.ops[op][1]);
-		}
-	}
-
-	return 0;
-}
-
-void usage() {
-	printf("Usage:\n");
-	printf("%-24s %s\n", "-h, --help", "Print this message");
-	printf("%-24s %s\n", "    --version", "Print FDB version");
-	printf("%-24s %s\n", "-v, --verbose", "Specify verbosity");
-	printf("%-24s %s\n", "-a, --api_version=API_VERSION", "Specify API_VERSION to use");
-	printf("%-24s %s\n", "-c, --cluster=FILE", "Specify FDB cluster file");
-	printf("%-24s %s\n", "-d, --num_databases=NUM_DATABASES", "Specify number of databases");
-	printf("%-24s %s\n", "-p, --procs=PROCS", "Specify number of worker processes");
-	printf("%-24s %s\n", "-t, --threads=THREADS", "Specify number of worker threads");
-	printf("%-24s %s\n", "-r, --rows=ROWS", "Specify number of records");
-	printf("%-24s %s\n", "-s, --seconds=SECONDS", "Specify the test duration in seconds\n");
-	printf("%-24s %s\n", "", "This option cannot be specified with --iteration.");
-	printf("%-24s %s\n", "-i, --iteration=ITERS", "Specify the number of iterations.\n");
-	printf("%-24s %s\n", "", "This option cannot be specified with --seconds.");
-	printf("%-24s %s\n", "    --keylen=LENGTH", "Specify the key lengths");
-	printf("%-24s %s\n", "    --vallen=LENGTH", "Specify the value lengths");
-	printf("%-24s %s\n", "-x, --transaction=SPEC", "Transaction specification");
-	printf("%-24s %s\n", "    --tps|--tpsmax=TPS", "Specify the target max TPS");
-	printf("%-24s %s\n", "    --tpsmin=TPS", "Specify the target min TPS");
-	printf("%-24s %s\n", "    --tpsinterval=SEC", "Specify the TPS change interval (Default: 10 seconds)");
-	printf("%-24s %s\n", "    --tpschange=<sin|square|pulse>", "Specify the TPS change type (Default: sin)");
-	printf("%-24s %s\n", "    --sampling=RATE", "Specify the sampling rate for latency stats");
-	printf("%-24s %s\n", "-m, --mode=MODE", "Specify the mode (build, run, clean)");
-	printf("%-24s %s\n", "-z, --zipf", "Use zipfian distribution instead of uniform distribution");
-	printf("%-24s %s\n", "    --commitget", "Commit GETs");
-	printf("%-24s %s\n", "    --loggroup=LOGGROUP", "Set client log group");
-	printf("%-24s %s\n", "    --prefix_padding", "Pad key by prefixing data (Default: postfix padding)");
-	printf("%-24s %s\n", "    --trace", "Enable tracing");
-	printf("%-24s %s\n", "    --tracepath=PATH", "Set trace file path");
-	printf("%-24s %s\n", "    --trace_format <xml|json>", "Set trace format (Default: json)");
-	printf("%-24s %s\n", "    --txntrace=sec", "Specify transaction tracing interval (Default: 0)");
-	printf(
-	    "%-24s %s\n", "    --txntagging", "Specify the number of different transaction tag (Default: 0, max = 1000)");
-	printf("%-24s %s\n",
-	       "    --txntagging_prefix",
-	       "Specify the prefix of transaction tag - mako${txntagging_prefix} (Default: '')");
-	printf("%-24s %s\n", "    --knobs=KNOBS", "Set client knobs");
-	printf("%-24s %s\n", "    --flatbuffers", "Use flatbuffers");
-	printf("%-24s %s\n", "    --streaming", "Streaming mode: all (default), iterator, small, medium, large, serial");
-	printf("%-24s %s\n", "    --disable_ryw", "Disable snapshot read-your-writes");
-	printf("%-24s %s\n", "    --json_report=PATH", "Output stats to the specified json file (Default: mako.json)");
-	printf("%-24s %s\n",
-	       "    --bg_file_path=PATH",
-	       "Read blob granule files from the local filesystem at PATH and materialize the results.");
-}
-
-/* parse benchmark paramters */
-int parse_args(int argc, char* argv[], mako_args_t* args) {
-	int rc;
-	int c;
-	int idx;
-	while (1) {
-		const char* short_options = "a:c:d:p:t:r:s:i:x:v:m:hz";
-		static struct option long_options[] = {
-			/* name, has_arg, flag, val */
-			{ "api_version", required_argument, NULL, 'a' },
-			{ "cluster", required_argument, NULL, 'c' },
-			{ "num_databases", optional_argument, NULL, 'd' },
-			{ "procs", required_argument, NULL, 'p' },
-			{ "threads", required_argument, NULL, 't' },
-			{ "rows", required_argument, NULL, 'r' },
-			{ "seconds", required_argument, NULL, 's' },
-			{ "iteration", required_argument, NULL, 'i' },
-			{ "keylen", required_argument, NULL, ARG_KEYLEN },
-			{ "vallen", required_argument, NULL, ARG_VALLEN },
-			{ "transaction", required_argument, NULL, 'x' },
-			{ "tps", required_argument, NULL, ARG_TPS },
-			{ "tpsmax", required_argument, NULL, ARG_TPSMAX },
-			{ "tpsmin", required_argument, NULL, ARG_TPSMIN },
-			{ "tpsinterval", required_argument, NULL, ARG_TPSINTERVAL },
-			{ "tpschange", required_argument, NULL, ARG_TPSCHANGE },
-			{ "sampling", required_argument, NULL, ARG_SAMPLING },
-			{ "verbose", required_argument, NULL, 'v' },
-			{ "mode", required_argument, NULL, 'm' },
-			{ "knobs", required_argument, NULL, ARG_KNOBS },
-			{ "loggroup", required_argument, NULL, ARG_LOGGROUP },
-			{ "tracepath", required_argument, NULL, ARG_TRACEPATH },
-			{ "trace_format", required_argument, NULL, ARG_TRACEFORMAT },
-			{ "streaming", required_argument, NULL, ARG_STREAMING_MODE },
-			{ "txntrace", required_argument, NULL, ARG_TXNTRACE },
-			/* no args */
-			{ "help", no_argument, NULL, 'h' },
-			{ "zipf", no_argument, NULL, 'z' },
-			{ "commitget", no_argument, NULL, ARG_COMMITGET },
-			{ "flatbuffers", no_argument, NULL, ARG_FLATBUFFERS },
-			{ "prefix_padding", no_argument, NULL, ARG_PREFIXPADDING },
-			{ "trace", no_argument, NULL, ARG_TRACE },
-			{ "txntagging", required_argument, NULL, ARG_TXNTAGGING },
-			{ "txntagging_prefix", required_argument, NULL, ARG_TXNTAGGINGPREFIX },
-			{ "version", no_argument, NULL, ARG_VERSION },
-			{ "client_threads_per_version", required_argument, NULL, ARG_CLIENT_THREADS_PER_VERSION },
-			{ "disable_ryw", no_argument, NULL, ARG_DISABLE_RYW },
-			{ "json_report", optional_argument, NULL, ARG_JSON_REPORT },
-			{ "bg_file_path", required_argument, NULL, ARG_BG_FILE_PATH },
-			{ NULL, 0, NULL, 0 }
-		};
-		idx = 0;
-		c = getopt_long(argc, argv, short_options, long_options, &idx);
-		if (c < 0) {
-			break;
-		}
-		switch (c) {
-		case '?':
-		case 'h':
-			usage();
-			return -1;
-		case 'a':
-			args->api_version = atoi(optarg);
-			break;
-		case 'c': {
-			const char delim[] = ",";
-			char* cluster_file = strtok(optarg, delim);
-			while (cluster_file != NULL) {
-				strcpy(args->cluster_files[args->num_fdb_clusters++], cluster_file);
-				cluster_file = strtok(NULL, delim);
-			}
-			break;
-		}
-		case 'd':
-			args->num_databases = atoi(optarg);
-			break;
-		case 'p':
-			args->num_processes = atoi(optarg);
-			break;
-		case 't':
-			args->num_threads = atoi(optarg);
-			break;
-		case 'r':
-			args->rows = atoi(optarg);
-			break;
-		case 's':
-			args->seconds = atoi(optarg);
-			break;
-		case 'i':
-			args->iteration = atoi(optarg);
-			break;
-		case 'x':
-			rc = parse_transaction(args, optarg);
-			if (rc < 0)
-				return -1;
-			break;
-		case 'v':
-			args->verbose = atoi(optarg);
-			break;
-		case 'z':
-			args->zipf = 1;
-			break;
-		case 'm':
-			if (strcmp(optarg, "clean") == 0) {
-				args->mode = MODE_CLEAN;
-			} else if (strcmp(optarg, "build") == 0) {
-				args->mode = MODE_BUILD;
-			} else if (strcmp(optarg, "run") == 0) {
-				args->mode = MODE_RUN;
-			}
-			break;
-		case ARG_KEYLEN:
-			args->key_length = atoi(optarg);
-			break;
-		case ARG_VALLEN:
-			args->value_length = atoi(optarg);
-			break;
-		case ARG_TPS:
-		case ARG_TPSMAX:
-			args->tpsmax = atoi(optarg);
-			break;
-		case ARG_TPSMIN:
-			args->tpsmin = atoi(optarg);
-			break;
-		case ARG_TPSINTERVAL:
-			args->tpsinterval = atoi(optarg);
-			break;
-		case ARG_TPSCHANGE:
-			if (strcmp(optarg, "sin") == 0)
-				args->tpschange = TPS_SIN;
-			else if (strcmp(optarg, "square") == 0)
-				args->tpschange = TPS_SQUARE;
-			else if (strcmp(optarg, "pulse") == 0)
-				args->tpschange = TPS_PULSE;
-			else {
-				fprintf(stderr, "--tpschange must be sin, square or pulse\n");
-				return -1;
-			}
-			break;
-		case ARG_SAMPLING:
-			args->sampling = atoi(optarg);
-			break;
-		case ARG_VERSION:
-			fprintf(stderr, "Version: %d\n", FDB_API_VERSION);
-			exit(0);
-			break;
-		case ARG_COMMITGET:
-			args->commit_get = 1;
-			break;
-		case ARG_FLATBUFFERS:
-			args->flatbuffers = 1;
-			break;
-		case ARG_KNOBS:
-			memcpy(args->knobs, optarg, strlen(optarg) + 1);
-			break;
-		case ARG_LOGGROUP:
-			memcpy(args->log_group, optarg, strlen(optarg) + 1);
-			break;
-		case ARG_PREFIXPADDING:
-			args->prefixpadding = 1;
-			break;
-		case ARG_TRACE:
-			args->trace = 1;
-			break;
-		case ARG_TRACEPATH:
-			args->trace = 1;
-			memcpy(args->tracepath, optarg, strlen(optarg) + 1);
-			break;
-		case ARG_TRACEFORMAT:
-			if (strncmp(optarg, "json", 5) == 0) {
-				args->traceformat = 1;
-			} else if (strncmp(optarg, "xml", 4) == 0) {
-				args->traceformat = 0;
-			} else {
-				fprintf(stderr, "Error: Invalid trace_format %s\n", optarg);
-				return -1;
-			}
-			break;
-		case ARG_STREAMING_MODE:
-			if (strncmp(optarg, "all", 3) == 0) {
-				args->streaming_mode = FDB_STREAMING_MODE_WANT_ALL;
-			} else if (strncmp(optarg, "iterator", 8) == 0) {
-				args->streaming_mode = FDB_STREAMING_MODE_ITERATOR;
-			} else if (strncmp(optarg, "small", 5) == 0) {
-				args->streaming_mode = FDB_STREAMING_MODE_SMALL;
-			} else if (strncmp(optarg, "medium", 6) == 0) {
-				args->streaming_mode = FDB_STREAMING_MODE_MEDIUM;
-			} else if (strncmp(optarg, "large", 5) == 0) {
-				args->streaming_mode = FDB_STREAMING_MODE_LARGE;
-			} else if (strncmp(optarg, "serial", 6) == 0) {
-				args->streaming_mode = FDB_STREAMING_MODE_SERIAL;
-			} else {
-				fprintf(stderr, "Error: Invalid streaming mode %s\n", optarg);
-				return -1;
-			}
-			break;
-		case ARG_TXNTRACE:
-			args->txntrace = atoi(optarg);
-			break;
-
-		case ARG_TXNTAGGING:
-			args->txntagging = atoi(optarg);
-			if (args->txntagging > 1000) {
-				args->txntagging = 1000;
-			}
-			break;
-		case ARG_TXNTAGGINGPREFIX:
-			if (strlen(optarg) > TAGPREFIXLENGTH_MAX) {
-				fprintf(stderr, "Error: the length of txntagging_prefix is larger than %d\n", TAGPREFIXLENGTH_MAX);
-				exit(0);
-			}
-			memcpy(args->txntagging_prefix, optarg, strlen(optarg));
-			break;
-		case ARG_CLIENT_THREADS_PER_VERSION:
-			args->client_threads_per_version = atoi(optarg);
-			break;
-		case ARG_DISABLE_RYW:
-			args->disable_ryw = 1;
-			break;
-		case ARG_JSON_REPORT:
-			if (optarg == NULL && (argv[optind] == NULL || (argv[optind] != NULL && argv[optind][0] == '-'))) {
-				// if --report_json is the last option and no file is specified
-				// or --report_json is followed by another option
-				char default_file[] = "mako.json";
-				strncpy(args->json_output_path, default_file, strlen(default_file));
-			} else {
-				strncpy(args->json_output_path, optarg, strlen(optarg) + 1);
-			}
-			break;
-		case ARG_BG_FILE_PATH:
-			args->bg_materialize_files = true;
-			strncpy(args->bg_file_path, optarg, strlen(optarg) + 1);
-		}
-	}
-
-	if ((args->tpsmin == -1) || (args->tpsmin > args->tpsmax)) {
-		args->tpsmin = args->tpsmax;
-	}
-
-	if (args->verbose >= VERBOSE_DEFAULT) {
-		printme = stdout;
-	} else {
-		printme = fopen("/dev/null", "w");
-	}
-	if (args->verbose >= VERBOSE_ANNOYING) {
-		annoyme = stdout;
-	} else {
-		annoyme = fopen("/dev/null", "w");
-	}
-	if (args->verbose >= VERBOSE_DEBUG) {
-		debugme = stdout;
-	} else {
-		debugme = fopen("/dev/null", "w");
-	}
-
-	return 0;
-}
-
-char* get_ops_name(int ops_code) {
-	switch (ops_code) {
-	case OP_GETREADVERSION:
-		return "GRV";
-	case OP_GET:
-		return "GET";
-	case OP_GETRANGE:
-		return "GETRANGE";
-	case OP_SGET:
-		return "SGET";
-	case OP_SGETRANGE:
-		return "SGETRANGE";
-	case OP_UPDATE:
-		return "UPDATE";
-	case OP_INSERT:
-		return "INSERT";
-	case OP_INSERTRANGE:
-		return "INSERTRANGE";
-	case OP_OVERWRITE:
-		return "OVERWRITE";
-	case OP_CLEAR:
-		return "CLEAR";
-	case OP_SETCLEAR:
-		return "SETCLEAR";
-	case OP_CLEARRANGE:
-		return "CLEARRANGE";
-	case OP_SETCLEARRANGE:
-		return "SETCLEARRANGE";
-	case OP_COMMIT:
-		return "COMMIT";
-	case OP_TRANSACTION:
-		return "TRANSACTION";
-	case OP_READ_BG:
-		return "READBLOBGRANULE";
-	default:
-		return "";
-	}
-}
-
-int validate_args(mako_args_t* args) {
-	if (args->mode == MODE_INVALID) {
-		fprintf(stderr, "ERROR: --mode has to be set\n");
-		return -1;
-	}
-	if (args->rows <= 0) {
-		fprintf(stderr, "ERROR: --rows must be a positive integer\n");
-		return -1;
-	}
-	if (args->key_length < 0) {
-		fprintf(stderr, "ERROR: --keylen must be a positive integer\n");
-		return -1;
-	}
-	if (args->value_length < 0) {
-		fprintf(stderr, "ERROR: --vallen must be a positive integer\n");
-		return -1;
-	}
-	if (args->num_fdb_clusters > NUM_CLUSTERS_MAX) {
-		fprintf(stderr, "ERROR: Mako is not supported to do work to more than %d clusters\n", NUM_CLUSTERS_MAX);
-		return -1;
-	}
-	if (args->num_databases > NUM_DATABASES_MAX) {
-		fprintf(stderr, "ERROR: Mako is not supported to do work to more than %d databases\n", NUM_DATABASES_MAX);
-		return -1;
-	}
-	if (args->num_databases < args->num_fdb_clusters) {
-		fprintf(stderr,
-		        "ERROR: --num_databases (%d) must be >= number of clusters(%d)\n",
-		        args->num_databases,
-		        args->num_fdb_clusters);
-		return -1;
-	}
-	if (args->num_threads < args->num_databases) {
-		fprintf(stderr,
-		        "ERROR: --threads (%d) must be >= number of databases (%d)\n",
-		        args->num_threads,
-		        args->num_databases);
-		return -1;
-	}
-	if (args->key_length < 4 /* "mako" */ + digits(args->rows)) {
-		fprintf(stderr,
-		        "ERROR: --keylen must be larger than %d to store \"mako\" prefix "
-		        "and maximum row number\n",
-		        4 + digits(args->rows));
-		return -1;
-	}
-	if (args->mode == MODE_RUN) {
-		if ((args->seconds > 0) && (args->iteration > 0)) {
-			fprintf(stderr, "ERROR: Cannot specify seconds and iteration together\n");
-			return -1;
-		}
-		if ((args->seconds == 0) && (args->iteration == 0)) {
-			fprintf(stderr, "ERROR: Must specify either seconds or iteration\n");
-			return -1;
-		}
-		if (args->txntagging < 0) {
-			fprintf(stderr, "ERROR: --txntagging must be a non-negative integer\n");
-			return -1;
-		}
-	}
-	return 0;
-}
-
-/* stats output formatting */
-#define STR2(x) #x
-#define STR(x) STR2(x)
-#define STATS_TITLE_WIDTH 12
-#define STATS_FIELD_WIDTH 12
-
-void print_stats(mako_args_t* args, mako_stats_t* stats, struct timespec* now, struct timespec* prev, FILE* fp) {
-	int i, j;
-	int op;
-	int print_err;
-	static uint64_t ops_total_prev[MAX_OP] = { 0 };
-	uint64_t ops_total[MAX_OP] = { 0 };
-	static uint64_t errors_total_prev[MAX_OP] = { 0 };
-	uint64_t errors_total[MAX_OP] = { 0 };
-	uint64_t errors_diff[MAX_OP] = { 0 };
-	static uint64_t totalxacts_prev = 0;
-	uint64_t totalxacts = 0;
-	static uint64_t conflicts_prev = 0;
-	uint64_t conflicts = 0;
-	double duration_nsec = (now->tv_sec - prev->tv_sec) * 1000000000.0 + (now->tv_nsec - prev->tv_nsec);
-
-	for (i = 0; i < args->num_processes; i++) {
-		for (j = 0; j < args->num_threads; j++) {
-			totalxacts += stats[(i * args->num_threads) + j].xacts;
-			conflicts += stats[(i * args->num_threads) + j].conflicts;
-			for (op = 0; op < MAX_OP; op++) {
-				ops_total[op] += stats[(i * args->num_threads) + j].ops[op];
-				errors_total[op] += stats[(i * args->num_threads) + j].errors[op];
-			}
-		}
-	}
-
-	if (fp) {
-		fwrite("{", 1, 1, fp);
-	}
-	printf("%" STR(STATS_TITLE_WIDTH) "s ", "OPS");
-	for (op = 0; op < MAX_OP; op++) {
-		if (args->txnspec.ops[op][OP_COUNT] > 0) {
-			uint64_t ops_total_diff = ops_total[op] - ops_total_prev[op];
-			printf("%" STR(STATS_FIELD_WIDTH) PRIu64 " ", ops_total_diff);
-			if (fp) {
-				fprintf(fp, "\"%s\": %" PRIu64 ",", get_ops_name(op), ops_total_diff);
-			}
-			errors_diff[op] = errors_total[op] - errors_total_prev[op];
-			print_err = (errors_diff[op] > 0);
-			ops_total_prev[op] = ops_total[op];
-			errors_total_prev[op] = errors_total[op];
-		}
-	}
-	/* TPS */
-	double tps = (totalxacts - totalxacts_prev) * 1000000000.0 / duration_nsec;
-	printf("%" STR(STATS_FIELD_WIDTH) ".2f ", tps);
-	if (fp) {
-		fprintf(fp, "\"tps\": %.2f,", tps);
-	}
-	totalxacts_prev = totalxacts;
-
-	/* Conflicts */
-	double conflicts_diff = (conflicts - conflicts_prev) * 1000000000.0 / duration_nsec;
-	printf("%" STR(STATS_FIELD_WIDTH) ".2f\n", conflicts_diff);
-	if (fp) {
-		fprintf(fp, "\"conflictsPerSec\": %.2f", conflicts_diff);
-	}
-	conflicts_prev = conflicts;
-
-	if (print_err) {
-		printf("%" STR(STATS_TITLE_WIDTH) "s ", "Errors");
-		for (op = 0; op < MAX_OP; op++) {
-			if (args->txnspec.ops[op][OP_COUNT] > 0) {
-				printf("%" STR(STATS_FIELD_WIDTH) PRIu64 " ", errors_diff[op]);
-				if (fp) {
-					fprintf(fp, ",\"errors\": %.2f", conflicts_diff);
-				}
-			}
-		}
-		printf("\n");
-	}
-	if (fp) {
-		fprintf(fp, "}");
-	}
-
-	return;
-}
-
-void print_stats_header(mako_args_t* args, bool show_commit, bool is_first_header_empty, bool show_op_stats) {
-	int op;
-	int i;
-
-	/* header */
-	if (is_first_header_empty)
-		for (i = 0; i <= STATS_TITLE_WIDTH; i++)
-			printf(" ");
-	for (op = 0; op < MAX_OP; op++) {
-		if (args->txnspec.ops[op][OP_COUNT] > 0) {
-			printf("%" STR(STATS_FIELD_WIDTH) "s ", get_ops_name(op));
-		}
-	}
-
-	if (show_commit)
-		printf("%" STR(STATS_FIELD_WIDTH) "s ", "COMMIT");
-	if (show_op_stats) {
-		printf("%" STR(STATS_FIELD_WIDTH) "s\n", "TRANSACTION");
-	} else {
-		printf("%" STR(STATS_FIELD_WIDTH) "s ", "TPS");
-		printf("%" STR(STATS_FIELD_WIDTH) "s\n", "Conflicts/s");
-	}
-
-	for (i = 0; i < STATS_TITLE_WIDTH; i++)
-		printf("=");
-	printf(" ");
-	for (op = 0; op < MAX_OP; op++) {
-		if (args->txnspec.ops[op][OP_COUNT] > 0) {
-			for (i = 0; i < STATS_FIELD_WIDTH; i++)
-				printf("=");
-			printf(" ");
-		}
-	}
-
-	/* COMMIT */
-	if (show_commit) {
-		for (i = 0; i < STATS_FIELD_WIDTH; i++)
-			printf("=");
-		printf(" ");
-	}
-
-	if (show_op_stats) {
-		/* TRANSACTION */
-		for (i = 0; i < STATS_FIELD_WIDTH; i++)
-			printf("=");
-		printf(" ");
-	} else {
-		/* TPS */
-		for (i = 0; i < STATS_FIELD_WIDTH; i++)
-			printf("=");
-		printf(" ");
-
-		/* Conflicts */
-		for (i = 0; i < STATS_FIELD_WIDTH; i++)
-			printf("=");
-	}
-	printf("\n");
-}
-
-void print_report(mako_args_t* args,
-                  mako_stats_t* stats,
-                  struct timespec* timer_now,
-                  struct timespec* timer_start,
-                  pid_t* pid_main,
-                  FILE* fp) {
-	int i, j, k, op, index;
-	int first_op = 1;
-	uint64_t totalxacts = 0;
-	uint64_t conflicts = 0;
-	uint64_t totalerrors = 0;
-	uint64_t ops_total[MAX_OP] = { 0 };
-	uint64_t errors_total[MAX_OP] = { 0 };
-	uint64_t lat_min[MAX_OP] = { 0 };
-	uint64_t lat_total[MAX_OP] = { 0 };
-	uint64_t lat_samples[MAX_OP] = { 0 };
-	uint64_t lat_max[MAX_OP] = { 0 };
-
-	uint64_t duration_nsec =
-	    (timer_now->tv_sec - timer_start->tv_sec) * 1000000000 + (timer_now->tv_nsec - timer_start->tv_nsec);
-
-	for (op = 0; op < MAX_OP; op++) {
-		lat_min[op] = 0xFFFFFFFFFFFFFFFF; /* uint64_t */
-		lat_max[op] = 0;
-		lat_total[op] = 0;
-		lat_samples[op] = 0;
-	}
-
-	for (i = 0; i < args->num_processes; i++) {
-		for (j = 0; j < args->num_threads; j++) {
-			int idx = i * args->num_threads + j;
-			totalxacts += stats[idx].xacts;
-			conflicts += stats[idx].conflicts;
-			for (op = 0; op < MAX_OP; op++) {
-				if ((args->txnspec.ops[op][OP_COUNT] > 0) || (op == OP_TRANSACTION) || (op == OP_COMMIT)) {
-					totalerrors += stats[idx].errors[op];
-					ops_total[op] += stats[idx].ops[op];
-					errors_total[op] += stats[idx].errors[op];
-					lat_total[op] += stats[idx].latency_us_total[op];
-					lat_samples[op] += stats[idx].latency_samples[op];
-					if (stats[idx].latency_us_min[op] < lat_min[op]) {
-						lat_min[op] = stats[idx].latency_us_min[op];
-					}
-					if (stats[idx].latency_us_max[op] > lat_max[op]) {
-						lat_max[op] = stats[idx].latency_us_max[op];
-					}
-				} /* if count > 0 */
-			}
-		}
-	}
-
-	/* overall stats */
-	double total_duration = duration_nsec * 1.0 / 1000000000;
-	printf("\n====== Total Duration %6.3f sec ======\n\n", total_duration);
-	printf("Total Processes:  %8d\n", args->num_processes);
-	printf("Total Threads:    %8d\n", args->num_threads);
-	if (args->tpsmax == args->tpsmin)
-		printf("Target TPS:       %8d\n", args->tpsmax);
-	else {
-		printf("Target TPS (MAX): %8d\n", args->tpsmax);
-		printf("Target TPS (MIN): %8d\n", args->tpsmin);
-		printf("TPS Interval:     %8d\n", args->tpsinterval);
-		printf("TPS Change:       ");
-		switch (args->tpschange) {
-		case TPS_SIN:
-			printf("%8s\n", "SIN");
-			break;
-		case TPS_SQUARE:
-			printf("%8s\n", "SQUARE");
-			break;
-		case TPS_PULSE:
-			printf("%8s\n", "PULSE");
-			break;
-		}
-	}
-	printf("Total Xacts:      %8" PRIu64 "\n", totalxacts);
-	printf("Total Conflicts:  %8" PRIu64 "\n", conflicts);
-	printf("Total Errors:     %8" PRIu64 "\n", totalerrors);
-	printf("Overall TPS:      %8" PRIu64 "\n\n", totalxacts * 1000000000 / duration_nsec);
-
-	if (fp) {
-		fprintf(fp, "\"results\": {");
-		fprintf(fp, "\"totalDuration\": %6.3f,", total_duration);
-		fprintf(fp, "\"totalProcesses\": %d,", args->num_processes);
-		fprintf(fp, "\"totalThreads\": %d,", args->num_threads);
-		fprintf(fp, "\"targetTPS\": %d,", args->tpsmax);
-		fprintf(fp, "\"totalXacts\": %" PRIu64 ",", totalxacts);
-		fprintf(fp, "\"totalConflicts\": %" PRIu64 ",", conflicts);
-		fprintf(fp, "\"totalErrors\": %" PRIu64 ",", totalerrors);
-		fprintf(fp, "\"overallTPS\": %" PRIu64 ",", totalxacts * 1000000000 / duration_nsec);
-	}
-
-	/* per-op stats */
-	print_stats_header(args, true, true, false);
-
-	/* OPS */
-	printf("%-" STR(STATS_TITLE_WIDTH) "s ", "Total OPS");
-	if (fp) {
-		fprintf(fp, "\"totalOps\": {");
-	}
-	for (op = 0; op < MAX_OP; op++) {
-		if ((args->txnspec.ops[op][OP_COUNT] > 0 && op != OP_TRANSACTION) || op == OP_COMMIT) {
-			printf("%" STR(STATS_FIELD_WIDTH) PRIu64 " ", ops_total[op]);
-			if (fp) {
-				if (first_op) {
-					first_op = 0;
-				} else {
-					fprintf(fp, ",");
-				}
-				fprintf(fp, "\"%s\": %" PRIu64, get_ops_name(op), ops_total[op]);
-			}
-		}
-	}
-
-	/* TPS */
-	double tps = totalxacts * 1000000000.0 / duration_nsec;
-	printf("%" STR(STATS_FIELD_WIDTH) ".2f ", tps);
-
-	/* Conflicts */
-	double conflicts_rate = conflicts * 1000000000.0 / duration_nsec;
-	printf("%" STR(STATS_FIELD_WIDTH) ".2f\n", conflicts_rate);
-
-	if (fp) {
-		fprintf(fp, "}, \"tps\": %.2f, \"conflictsPerSec\": %.2f, \"errors\": {", tps, conflicts_rate);
-	}
-
-	/* Errors */
-	printf("%-" STR(STATS_TITLE_WIDTH) "s ", "Errors");
-	first_op = 1;
-	for (op = 0; op < MAX_OP; op++) {
-		if (args->txnspec.ops[op][OP_COUNT] > 0 && op != OP_TRANSACTION) {
-			printf("%" STR(STATS_FIELD_WIDTH) PRIu64 " ", errors_total[op]);
-			if (fp) {
-				if (first_op) {
-					first_op = 0;
-				} else {
-					fprintf(fp, ",");
-				}
-				fprintf(fp, "\"%s\": %" PRIu64, get_ops_name(op), errors_total[op]);
-			}
-		}
-	}
-	if (fp) {
-		fprintf(fp, "}, \"numSamples\": {");
-	}
-	printf("\n\n");
-
-	printf("%s", "Latency (us)");
-	print_stats_header(args, true, false, true);
-
-	/* Total Samples */
-	printf("%-" STR(STATS_TITLE_WIDTH) "s ", "Samples");
-	first_op = 1;
-	for (op = 0; op < MAX_OP; op++) {
-		if (args->txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-			if (lat_total[op]) {
-				printf("%" STR(STATS_FIELD_WIDTH) PRIu64 " ", lat_samples[op]);
-			} else {
-				printf("%" STR(STATS_FIELD_WIDTH) "s ", "N/A");
-			}
-			if (fp) {
-				if (first_op) {
-					first_op = 0;
-				} else {
-					fprintf(fp, ",");
-				}
-				fprintf(fp, "\"%s\": %" PRIu64, get_ops_name(op), lat_samples[op]);
-			}
-		}
-	}
-	printf("\n");
-
-	/* Min Latency */
-	if (fp) {
-		fprintf(fp, "}, \"minLatency\": {");
-	}
-	printf("%-" STR(STATS_TITLE_WIDTH) "s ", "Min");
-	first_op = 1;
-	for (op = 0; op < MAX_OP; op++) {
-		if (args->txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-			if (lat_min[op] == -1) {
-				printf("%" STR(STATS_FIELD_WIDTH) "s ", "N/A");
-			} else {
-				printf("%" STR(STATS_FIELD_WIDTH) PRIu64 " ", lat_min[op]);
-				if (fp) {
-					if (first_op) {
-						first_op = 0;
-					} else {
-						fprintf(fp, ",");
-					}
-					fprintf(fp, "\"%s\": %" PRIu64, get_ops_name(op), lat_min[op]);
-				}
-			}
-		}
-	}
-	printf("\n");
-
-	/* Avg Latency */
-	if (fp) {
-		fprintf(fp, "}, \"avgLatency\": {");
-	}
-	printf("%-" STR(STATS_TITLE_WIDTH) "s ", "Avg");
-	first_op = 1;
-	for (op = 0; op < MAX_OP; op++) {
-		if (args->txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-			if (lat_total[op]) {
-				printf("%" STR(STATS_FIELD_WIDTH) PRIu64 " ", lat_total[op] / lat_samples[op]);
-				if (fp) {
-					if (first_op) {
-						first_op = 0;
-					} else {
-						fprintf(fp, ",");
-					}
-					fprintf(fp, "\"%s\": %" PRIu64, get_ops_name(op), lat_total[op] / lat_samples[op]);
-				}
-			} else {
-				printf("%" STR(STATS_FIELD_WIDTH) "s ", "N/A");
-			}
-		}
-	}
-	printf("\n");
-
-	/* Max Latency */
-	if (fp) {
-		fprintf(fp, "}, \"maxLatency\": {");
-	}
-	printf("%-" STR(STATS_TITLE_WIDTH) "s ", "Max");
-	first_op = 1;
-	for (op = 0; op < MAX_OP; op++) {
-		if (args->txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-			if (lat_max[op] == 0) {
-				printf("%" STR(STATS_FIELD_WIDTH) "s ", "N/A");
-			} else {
-				printf("%" STR(STATS_FIELD_WIDTH) PRIu64 " ", lat_max[op]);
-				if (fp) {
-					if (first_op) {
-						first_op = 0;
-					} else {
-						fprintf(fp, ",");
-					}
-					fprintf(fp, "\"%s\": %" PRIu64, get_ops_name(op), lat_max[op]);
-				}
-			}
-		}
-	}
-	printf("\n");
-
-	uint64_t* dataPoints[MAX_OP];
-	uint64_t median;
-	int point_99_9pct, point_99pct, point_95pct;
-
-	/* Median Latency */
-	if (fp) {
-		fprintf(fp, "}, \"medianLatency\": {");
-	}
-	printf("%-" STR(STATS_TITLE_WIDTH) "s ", "Median");
-	int num_points[MAX_OP] = { 0 };
-	first_op = 1;
-	for (op = 0; op < MAX_OP; op++) {
-		if (args->txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-			if (lat_total[op]) {
-				dataPoints[op] = (uint64_t*)malloc(sizeof(uint64_t) * lat_samples[op]);
-				if (dataPoints[op] == NULL) {
-					printf("%" STR(STATS_FIELD_WIDTH) "s ", "N/A");
-					continue;
-				}
-				k = 0;
-				for (i = 0; i < args->num_processes; i++) {
-					for (j = 0; j < args->num_threads; j++) {
-						char file_name[NAME_MAX] = { '\0' };
-						sprintf(file_name, "%s%d", TEMP_DATA_STORE, *pid_main);
-						get_stats_file_name(file_name, i, j, op);
-						FILE* f = fopen(file_name, "r");
-						fseek(f, 0, SEEK_END);
-						int numPoints = ftell(f) / sizeof(uint64_t);
-						fseek(f, 0, 0);
-						index = 0;
-						while (index < numPoints) {
-							fread(&dataPoints[op][k++], sizeof(uint64_t), 1, f);
-							++index;
-						}
-						fclose(f);
-					}
-				}
-				num_points[op] = k;
-				quick_sort(dataPoints[op], num_points[op]);
-				if (num_points[op] & 1) {
-					median = dataPoints[op][num_points[op] / 2];
-				} else {
-					median = (dataPoints[op][num_points[op] / 2] + dataPoints[op][num_points[op] / 2 - 1]) >> 1;
-				}
-				printf("%" STR(STATS_FIELD_WIDTH) PRIu64 " ", median);
-				if (fp) {
-					if (first_op) {
-						first_op = 0;
-					} else {
-						fprintf(fp, ",");
-					}
-					fprintf(fp, "\"%s\": %" PRIu64, get_ops_name(op), median);
-				}
-			} else {
-				printf("%" STR(STATS_FIELD_WIDTH) "s ", "N/A");
-			}
-		}
-	}
-	printf("\n");
-
-	/* 95%ile Latency */
-	if (fp) {
-		fprintf(fp, "}, \"p95Latency\": {");
-	}
-	printf("%-" STR(STATS_TITLE_WIDTH) "s ", "95.0 pctile");
-	first_op = 1;
-	for (op = 0; op < MAX_OP; op++) {
-		if (args->txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-			if (dataPoints[op] == NULL) {
-				printf("%" STR(STATS_FIELD_WIDTH) "s ", "N/A");
-				continue;
-			}
-			if (lat_total[op]) {
-				point_95pct = ((float)(num_points[op]) * 0.95) - 1;
-				printf("%" STR(STATS_FIELD_WIDTH) PRIu64 " ", dataPoints[op][point_95pct]);
-				if (fp) {
-					if (first_op) {
-						first_op = 0;
-					} else {
-						fprintf(fp, ",");
-					}
-					fprintf(fp, "\"%s\": %" PRIu64, get_ops_name(op), dataPoints[op][point_95pct]);
-				}
-			} else {
-				printf("%" STR(STATS_FIELD_WIDTH) "s ", "N/A");
-			}
-		}
-	}
-	printf("\n");
-
-	/* 99%ile Latency */
-	if (fp) {
-		fprintf(fp, "}, \"p99Latency\": {");
-	}
-	printf("%-" STR(STATS_TITLE_WIDTH) "s ", "99.0 pctile");
-	first_op = 1;
-	for (op = 0; op < MAX_OP; op++) {
-		if (args->txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-			if (dataPoints[op] == NULL) {
-				printf("%" STR(STATS_FIELD_WIDTH) "s ", "N/A");
-				continue;
-			}
-			if (lat_total[op]) {
-				point_99pct = ((float)(num_points[op]) * 0.99) - 1;
-				printf("%" STR(STATS_FIELD_WIDTH) PRIu64 " ", dataPoints[op][point_99pct]);
-				if (fp) {
-					if (first_op) {
-						first_op = 0;
-					} else {
-						fprintf(fp, ",");
-					}
-					fprintf(fp, "\"%s\": %" PRIu64, get_ops_name(op), dataPoints[op][point_99pct]);
-				}
-			} else {
-				printf("%" STR(STATS_FIELD_WIDTH) "s ", "N/A");
-			}
-		}
-	}
-	printf("\n");
-
-	/* 99.9%ile Latency */
-	if (fp) {
-		fprintf(fp, "}, \"p99.9Latency\": {");
-	}
-	printf("%-" STR(STATS_TITLE_WIDTH) "s ", "99.9 pctile");
-	first_op = 1;
-	for (op = 0; op < MAX_OP; op++) {
-		if (args->txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION || op == OP_COMMIT) {
-			if (dataPoints[op] == NULL) {
-				printf("%" STR(STATS_FIELD_WIDTH) "s ", "N/A");
-				continue;
-			}
-			if (lat_total[op]) {
-				point_99_9pct = ((float)(num_points[op]) * 0.999) - 1;
-				printf("%" STR(STATS_FIELD_WIDTH) PRIu64 " ", dataPoints[op][point_99_9pct]);
-				if (fp) {
-					if (first_op) {
-						first_op = 0;
-					} else {
-						fprintf(fp, ",");
-					}
-					fprintf(fp, "\"%s\": %" PRIu64, get_ops_name(op), dataPoints[op][point_99_9pct]);
-				}
-			} else {
-				printf("%" STR(STATS_FIELD_WIDTH) "s ", "N/A");
-			}
-		}
-	}
-	printf("\n");
-	if (fp) {
-		fprintf(fp, "}}");
-	}
-
-	char command_remove[NAME_MAX] = { '\0' };
-	sprintf(command_remove, "rm -rf %s%d", TEMP_DATA_STORE, *pid_main);
-	system(command_remove);
-
-	for (op = 0; op < MAX_OP; op++) {
-		if (args->txnspec.ops[op][OP_COUNT] > 0 || op == OP_TRANSACTION) {
-			if (lat_total[op])
-				free(dataPoints[op]);
-		}
-	}
-}
-
-int stats_process_main(mako_args_t* args,
-                       mako_stats_t* stats,
-                       volatile double* throttle_factor,
-                       volatile int* signal,
-                       volatile int* stopcount,
-                       pid_t* pid_main) {
-	struct timespec timer_start, timer_prev, timer_now;
-	double sin_factor;
-	int first_stats = 1;
-
-	/* wait until the signal turn on */
-	while (*signal == SIGNAL_OFF) {
-		usleep(10000); /* 10ms */
-	}
-
-	if (args->verbose >= VERBOSE_DEFAULT)
-		print_stats_header(args, false, true, false);
-
-	FILE* fp = NULL;
-	if (args->json_output_path[0] != '\0') {
-		fp = fopen(args->json_output_path, "w");
-		fprintf(fp, "{\"makoArgs\": {");
-		fprintf(fp, "\"api_version\": %d,", args->api_version);
-		fprintf(fp, "\"json\": %d,", args->json);
-		fprintf(fp, "\"num_processes\": %d,", args->num_processes);
-		fprintf(fp, "\"num_threads\": %d,", args->num_threads);
-		fprintf(fp, "\"mode\": %d,", args->mode);
-		fprintf(fp, "\"rows\": %d,", args->rows);
-		fprintf(fp, "\"seconds\": %d,", args->seconds);
-		fprintf(fp, "\"iteration\": %d,", args->iteration);
-		fprintf(fp, "\"tpsmax\": %d,", args->tpsmax);
-		fprintf(fp, "\"tpsmin\": %d,", args->tpsmin);
-		fprintf(fp, "\"tpsinterval\": %d,", args->tpsinterval);
-		fprintf(fp, "\"tpschange\": %d,", args->tpschange);
-		fprintf(fp, "\"sampling\": %d,", args->sampling);
-		fprintf(fp, "\"key_length\": %d,", args->key_length);
-		fprintf(fp, "\"value_length\": %d,", args->value_length);
-		fprintf(fp, "\"commit_get\": %d,", args->commit_get);
-		fprintf(fp, "\"verbose\": %d,", args->verbose);
-		fprintf(fp, "\"cluster_files\": \"%s\",", args->cluster_files[0]);
-		fprintf(fp, "\"log_group\": \"%s\",", args->log_group);
-		fprintf(fp, "\"prefixpadding\": %d,", args->prefixpadding);
-		fprintf(fp, "\"trace\": %d,", args->trace);
-		fprintf(fp, "\"tracepath\": \"%s\",", args->tracepath);
-		fprintf(fp, "\"traceformat\": %d,", args->traceformat);
-		fprintf(fp, "\"knobs\": \"%s\",", args->knobs);
-		fprintf(fp, "\"flatbuffers\": %d,", args->flatbuffers);
-		fprintf(fp, "\"txntrace\": %d,", args->txntrace);
-		fprintf(fp, "\"txntagging\": %d,", args->txntagging);
-		fprintf(fp, "\"txntagging_prefix\": \"%s\",", args->txntagging_prefix);
-		fprintf(fp, "\"streaming_mode\": %d,", args->streaming_mode);
-		fprintf(fp, "\"disable_ryw\": %d,", args->disable_ryw);
-		fprintf(fp, "\"json_output_path\": \"%s\"", args->json_output_path);
-		fprintf(fp, "},\"samples\": [");
-	}
-
-	clock_gettime(CLOCK_MONOTONIC_COARSE, &timer_start);
-	timer_prev.tv_sec = timer_start.tv_sec;
-	timer_prev.tv_nsec = timer_start.tv_nsec;
-	while (*signal != SIGNAL_RED) {
-		usleep(100000); /* sleep for 100ms */
-		clock_gettime(CLOCK_MONOTONIC_COARSE, &timer_now);
-
-		/* print stats every (roughly) 1 sec */
-		if (timer_now.tv_sec > timer_prev.tv_sec) {
-
-			/* adjust throttle rate if needed */
-			if (args->tpsmax != args->tpsmin) {
-				/* set the throttle factor between 0.0 and 1.0 */
-				switch (args->tpschange) {
-				case TPS_SIN:
-					sin_factor =
-					    sin((timer_now.tv_sec % args->tpsinterval) / (double)args->tpsinterval * M_PI * 2) / 2.0 + 0.5;
-					*throttle_factor = 1 - (sin_factor * (1.0 - ((double)args->tpsmin / args->tpsmax)));
-					break;
-				case TPS_SQUARE:
-					if (timer_now.tv_sec % args->tpsinterval < (args->tpsinterval / 2)) {
-						/* set to max */
-						*throttle_factor = 1.0;
-					} else {
-						/* set to min */
-						*throttle_factor = (double)args->tpsmin / (double)args->tpsmax;
-					}
-					break;
-				case TPS_PULSE:
-					if (timer_now.tv_sec % args->tpsinterval == 0) {
-						/* set to max */
-						*throttle_factor = 1.0;
-					} else {
-						/* set to min */
-						*throttle_factor = (double)args->tpsmin / (double)args->tpsmax;
-					}
-					break;
-				}
-			}
-
-			if (args->verbose >= VERBOSE_DEFAULT) {
-				if (first_stats) {
-					first_stats = 0;
-				} else {
-					if (fp)
-						fprintf(fp, ",");
-				}
-				print_stats(args, stats, &timer_now, &timer_prev, fp);
-			}
-			timer_prev.tv_sec = timer_now.tv_sec;
-			timer_prev.tv_nsec = timer_now.tv_nsec;
-		}
-	}
-
-	if (fp) {
-		fprintf(fp, "],");
-	}
-
-	/* print report */
-	if (args->verbose >= VERBOSE_DEFAULT) {
-		clock_gettime(CLOCK_MONOTONIC_COARSE, &timer_now);
-		while (*stopcount < args->num_threads * args->num_processes) {
-			usleep(10000); /* 10ms */
-		}
-		print_report(args, stats, &timer_now, &timer_start, pid_main, fp);
-	}
-
-	if (fp) {
-		fprintf(fp, "}");
-		fclose(fp);
-	}
-
-	return 0;
-}
-
-int main(int argc, char* argv[]) {
-	int rc;
-	mako_args_t args;
-	int p;
-	pid_t* worker_pids = NULL;
-	proc_type_t proc_type = proc_master;
-	int worker_id;
-	pid_t pid;
-	int status;
-	mako_shmhdr_t* shm; /* shmhdr + stats */
-	int shmfd;
-	char shmpath[NAME_MAX];
-	size_t shmsize;
-	mako_stats_t* stats;
-	pid_t pid_main;
-
-	setlinebuf(stdout);
-
-	rc = init_args(&args);
-	if (rc < 0) {
-		fprintf(stderr, "ERROR: init_args failed\n");
-		return -1;
-	}
-	rc = parse_args(argc, argv, &args);
-	if (rc < 0) {
-		/* usage printed */
-		return 0;
-	}
-
-	rc = validate_args(&args);
-	if (rc < 0)
-		return -1;
-
-	if (args.mode == MODE_CLEAN) {
-		/* cleanup will be done from a single thread */
-		args.num_processes = 1;
-		args.num_threads = 1;
-	}
-
-	if (args.mode == MODE_BUILD) {
-		if (args.txnspec.ops[OP_INSERT][OP_COUNT] == 0) {
-			parse_transaction(&args, "i100");
-		}
-	}
-
-	pid_main = getpid();
-	/* create the shared memory for stats */
-	sprintf(shmpath, "mako%d", pid_main);
-	shmfd = shm_open(shmpath, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
-	if (shmfd < 0) {
-		fprintf(stderr, "ERROR: shm_open failed\n");
-		return -1;
-	}
-
-	/* allocate */
-	shmsize = sizeof(mako_shmhdr_t) + (sizeof(mako_stats_t) * args.num_processes * args.num_threads);
-	if (ftruncate(shmfd, shmsize) < 0) {
-		shm = MAP_FAILED;
-		fprintf(stderr, "ERROR: ftruncate (fd:%d size:%llu) failed\n", shmfd, (unsigned long long)shmsize);
-		goto failExit;
-	}
-
-	/* map it */
-	shm = (mako_shmhdr_t*)mmap(NULL, shmsize, PROT_READ | PROT_WRITE, MAP_SHARED, shmfd, 0);
-	if (shm == MAP_FAILED) {
-		fprintf(stderr, "ERROR: mmap (fd:%d size:%llu) failed\n", shmfd, (unsigned long long)shmsize);
-		goto failExit;
-	}
-
-	stats = (mako_stats_t*)((void*)shm + sizeof(mako_shmhdr_t));
-
-	/* initialize the shared memory */
-	memset(shm, 0, shmsize);
-
-	/* get ready */
-	shm->signal = SIGNAL_OFF;
-	shm->readycount = 0;
-	shm->stopcount = 0;
-	shm->throttle_factor = 1.0;
-
-	/* fork worker processes + 1 stats process */
-	worker_pids = (pid_t*)calloc(sizeof(pid_t), args.num_processes + 1);
-	if (!worker_pids) {
-		fprintf(stderr, "ERROR: cannot allocate worker_pids (%d processes)\n", args.num_processes);
-		goto failExit;
-	}
-
-	/* forking (num_process + 1) children */
-	/* last process is the stats handler */
-	for (p = 0; p < args.num_processes + 1; p++) {
-		pid = fork();
-		if (pid != 0) {
-			/* master */
-			worker_pids[p] = pid;
-			if (args.verbose == VERBOSE_DEBUG) {
-				printf("DEBUG: worker %d (PID:%d) forked\n", p, worker_pids[p]);
-			}
-		} else {
-			if (p < args.num_processes) {
-				/* worker process */
-				proc_type = proc_worker;
-				worker_id = p;
-			} else {
-				/* stats */
-				proc_type = proc_stats;
-			}
-			break;
-		}
-	}
-
-	/* initialize the randomizer */
-	srand(time(0) * getpid());
-
-	/* initialize zipfian if necessary (per-process) */
-	if (args.zipf) {
-		zipfian_generator(args.rows);
-	}
-
-	if (proc_type == proc_worker) {
-		/* worker process */
-		worker_process_main(&args, worker_id, shm, &pid_main);
-		/* worker can exit here */
-		exit(0);
-	} else if (proc_type == proc_stats) {
-		/* stats */
-		if (args.mode == MODE_CLEAN) {
-			/* no stats needed for clean mode */
-			exit(0);
-		}
-		stats_process_main(&args, stats, &shm->throttle_factor, &shm->signal, &shm->stopcount, &pid_main);
-		exit(0);
-	}
-
-	/* master */
-	/* wait for everyone to be ready */
-	while (shm->readycount < (args.num_processes * args.num_threads)) {
-		usleep(1000);
-	}
-	shm->signal = SIGNAL_GREEN;
-
-	if (args.mode == MODE_RUN) {
-		struct timespec timer_start, timer_now;
-
-		/* run the benchamrk */
-
-		/* if seconds is specified, stop child processes after the specified
-		 * duration */
-		if (args.seconds > 0) {
-			if (args.verbose == VERBOSE_DEBUG) {
-				printf("DEBUG: master sleeping for %d seconds\n", args.seconds);
-			}
-
-			clock_gettime(CLOCK_MONOTONIC_COARSE, &timer_start);
-			while (1) {
-				usleep(100000); /* sleep for 100ms */
-				clock_gettime(CLOCK_MONOTONIC_COARSE, &timer_now);
-				/* doesn't have to be precise */
-				if (timer_now.tv_sec - timer_start.tv_sec > args.seconds) {
-					if (args.verbose == VERBOSE_DEBUG) {
-						printf("DEBUG: time's up (%d seconds)\n", args.seconds);
-					}
-					break;
-				}
-			}
-
-			/* notify everyone the time's up */
-			shm->signal = SIGNAL_RED;
-		}
-	}
-
-	/* wait for worker processes to exit */
-	for (p = 0; p < args.num_processes; p++) {
-		if (args.verbose == VERBOSE_DEBUG) {
-			printf("DEBUG: waiting worker %d (PID:%d) to exit\n", p, worker_pids[p]);
-		}
-		pid = waitpid(worker_pids[p], &status, 0 /* or what? */);
-		if (pid < 0) {
-			fprintf(stderr, "ERROR: waitpid failed for worker process PID %d\n", worker_pids[p]);
-		}
-		if (args.verbose == VERBOSE_DEBUG) {
-			printf("DEBUG: worker %d (PID:%d) exited\n", p, worker_pids[p]);
-		}
-	}
-
-	/* all worker threads finished, stop the stats */
-	if (args.mode == MODE_BUILD || args.iteration > 0) {
-		shm->signal = SIGNAL_RED;
-	}
-
-	/* wait for stats to stop */
-	pid = waitpid(worker_pids[args.num_processes], &status, 0 /* or what? */);
-	if (pid < 0) {
-		fprintf(stderr, "ERROR: waitpid failed for stats process PID %d\n", worker_pids[args.num_processes]);
-	}
-
-failExit:
-
-	if (worker_pids)
-		free(worker_pids);
-
-	if (shm != MAP_FAILED)
-		munmap(shm, shmsize);
-
-	if (shmfd) {
-		close(shmfd);
-		shm_unlink(shmpath);
-		unlink(shmpath);
-	}
-
-	return 0;
-}
diff --git a/bindings/c/test/mako/mako.cpp b/bindings/c/test/mako/mako.cpp
index 35096620dc..87cf81351b 100644
--- a/bindings/c/test/mako/mako.cpp
+++ b/bindings/c/test/mako/mako.cpp
@@ -233,6 +233,8 @@ int runOneTask(Transaction tx, Arguments const& args, ThreadStatistics& stats, L
 				future_rc = waitAndHandleForOnError(tx, f, opTable[op].name());
 			}
 		}
+		if (auto postStepFn = opTable[op].postStepFunction(step))
+			postStepFn(f, tx, args, key1, key2, val);
 		watch_step.stop();
 		if (future_rc != FutureRC::OK) {
 			if (future_rc == FutureRC::CONFLICT) {
diff --git a/bindings/c/test/mako/mako.h b/bindings/c/test/mako/mako.h
deleted file mode 100644
index db43f3341e..0000000000
--- a/bindings/c/test/mako/mako.h
+++ /dev/null
@@ -1,209 +0,0 @@
-#ifndef MAKO_H
-#define MAKO_H
-#pragma once
-
-#ifndef FDB_API_VERSION
-#define FDB_API_VERSION 720
-#endif
-
-#include <foundationdb/fdb_c.h>
-#include <pthread.h>
-#include <sys/types.h>
-#include <stdbool.h>
-#if defined(__linux__)
-#include <linux/limits.h>
-#elif defined(__APPLE__)
-#include <sys/syslimits.h>
-#else
-#include <limits.h>
-#endif
-
-#define VERBOSE_NONE 0
-#define VERBOSE_DEFAULT 1
-#define VERBOSE_ANNOYING 2
-#define VERBOSE_DEBUG 3
-
-#define MODE_INVALID -1
-#define MODE_CLEAN 0
-#define MODE_BUILD 1
-#define MODE_RUN 2
-
-#define FDB_SUCCESS 0
-#define FDB_ERROR_RETRY -1
-#define FDB_ERROR_ABORT -2
-#define FDB_ERROR_CONFLICT -3
-
-#define LAT_BLOCK_SIZE 511 /* size of each block to get detailed latency for each operation */
-
-/* transaction specification */
-enum Operations {
-	OP_GETREADVERSION,
-	OP_GET,
-	OP_GETRANGE,
-	OP_SGET,
-	OP_SGETRANGE,
-	OP_UPDATE,
-	OP_INSERT,
-	OP_INSERTRANGE,
-	OP_OVERWRITE,
-	OP_CLEAR,
-	OP_SETCLEAR,
-	OP_CLEARRANGE,
-	OP_SETCLEARRANGE,
-	OP_COMMIT,
-	OP_TRANSACTION, /* pseudo-operation - cumulative time for the operation + commit */
-	OP_READ_BG,
-	MAX_OP /* must be the last item */
-};
-
-#define OP_COUNT 0
-#define OP_RANGE 1
-#define OP_REVERSE 2
-
-/* for long arguments */
-enum Arguments {
-	ARG_KEYLEN,
-	ARG_VALLEN,
-	ARG_TPS,
-	ARG_COMMITGET,
-	ARG_SAMPLING,
-	ARG_VERSION,
-	ARG_KNOBS,
-	ARG_FLATBUFFERS,
-	ARG_LOGGROUP,
-	ARG_PREFIXPADDING,
-	ARG_TRACE,
-	ARG_TRACEPATH,
-	ARG_TRACEFORMAT,
-	ARG_TPSMAX,
-	ARG_TPSMIN,
-	ARG_TPSINTERVAL,
-	ARG_TPSCHANGE,
-	ARG_TXNTRACE,
-	ARG_TXNTAGGING,
-	ARG_TXNTAGGINGPREFIX,
-	ARG_STREAMING_MODE,
-	ARG_DISABLE_RYW,
-	ARG_CLIENT_THREADS_PER_VERSION,
-	ARG_JSON_REPORT,
-	ARG_BG_FILE_PATH // if blob granule files are stored locally, mako will read and materialize them if this is set
-};
-
-enum TPSChangeTypes { TPS_SIN, TPS_SQUARE, TPS_PULSE };
-
-#define KEYPREFIX "mako"
-#define KEYPREFIXLEN 4
-
-#define TEMP_DATA_STORE "/tmp/makoTemp"
-
-/* we set mako_txnspec_t and mako_args_t only once in the master process,
- * and won't be touched by child processes.
- */
-
-typedef struct {
-	/* for each operation, it stores "count", "range" and "reverse" */
-	int ops[MAX_OP][3];
-} mako_txnspec_t;
-
-#define LOGGROUP_MAX 256
-#define KNOB_MAX 256
-#define TAGPREFIXLENGTH_MAX 8
-#define NUM_CLUSTERS_MAX 3
-#define NUM_DATABASES_MAX 10
-#define MAX_BG_IDS 1000
-
-/* benchmark parameters */
-typedef struct {
-	int api_version;
-	int json;
-	int num_processes;
-	int num_threads;
-	int mode;
-	int rows; /* is 2 billion enough? */
-	int seconds;
-	int iteration;
-	int tpsmax;
-	int tpsmin;
-	int tpsinterval;
-	int tpschange;
-	int sampling;
-	int key_length;
-	int value_length;
-	int zipf;
-	int commit_get;
-	int verbose;
-	mako_txnspec_t txnspec;
-	char cluster_files[NUM_CLUSTERS_MAX][PATH_MAX];
-	int num_fdb_clusters;
-	int num_databases;
-	char log_group[LOGGROUP_MAX];
-	int prefixpadding;
-	int trace;
-	char tracepath[PATH_MAX];
-	int traceformat; /* 0 - XML, 1 - JSON */
-	char knobs[KNOB_MAX];
-	uint8_t flatbuffers;
-	int txntrace;
-	int txntagging;
-	char txntagging_prefix[TAGPREFIXLENGTH_MAX];
-	FDBStreamingMode streaming_mode;
-	int client_threads_per_version;
-	int disable_ryw;
-	char json_output_path[PATH_MAX];
-	bool bg_materialize_files;
-	char bg_file_path[PATH_MAX];
-} mako_args_t;
-
-/* shared memory */
-#define SIGNAL_RED 0
-#define SIGNAL_GREEN 1
-#define SIGNAL_OFF 2
-
-typedef struct {
-	int signal;
-	int readycount;
-	double throttle_factor;
-	int stopcount;
-} mako_shmhdr_t;
-
-/* memory block allocated to each operation when collecting detailed latency */
-typedef struct {
-	uint64_t data[LAT_BLOCK_SIZE];
-	void* next_block;
-} lat_block_t;
-
-typedef struct {
-	uint64_t xacts;
-	uint64_t conflicts;
-	uint64_t ops[MAX_OP];
-	uint64_t errors[MAX_OP];
-	uint64_t latency_samples[MAX_OP];
-	uint64_t latency_us_total[MAX_OP];
-	uint64_t latency_us_min[MAX_OP];
-	uint64_t latency_us_max[MAX_OP];
-} mako_stats_t;
-
-/* per-process information */
-typedef struct {
-	int worker_id;
-	pid_t parent_id;
-	mako_args_t* args;
-	mako_shmhdr_t* shm;
-	FDBDatabase* databases[NUM_DATABASES_MAX];
-} process_info_t;
-
-/* args for threads */
-typedef struct {
-	int thread_id;
-	int database_index; // index of the database to do work to
-	int elem_size[MAX_OP]; /* stores the multiple of LAT_BLOCK_SIZE to check the memory allocation of each operation */
-	bool is_memory_allocated[MAX_OP]; /* flag specified for each operation, whether the memory was allocated to that
-	                                     specific operation */
-	lat_block_t* block[MAX_OP];
-	process_info_t* process;
-} thread_args_t;
-
-/* process type */
-typedef enum { proc_master = 0, proc_worker, proc_stats } proc_type_t;
-
-#endif /* MAKO_H */
diff --git a/bindings/c/test/mako/operations.cpp b/bindings/c/test/mako/operations.cpp
index 8667747c4c..3725f30889 100644
--- a/bindings/c/test/mako/operations.cpp
+++ b/bindings/c/test/mako/operations.cpp
@@ -74,6 +74,11 @@ const std::array<Operation, MAX_OP> opTable{
 	    { { StepKind::READ,
 	        [](Transaction tx, Arguments const&, ByteString&, ByteString&, ByteString&) {
 	            return tx.getReadVersion().eraseType();
+	        },
+	        [](Future f, Transaction, Arguments const&, ByteString&, ByteString&, ByteString&) {
+	            if (f && !f.error()) {
+		            f.get<future_var::Int64>();
+	            }
 	        } } },
 	    false },
 	  { "GET",
@@ -82,6 +87,11 @@ const std::array<Operation, MAX_OP> opTable{
 	            const auto num = nextKey(args);
 	            genKey(key, KEY_PREFIX, args, num);
 	            return tx.get(key, false /*snapshot*/).eraseType();
+	        },
+	        [](Future f, Transaction, Arguments const&, ByteString&, ByteString&, ByteString& val) {
+	            if (f && !f.error()) {
+		            f.get<future_var::Value>();
+	            }
 	        } } },
 	    false },
 	  { "GETRANGE",
@@ -103,6 +113,11 @@ const std::array<Operation, MAX_OP> opTable{
 	                                                                        false /*snapshot*/,
 	                                                                        args.txnspec.ops[OP_GETRANGE][OP_REVERSE])
 	                .eraseType();
+	        },
+	        [](Future f, Transaction, Arguments const&, ByteString&, ByteString&, ByteString& val) {
+	            if (f && !f.error()) {
+		            f.get<future_var::KeyValueArray>();
+	            }
 	        } } },
 	    false },
 	  { "SGET",
@@ -111,6 +126,11 @@ const std::array<Operation, MAX_OP> opTable{
 	            const auto num = nextKey(args);
 	            genKey(key, KEY_PREFIX, args, num);
 	            return tx.get(key, true /*snapshot*/).eraseType();
+	        },
+	        [](Future f, Transaction, Arguments const&, ByteString&, ByteString&, ByteString& val) {
+	            if (f && !f.error()) {
+		            f.get<future_var::Value>();
+	            }
 	        } } },
 	    false },
 	  { "SGETRANGE",
@@ -134,9 +154,12 @@ const std::array<Operation, MAX_OP> opTable{
 	                                                                        true /*snapshot*/,
 	                                                                        args.txnspec.ops[OP_SGETRANGE][OP_REVERSE])
 	                .eraseType();
-	        }
-
-	    } },
+	        },
+	        [](Future f, Transaction, Arguments const&, ByteString&, ByteString&, ByteString& val) {
+	            if (f && !f.error()) {
+		            f.get<future_var::KeyValueArray>();
+	            }
+	        } } },
 	    false },
 	  { "UPDATE",
 	    { { StepKind::READ,
@@ -144,6 +167,11 @@ const std::array<Operation, MAX_OP> opTable{
 	            const auto num = nextKey(args);
 	            genKey(key, KEY_PREFIX, args, num);
 	            return tx.get(key, false /*snapshot*/).eraseType();
+	        },
+	        [](Future f, Transaction, Arguments const&, ByteString&, ByteString&, ByteString& val) {
+	            if (f && !f.error()) {
+		            f.get<future_var::Value>();
+	            }
 	        } },
 	      { StepKind::IMM,
 	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
@@ -290,8 +318,11 @@ const std::array<Operation, MAX_OP> opTable{
 
 	            auto api_context = blob_granules::local_file::createApiContext(user_context, args.bg_materialize_files);
 
-	            auto r =
-	                tx.readBlobGranules(begin, end, 0 /*begin_version*/, -1 /*end_version, use txn's*/, api_context);
+	            auto r = tx.readBlobGranules(begin,
+	                                         end,
+	                                         0 /* beginVersion*/,
+	                                         -2, /* endVersion. -2 (latestVersion) is use txn read version */
+	                                         api_context);
 
 	            user_context.clear();
 
diff --git a/bindings/c/test/mako/operations.hpp b/bindings/c/test/mako/operations.hpp
index d454132126..14feecd311 100644
--- a/bindings/c/test/mako/operations.hpp
+++ b/bindings/c/test/mako/operations.hpp
@@ -79,8 +79,20 @@ using StepFunction = fdb::Future (*)(fdb::Transaction tx,
                                      fdb::ByteString& /*key2*/,
                                      fdb::ByteString& /*value*/);
 
+using PostStepFunction = void (*)(fdb::Future,
+                                  fdb::Transaction tx,
+                                  Arguments const&,
+                                  fdb::ByteString& /*key1*/,
+                                  fdb::ByteString& /*key2*/,
+                                  fdb::ByteString& /*value*/);
+
+struct Step {
+	StepKind kind;
+	StepFunction step_func_;
+	PostStepFunction post_step_func_{ nullptr };
+};
+
 class Operation {
-	using Step = std::pair<StepKind, StepFunction>;
 	std::string_view name_;
 	std::vector<Step> steps_;
 	bool needs_commit_;
@@ -93,11 +105,12 @@ public:
 
 	StepKind stepKind(int step) const noexcept {
 		assert(step < steps());
-		return steps_[step].first;
+		return steps_[step].kind;
 	}
 
-	StepFunction stepFunction(int step) const noexcept { return steps_[step].second; }
+	StepFunction stepFunction(int step) const noexcept { return steps_[step].step_func_; }
 
+	PostStepFunction postStepFunction(int step) const noexcept { return steps_[step].post_step_func_; }
 	// how many steps in this op?
 	int steps() const noexcept { return static_cast<int>(steps_.size()); }
 	// does the op needs to commit some time after its final step?

From a994588e7281ebe6605980c4f30f7d6bccc7b56b Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Thu, 14 Apr 2022 16:28:46 +0200
Subject: [PATCH 28/84] Add assert header

---
 bindings/c/test/fdb_api.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/bindings/c/test/fdb_api.hpp b/bindings/c/test/fdb_api.hpp
index 9f7090da07..9fc30b76d0 100644
--- a/bindings/c/test/fdb_api.hpp
+++ b/bindings/c/test/fdb_api.hpp
@@ -26,6 +26,7 @@
 #define FDB_API_VERSION 720
 #endif
 
+#include <cassert>
 #include <cstdint>
 #include <memory>
 #include <stdexcept>

From e74a676e269666129e99cf165009a8891df3ebf1 Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Fri, 15 Apr 2022 02:01:31 +0200
Subject: [PATCH 29/84] Perf-optimize synchronous execution path

- Wrap timer ops into if blocks
- Pull key/value buffer out to upper level function
---
 bindings/c/test/mako/mako.cpp | 81 +++++++++++++++++++++--------------
 1 file changed, 50 insertions(+), 31 deletions(-)

diff --git a/bindings/c/test/mako/mako.cpp b/bindings/c/test/mako/mako.cpp
index 87cf81351b..fbc3b69206 100644
--- a/bindings/c/test/mako/mako.cpp
+++ b/bindings/c/test/mako/mako.cpp
@@ -200,30 +200,34 @@ int populate(Transaction tx,
 	return 0;
 }
 
-/* run one transaction */
-int runOneTask(Transaction tx, Arguments const& args, ThreadStatistics& stats, LatencySampleBinArray& sample_bins) {
-	// reuse memory for keys to avoid realloc overhead
-	auto key1 = ByteString{};
-	key1.reserve(args.key_length);
-	auto key2 = ByteString{};
-	key2.reserve(args.key_length);
-	auto val = ByteString{};
-	val.reserve(args.value_length);
-
-	auto watch_tx = Stopwatch(StartAtCtor{});
-	auto watch_task = Stopwatch(watch_tx.getStart());
+/* run one iteration of configured task */
+int runOneTask(Transaction tx,
+               Arguments const& args,
+               ThreadStatistics& stats,
+               LatencySampleBinArray& sample_bins,
+               ByteString& key1,
+               ByteString& key2,
+               ByteString& val) {
+	const auto do_sample = (stats.getOpCount(OP_TASK) % args.sampling) == 0;
+	auto watch_task = Stopwatch{};
+	auto watch_tx = Stopwatch{};
+	auto watch_op = Stopwatch{};
+	if (do_sample) {
+		watch_tx.start();
+		watch_task = Stopwatch(watch_tx.getStart());
+	}
 
 	auto op_iter = getOpBegin(args);
 	auto needs_commit = false;
-	auto watch_per_op = std::array<Stopwatch, MAX_OP>{};
-	const auto do_sample = (stats.getOpCount(OP_TASK) % args.sampling) == 0;
 	while (op_iter != OpEnd) {
 		const auto [op, count, step] = op_iter;
 		const auto step_kind = opTable[op].stepKind(step);
 		auto watch_step = Stopwatch{};
-		watch_step.start();
-		if (step == 0 /* first step */)
-			watch_per_op[op] = Stopwatch(watch_step.getStart());
+		if (do_sample) {
+			watch_step.start();
+			if (step == 0 /* first step */)
+				watch_op = Stopwatch(watch_step.getStart());
+		}
 		auto f = opTable[op].stepFunction(step)(tx, args, key1, key2, val);
 		auto future_rc = FutureRC::OK;
 		if (f) {
@@ -235,7 +239,8 @@ int runOneTask(Transaction tx, Arguments const& args, ThreadStatistics& stats, L
 		}
 		if (auto postStepFn = opTable[op].postStepFunction(step))
 			postStepFn(f, tx, args, key1, key2, val);
-		watch_step.stop();
+		if (do_sample)
+			watch_step.stop();
 		if (future_rc != FutureRC::OK) {
 			if (future_rc == FutureRC::CONFLICT) {
 				stats.incrConflictCount();
@@ -254,17 +259,17 @@ int runOneTask(Transaction tx, Arguments const& args, ThreadStatistics& stats, L
 		// step successful
 		if (step_kind == StepKind::COMMIT) {
 			// reset transaction boundary
-			const auto step_latency = watch_step.diff();
-			watch_tx.setStop(watch_step.getStop());
 			if (do_sample) {
+				const auto step_latency = watch_step.diff();
+				watch_tx.setStop(watch_step.getStop());
 				const auto tx_duration = watch_tx.diff();
 				stats.addLatency(OP_COMMIT, step_latency);
 				stats.addLatency(OP_TRANSACTION, tx_duration);
 				sample_bins[OP_COMMIT].put(step_latency);
 				sample_bins[OP_TRANSACTION].put(tx_duration);
+				watch_tx.startFromStop(); // new tx begins
 			}
 			tx.reset();
-			watch_tx.startFromStop(); // new tx begins
 			stats.incrOpCount(OP_COMMIT);
 			stats.incrOpCount(OP_TRANSACTION);
 			needs_commit = false;
@@ -274,9 +279,9 @@ int runOneTask(Transaction tx, Arguments const& args, ThreadStatistics& stats, L
 		if (step + 1 == opTable[op].steps() /* last step */) {
 			if (opTable[op].needsCommit())
 				needs_commit = true;
-			watch_per_op[op].setStop(watch_step.getStop());
 			if (do_sample) {
-				const auto op_latency = watch_per_op[op].diff();
+				watch_op.setStop(watch_step.getStop());
+				const auto op_latency = watch_op.diff();
 				stats.addLatency(op, op_latency);
 				sample_bins[op].put(op_latency);
 			}
@@ -287,14 +292,19 @@ int runOneTask(Transaction tx, Arguments const& args, ThreadStatistics& stats, L
 
 		// reached the end?
 		if (op_iter == OpEnd && (needs_commit || args.commit_get)) {
-			auto watch_commit = Stopwatch(StartAtCtor{});
+			auto watch_commit = Stopwatch();
+			if (do_sample)
+				watch_commit.start();
 			auto f = tx.commit();
 			const auto rc = waitAndHandleError(tx, f, "COMMIT_AT_TX_END");
-			watch_commit.stop();
-			watch_tx.setStop(watch_commit.getStop());
-			auto tx_resetter = ExitGuard([&watch_tx, &tx]() {
+			if (do_sample) {
+				watch_commit.stop();
+				watch_tx.setStop(watch_commit.getStop());
+			}
+			auto tx_resetter = ExitGuard([&do_sample, &watch_tx, &tx]() {
 				tx.reset();
-				watch_tx.startFromStop();
+				if (do_sample)
+					watch_tx.startFromStop();
 			});
 			if (rc == FutureRC::OK) {
 				if (do_sample) {
@@ -322,8 +332,8 @@ int runOneTask(Transaction tx, Arguments const& args, ThreadStatistics& stats, L
 		}
 	}
 	// one task iteration has completed successfully
-	const auto task_duration = watch_task.stop().diff();
-	if (stats.getOpCount(OP_TASK) % args.sampling == 0) {
+	if (do_sample) {
+		const auto task_duration = watch_task.stop().diff();
 		sample_bins[OP_TASK].put(task_duration);
 		stats.addLatency(OP_TASK, task_duration);
 	}
@@ -363,6 +373,15 @@ int runWorkload(Transaction tx,
 	auto rc = 0;
 	auto xacts = 0;
 	auto total_xacts = int64_t{};
+
+	// reuse memory for keys to avoid realloc overhead
+	auto key1 = ByteString{};
+	key1.reserve(args.key_length);
+	auto key2 = ByteString{};
+	key2.reserve(args.key_length);
+	auto val = ByteString{};
+	val.reserve(args.value_length);
+
 	/* main transaction loop */
 	while (1) {
 		while ((thread_tps > 0) && (xacts >= current_tps)) {
@@ -413,7 +432,7 @@ int runWorkload(Transaction tx,
 			}
 		}
 
-		rc = runOneTask(tx, args, stats, sample_bins);
+		rc = runOneTask(tx, args, stats, sample_bins, key1, key2, val);
 		if (rc) {
 			logr.warn("runOneTask failed ({})", rc);
 		}

From 0cf1349c37c5b16457d64a30fdb1f941bf7ddb8b Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Tue, 19 Apr 2022 10:48:56 +0200
Subject: [PATCH 30/84] Optimizations and restructuring

---
 bindings/c/test/mako/async.cpp      |   6 +-
 bindings/c/test/mako/async.hpp      |   2 +-
 bindings/c/test/mako/macro.hpp      |  32 ++++++++
 bindings/c/test/mako/mako.cpp       | 117 +++++++++++++++-------------
 bindings/c/test/mako/mako.hpp       |  39 ++++++----
 bindings/c/test/mako/operations.cpp |  97 ++++++++++-------------
 bindings/c/test/mako/operations.hpp |  78 +++++++++----------
 7 files changed, 200 insertions(+), 171 deletions(-)
 create mode 100644 bindings/c/test/mako/macro.hpp

diff --git a/bindings/c/test/mako/async.cpp b/bindings/c/test/mako/async.cpp
index 0d5b254d19..14077f8735 100644
--- a/bindings/c/test/mako/async.cpp
+++ b/bindings/c/test/mako/async.cpp
@@ -107,7 +107,7 @@ void ResumableStateForRunWorkload::runOneTick() {
 	assert(iter != OpEnd);
 	watch_step.start();
 	if (iter.step == 0 /* first step */) {
-		watch_per_op[iter.op] = Stopwatch(watch_step.getStart());
+		watch_op = Stopwatch(watch_step.getStart());
 	}
 	auto f = Future{};
 	// to minimize context switch overhead, repeat immediately completed ops
@@ -208,9 +208,9 @@ void ResumableStateForRunWorkload::updateStepStats() {
 	if (iter.step + 1 == opTable[iter.op].steps()) {
 		if (opTable[iter.op].needsCommit())
 			needs_commit = true;
-		watch_per_op[iter.op].setStop(watch_step.getStop());
+		watch_op.setStop(watch_step.getStop());
 		if (do_sample) {
-			const auto op_latency = watch_per_op[iter.op].diff();
+			const auto op_latency = watch_op.diff();
 			stats.addLatency(iter.op, op_latency);
 			sample_bins[iter.op].put(op_latency);
 		}
diff --git a/bindings/c/test/mako/async.hpp b/bindings/c/test/mako/async.hpp
index 717e81fc22..7aea0120e2 100644
--- a/bindings/c/test/mako/async.hpp
+++ b/bindings/c/test/mako/async.hpp
@@ -87,8 +87,8 @@ struct ResumableStateForRunWorkload : std::enable_shared_from_this<ResumableStat
 	fdb::ByteString key1;
 	fdb::ByteString key2;
 	fdb::ByteString val;
-	std::array<Stopwatch, MAX_OP> watch_per_op;
 	Stopwatch watch_step;
+	Stopwatch watch_op;
 	Stopwatch watch_commit;
 	Stopwatch watch_tx;
 	Stopwatch watch_task;
diff --git a/bindings/c/test/mako/macro.hpp b/bindings/c/test/mako/macro.hpp
new file mode 100644
index 0000000000..3b683acf45
--- /dev/null
+++ b/bindings/c/test/mako/macro.hpp
@@ -0,0 +1,32 @@
+/*
+ * macro.hpp
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2013-2022 Apple Inc. and the FoundationDB project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef MAKO_MACRO_HPP
+#define MAKO_MACRO_HPP
+
+#if defined(__GNUG__)
+#define force_inline inline __attribute__((__always_inline__))
+#elif defined(_MSC_VER)
+#define force_inline __forceinline
+#else
+#error Missing force inline
+#endif
+
+#endif /*MAKO_MACRO_HPP*/
diff --git a/bindings/c/test/mako/mako.cpp b/bindings/c/test/mako/mako.cpp
index fbc3b69206..18e775c2f6 100644
--- a/bindings/c/test/mako/mako.cpp
+++ b/bindings/c/test/mako/mako.cpp
@@ -54,12 +54,32 @@
 #include <fmt/printf.h>
 #include <fdb_api.hpp>
 #include "fdbclient/zipf.h"
+
+#include "async.hpp"
+#include "future.hpp"
 #include "logger.hpp"
 #include "mako.hpp"
+#include "operations.hpp"
 #include "process.hpp"
 #include "utils.hpp"
-#include "future.hpp"
-#include "async.hpp"
+#include "shm.hpp"
+#include "stats.hpp"
+#include "time.hpp"
+
+namespace mako {
+
+/* args for threads */
+struct alignas(64) ThreadArgs {
+	int worker_id;
+	int thread_id;
+	pid_t parent_id;
+	LatencySampleBinArray sample_bins;
+	Arguments const* args;
+	shared_memory::Access shm;
+	fdb::Database database; // database to work with
+};
+
+} // namespace mako
 
 using namespace fdb;
 using namespace mako;
@@ -201,7 +221,7 @@ int populate(Transaction tx,
 }
 
 /* run one iteration of configured task */
-int runOneTask(Transaction tx,
+int runOneTask(Transaction& tx,
                Arguments const& args,
                ThreadStatistics& stats,
                LatencySampleBinArray& sample_bins,
@@ -209,25 +229,19 @@ int runOneTask(Transaction tx,
                ByteString& key2,
                ByteString& val) {
 	const auto do_sample = (stats.getOpCount(OP_TASK) % args.sampling) == 0;
-	auto watch_task = Stopwatch{};
-	auto watch_tx = Stopwatch{};
+	auto watch_task = Stopwatch(StartAtCtor{});
+	auto watch_tx = Stopwatch(watch_task.getStart());
 	auto watch_op = Stopwatch{};
-	if (do_sample) {
-		watch_tx.start();
-		watch_task = Stopwatch(watch_tx.getStart());
-	}
 
 	auto op_iter = getOpBegin(args);
 	auto needs_commit = false;
+task_begin:
 	while (op_iter != OpEnd) {
 		const auto [op, count, step] = op_iter;
 		const auto step_kind = opTable[op].stepKind(step);
-		auto watch_step = Stopwatch{};
-		if (do_sample) {
-			watch_step.start();
-			if (step == 0 /* first step */)
-				watch_op = Stopwatch(watch_step.getStart());
-		}
+		auto watch_step = Stopwatch(StartAtCtor{});
+		if (step == 0 /* first step */)
+			watch_op = Stopwatch(watch_step.getStart());
 		auto f = opTable[op].stepFunction(step)(tx, args, key1, key2, val);
 		auto future_rc = FutureRC::OK;
 		if (f) {
@@ -239,8 +253,7 @@ int runOneTask(Transaction tx,
 		}
 		if (auto postStepFn = opTable[op].postStepFunction(step))
 			postStepFn(f, tx, args, key1, key2, val);
-		if (do_sample)
-			watch_step.stop();
+		watch_step.stop();
 		if (future_rc != FutureRC::OK) {
 			if (future_rc == FutureRC::CONFLICT) {
 				stats.incrConflictCount();
@@ -279,8 +292,8 @@ int runOneTask(Transaction tx,
 		if (step + 1 == opTable[op].steps() /* last step */) {
 			if (opTable[op].needsCommit())
 				needs_commit = true;
+			watch_op.setStop(watch_step.getStop());
 			if (do_sample) {
-				watch_op.setStop(watch_step.getStop());
 				const auto op_latency = watch_op.diff();
 				stats.addLatency(op, op_latency);
 				sample_bins[op].put(op_latency);
@@ -289,46 +302,40 @@ int runOneTask(Transaction tx,
 		}
 		// move to next op
 		op_iter = getOpNext(args, op_iter);
-
-		// reached the end?
-		if (op_iter == OpEnd && (needs_commit || args.commit_get)) {
-			auto watch_commit = Stopwatch();
-			if (do_sample)
-				watch_commit.start();
-			auto f = tx.commit();
-			const auto rc = waitAndHandleError(tx, f, "COMMIT_AT_TX_END");
+	}
+	// reached the end?
+	if (needs_commit || args.commit_get) {
+		auto watch_commit = Stopwatch(StartAtCtor{});
+		auto f = tx.commit();
+		const auto rc = waitAndHandleError(tx, f, "COMMIT_AT_TX_END");
+		watch_commit.stop();
+		watch_tx.setStop(watch_commit.getStop());
+		auto tx_resetter = ExitGuard([&watch_tx, &tx]() {
+			tx.reset();
+			watch_tx.startFromStop();
+		});
+		if (rc == FutureRC::OK) {
 			if (do_sample) {
-				watch_commit.stop();
-				watch_tx.setStop(watch_commit.getStop());
+				const auto commit_latency = watch_commit.diff();
+				const auto tx_duration = watch_tx.diff();
+				stats.addLatency(OP_COMMIT, commit_latency);
+				stats.addLatency(OP_TRANSACTION, tx_duration);
+				sample_bins[OP_COMMIT].put(commit_latency);
+				sample_bins[OP_TRANSACTION].put(tx_duration);
 			}
-			auto tx_resetter = ExitGuard([&do_sample, &watch_tx, &tx]() {
-				tx.reset();
-				if (do_sample)
-					watch_tx.startFromStop();
-			});
-			if (rc == FutureRC::OK) {
-				if (do_sample) {
-					const auto commit_latency = watch_commit.diff();
-					const auto tx_duration = watch_tx.diff();
-					stats.addLatency(OP_COMMIT, commit_latency);
-					stats.addLatency(OP_TRANSACTION, tx_duration);
-					sample_bins[OP_COMMIT].put(commit_latency);
-					sample_bins[OP_TRANSACTION].put(tx_duration);
-				}
-				stats.incrOpCount(OP_COMMIT);
-				stats.incrOpCount(OP_TRANSACTION);
-			} else {
-				if (rc == FutureRC::CONFLICT)
-					stats.incrConflictCount();
-				else
-					stats.incrErrorCount(OP_COMMIT);
-				if (rc == FutureRC::ABORT) {
-					return -1;
-				}
-				// restart from beginning
-				op_iter = getOpBegin(args);
+			stats.incrOpCount(OP_COMMIT);
+			stats.incrOpCount(OP_TRANSACTION);
+		} else {
+			if (rc == FutureRC::CONFLICT)
+				stats.incrConflictCount();
+			else
+				stats.incrErrorCount(OP_COMMIT);
+			if (rc == FutureRC::ABORT) {
+				return -1;
 			}
-			needs_commit = false;
+			// restart from beginning
+			op_iter = getOpBegin(args);
+			goto task_begin;
 		}
 	}
 	// one task iteration has completed successfully
diff --git a/bindings/c/test/mako/mako.hpp b/bindings/c/test/mako/mako.hpp
index 6c1862e6d2..4c56f33676 100644
--- a/bindings/c/test/mako/mako.hpp
+++ b/bindings/c/test/mako/mako.hpp
@@ -22,7 +22,7 @@
 #define MAKO_HPP
 
 #ifndef FDB_API_VERSION
-#define FDB_API_VERSION 710
+#define FDB_API_VERSION 720
 #endif
 
 #include <array>
@@ -43,10 +43,6 @@
 #else
 #include <limits.h>
 #endif
-#include "operations.hpp"
-#include "shm.hpp"
-#include "stats.hpp"
-#include "time.hpp"
 
 namespace mako {
 
@@ -85,6 +81,28 @@ enum ArgKind {
 	ARG_BG_FILE_PATH // if blob granule files are stored locally, mako will read and materialize them if this is set
 };
 
+/* transaction specification */
+enum OpKind {
+	OP_GETREADVERSION,
+	OP_GET,
+	OP_GETRANGE,
+	OP_SGET,
+	OP_SGETRANGE,
+	OP_UPDATE,
+	OP_INSERT,
+	OP_INSERTRANGE,
+	OP_OVERWRITE,
+	OP_CLEAR,
+	OP_SETCLEAR,
+	OP_CLEARRANGE,
+	OP_SETCLEARRANGE,
+	OP_COMMIT,
+	OP_TRANSACTION, /* pseudo-operation - cumulative time for the operation + commit */
+	OP_TASK, /* pseudo-operation - cumulative time for each iteraton in runWorkload */
+	OP_READ_BG,
+	MAX_OP /* must be the last item */
+};
+
 enum TPSChangeTypes { TPS_SIN, TPS_SQUARE, TPS_PULSE };
 
 /* we set WorkloadSpec and Arguments only once in the master process,
@@ -153,17 +171,6 @@ constexpr const int SIGNAL_RED = 0;
 constexpr const int SIGNAL_GREEN = 1;
 constexpr const int SIGNAL_OFF = 2;
 
-/* args for threads */
-struct alignas(64) ThreadArgs {
-	int worker_id;
-	int thread_id;
-	pid_t parent_id;
-	LatencySampleBinArray sample_bins;
-	Arguments const* args;
-	shared_memory::Access shm;
-	fdb::Database database; // database to work with
-};
-
 } // namespace mako
 
 #endif /* MAKO_HPP */
diff --git a/bindings/c/test/mako/operations.cpp b/bindings/c/test/mako/operations.cpp
index 3725f30889..34817dc4d7 100644
--- a/bindings/c/test/mako/operations.cpp
+++ b/bindings/c/test/mako/operations.cpp
@@ -30,31 +30,6 @@ extern thread_local mako::Logger logr;
 
 namespace mako {
 
-OpIterator getOpBegin(Arguments const& args) noexcept {
-	for (auto op = 0; op < MAX_OP; op++) {
-		if (isAbstractOp(op) || args.txnspec.ops[op][OP_COUNT] == 0)
-			continue;
-		return OpIterator{ op, 0, 0 };
-	}
-	return OpEnd;
-}
-
-OpIterator getOpNext(Arguments const& args, OpIterator current) noexcept {
-	if (OpEnd == current)
-		return OpEnd;
-	auto [op, count, step] = current;
-	assert(op < MAX_OP && !isAbstractOp(op));
-	if (opTable[op].steps() > step + 1)
-		return OpIterator{ op, count, step + 1 };
-	count++;
-	for (; op < MAX_OP; op++, count = 0) {
-		if (isAbstractOp(op) || args.txnspec.ops[op][OP_COUNT] <= count)
-			continue;
-		return OpIterator{ op, count, 0 };
-	}
-	return OpEnd;
-}
-
 using namespace fdb;
 
 inline int nextKey(Arguments const& args) {
@@ -63,40 +38,36 @@ inline int nextKey(Arguments const& args) {
 	return urand(0, args.rows - 1);
 }
 
-char const* getOpName(int ops_code) {
-	if (ops_code >= 0 && ops_code < MAX_OP)
-		return opTable[ops_code].name().data();
-	return "";
-}
-
 const std::array<Operation, MAX_OP> opTable{
 	{ { "GRV",
 	    { { StepKind::READ,
-	        [](Transaction tx, Arguments const&, ByteString&, ByteString&, ByteString&) {
+	        [](Transaction& tx, Arguments const&, ByteString&, ByteString&, ByteString&) {
 	            return tx.getReadVersion().eraseType();
 	        },
-	        [](Future f, Transaction, Arguments const&, ByteString&, ByteString&, ByteString&) {
+	        [](Future& f, Transaction&, Arguments const&, ByteString&, ByteString&, ByteString&) {
 	            if (f && !f.error()) {
 		            f.get<future_var::Int64>();
 	            }
 	        } } },
+	    1,
 	    false },
 	  { "GET",
 	    { { StepKind::READ,
-	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
+	        [](Transaction& tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
 	            const auto num = nextKey(args);
 	            genKey(key, KEY_PREFIX, args, num);
 	            return tx.get(key, false /*snapshot*/).eraseType();
 	        },
-	        [](Future f, Transaction, Arguments const&, ByteString&, ByteString&, ByteString& val) {
+	        [](Future& f, Transaction&, Arguments const&, ByteString&, ByteString&, ByteString& val) {
 	            if (f && !f.error()) {
 		            f.get<future_var::Value>();
 	            }
 	        } } },
+	    1,
 	    false },
 	  { "GETRANGE",
 	    { { StepKind::READ,
-	        [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
+	        [](Transaction& tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
 	            const auto num_begin = nextKey(args);
 	            genKey(begin, KEY_PREFIX, args, num_begin);
 	            auto num_end = num_begin + args.txnspec.ops[OP_GETRANGE][OP_RANGE] - 1;
@@ -114,30 +85,32 @@ const std::array<Operation, MAX_OP> opTable{
 	                                                                        args.txnspec.ops[OP_GETRANGE][OP_REVERSE])
 	                .eraseType();
 	        },
-	        [](Future f, Transaction, Arguments const&, ByteString&, ByteString&, ByteString& val) {
+	        [](Future& f, Transaction&, Arguments const&, ByteString&, ByteString&, ByteString& val) {
 	            if (f && !f.error()) {
 		            f.get<future_var::KeyValueArray>();
 	            }
 	        } } },
+	    1,
 	    false },
 	  { "SGET",
 	    { { StepKind::READ,
-	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
+	        [](Transaction& tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
 	            const auto num = nextKey(args);
 	            genKey(key, KEY_PREFIX, args, num);
 	            return tx.get(key, true /*snapshot*/).eraseType();
 	        },
-	        [](Future f, Transaction, Arguments const&, ByteString&, ByteString&, ByteString& val) {
+	        [](Future& f, Transaction&, Arguments const&, ByteString&, ByteString&, ByteString& val) {
 	            if (f && !f.error()) {
 		            f.get<future_var::Value>();
 	            }
 	        } } },
+	    1,
 	    false },
 	  { "SGETRANGE",
 	    { {
 
 	        StepKind::READ,
-	        [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
+	        [](Transaction& tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
 	            const auto num_begin = nextKey(args);
 	            genKey(begin, KEY_PREFIX, args, num_begin);
 	            auto num_end = num_begin + args.txnspec.ops[OP_SGETRANGE][OP_RANGE] - 1;
@@ -155,34 +128,36 @@ const std::array<Operation, MAX_OP> opTable{
 	                                                                        args.txnspec.ops[OP_SGETRANGE][OP_REVERSE])
 	                .eraseType();
 	        },
-	        [](Future f, Transaction, Arguments const&, ByteString&, ByteString&, ByteString& val) {
+	        [](Future& f, Transaction&, Arguments const&, ByteString&, ByteString&, ByteString& val) {
 	            if (f && !f.error()) {
 		            f.get<future_var::KeyValueArray>();
 	            }
 	        } } },
+	    1,
 	    false },
 	  { "UPDATE",
 	    { { StepKind::READ,
-	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
+	        [](Transaction& tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
 	            const auto num = nextKey(args);
 	            genKey(key, KEY_PREFIX, args, num);
 	            return tx.get(key, false /*snapshot*/).eraseType();
 	        },
-	        [](Future f, Transaction, Arguments const&, ByteString&, ByteString&, ByteString& val) {
+	        [](Future& f, Transaction&, Arguments const&, ByteString&, ByteString&, ByteString& val) {
 	            if (f && !f.error()) {
 		            f.get<future_var::Value>();
 	            }
 	        } },
 	      { StepKind::IMM,
-	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
+	        [](Transaction& tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
 	            randomString(value, args.value_length);
 	            tx.set(key, value);
 	            return Future();
 	        } } },
+	    2,
 	    true },
 	  { "INSERT",
 	    { { StepKind::IMM,
-	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
+	        [](Transaction& tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
 	            genKeyPrefix(key, KEY_PREFIX, args);
 	            // concat([padding], key_prefix, random_string): reasonably unique
 	            randomString<false /*clear-before-append*/>(key, args.key_length - static_cast<int>(key.size()));
@@ -190,10 +165,11 @@ const std::array<Operation, MAX_OP> opTable{
 	            tx.set(key, value);
 	            return Future();
 	        } } },
+	    1,
 	    true },
 	  { "INSERTRANGE",
 	    { { StepKind::IMM,
-	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
+	        [](Transaction& tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
 	            genKeyPrefix(key, KEY_PREFIX, args);
 	            const auto prefix_len = static_cast<int>(key.size());
 	            const auto range = args.txnspec.ops[OP_INSERTRANGE][OP_RANGE];
@@ -211,27 +187,30 @@ const std::array<Operation, MAX_OP> opTable{
 	            }
 	            return Future();
 	        } } },
+	    1,
 	    true },
 	  { "OVERWRITE",
 	    { { StepKind::IMM,
-	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
+	        [](Transaction& tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
 	            genKey(key, KEY_PREFIX, args, nextKey(args));
 	            randomString(value, args.value_length);
 	            tx.set(key, value);
 	            return Future();
 	        } } },
+	    1,
 	    true },
 	  { "CLEAR",
 	    { { StepKind::IMM,
-	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
+	        [](Transaction& tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
 	            genKey(key, KEY_PREFIX, args, nextKey(args));
 	            tx.clear(key);
 	            return Future();
 	        } } },
+	    1,
 	    true },
 	  { "SETCLEAR",
 	    { { StepKind::COMMIT,
-	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
+	        [](Transaction& tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
 	            genKeyPrefix(key, KEY_PREFIX, args);
 	            const auto prefix_len = static_cast<int>(key.size());
 	            randomString<false /*append-after-clear*/>(key, args.key_length - prefix_len);
@@ -240,15 +219,16 @@ const std::array<Operation, MAX_OP> opTable{
 	            return tx.commit().eraseType();
 	        } },
 	      { StepKind::IMM,
-	        [](Transaction tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
+	        [](Transaction& tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
 	            tx.reset(); // assuming commit from step 0 worked.
 	            tx.clear(key); // key should forward unchanged from step 0
 	            return Future();
 	        } } },
+	    2,
 	    true },
 	  { "CLEARRANGE",
 	    { { StepKind::IMM,
-	        [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
+	        [](Transaction& tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
 	            const auto num_begin = nextKey(args);
 	            genKey(begin, KEY_PREFIX, args, num_begin);
 	            const auto range = args.txnspec.ops[OP_CLEARRANGE][OP_RANGE];
@@ -257,10 +237,11 @@ const std::array<Operation, MAX_OP> opTable{
 	            tx.clearRange(begin, end);
 	            return Future();
 	        } } },
+	    1,
 	    true },
 	  { "SETCLEARRANGE",
 	    { { StepKind::COMMIT,
-	        [](Transaction tx, Arguments const& args, ByteString& key_begin, ByteString& key, ByteString& value) {
+	        [](Transaction& tx, Arguments const& args, ByteString& key_begin, ByteString& key, ByteString& value) {
 	            genKeyPrefix(key, KEY_PREFIX, args);
 	            const auto prefix_len = static_cast<int>(key.size());
 	            const auto range = args.txnspec.ops[OP_SETCLEARRANGE][OP_RANGE];
@@ -285,18 +266,19 @@ const std::array<Operation, MAX_OP> opTable{
 	            return tx.commit().eraseType();
 	        } },
 	      { StepKind::IMM,
-	        [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
+	        [](Transaction& tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
 	            tx.reset();
 	            tx.clearRange(begin, end);
 	            return Future();
 	        } } },
+	    2,
 	    true },
-	  { "COMMIT", { { StepKind::NONE, nullptr } }, false },
-	  { "TRANSACTION", { { StepKind::NONE, nullptr } }, false },
-	  { "TASK", { { StepKind::NONE, nullptr } }, false },
+	  { "COMMIT", { { StepKind::NONE, nullptr } }, 0, false },
+	  { "TRANSACTION", { { StepKind::NONE, nullptr } }, 0, false },
+	  { "TASK", { { StepKind::NONE, nullptr } }, 0, false },
 	  { "READBLOBGRANULE",
 	    { { StepKind::ON_ERROR,
-	        [](Transaction tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
+	        [](Transaction& tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
 	            const auto num_begin = nextKey(args);
 	            genKey(begin, KEY_PREFIX, args, num_begin);
 	            const auto range = args.txnspec.ops[OP_READ_BG][OP_RANGE];
@@ -337,6 +319,7 @@ const std::array<Operation, MAX_OP> opTable{
 	            logr.printWithLogLevel(level, "ERROR", "get_keyvalue_array() after readBlobGranules(): {}", err.what());
 	            return tx.onError(err).eraseType();
 	        } } },
+	    1,
 	    false } }
 };
 
diff --git a/bindings/c/test/mako/operations.hpp b/bindings/c/test/mako/operations.hpp
index 14feecd311..d973377aed 100644
--- a/bindings/c/test/mako/operations.hpp
+++ b/bindings/c/test/mako/operations.hpp
@@ -28,33 +28,11 @@
 #include <tuple>
 #include <utility>
 #include <vector>
+#include "macro.hpp"
+#include "mako.hpp"
 
 namespace mako {
 
-struct Arguments;
-
-/* transaction specification */
-enum OpKind {
-	OP_GETREADVERSION,
-	OP_GET,
-	OP_GETRANGE,
-	OP_SGET,
-	OP_SGETRANGE,
-	OP_UPDATE,
-	OP_INSERT,
-	OP_INSERTRANGE,
-	OP_OVERWRITE,
-	OP_CLEAR,
-	OP_SETCLEAR,
-	OP_CLEARRANGE,
-	OP_SETCLEARRANGE,
-	OP_COMMIT,
-	OP_TRANSACTION, /* pseudo-operation - cumulative time for the operation + commit */
-	OP_TASK, /* pseudo-operation - cumulative time for each iteraton in run_workload */
-	OP_READ_BG,
-	MAX_OP /* must be the last item */
-};
-
 constexpr const int OP_COUNT = 0;
 constexpr const int OP_RANGE = 1;
 constexpr const int OP_REVERSE = 2;
@@ -69,18 +47,18 @@ enum class StepKind {
 };
 
 // Ops that doesn't have concrete steps to execute and are there for measurements only
-inline bool isAbstractOp(int op) noexcept {
+force_inline bool isAbstractOp(int op) noexcept {
 	return op == OP_COMMIT || op == OP_TRANSACTION; // || op == OP_TASK;
 }
 
-using StepFunction = fdb::Future (*)(fdb::Transaction tx,
+using StepFunction = fdb::Future (*)(fdb::Transaction& tx,
                                      Arguments const&,
                                      fdb::ByteString& /*key1*/,
                                      fdb::ByteString& /*key2*/,
                                      fdb::ByteString& /*value*/);
 
-using PostStepFunction = void (*)(fdb::Future,
-                                  fdb::Transaction tx,
+using PostStepFunction = void (*)(fdb::Future&,
+                                  fdb::Transaction& tx,
                                   Arguments const&,
                                   fdb::ByteString& /*key1*/,
                                   fdb::ByteString& /*key2*/,
@@ -92,15 +70,12 @@ struct Step {
 	PostStepFunction post_step_func_{ nullptr };
 };
 
-class Operation {
+struct Operation {
 	std::string_view name_;
-	std::vector<Step> steps_;
+	Step steps_[2];
+	int num_steps_;
 	bool needs_commit_;
 
-public:
-	Operation(std::string_view name, std::vector<Step>&& steps, bool needs_commit)
-	  : name_(name), steps_(std::move(steps)), needs_commit_(needs_commit) {}
-
 	std::string_view name() const noexcept { return name_; }
 
 	StepKind stepKind(int step) const noexcept {
@@ -112,15 +87,19 @@ public:
 
 	PostStepFunction postStepFunction(int step) const noexcept { return steps_[step].post_step_func_; }
 	// how many steps in this op?
-	int steps() const noexcept { return static_cast<int>(steps_.size()); }
+	int steps() const noexcept { return num_steps_; }
 	// does the op needs to commit some time after its final step?
 	bool needsCommit() const noexcept { return needs_commit_; }
 };
 
-char const* getOpName(int ops_code);
-
 extern const std::array<Operation, MAX_OP> opTable;
 
+force_inline char const* getOpName(int ops_code) {
+	if (ops_code >= 0 && ops_code < MAX_OP)
+		return opTable[ops_code].name().data();
+	return "";
+}
+
 struct OpIterator {
 	int op, count, step;
 
@@ -137,9 +116,30 @@ struct OpIterator {
 
 constexpr const OpIterator OpEnd = OpIterator{ MAX_OP, -1, -1 };
 
-OpIterator getOpBegin(Arguments const& args) noexcept;
+force_inline OpIterator getOpBegin(Arguments const& args) noexcept {
+	for (auto op = 0; op < MAX_OP; op++) {
+		if (isAbstractOp(op) || args.txnspec.ops[op][OP_COUNT] == 0)
+			continue;
+		return OpIterator{ op, 0, 0 };
+	}
+	return OpEnd;
+}
 
-OpIterator getOpNext(Arguments const& args, OpIterator current) noexcept;
+force_inline OpIterator getOpNext(Arguments const& args, OpIterator current) noexcept {
+	if (OpEnd == current)
+		return OpEnd;
+	auto [op, count, step] = current;
+	assert(op < MAX_OP && !isAbstractOp(op));
+	if (opTable[op].steps() > step + 1)
+		return OpIterator{ op, count, step + 1 };
+	count++;
+	for (; op < MAX_OP; op++, count = 0) {
+		if (isAbstractOp(op) || args.txnspec.ops[op][OP_COUNT] <= count)
+			continue;
+		return OpIterator{ op, count, 0 };
+	}
+	return OpEnd;
+}
 
 } // namespace mako
 

From 278009e1c897b6b920153f1132b4c577aaad52e8 Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Wed, 20 Apr 2022 04:27:16 +0200
Subject: [PATCH 31/84] Let OP_TRANSACTION to measure one iteration of '-x'

---
 bindings/c/test/mako/async.cpp      | 43 ++++++-----------
 bindings/c/test/mako/async.hpp      |  5 +-
 bindings/c/test/mako/mako.cpp       | 73 +++++++++++------------------
 bindings/c/test/mako/mako.hpp       |  3 +-
 bindings/c/test/mako/operations.cpp |  1 -
 bindings/c/test/mako/operations.hpp |  2 +-
 6 files changed, 46 insertions(+), 81 deletions(-)

diff --git a/bindings/c/test/mako/async.cpp b/bindings/c/test/mako/async.cpp
index 14077f8735..90f4090655 100644
--- a/bindings/c/test/mako/async.cpp
+++ b/bindings/c/test/mako/async.cpp
@@ -65,19 +65,16 @@ void ResumableStateForPopulate::runOneTick() {
 					// successfully committed
 					watch_commit.stop();
 					watch_tx.setStop(watch_commit.getStop());
-					if (stats.getOpCount(OP_TASK) % args.sampling == 0) {
+					if (stats.getOpCount(OP_TRANSACTION) % args.sampling == 0) {
 						const auto commit_latency = watch_commit.diff();
 						const auto tx_duration = watch_tx.diff();
 						stats.addLatency(OP_COMMIT, commit_latency);
 						stats.addLatency(OP_TRANSACTION, tx_duration);
-						stats.addLatency(OP_TASK, tx_duration);
 						sample_bins[OP_COMMIT].put(commit_latency);
 						sample_bins[OP_TRANSACTION].put(tx_duration);
-						sample_bins[OP_TASK].put(tx_duration);
 					}
 					stats.incrOpCount(OP_COMMIT);
 					stats.incrOpCount(OP_TRANSACTION);
-					stats.incrOpCount(OP_TASK);
 					tx.reset();
 					watch_tx.startFromStop();
 					key_checkpoint = i + 1;
@@ -119,7 +116,7 @@ repeat_immediate_steps:
 		updateStepStats();
 		iter = getOpNext(args, iter);
 		if (iter == OpEnd)
-			onTaskSuccess();
+			onTransactionSuccess();
 		else
 			goto repeat_immediate_steps;
 	} else {
@@ -156,7 +153,7 @@ repeat_immediate_steps:
 					updateStepStats();
 					iter = getOpNext(args, iter);
 					if (iter == OpEnd) {
-						onTaskSuccess();
+						onTransactionSuccess();
 					} else {
 						postNextTick();
 					}
@@ -186,22 +183,16 @@ void ResumableStateForRunWorkload::updateStepStats() {
 	logr.debug("Step {}:{} succeeded", iter.opName(), iter.step);
 	// step successful
 	watch_step.stop();
-	const auto do_sample = stats.getOpCount(OP_TASK) % args.sampling == 0;
+	const auto do_sample = stats.getOpCount(OP_TRANSACTION) % args.sampling == 0;
 	if (iter.stepKind() == StepKind::COMMIT) {
 		// reset transaction boundary
 		const auto step_latency = watch_step.diff();
-		watch_tx.setStop(watch_step.getStop());
 		if (do_sample) {
-			const auto tx_duration = watch_tx.diff();
 			stats.addLatency(OP_COMMIT, step_latency);
-			stats.addLatency(OP_TRANSACTION, tx_duration);
 			sample_bins[OP_COMMIT].put(step_latency);
-			sample_bins[OP_TRANSACTION].put(tx_duration);
 		}
 		tx.reset();
-		watch_tx.startFromStop();
 		stats.incrOpCount(OP_COMMIT);
-		stats.incrOpCount(OP_TRANSACTION);
 		needs_commit = false;
 	}
 	// op completed successfully
@@ -218,7 +209,7 @@ void ResumableStateForRunWorkload::updateStepStats() {
 	}
 }
 
-void ResumableStateForRunWorkload::onTaskSuccess() {
+void ResumableStateForRunWorkload::onTransactionSuccess() {
 	if (needs_commit || args.commit_get) {
 		// task completed, need to commit before finish
 		watch_commit.start();
@@ -251,24 +242,18 @@ void ResumableStateForRunWorkload::onTaskSuccess() {
 				// commit successful
 				watch_commit.stop();
 				watch_tx.setStop(watch_commit.getStop());
-				watch_task.setStop(watch_commit.getStop());
-				if (stats.getOpCount(OP_TASK) % args.sampling == 0) {
+				if (stats.getOpCount(OP_TRANSACTION) % args.sampling == 0) {
 					const auto commit_latency = watch_commit.diff();
 					const auto tx_duration = watch_tx.diff();
-					const auto task_duration = watch_task.diff();
 					stats.addLatency(OP_COMMIT, commit_latency);
 					stats.addLatency(OP_TRANSACTION, commit_latency);
-					stats.addLatency(OP_TASK, task_duration);
 					sample_bins[OP_COMMIT].put(commit_latency);
 					sample_bins[OP_TRANSACTION].put(tx_duration);
-					sample_bins[OP_TASK].put(task_duration);
 				}
 				stats.incrOpCount(OP_COMMIT);
 				stats.incrOpCount(OP_TRANSACTION);
-				stats.incrOpCount(OP_TASK);
 				tx.reset();
 				watch_tx.startFromStop();
-				watch_task.startFromStop();
 				if (ended()) {
 					signalEnd();
 				} else {
@@ -279,15 +264,15 @@ void ResumableStateForRunWorkload::onTaskSuccess() {
 			}
 		});
 	} else {
-		// task completed but no need to commit
-		watch_task.stop();
-		if (stats.getOpCount(OP_TASK) % args.sampling == 0) {
-			const auto task_duration = watch_task.diff();
-			stats.addLatency(OP_TASK, task_duration);
-			sample_bins[OP_TASK].put(task_duration);
+		// transaction completed but no need to commit
+		watch_tx.stop();
+		if (stats.getOpCount(OP_TRANSACTION) % args.sampling == 0) {
+			const auto tx_duration = watch_tx.diff();
+			stats.addLatency(OP_TRANSACTION, tx_duration);
+			sample_bins[OP_TRANSACTION].put(tx_duration);
 		}
-		stats.incrOpCount(OP_TASK);
-		watch_task.startFromStop();
+		stats.incrOpCount(OP_TRANSACTION);
+		watch_tx.startFromStop();
 		tx.reset();
 		if (ended()) {
 			signalEnd();
diff --git a/bindings/c/test/mako/async.hpp b/bindings/c/test/mako/async.hpp
index 7aea0120e2..a5025202d8 100644
--- a/bindings/c/test/mako/async.hpp
+++ b/bindings/c/test/mako/async.hpp
@@ -91,7 +91,6 @@ struct ResumableStateForRunWorkload : std::enable_shared_from_this<ResumableStat
 	Stopwatch watch_op;
 	Stopwatch watch_commit;
 	Stopwatch watch_tx;
-	Stopwatch watch_task;
 	bool needs_commit;
 
 	ResumableStateForRunWorkload(Logger logr,
@@ -112,12 +111,12 @@ struct ResumableStateForRunWorkload : std::enable_shared_from_this<ResumableStat
 	}
 	void signalEnd() noexcept { stopcount.fetch_add(1); }
 	bool ended() noexcept {
-		return (max_iters != -1 && max_iters >= stats.getOpCount(OP_TASK)) || signal.load() == SIGNAL_RED;
+		return (max_iters != -1 && max_iters >= stats.getOpCount(OP_TRANSACTION)) || signal.load() == SIGNAL_RED;
 	}
 	void postNextTick();
 	void runOneTick();
 	void updateStepStats();
-	void onTaskSuccess();
+	void onTransactionSuccess();
 };
 
 using RunWorkloadStateHandle = std::shared_ptr<ResumableStateForRunWorkload>;
diff --git a/bindings/c/test/mako/mako.cpp b/bindings/c/test/mako/mako.cpp
index 18e775c2f6..865e12c329 100644
--- a/bindings/c/test/mako/mako.cpp
+++ b/bindings/c/test/mako/mako.cpp
@@ -179,7 +179,7 @@ int populate(Transaction tx,
 
 		/* commit every 100 inserts (default) or if this is the last key */
 		if (i == key_end || (i - key_begin + 1) % num_commit_every == 0) {
-			const auto do_sample = (stats.getOpCount(OP_TASK) % args.sampling) == 0;
+			const auto do_sample = (stats.getOpCount(OP_TRANSACTION) % args.sampling) == 0;
 			auto watch_commit = Stopwatch(StartAtCtor{});
 			auto future_commit = tx.commit();
 			const auto rc = waitAndHandleError(tx, future_commit, "COMMIT_POPULATE_INSERT");
@@ -207,7 +207,6 @@ int populate(Transaction tx,
 			stats.incrOpCount(OP_COMMIT);
 			stats.incrOpCount(OP_TRANSACTION);
 
-			stats.incrOpCount(OP_TASK);
 			xacts++; /* for throttling */
 		}
 	}
@@ -220,22 +219,21 @@ int populate(Transaction tx,
 	return 0;
 }
 
-/* run one iteration of configured task */
-int runOneTask(Transaction& tx,
-               Arguments const& args,
-               ThreadStatistics& stats,
-               LatencySampleBinArray& sample_bins,
-               ByteString& key1,
-               ByteString& key2,
-               ByteString& val) {
-	const auto do_sample = (stats.getOpCount(OP_TASK) % args.sampling) == 0;
-	auto watch_task = Stopwatch(StartAtCtor{});
-	auto watch_tx = Stopwatch(watch_task.getStart());
+/* run one iteration of configured transaction */
+int runOneTransaction(Transaction& tx,
+                      Arguments const& args,
+                      ThreadStatistics& stats,
+                      LatencySampleBinArray& sample_bins,
+                      ByteString& key1,
+                      ByteString& key2,
+                      ByteString& val) {
+	const auto do_sample = (stats.getOpCount(OP_TRANSACTION) % args.sampling) == 0;
+	auto watch_tx = Stopwatch(StartAtCtor{});
 	auto watch_op = Stopwatch{};
 
 	auto op_iter = getOpBegin(args);
 	auto needs_commit = false;
-task_begin:
+transaction_begin:
 	while (op_iter != OpEnd) {
 		const auto [op, count, step] = op_iter;
 		const auto step_kind = opTable[op].stepKind(step);
@@ -274,17 +272,11 @@ task_begin:
 			// reset transaction boundary
 			if (do_sample) {
 				const auto step_latency = watch_step.diff();
-				watch_tx.setStop(watch_step.getStop());
-				const auto tx_duration = watch_tx.diff();
 				stats.addLatency(OP_COMMIT, step_latency);
-				stats.addLatency(OP_TRANSACTION, tx_duration);
 				sample_bins[OP_COMMIT].put(step_latency);
-				sample_bins[OP_TRANSACTION].put(tx_duration);
-				watch_tx.startFromStop(); // new tx begins
 			}
 			tx.reset();
 			stats.incrOpCount(OP_COMMIT);
-			stats.incrOpCount(OP_TRANSACTION);
 			needs_commit = false;
 		}
 
@@ -309,22 +301,14 @@ task_begin:
 		auto f = tx.commit();
 		const auto rc = waitAndHandleError(tx, f, "COMMIT_AT_TX_END");
 		watch_commit.stop();
-		watch_tx.setStop(watch_commit.getStop());
-		auto tx_resetter = ExitGuard([&watch_tx, &tx]() {
-			tx.reset();
-			watch_tx.startFromStop();
-		});
+		auto tx_resetter = ExitGuard([&tx]() { tx.reset(); });
 		if (rc == FutureRC::OK) {
 			if (do_sample) {
 				const auto commit_latency = watch_commit.diff();
-				const auto tx_duration = watch_tx.diff();
 				stats.addLatency(OP_COMMIT, commit_latency);
-				stats.addLatency(OP_TRANSACTION, tx_duration);
 				sample_bins[OP_COMMIT].put(commit_latency);
-				sample_bins[OP_TRANSACTION].put(tx_duration);
 			}
 			stats.incrOpCount(OP_COMMIT);
-			stats.incrOpCount(OP_TRANSACTION);
 		} else {
 			if (rc == FutureRC::CONFLICT)
 				stats.incrConflictCount();
@@ -335,16 +319,16 @@ task_begin:
 			}
 			// restart from beginning
 			op_iter = getOpBegin(args);
-			goto task_begin;
+			goto transaction_begin;
 		}
 	}
-	// one task iteration has completed successfully
+	// one transaction has completed successfully
 	if (do_sample) {
-		const auto task_duration = watch_task.stop().diff();
-		sample_bins[OP_TASK].put(task_duration);
-		stats.addLatency(OP_TASK, task_duration);
+		const auto tx_duration = watch_tx.stop().diff();
+		sample_bins[OP_TRANSACTION].put(tx_duration);
+		stats.addLatency(OP_TRANSACTION, tx_duration);
 	}
-	stats.incrOpCount(OP_TASK);
+	stats.incrOpCount(OP_TRANSACTION);
 	/* make sure to reset transaction */
 	tx.reset();
 	return 0;
@@ -439,13 +423,13 @@ int runWorkload(Transaction tx,
 			}
 		}
 
-		rc = runOneTask(tx, args, stats, sample_bins, key1, key2, val);
+		rc = runOneTransaction(tx, args, stats, sample_bins, key1, key2, val);
 		if (rc) {
-			logr.warn("runOneTask failed ({})", rc);
+			logr.warn("runOneTransaction failed ({})", rc);
 		}
 
 		if (thread_iters != -1) {
-			if (thread_iters >= xacts) {
+			if (thread_iters >= total_xacts) {
 				/* xact limit reached */
 				break;
 			}
@@ -552,7 +536,6 @@ void runAsyncWorkload(Arguments const& args,
 			                                                   max_iters,
 			                                                   getOpBegin(args));
 			states[i] = state;
-			state->watch_task.start();
 			state->watch_tx.start();
 		}
 		while (shm.headerConst().signal.load() != SIGNAL_GREEN)
@@ -1356,7 +1339,7 @@ void printStats(Arguments const& args, ThreadStatistics const* stats, double con
 		}
 	}
 	/* TPS */
-	const auto tps = (current.getOpCount(OP_TASK) - prev.getOpCount(OP_TASK)) / duration_sec;
+	const auto tps = (current.getOpCount(OP_TRANSACTION) - prev.getOpCount(OP_TRANSACTION)) / duration_sec;
 	putFieldFloat(tps, 2);
 	if (fp) {
 		fprintf(fp, "\"tps\": %.2f,", tps);
@@ -1473,9 +1456,9 @@ void printReport(Arguments const& args,
 			break;
 		}
 	}
-	const auto tps_f = final_stats.getOpCount(OP_TASK) / duration_sec;
+	const auto tps_f = final_stats.getOpCount(OP_TRANSACTION) / duration_sec;
 	const auto tps_i = static_cast<uint64_t>(tps_f);
-	fmt::printf("Total Xacts:       %8lu\n", final_stats.getOpCount(OP_TASK));
+	fmt::printf("Total Xacts:       %8lu\n", final_stats.getOpCount(OP_TRANSACTION));
 	fmt::printf("Total Conflicts:   %8lu\n", final_stats.getConflictCount());
 	fmt::printf("Total Errors:      %8lu\n", final_stats.getTotalErrorCount());
 	fmt::printf("Overall TPS:       %8lu\n\n", tps_i);
@@ -1487,7 +1470,7 @@ void printReport(Arguments const& args,
 		fmt::fprintf(fp, "\"totalThreads\": %d,", args.num_threads);
 		fmt::fprintf(fp, "\"totalAsyncXacts\": %d,", args.async_xacts);
 		fmt::fprintf(fp, "\"targetTPS\": %d,", args.tpsmax);
-		fmt::fprintf(fp, "\"totalXacts\": %lu,", final_stats.getOpCount(OP_TASK));
+		fmt::fprintf(fp, "\"totalXacts\": %lu,", final_stats.getOpCount(OP_TRANSACTION));
 		fmt::fprintf(fp, "\"totalConflicts\": %lu,", final_stats.getConflictCount());
 		fmt::fprintf(fp, "\"totalErrors\": %lu,", final_stats.getTotalErrorCount());
 		fmt::fprintf(fp, "\"overallTPS\": %lu,", tps_i);
@@ -1503,7 +1486,7 @@ void printReport(Arguments const& args,
 	}
 	auto first_op = true;
 	for (auto op = 0; op < MAX_OP; op++) {
-		if ((args.txnspec.ops[op][OP_COUNT] > 0 && op != OP_TASK && op != OP_TRANSACTION) || op == OP_COMMIT) {
+		if ((args.txnspec.ops[op][OP_COUNT] > 0 && op != OP_TRANSACTION) || op == OP_COMMIT) {
 			putField(final_stats.getOpCount(op));
 			if (fp) {
 				if (first_op) {
@@ -1517,7 +1500,7 @@ void printReport(Arguments const& args,
 	}
 
 	/* TPS */
-	const auto tps = final_stats.getOpCount(OP_TASK) / duration_sec;
+	const auto tps = final_stats.getOpCount(OP_TRANSACTION) / duration_sec;
 	putFieldFloat(tps, 2);
 
 	/* Conflicts */
diff --git a/bindings/c/test/mako/mako.hpp b/bindings/c/test/mako/mako.hpp
index 4c56f33676..7c9c902b25 100644
--- a/bindings/c/test/mako/mako.hpp
+++ b/bindings/c/test/mako/mako.hpp
@@ -97,8 +97,7 @@ enum OpKind {
 	OP_CLEARRANGE,
 	OP_SETCLEARRANGE,
 	OP_COMMIT,
-	OP_TRANSACTION, /* pseudo-operation - cumulative time for the operation + commit */
-	OP_TASK, /* pseudo-operation - cumulative time for each iteraton in runWorkload */
+	OP_TRANSACTION, /* pseudo-operation - time it takes to run one iteration of ops sequence */
 	OP_READ_BG,
 	MAX_OP /* must be the last item */
 };
diff --git a/bindings/c/test/mako/operations.cpp b/bindings/c/test/mako/operations.cpp
index 34817dc4d7..46b34e8b50 100644
--- a/bindings/c/test/mako/operations.cpp
+++ b/bindings/c/test/mako/operations.cpp
@@ -275,7 +275,6 @@ const std::array<Operation, MAX_OP> opTable{
 	    true },
 	  { "COMMIT", { { StepKind::NONE, nullptr } }, 0, false },
 	  { "TRANSACTION", { { StepKind::NONE, nullptr } }, 0, false },
-	  { "TASK", { { StepKind::NONE, nullptr } }, 0, false },
 	  { "READBLOBGRANULE",
 	    { { StepKind::ON_ERROR,
 	        [](Transaction& tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
diff --git a/bindings/c/test/mako/operations.hpp b/bindings/c/test/mako/operations.hpp
index d973377aed..e029724de3 100644
--- a/bindings/c/test/mako/operations.hpp
+++ b/bindings/c/test/mako/operations.hpp
@@ -48,7 +48,7 @@ enum class StepKind {
 
 // Ops that doesn't have concrete steps to execute and are there for measurements only
 force_inline bool isAbstractOp(int op) noexcept {
-	return op == OP_COMMIT || op == OP_TRANSACTION; // || op == OP_TASK;
+	return op == OP_COMMIT || op == OP_TRANSACTION;
 }
 
 using StepFunction = fdb::Future (*)(fdb::Transaction& tx,

From d4ee7be1d7d778421c9baec5e3bf525d6045e668 Mon Sep 17 00:00:00 2001
From: Markus Pilman <markus.pilman@snowflake.com>
Date: Tue, 19 Apr 2022 21:11:51 -0600
Subject: [PATCH 32/84] Reduce excessive tracing and fail after 1M traces

---
 fdbclient/NativeAPI.actor.cpp       | 22 +++++++++----------
 fdbserver/workloads/Cycle.actor.cpp |  2 +-
 flow/Knobs.cpp                      |  1 +
 flow/Knobs.h                        |  1 +
 flow/Trace.cpp                      | 34 +++++++++++++++++++----------
 5 files changed, 37 insertions(+), 23 deletions(-)

diff --git a/fdbclient/NativeAPI.actor.cpp b/fdbclient/NativeAPI.actor.cpp
index ab8c957d53..47d44e599f 100644
--- a/fdbclient/NativeAPI.actor.cpp
+++ b/fdbclient/NativeAPI.actor.cpp
@@ -265,11 +265,11 @@ void DatabaseContext::getLatestCommitVersions(const Reference<LocationInfo>& loc
 void updateCachedReadVersionShared(double t, Version v, DatabaseSharedState* p) {
 	MutexHolder mutex(p->mutexLock);
 	if (v >= p->grvCacheSpace.cachedReadVersion) {
-		TraceEvent(SevDebug, "CacheReadVersionUpdate")
-		    .detail("Version", v)
-		    .detail("CurTime", t)
-		    .detail("LastVersion", p->grvCacheSpace.cachedReadVersion)
-		    .detail("LastTime", p->grvCacheSpace.lastGrvTime);
+		//TraceEvent(SevDebug, "CacheReadVersionUpdate")
+		//    .detail("Version", v)
+		//    .detail("CurTime", t)
+		//    .detail("LastVersion", p->grvCacheSpace.cachedReadVersion)
+		//    .detail("LastTime", p->grvCacheSpace.lastGrvTime);
 		p->grvCacheSpace.cachedReadVersion = v;
 		if (t > p->grvCacheSpace.lastGrvTime) {
 			p->grvCacheSpace.lastGrvTime = t;
@@ -282,11 +282,11 @@ void DatabaseContext::updateCachedReadVersion(double t, Version v) {
 		return updateCachedReadVersionShared(t, v, sharedStatePtr);
 	}
 	if (v >= cachedReadVersion) {
-		TraceEvent(SevDebug, "CachedReadVersionUpdate")
-		    .detail("Version", v)
-		    .detail("GrvStartTime", t)
-		    .detail("LastVersion", cachedReadVersion)
-		    .detail("LastTime", lastGrvTime);
+		//TraceEvent(SevDebug, "CachedReadVersionUpdate")
+		//    .detail("Version", v)
+		//    .detail("GrvStartTime", t)
+		//    .detail("LastVersion", cachedReadVersion)
+		//    .detail("LastTime", lastGrvTime);
 		cachedReadVersion = v;
 		// Since the time is based on the start of the request, it's possible that we
 		// get a newer version with an older time.
@@ -9389,4 +9389,4 @@ ACTOR Future<Void> waitPurgeGranulesCompleteActor(Reference<DatabaseContext> db,
 
 Future<Void> DatabaseContext::waitPurgeGranulesComplete(Key purgeKey) {
 	return waitPurgeGranulesCompleteActor(Reference<DatabaseContext>::addRef(this), purgeKey);
-}
\ No newline at end of file
+}
diff --git a/fdbserver/workloads/Cycle.actor.cpp b/fdbserver/workloads/Cycle.actor.cpp
index 23ce15858c..7413f59e75 100644
--- a/fdbserver/workloads/Cycle.actor.cpp
+++ b/fdbserver/workloads/Cycle.actor.cpp
@@ -106,7 +106,7 @@ struct CycleWorkload : TestWorkload {
 				state Transaction tr(cx);
 				if (deterministicRandom()->random01() >= self->traceParentProbability) {
 					state Span span("CycleClient"_loc);
-					TraceEvent("CycleTracingTransaction", span.context).log();
+					//TraceEvent("CycleTracingTransaction", span.context).log();
 					tr.setOption(FDBTransactionOptions::SPAN_PARENT,
 					             BinaryWriter::toValue(span.context, Unversioned()));
 				}
diff --git a/flow/Knobs.cpp b/flow/Knobs.cpp
index 555112c16f..c6cbf5318f 100644
--- a/flow/Knobs.cpp
+++ b/flow/Knobs.cpp
@@ -214,6 +214,7 @@ void FlowKnobs::initialize(Randomize randomize, IsSimulated isSimulated) {
 	init( MAX_TRACE_EVENT_LENGTH,                             4000 ); // If the value of this is changed, the corresponding default in Trace.cpp should be changed as well
 	init( ALLOCATION_TRACING_ENABLED,                         true );
 	init( SIM_SPEEDUP_AFTER_SECONDS,                           450 );
+	init( MAX_TRACE_LINES,                               1'000'000 );
 	init( CODE_COV_TRACE_EVENT_SEVERITY,                        10 ); // Code coverage TraceEvent severity level
 
 	//TDMetrics
diff --git a/flow/Knobs.h b/flow/Knobs.h
index d2faff94af..debbebe0fe 100644
--- a/flow/Knobs.h
+++ b/flow/Knobs.h
@@ -268,6 +268,7 @@ public:
 	double MAX_BUGGIFIED_DELAY;
 	int SIM_CONNECT_ERROR_MODE;
 	double SIM_SPEEDUP_AFTER_SECONDS;
+	int MAX_TRACE_LINES;
 
 	// Tracefiles
 	int ZERO_LENGTH_FILE_PAD;
diff --git a/flow/Trace.cpp b/flow/Trace.cpp
index 86d572d4fe..bd43e38bd2 100644
--- a/flow/Trace.cpp
+++ b/flow/Trace.cpp
@@ -53,6 +53,8 @@
 // 2. To avoid a historically documented but unknown crash that occurs when logging allocations
 //    during an open trace event
 thread_local int g_allocation_tracing_disabled = 1;
+thread_local unsigned tracedLines = 0;
+thread_local int failedLineOverflow = 0;
 
 ITraceLogIssuesReporter::~ITraceLogIssuesReporter() {}
 
@@ -394,17 +396,22 @@ public:
 		eventBuffer.push_back(fields);
 		bufferLength += fields.sizeBytes();
 
-		// If we have queued up a large number of events in simulation, then throw an error. This makes it easier to
-		// diagnose cases where we get stuck in a loop logging trace events that eventually runs out of memory.
-		// Without this we would never see any trace events from that loop, and it would be more difficult to identify
-		// where the process is actually stuck.
-		if (g_network && g_network->isSimulated() && bufferLength > 1e8) {
-			fprintf(stderr, "Trace log buffer overflow\n");
-			fprintf(stderr, "Last event: %s\n", fields.toString().c_str());
-			// Setting this to 0 avoids a recurse from the assertion trace event and also prevents a situation where
-			// we roll the trace log only to log the single assertion event when using --crash.
-			bufferLength = 0;
-			ASSERT(false);
+		if (g_network && g_network->isSimulated()) {
+			// If we have queued up a large number of events in simulation, then throw an error. This makes it easier to
+			// diagnose cases where we get stuck in a loop logging trace events that eventually runs out of memory.
+			// Without this we would never see any trace events from that loop, and it would be more difficult to
+			// identify where the process is actually stuck.
+			if (bufferLength > 1e8) {
+				fprintf(stderr, "Trace log buffer overflow\n");
+				fprintf(stderr, "Last event: %s\n", fields.toString().c_str());
+				// Setting this to 0 avoids a recurse from the assertion trace event and also prevents a situation where
+				// we roll the trace log only to log the single assertion event when using --crash.
+				bufferLength = 0;
+				ASSERT(false);
+			}
+			if (++tracedLines > FLOW_KNOBS->MAX_TRACE_LINES && failedLineOverflow == 0) {
+				failedLineOverflow = 1; // we only want to do this once
+			}
 		}
 
 		if (trackError) {
@@ -1265,6 +1272,11 @@ void BaseTraceEvent::log() {
 
 BaseTraceEvent::~BaseTraceEvent() {
 	log();
+	if (failedLineOverflow == 1) {
+		failedLineOverflow = 2;
+		TraceEvent(SevError, "TracedTooManyLines").log();
+		crashAndDie();
+	}
 }
 
 thread_local bool BaseTraceEvent::networkThread = false;

From 50dcde0ca5c3004f7962fdf32c76d23b4c09fcdd Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Wed, 20 Apr 2022 10:10:18 +0200
Subject: [PATCH 33/84] fmt::format for key string generation is slow

---
 bindings/c/test/mako/mako.cpp       |  2 +-
 bindings/c/test/mako/operations.hpp |  4 +---
 bindings/c/test/mako/utils.hpp      | 30 ++++++++++++++---------------
 3 files changed, 16 insertions(+), 20 deletions(-)

diff --git a/bindings/c/test/mako/mako.cpp b/bindings/c/test/mako/mako.cpp
index 865e12c329..56817c6ac9 100644
--- a/bindings/c/test/mako/mako.cpp
+++ b/bindings/c/test/mako/mako.cpp
@@ -235,7 +235,7 @@ int runOneTransaction(Transaction& tx,
 	auto needs_commit = false;
 transaction_begin:
 	while (op_iter != OpEnd) {
-		const auto [op, count, step] = op_iter;
+		const auto& [op, count, step] = op_iter;
 		const auto step_kind = opTable[op].stepKind(step);
 		auto watch_step = Stopwatch(StartAtCtor{});
 		if (step == 0 /* first step */)
diff --git a/bindings/c/test/mako/operations.hpp b/bindings/c/test/mako/operations.hpp
index e029724de3..793d4e999c 100644
--- a/bindings/c/test/mako/operations.hpp
+++ b/bindings/c/test/mako/operations.hpp
@@ -126,9 +126,7 @@ force_inline OpIterator getOpBegin(Arguments const& args) noexcept {
 }
 
 force_inline OpIterator getOpNext(Arguments const& args, OpIterator current) noexcept {
-	if (OpEnd == current)
-		return OpEnd;
-	auto [op, count, step] = current;
+	auto& [op, count, step] = current;
 	assert(op < MAX_OP && !isAbstractOp(op));
 	if (opTable[op].steps() > step + 1)
 		return OpIterator{ op, count, step + 1 };
diff --git a/bindings/c/test/mako/utils.hpp b/bindings/c/test/mako/utils.hpp
index 4ed10183b2..04c25c3a20 100644
--- a/bindings/c/test/mako/utils.hpp
+++ b/bindings/c/test/mako/utils.hpp
@@ -99,28 +99,26 @@ void genKeyPrefix(std::basic_string<Char>& str, std::string_view prefix, Argumen
 	    args.prefixpadding ? (args.key_length - args.row_digits - static_cast<int>(prefix.size())) : 0;
 	assert(padding_len >= 0);
 	str.reserve(str.size() + padding_len + prefix.size());
-	fmt::format_to(std::back_inserter(str), "{0:x>{1}}{2}", "", padding_len, prefix);
+	for (auto i = 0; i < padding_len; i++)
+		str.push_back('x');
+	str.append(reinterpret_cast<Char const*>(prefix.data()), prefix.size());
 }
 
 /* generate a key for a given key number */
 /* prefix is "mako" by default, prefixpadding = 1 means 'x' will be in front rather than trailing the keyname */
-template <bool Clear = true, typename Char>
+template <typename Char>
 void genKey(std::basic_string<Char>& str, std::string_view prefix, Arguments const& args, int num) {
 	static_assert(sizeof(Char) == 1);
-	const auto pad_len = args.prefixpadding ? args.key_length - (static_cast<int>(prefix.size()) + args.row_digits) : 0;
-	assert(pad_len >= 0);
-	if constexpr (Clear)
-		str.clear();
-	str.reserve(str.size() + static_cast<size_t>(args.key_length));
-	fmt::format_to(std::back_inserter(str),
-	               "{0:x>{1}}{2}{3:0{4}d}{5:x>{6}}",
-	               "",
-	               pad_len,
-	               prefix,
-	               num,
-	               args.row_digits,
-	               "",
-	               args.key_length - pad_len - static_cast<int>(prefix.size()) - args.row_digits);
+	str.clear();
+	str.resize(args.key_length, 'x');
+	const auto prefix_len = static_cast<int>(prefix.size());
+	auto pos = args.prefixpadding ? (args.key_length - prefix_len - args.row_digits) : 0;
+	memcpy(&str[pos], prefix.data(), prefix.size());
+	pos += prefix_len;
+	for (auto i = 0; i < args.row_digits; i++) {
+		str[pos + (args.row_digits - i - 1)] = (num % 10) + '0';
+		num /= 10;
+	}
 }
 
 // invoke user-provided callable when object goes out of scope.

From d202d482d9f3389f39b44fd2ee34eb564b0893fc Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Wed, 20 Apr 2022 14:15:09 +0200
Subject: [PATCH 34/84] Preserve key string generation behavior of mako.c

---
 bindings/c/test/mako/async.cpp      |  5 ++--
 bindings/c/test/mako/mako.cpp       |  4 ++-
 bindings/c/test/mako/mako.hpp       |  4 +++
 bindings/c/test/mako/operations.cpp | 39 +----------------------------
 bindings/c/test/mako/operations.hpp |  4 ---
 bindings/c/test/mako/utils.cpp      | 18 -------------
 bindings/c/test/mako/utils.hpp      | 34 ++++++++++++++++++++++---
 7 files changed, 42 insertions(+), 66 deletions(-)

diff --git a/bindings/c/test/mako/async.cpp b/bindings/c/test/mako/async.cpp
index 90f4090655..e3ba4e1584 100644
--- a/bindings/c/test/mako/async.cpp
+++ b/bindings/c/test/mako/async.cpp
@@ -102,10 +102,11 @@ void ResumableStateForRunWorkload::postNextTick() {
 
 void ResumableStateForRunWorkload::runOneTick() {
 	assert(iter != OpEnd);
+	if (iter.step == 0 /* first step */)
+		prepareKeys(iter.op, key1, key2, args);
 	watch_step.start();
-	if (iter.step == 0 /* first step */) {
+	if (iter.step == 0)
 		watch_op = Stopwatch(watch_step.getStart());
-	}
 	auto f = Future{};
 	// to minimize context switch overhead, repeat immediately completed ops
 	// in a loop, not an async continuation.
diff --git a/bindings/c/test/mako/mako.cpp b/bindings/c/test/mako/mako.cpp
index 56817c6ac9..ec5f1734fd 100644
--- a/bindings/c/test/mako/mako.cpp
+++ b/bindings/c/test/mako/mako.cpp
@@ -237,8 +237,10 @@ transaction_begin:
 	while (op_iter != OpEnd) {
 		const auto& [op, count, step] = op_iter;
 		const auto step_kind = opTable[op].stepKind(step);
-		auto watch_step = Stopwatch(StartAtCtor{});
 		if (step == 0 /* first step */)
+			prepareKeys(op, key1, key2, args);
+		auto watch_step = Stopwatch(StartAtCtor{});
+		if (step == 0)
 			watch_op = Stopwatch(watch_step.getStart());
 		auto f = opTable[op].stepFunction(step)(tx, args, key1, key2, val);
 		auto future_rc = FutureRC::OK;
diff --git a/bindings/c/test/mako/mako.hpp b/bindings/c/test/mako/mako.hpp
index 7c9c902b25..daa296db83 100644
--- a/bindings/c/test/mako/mako.hpp
+++ b/bindings/c/test/mako/mako.hpp
@@ -81,6 +81,10 @@ enum ArgKind {
 	ARG_BG_FILE_PATH // if blob granule files are stored locally, mako will read and materialize them if this is set
 };
 
+constexpr const int OP_COUNT = 0;
+constexpr const int OP_RANGE = 1;
+constexpr const int OP_REVERSE = 2;
+
 /* transaction specification */
 enum OpKind {
 	OP_GETREADVERSION,
diff --git a/bindings/c/test/mako/operations.cpp b/bindings/c/test/mako/operations.cpp
index 46b34e8b50..789d311a2e 100644
--- a/bindings/c/test/mako/operations.cpp
+++ b/bindings/c/test/mako/operations.cpp
@@ -23,7 +23,6 @@
 #include "mako.hpp"
 #include "logger.hpp"
 #include "utils.hpp"
-#include "fdbclient/zipf.h"
 #include <array>
 
 extern thread_local mako::Logger logr;
@@ -32,12 +31,6 @@ namespace mako {
 
 using namespace fdb;
 
-inline int nextKey(Arguments const& args) {
-	if (args.zipf)
-		return zipfian_next();
-	return urand(0, args.rows - 1);
-}
-
 const std::array<Operation, MAX_OP> opTable{
 	{ { "GRV",
 	    { { StepKind::READ,
@@ -54,8 +47,6 @@ const std::array<Operation, MAX_OP> opTable{
 	  { "GET",
 	    { { StepKind::READ,
 	        [](Transaction& tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
-	            const auto num = nextKey(args);
-	            genKey(key, KEY_PREFIX, args, num);
 	            return tx.get(key, false /*snapshot*/).eraseType();
 	        },
 	        [](Future& f, Transaction&, Arguments const&, ByteString&, ByteString&, ByteString& val) {
@@ -68,12 +59,6 @@ const std::array<Operation, MAX_OP> opTable{
 	  { "GETRANGE",
 	    { { StepKind::READ,
 	        [](Transaction& tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
-	            const auto num_begin = nextKey(args);
-	            genKey(begin, KEY_PREFIX, args, num_begin);
-	            auto num_end = num_begin + args.txnspec.ops[OP_GETRANGE][OP_RANGE] - 1;
-	            if (num_end > args.rows - 1)
-		            num_end = args.rows - 1;
-	            genKey(end, KEY_PREFIX, args, num_end);
 	            return tx
 	                .getRange<key_select::Inclusive, key_select::Inclusive>(begin,
 	                                                                        end,
@@ -95,8 +80,6 @@ const std::array<Operation, MAX_OP> opTable{
 	  { "SGET",
 	    { { StepKind::READ,
 	        [](Transaction& tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
-	            const auto num = nextKey(args);
-	            genKey(key, KEY_PREFIX, args, num);
 	            return tx.get(key, true /*snapshot*/).eraseType();
 	        },
 	        [](Future& f, Transaction&, Arguments const&, ByteString&, ByteString&, ByteString& val) {
@@ -111,12 +94,6 @@ const std::array<Operation, MAX_OP> opTable{
 
 	        StepKind::READ,
 	        [](Transaction& tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
-	            const auto num_begin = nextKey(args);
-	            genKey(begin, KEY_PREFIX, args, num_begin);
-	            auto num_end = num_begin + args.txnspec.ops[OP_SGETRANGE][OP_RANGE] - 1;
-	            if (num_end > args.rows - 1)
-		            num_end = args.rows - 1;
-	            genKey(end, KEY_PREFIX, args, num_end);
 	            return tx
 	                .getRange<key_select::Inclusive, key_select::Inclusive>(begin,
 	                                                                        end,
@@ -138,8 +115,6 @@ const std::array<Operation, MAX_OP> opTable{
 	  { "UPDATE",
 	    { { StepKind::READ,
 	        [](Transaction& tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
-	            const auto num = nextKey(args);
-	            genKey(key, KEY_PREFIX, args, num);
 	            return tx.get(key, false /*snapshot*/).eraseType();
 	        },
 	        [](Future& f, Transaction&, Arguments const&, ByteString&, ByteString&, ByteString& val) {
@@ -192,7 +167,6 @@ const std::array<Operation, MAX_OP> opTable{
 	  { "OVERWRITE",
 	    { { StepKind::IMM,
 	        [](Transaction& tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
-	            genKey(key, KEY_PREFIX, args, nextKey(args));
 	            randomString(value, args.value_length);
 	            tx.set(key, value);
 	            return Future();
@@ -202,7 +176,6 @@ const std::array<Operation, MAX_OP> opTable{
 	  { "CLEAR",
 	    { { StepKind::IMM,
 	        [](Transaction& tx, Arguments const& args, ByteString& key, ByteString&, ByteString&) {
-	            genKey(key, KEY_PREFIX, args, nextKey(args));
 	            tx.clear(key);
 	            return Future();
 	        } } },
@@ -213,7 +186,7 @@ const std::array<Operation, MAX_OP> opTable{
 	        [](Transaction& tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
 	            genKeyPrefix(key, KEY_PREFIX, args);
 	            const auto prefix_len = static_cast<int>(key.size());
-	            randomString<false /*append-after-clear*/>(key, args.key_length - prefix_len);
+	            randomString<false /*clear-before-append*/>(key, args.key_length - prefix_len);
 	            randomString(value, args.value_length);
 	            tx.set(key, value);
 	            return tx.commit().eraseType();
@@ -229,11 +202,6 @@ const std::array<Operation, MAX_OP> opTable{
 	  { "CLEARRANGE",
 	    { { StepKind::IMM,
 	        [](Transaction& tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
-	            const auto num_begin = nextKey(args);
-	            genKey(begin, KEY_PREFIX, args, num_begin);
-	            const auto range = args.txnspec.ops[OP_CLEARRANGE][OP_RANGE];
-	            assert(range > 0);
-	            genKey(end, KEY_PREFIX, args, std::min(args.rows - 1, num_begin + range - 1));
 	            tx.clearRange(begin, end);
 	            return Future();
 	        } } },
@@ -278,11 +246,6 @@ const std::array<Operation, MAX_OP> opTable{
 	  { "READBLOBGRANULE",
 	    { { StepKind::ON_ERROR,
 	        [](Transaction& tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
-	            const auto num_begin = nextKey(args);
-	            genKey(begin, KEY_PREFIX, args, num_begin);
-	            const auto range = args.txnspec.ops[OP_READ_BG][OP_RANGE];
-	            assert(range > 0);
-	            genKey(end, KEY_PREFIX, args, std::min(args.rows - 1, num_begin + range - 1));
 	            auto err = Error{};
 
 	            err = tx.setOptionNothrow(FDB_TR_OPTION_READ_YOUR_WRITES_DISABLE, BytesRef());
diff --git a/bindings/c/test/mako/operations.hpp b/bindings/c/test/mako/operations.hpp
index 793d4e999c..62ebf276a6 100644
--- a/bindings/c/test/mako/operations.hpp
+++ b/bindings/c/test/mako/operations.hpp
@@ -33,10 +33,6 @@
 
 namespace mako {
 
-constexpr const int OP_COUNT = 0;
-constexpr const int OP_RANGE = 1;
-constexpr const int OP_REVERSE = 2;
-
 // determines how resultant future will be handled
 enum class StepKind {
 	NONE, ///< not part of the table: OP_TRANSACTION, OP_COMMIT
diff --git a/bindings/c/test/mako/utils.cpp b/bindings/c/test/mako/utils.cpp
index e267385336..c02770c89c 100644
--- a/bindings/c/test/mako/utils.cpp
+++ b/bindings/c/test/mako/utils.cpp
@@ -27,25 +27,7 @@
 
 namespace mako {
 
-/* uniform-distribution random */
-int urand(int low, int high) {
-	double r = rand() / (1.0 + RAND_MAX);
-	int range = high - low + 1;
-	return (int)((r * range) + low);
-}
-
-/* return the first key to be inserted */
-int insertBegin(int rows, int p_idx, int t_idx, int total_p, int total_t) {
-	double interval = (double)rows / total_p / total_t;
-	return (int)(round(interval * ((p_idx * total_t) + t_idx)));
-}
-
 /* return the last key to be inserted */
-int insertEnd(int rows, int p_idx, int t_idx, int total_p, int total_t) {
-	double interval = (double)rows / total_p / total_t;
-	return (int)(round(interval * ((p_idx * total_t) + t_idx + 1) - 1));
-}
-
 /* devide val equally among threads */
 int computeThreadPortion(int val, int p_idx, int t_idx, int total_p, int total_t) {
 	int interval = val / total_p / total_t;
diff --git a/bindings/c/test/mako/utils.hpp b/bindings/c/test/mako/utils.hpp
index 04c25c3a20..a08b9c0df1 100644
--- a/bindings/c/test/mako/utils.hpp
+++ b/bindings/c/test/mako/utils.hpp
@@ -22,7 +22,9 @@
 #define UTILS_HPP
 #pragma once
 
+#include "macro.hpp"
 #include "mako.hpp"
+#include "fdbclient/zipf.h"
 #include <cassert>
 #include <chrono>
 #include <cstdint>
@@ -34,7 +36,17 @@ namespace mako {
 
 /* uniform-distribution random */
 /* return a uniform random number between low and high, both inclusive */
-int urand(int low, int high);
+force_inline int urand(int low, int high) {
+	double r = rand() / (1.0 + RAND_MAX);
+	int range = high - low + 1;
+	return (int)((r * range) + low);
+}
+
+force_inline int nextKey(Arguments const& args) {
+	if (args.zipf)
+		return zipfian_next();
+	return urand(0, args.rows - 1);
+}
 
 /* random string */
 template <bool Clear = true, typename Char>
@@ -65,10 +77,16 @@ void randomNumericString(std::basic_string<Char>& str, int len) {
  * and the total number of processes, total_p, and threads, total_t,
  * returns the first row number assigned to this partition.
  */
-int insertBegin(int rows, int p_idx, int t_idx, int total_p, int total_t);
+force_inline int insertBegin(int rows, int p_idx, int t_idx, int total_p, int total_t) {
+	double interval = (double)rows / total_p / total_t;
+	return (int)(round(interval * ((p_idx * total_t) + t_idx)));
+}
 
 /* similar to insertBegin, insertEnd returns the last row numer */
-int insertEnd(int rows, int p_idx, int t_idx, int total_p, int total_t);
+force_inline int insertEnd(int rows, int p_idx, int t_idx, int total_p, int total_t) {
+	double interval = (double)rows / total_p / total_t;
+	return (int)(round(interval * ((p_idx * total_t) + t_idx + 1) - 1));
+}
 
 /* devide a value equally among threads */
 int computeThreadPortion(int val, int p_idx, int t_idx, int total_p, int total_t);
@@ -121,6 +139,16 @@ void genKey(std::basic_string<Char>& str, std::string_view prefix, Arguments con
 	}
 }
 
+template <typename Char>
+void prepareKeys(int op, std::basic_string<Char>& key1, std::basic_string<Char>& key2, Arguments const& args) {
+	const auto key1_num = nextKey(args);
+	genKey(key1, KEY_PREFIX, args, key1_num);
+	if (args.txnspec.ops[op][OP_RANGE] > 0) {
+		const auto key2_num = std::min(key1_num + args.txnspec.ops[op][OP_RANGE] - 1, args.rows - 1);
+		genKey(key2, KEY_PREFIX, args, key2_num);
+	}
+}
+
 // invoke user-provided callable when object goes out of scope.
 template <typename Func>
 class ExitGuard {

From b7e493f03087bad82e0824efbebb97d3f9e71057 Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Wed, 20 Apr 2022 16:26:48 +0200
Subject: [PATCH 35/84] Simplify string generation

---
 bindings/c/test/mako/async.cpp      |  4 +-
 bindings/c/test/mako/async.hpp      | 10 ++---
 bindings/c/test/mako/mako.cpp       | 38 +++++++++++--------
 bindings/c/test/mako/operations.cpp | 59 +++++++++++------------------
 bindings/c/test/mako/utils.hpp      | 54 +++++++++++---------------
 5 files changed, 75 insertions(+), 90 deletions(-)

diff --git a/bindings/c/test/mako/async.cpp b/bindings/c/test/mako/async.cpp
index e3ba4e1584..b4b601e5b0 100644
--- a/bindings/c/test/mako/async.cpp
+++ b/bindings/c/test/mako/async.cpp
@@ -40,8 +40,8 @@ void ResumableStateForPopulate::postNextTick() {
 void ResumableStateForPopulate::runOneTick() {
 	const auto num_commit_every = args.txnspec.ops[OP_INSERT][OP_COUNT];
 	for (auto i = key_checkpoint; i <= key_end; i++) {
-		genKey(keystr, KEY_PREFIX, args, i);
-		randomString(valstr, args.value_length);
+		genKey(keystr.data(), KEY_PREFIX, args, i);
+		randomString(valstr.data(), args.value_length);
 		tx.set(keystr, valstr);
 		stats.incrOpCount(OP_INSERT);
 		if (i == key_end || (i - key_begin + 1) % num_commit_every == 0) {
diff --git a/bindings/c/test/mako/async.hpp b/bindings/c/test/mako/async.hpp
index a5025202d8..8105ed72c1 100644
--- a/bindings/c/test/mako/async.hpp
+++ b/bindings/c/test/mako/async.hpp
@@ -62,8 +62,8 @@ struct ResumableStateForPopulate : std::enable_shared_from_this<ResumableStateFo
 	                          int key_end)
 	  : logr(logr), db(db), tx(tx), io_context(io_context), args(args), stats(stats), stopcount(stopcount),
 	    key_begin(key_begin), key_end(key_end), key_checkpoint(key_begin) {
-		keystr.reserve(args.key_length);
-		valstr.reserve(args.value_length);
+		keystr.resize(args.key_length);
+		valstr.resize(args.value_length);
 	}
 	void runOneTick();
 	void postNextTick();
@@ -105,9 +105,9 @@ struct ResumableStateForRunWorkload : std::enable_shared_from_this<ResumableStat
 	                             OpIterator iter)
 	  : logr(logr), db(db), tx(tx), io_context(io_context), args(args), stats(stats), stopcount(stopcount),
 	    signal(signal), max_iters(max_iters), iter(iter), needs_commit(false) {
-		key1.reserve(args.key_length);
-		key2.reserve(args.key_length);
-		val.reserve(args.value_length);
+		key1.resize(args.key_length);
+		key2.resize(args.key_length);
+		val.resize(args.value_length);
 	}
 	void signalEnd() noexcept { stopcount.fetch_add(1); }
 	bool ended() noexcept {
diff --git a/bindings/c/test/mako/mako.cpp b/bindings/c/test/mako/mako.cpp
index ec5f1734fd..970224eda8 100644
--- a/bindings/c/test/mako/mako.cpp
+++ b/bindings/c/test/mako/mako.cpp
@@ -88,15 +88,21 @@ thread_local Logger logr = Logger(MainProcess{}, VERBOSE_DEFAULT);
 
 /* cleanup database */
 int cleanup(Transaction tx, Arguments const& args) {
-	auto beginstr = ByteString{};
-	beginstr.reserve(args.key_length);
-	genKeyPrefix(beginstr, KEY_PREFIX, args);
-	beginstr.push_back(0);
-
-	auto endstr = ByteString{};
-	endstr.reserve(args.key_length);
-	genKeyPrefix(endstr, KEY_PREFIX, args);
-	endstr.push_back(0xff);
+	const auto prefix_len = args.prefixpadding ? args.key_length - args.row_digits : intSize(KEY_PREFIX);
+	auto genprefix = [&args](ByteString& s) {
+		const auto padding_len = args.key_length - intSize(KEY_PREFIX) - args.row_digits;
+		auto pos = 0;
+		if (args.prefixpadding) {
+			memset(s.data(), 'x', padding_len);
+			pos += padding_len;
+		}
+		const auto key_prefix_len = intSize(KEY_PREFIX);
+		memcpy(&s[pos], KEY_PREFIX.data(), key_prefix_len);
+	};
+	auto beginstr = ByteString(prefix_len + 1, '\0');
+	genprefix(beginstr);
+	auto endstr = ByteString(prefix_len + 1, '\xff');
+	genprefix(endstr);
 
 	auto watch = Stopwatch(StartAtCtor{});
 
@@ -133,8 +139,8 @@ int populate(Transaction tx,
 
 	auto keystr = ByteString{};
 	auto valstr = ByteString{};
-	keystr.reserve(args.key_length);
-	valstr.reserve(args.value_length);
+	keystr.resize(args.key_length);
+	valstr.resize(args.value_length);
 	const auto num_commit_every = args.txnspec.ops[OP_INSERT][OP_COUNT];
 	const auto num_seconds_trace_every = args.txntrace;
 	auto watch_total = Stopwatch(StartAtCtor{});
@@ -145,9 +151,9 @@ int populate(Transaction tx,
 
 	for (auto i = key_begin; i <= key_end; i++) {
 		/* sequential keys */
-		genKey(keystr, KEY_PREFIX, args, i);
+		genKey(keystr.data(), KEY_PREFIX, args, i);
 		/* random values */
-		randomString(valstr, args.value_length);
+		randomString(valstr.data(), args.value_length);
 
 		while (thread_tps > 0 && xacts >= thread_tps /* throttle */) {
 			if (toIntegerSeconds(watch_throttle.stop().diff()) >= 1) {
@@ -369,11 +375,11 @@ int runWorkload(Transaction tx,
 
 	// reuse memory for keys to avoid realloc overhead
 	auto key1 = ByteString{};
-	key1.reserve(args.key_length);
+	key1.resize(args.key_length);
 	auto key2 = ByteString{};
-	key2.reserve(args.key_length);
+	key2.resize(args.key_length);
 	auto val = ByteString{};
-	val.reserve(args.value_length);
+	val.resize(args.value_length);
 
 	/* main transaction loop */
 	while (1) {
diff --git a/bindings/c/test/mako/operations.cpp b/bindings/c/test/mako/operations.cpp
index 789d311a2e..ab4923638a 100644
--- a/bindings/c/test/mako/operations.cpp
+++ b/bindings/c/test/mako/operations.cpp
@@ -124,7 +124,7 @@ const std::array<Operation, MAX_OP> opTable{
 	        } },
 	      { StepKind::IMM,
 	        [](Transaction& tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
-	            randomString(value, args.value_length);
+	            randomString(value.data(), args.value_length);
 	            tx.set(key, value);
 	            return Future();
 	        } } },
@@ -133,10 +133,9 @@ const std::array<Operation, MAX_OP> opTable{
 	  { "INSERT",
 	    { { StepKind::IMM,
 	        [](Transaction& tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
-	            genKeyPrefix(key, KEY_PREFIX, args);
-	            // concat([padding], key_prefix, random_string): reasonably unique
-	            randomString<false /*clear-before-append*/>(key, args.key_length - static_cast<int>(key.size()));
-	            randomString(value, args.value_length);
+	            // key[0..args.key_length] := concat(key_prefix, random_string)
+	            randomString(key.data() + intSize(KEY_PREFIX), args.key_length - intSize(KEY_PREFIX));
+	            randomString(value.data(), args.value_length);
 	            tx.set(key, value);
 	            return Future();
 	        } } },
@@ -145,20 +144,17 @@ const std::array<Operation, MAX_OP> opTable{
 	  { "INSERTRANGE",
 	    { { StepKind::IMM,
 	        [](Transaction& tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
-	            genKeyPrefix(key, KEY_PREFIX, args);
-	            const auto prefix_len = static_cast<int>(key.size());
+	            randomString(value.data(), args.value_length);
+
+	            // key[0..args.key_length] := concat(prefix, random_string, num[0..range_digits])
 	            const auto range = args.txnspec.ops[OP_INSERTRANGE][OP_RANGE];
 	            assert(range > 0);
 	            const auto range_digits = digits(range);
-	            assert(args.key_length - prefix_len >= range_digits);
-	            const auto rand_len = args.key_length - prefix_len - range_digits;
-	            // concat([padding], prefix, random_string, range_digits)
-	            randomString<false /*clear-before-append*/>(key, rand_len);
-	            randomString(value, args.value_length);
+	            const auto random_len = args.key_length - intSize(KEY_PREFIX) - range_digits;
+	            randomString(&key[intSize(KEY_PREFIX)], random_len);
 	            for (auto i = 0; i < range; i++) {
-		            fmt::format_to(std::back_inserter(key), "{0:0{1}d}", i, range_digits);
+		            numericWithFill(&key[args.key_length - range_digits], range_digits, i);
 		            tx.set(key, value);
-		            key.resize(key.size() - static_cast<size_t>(range_digits));
 	            }
 	            return Future();
 	        } } },
@@ -167,7 +163,7 @@ const std::array<Operation, MAX_OP> opTable{
 	  { "OVERWRITE",
 	    { { StepKind::IMM,
 	        [](Transaction& tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
-	            randomString(value, args.value_length);
+	            randomString(value.data(), args.value_length);
 	            tx.set(key, value);
 	            return Future();
 	        } } },
@@ -184,10 +180,8 @@ const std::array<Operation, MAX_OP> opTable{
 	  { "SETCLEAR",
 	    { { StepKind::COMMIT,
 	        [](Transaction& tx, Arguments const& args, ByteString& key, ByteString&, ByteString& value) {
-	            genKeyPrefix(key, KEY_PREFIX, args);
-	            const auto prefix_len = static_cast<int>(key.size());
-	            randomString<false /*clear-before-append*/>(key, args.key_length - prefix_len);
-	            randomString(value, args.value_length);
+	            randomString(&key[KEY_PREFIX.size()], args.key_length - intSize(KEY_PREFIX));
+	            randomString(value.data(), args.value_length);
 	            tx.set(key, value);
 	            return tx.commit().eraseType();
 	        } },
@@ -210,26 +204,19 @@ const std::array<Operation, MAX_OP> opTable{
 	  { "SETCLEARRANGE",
 	    { { StepKind::COMMIT,
 	        [](Transaction& tx, Arguments const& args, ByteString& key_begin, ByteString& key, ByteString& value) {
-	            genKeyPrefix(key, KEY_PREFIX, args);
-	            const auto prefix_len = static_cast<int>(key.size());
-	            const auto range = args.txnspec.ops[OP_SETCLEARRANGE][OP_RANGE];
+	            randomString(value.data(), args.value_length);
+
+	            // key[0..args.key_length] := concat(prefix, random_string, num[0..range_digits])
+	            const auto range = args.txnspec.ops[OP_INSERTRANGE][OP_RANGE];
 	            assert(range > 0);
 	            const auto range_digits = digits(range);
-	            assert(args.key_length - prefix_len >= range_digits);
-	            const auto rand_len = args.key_length - prefix_len - range_digits;
-	            // concat([padding], prefix, random_string, range_digits)
-	            randomString<false /*clear-before-append*/>(key, rand_len);
-	            randomString(value, args.value_length);
-	            for (auto i = 0; i <= range; i++) {
-		            fmt::format_to(std::back_inserter(key), "{0:0{1}d}", i, range_digits);
-		            if (i == range)
-			            break; // preserve "exclusive last"
-		            // preserve first key for step 1
-		            if (i == 0)
-			            key_begin = key;
+	            const auto random_len = args.key_length - intSize(KEY_PREFIX) - range_digits;
+	            randomString(&key[KEY_PREFIX.size()], random_len);
+	            for (auto i = 0; i < range; i++) {
+		            numericWithFill(&key[args.key_length - range_digits], range_digits, i);
 		            tx.set(key, value);
-		            // preserve last key for step 1
-		            key.resize(key.size() - static_cast<size_t>(range_digits));
+		            if (i == 0)
+			            key_begin.assign(key);
 	            }
 	            return tx.commit().eraseType();
 	        } },
diff --git a/bindings/c/test/mako/utils.hpp b/bindings/c/test/mako/utils.hpp
index a08b9c0df1..e499160e76 100644
--- a/bindings/c/test/mako/utils.hpp
+++ b/bindings/c/test/mako/utils.hpp
@@ -28,6 +28,7 @@
 #include <cassert>
 #include <chrono>
 #include <cstdint>
+#include <string_view>
 #include <type_traits>
 
 #include <fmt/format.h>
@@ -48,15 +49,16 @@ force_inline int nextKey(Arguments const& args) {
 	return urand(0, args.rows - 1);
 }
 
+force_inline int intSize(std::string_view sv) {
+	return static_cast<int>(sv.size());
+}
+
 /* random string */
-template <bool Clear = true, typename Char>
-void randomString(std::basic_string<Char>& str, int len) {
-	if constexpr (Clear)
-		str.clear();
+template <typename Char>
+void randomString(Char* str, int len) {
 	assert(len >= 0);
-	str.reserve(str.size() + static_cast<size_t>(len));
 	for (auto i = 0; i < len; i++) {
-		str.push_back('!' + urand(0, 'z' - '!')); /* generage a char from '!' to 'z' */
+		str[i] = ('!' + urand(0, 'z' - '!')); /* generate a char from '!' to 'z' */
 	}
 }
 
@@ -105,47 +107,37 @@ int computeThreadPortion(int val, int p_idx, int t_idx, int total_p, int total_t
 /* get the number of digits */
 int digits(int num);
 
-/* fill (str) with configured key prefix: i.e. non-numeric part
- * (str) is appended with concat([padding], PREFIX)
- */
-template <bool Clear = true, typename Char>
-void genKeyPrefix(std::basic_string<Char>& str, std::string_view prefix, Arguments const& args) {
-	// concat('x' * padding_len, key_prefix)
-	if constexpr (Clear)
-		str.clear();
-	const auto padding_len =
-	    args.prefixpadding ? (args.key_length - args.row_digits - static_cast<int>(prefix.size())) : 0;
-	assert(padding_len >= 0);
-	str.reserve(str.size() + padding_len + prefix.size());
-	for (auto i = 0; i < padding_len; i++)
-		str.push_back('x');
-	str.append(reinterpret_cast<Char const*>(prefix.data()), prefix.size());
+/* fill memory slice [str, str + len) as stringified, zero-padded num */
+template <typename Char>
+void numericWithFill(Char* str, int len, int num) {
+	static_assert(sizeof(Char) == 1);
+	assert(num >= 0);
+	for (auto i = len - 1; i >= 0; i--) {
+		str[i] = (num % 10) + '0';
+		num /= 10;
+	}
 }
 
 /* generate a key for a given key number */
 /* prefix is "mako" by default, prefixpadding = 1 means 'x' will be in front rather than trailing the keyname */
 template <typename Char>
-void genKey(std::basic_string<Char>& str, std::string_view prefix, Arguments const& args, int num) {
+void genKey(Char* str, std::string_view prefix, Arguments const& args, int num) {
 	static_assert(sizeof(Char) == 1);
-	str.clear();
-	str.resize(args.key_length, 'x');
+	memset(str, 'x', args.key_length);
 	const auto prefix_len = static_cast<int>(prefix.size());
 	auto pos = args.prefixpadding ? (args.key_length - prefix_len - args.row_digits) : 0;
-	memcpy(&str[pos], prefix.data(), prefix.size());
+	memcpy(&str[pos], prefix.data(), prefix_len);
 	pos += prefix_len;
-	for (auto i = 0; i < args.row_digits; i++) {
-		str[pos + (args.row_digits - i - 1)] = (num % 10) + '0';
-		num /= 10;
-	}
+	numericWithFill(&str[pos], args.row_digits, num);
 }
 
 template <typename Char>
 void prepareKeys(int op, std::basic_string<Char>& key1, std::basic_string<Char>& key2, Arguments const& args) {
 	const auto key1_num = nextKey(args);
-	genKey(key1, KEY_PREFIX, args, key1_num);
+	genKey(key1.data(), KEY_PREFIX, args, key1_num);
 	if (args.txnspec.ops[op][OP_RANGE] > 0) {
 		const auto key2_num = std::min(key1_num + args.txnspec.ops[op][OP_RANGE] - 1, args.rows - 1);
-		genKey(key2, KEY_PREFIX, args, key2_num);
+		genKey(key2.data(), KEY_PREFIX, args, key2_num);
 	}
 }
 

From 3f9f781226ecc6df1fc0befb5176c31bbeb93696 Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Wed, 20 Apr 2022 19:41:07 +0200
Subject: [PATCH 36/84] Fix typo

---
 bindings/c/test/mako/operations.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bindings/c/test/mako/operations.cpp b/bindings/c/test/mako/operations.cpp
index ab4923638a..02c0d2ea8e 100644
--- a/bindings/c/test/mako/operations.cpp
+++ b/bindings/c/test/mako/operations.cpp
@@ -207,7 +207,7 @@ const std::array<Operation, MAX_OP> opTable{
 	            randomString(value.data(), args.value_length);
 
 	            // key[0..args.key_length] := concat(prefix, random_string, num[0..range_digits])
-	            const auto range = args.txnspec.ops[OP_INSERTRANGE][OP_RANGE];
+	            const auto range = args.txnspec.ops[OP_SETCLEARRANGE][OP_RANGE];
 	            assert(range > 0);
 	            const auto range_digits = digits(range);
 	            const auto random_len = args.key_length - intSize(KEY_PREFIX) - range_digits;

From f7a8ebf818628e1a371a7d3e7e43c01243ba0c26 Mon Sep 17 00:00:00 2001
From: Markus Pilman <markus.pilman@snowflake.com>
Date: Wed, 20 Apr 2022 11:55:01 -0600
Subject: [PATCH 37/84] Update flow/Trace.cpp

Co-authored-by: A.J. Beamon <aj.beamon@snowflake.com>
---
 flow/Trace.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/flow/Trace.cpp b/flow/Trace.cpp
index bd43e38bd2..f4e6b77375 100644
--- a/flow/Trace.cpp
+++ b/flow/Trace.cpp
@@ -53,7 +53,7 @@
 // 2. To avoid a historically documented but unknown crash that occurs when logging allocations
 //    during an open trace event
 thread_local int g_allocation_tracing_disabled = 1;
-thread_local unsigned tracedLines = 0;
+unsigned tracedLines = 0;
 thread_local int failedLineOverflow = 0;
 
 ITraceLogIssuesReporter::~ITraceLogIssuesReporter() {}

From 85757eb47c12696fec5632f60b12a7333ef59670 Mon Sep 17 00:00:00 2001
From: Markus Pilman <markus.pilman@snowflake.com>
Date: Wed, 20 Apr 2022 15:30:42 -0600
Subject: [PATCH 38/84] Update flow/Trace.cpp

---
 flow/Trace.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/flow/Trace.cpp b/flow/Trace.cpp
index f4e6b77375..390e594112 100644
--- a/flow/Trace.cpp
+++ b/flow/Trace.cpp
@@ -397,7 +397,7 @@ public:
 		bufferLength += fields.sizeBytes();
 
 		if (g_network && g_network->isSimulated()) {
-			// If we have queued up a large number of events in simulation, then throw an error. This makes it easier to
+			// Throw an error if we have queued up a large number of events in simulation. This makes it easier to
 			// diagnose cases where we get stuck in a loop logging trace events that eventually runs out of memory.
 			// Without this we would never see any trace events from that loop, and it would be more difficult to
 			// identify where the process is actually stuck.

From 7304c337f8a0f02a3fd9f43a7d011f2529801736 Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Thu, 21 Apr 2022 02:44:19 +0200
Subject: [PATCH 39/84] Aggressive inlining

---
 bindings/c/test/mako/future.hpp |  7 ++++---
 bindings/c/test/mako/utils.hpp  | 25 ++++++++-----------------
 2 files changed, 12 insertions(+), 20 deletions(-)

diff --git a/bindings/c/test/mako/future.hpp b/bindings/c/test/mako/future.hpp
index ba25cfbcfa..2941102498 100644
--- a/bindings/c/test/mako/future.hpp
+++ b/bindings/c/test/mako/future.hpp
@@ -25,6 +25,7 @@
 #include <cassert>
 #include <string_view>
 #include "logger.hpp"
+#include "macro.hpp"
 
 extern thread_local mako::Logger logr;
 
@@ -33,7 +34,7 @@ namespace mako {
 enum class FutureRC { OK, RETRY, CONFLICT, ABORT };
 
 template <class FutureType>
-FutureRC handleForOnError(fdb::Transaction tx, FutureType f, std::string_view step) {
+force_inline FutureRC handleForOnError(fdb::Transaction& tx, FutureType& f, std::string_view step) {
 	if (auto err = f.error()) {
 		if (err.is(1020 /*not_committed*/)) {
 			return FutureRC::CONFLICT;
@@ -51,7 +52,7 @@ FutureRC handleForOnError(fdb::Transaction tx, FutureType f, std::string_view st
 }
 
 template <class FutureType>
-FutureRC waitAndHandleForOnError(fdb::Transaction tx, FutureType f, std::string_view step) {
+force_inline FutureRC waitAndHandleForOnError(fdb::Transaction& tx, FutureType& f, std::string_view step) {
 	assert(f);
 	if (auto err = f.blockUntilReady()) {
 		logr.error("'{}' found while waiting for on_error() future, step: {}", err.what(), step);
@@ -62,7 +63,7 @@ FutureRC waitAndHandleForOnError(fdb::Transaction tx, FutureType f, std::string_
 
 // wait on any non-immediate tx-related step to complete. Follow up with on_error().
 template <class FutureType>
-FutureRC waitAndHandleError(fdb::Transaction tx, FutureType f, std::string_view step) {
+force_inline FutureRC waitAndHandleError(fdb::Transaction& tx, FutureType& f, std::string_view step) {
 	assert(f);
 	auto err = fdb::Error{};
 	if ((err = f.blockUntilReady())) {
diff --git a/bindings/c/test/mako/utils.hpp b/bindings/c/test/mako/utils.hpp
index e499160e76..da166eeccc 100644
--- a/bindings/c/test/mako/utils.hpp
+++ b/bindings/c/test/mako/utils.hpp
@@ -55,25 +55,13 @@ force_inline int intSize(std::string_view sv) {
 
 /* random string */
 template <typename Char>
-void randomString(Char* str, int len) {
+force_inline void randomString(Char* str, int len) {
 	assert(len >= 0);
 	for (auto i = 0; i < len; i++) {
 		str[i] = ('!' + urand(0, 'z' - '!')); /* generate a char from '!' to 'z' */
 	}
 }
 
-/* random numeric string */
-template <bool Clear = true, typename Char>
-void randomNumericString(std::basic_string<Char>& str, int len) {
-	if constexpr (Clear)
-		str.clear();
-	assert(len >= 0);
-	str.reserve(str.size() + static_cast<size_t>(len));
-	for (auto i = 0; i < len; i++) {
-		str.push_back('0' + urand(0, 9)); /* generage a char from '0' to '9' */
-	}
-}
-
 /* given the total number of rows to be inserted,
  * the worker process index p_idx and the thread index t_idx (both 0-based),
  * and the total number of processes, total_p, and threads, total_t,
@@ -109,12 +97,12 @@ int digits(int num);
 
 /* fill memory slice [str, str + len) as stringified, zero-padded num */
 template <typename Char>
-void numericWithFill(Char* str, int len, int num) {
+force_inline void numericWithFill(Char* str, int len, int num) {
 	static_assert(sizeof(Char) == 1);
 	assert(num >= 0);
-	for (auto i = len - 1; i >= 0; i--) {
+	memset(str, '0', len);
+	for (auto i = len - 1; num > 0 && i >= 0; i--, num /= 10) {
 		str[i] = (num % 10) + '0';
-		num /= 10;
 	}
 }
 
@@ -132,7 +120,10 @@ void genKey(Char* str, std::string_view prefix, Arguments const& args, int num)
 }
 
 template <typename Char>
-void prepareKeys(int op, std::basic_string<Char>& key1, std::basic_string<Char>& key2, Arguments const& args) {
+force_inline void prepareKeys(int op,
+                              std::basic_string<Char>& key1,
+                              std::basic_string<Char>& key2,
+                              Arguments const& args) {
 	const auto key1_num = nextKey(args);
 	genKey(key1.data(), KEY_PREFIX, args, key1_num);
 	if (args.txnspec.ops[op][OP_RANGE] > 0) {

From c27635f607223f645db6025d13ba877ea354c462 Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Thu, 21 Apr 2022 10:55:41 +0200
Subject: [PATCH 40/84] Apply changes made to mako.c in main branch

---
 bindings/c/test/mako/mako.cpp | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/bindings/c/test/mako/mako.cpp b/bindings/c/test/mako/mako.cpp
index 970224eda8..b4dbe396f1 100644
--- a/bindings/c/test/mako/mako.cpp
+++ b/bindings/c/test/mako/mako.cpp
@@ -1674,7 +1674,11 @@ void printReport(Arguments const& args,
 						fseek(fp, 0, 0);
 						for (auto index = 0u; index < num_points; index++) {
 							auto value = uint64_t{};
-							fread(&value, sizeof(uint64_t), 1, fp);
+							auto nread = fread(&value, sizeof(uint64_t), 1, fp);
+							if (nread != 1) {
+								logr.error("Read sample returned {}", nread);
+								break;
+							}
 							data_points[op].push_back(value);
 						}
 					};
@@ -1796,7 +1800,10 @@ void printReport(Arguments const& args,
 	}
 
 	const auto command_remove = fmt::format("rm -rf {}{}", TEMP_DATA_STORE, pid_main);
-	system(command_remove.c_str());
+	if (auto rc = system(command_remove.c_str())) {
+		logr.error("Command {} returned {}", command_remove, rc);
+		return;
+	}
 }
 
 int statsProcessMain(Arguments const& args,

From b7e9cab0a789b66a31ffedb2abb573dc8390d155 Mon Sep 17 00:00:00 2001
From: LukasMol <lukas.molleman@ugent.be>
Date: Thu, 21 Apr 2022 16:24:51 +0200
Subject: [PATCH 41/84] made python files inside TestRunner more pythonic

---
 tests/TestRunner/TestRunner.py        | 111 +++++++++++++-------------
 tests/TestRunner/local_cluster.py     |  14 ++--
 tests/TestRunner/tmp_cluster.py       |   6 +-
 tests/TestRunner/tmp_multi_cluster.py |  62 +++++++-------
 tests/TestRunner/upgrade_test.py      |  53 ++++++------
 5 files changed, 126 insertions(+), 120 deletions(-)

diff --git a/tests/TestRunner/TestRunner.py b/tests/TestRunner/TestRunner.py
index 6316e47860..5dbecb9578 100755
--- a/tests/TestRunner/TestRunner.py
+++ b/tests/TestRunner/TestRunner.py
@@ -11,14 +11,13 @@ import json
 import xml.sax
 import xml.sax.handler
 import functools
-import multiprocessing
 import re
 import shutil
 import io
-import random
 
 _logger = None
 
+
 def init_logging(loglevel, logdir):
     global _logger
     _logger = logging.getLogger('TestRunner')
@@ -26,7 +25,7 @@ def init_logging(loglevel, logdir):
     formatter = logging.Formatter('%(asctime)s - %(process)d - %(levelname)s - %(message)s')
     try:
         os.makedirs(logdir)
-    except:
+    except OSError:
         pass
     fh = logging.FileHandler(os.path.join(logdir, 'run_test.log'))
     fh.setLevel(logging.DEBUG)
@@ -39,15 +38,15 @@ def init_logging(loglevel, logdir):
 
 
 class LogParser:
-    def __init__(self, basedir, name, infile, out, aggregationPolicy, symbolicateBacktraces):
+    def __init__(self, basedir, name, infile, out, aggregation_policy, symbolicate_backtraces):
         self.basedir = basedir
         self.name = name
         self.infile = infile
         self.backtraces = []
         self.result = True
         self.address_re = re.compile(r'(0x[0-9a-f]+\s+)+')
-        self.aggregationPolicy = aggregationPolicy
-        self.symbolicateBacktraces = symbolicateBacktraces
+        self.aggregationPolicy = aggregation_policy
+        self.symbolicateBacktraces = symbolicate_backtraces
         self.outStream = None
         if self.aggregationPolicy == 'NONE':
             self.out = None
@@ -71,24 +70,23 @@ class LogParser:
             self.out.write(self.outStream.getvalue())
             self.outStream = None
 
-    def writeHeader(self):
+    def write_header(self):
         pass
 
-    def writeFooter(self):
+    def write_footer(self):
         pass
 
-    def applyAddr2line(self, obj):
-        addresses = self.sanitizeBacktrace(obj)
+    def apply_address_to_line(self, obj):
+        addresses = self.sanitize_backtrace(obj)
         assert addresses is not None
-        config = ''
-        binaryExt = ''
+        binary_ext = ''
         if sys.platform == 'win32':
-            #config = options.config
-            binaryExt = '.exe'
-        fdbbin = os.path.realpath(os.path.join(basedir, 'bin', 'Release', 'fdbserver' + binaryExt))
+            # config = options.config
+            binary_ext = '.exe'
+        fdbbin = os.path.realpath(os.path.join(basedir, 'bin', 'Release', 'fdbserver' + binary_ext))
         try:
             resolved = subprocess.check_output(
-                    ('addr2line -e %s -C -f -i' % fdbbin).split() + addresses.split()).splitlines()
+                ('addr2line -e %s -C -f -i' % fdbbin).split() + addresses.split()).splitlines()
             tmp = dict(**obj)
             for i, line in enumerate(resolved):
                 tmp['line%04d' % i] = line.decode('utf-8')
@@ -97,8 +95,7 @@ class LogParser:
             obj['FailedAddr2LineResolution'] = 'true'
             return obj
 
-
-    def sanitizeBacktrace(self, obj):
+    def sanitize_backtrace(self, obj):
         if sys.platform != "linux" and sys.platform != "linux2":
             return None
         raw_backtrace = obj.get('Backtrace', None)
@@ -109,7 +106,7 @@ class LogParser:
             return None
         return match.group(0)
 
-    def processTraces(self):
+    def process_traces(self):
         linenr = 0
         with open(self.infile) as f:
             line = f.readline()
@@ -125,8 +122,8 @@ class LogParser:
                     self.fail()
                 if self.name is not None:
                     obj['testname'] = self.name
-                if self.symbolicateBacktraces and self.sanitizeBacktrace(obj) is not None:
-                    obj = self.applyAddr2line(obj)
+                if self.symbolicateBacktraces and self.sanitize_backtrace(obj) is not None:
+                    obj = self.apply_address_to_line(obj)
                 self.writeObject(obj)
 
     def log_trace_parse_error(self, linenr, e):
@@ -141,7 +138,7 @@ class LogParser:
         obj['File'] = self.infile
         return obj
 
-    def processReturnCodes(self, return_codes):
+    def process_return_codes(self, return_codes):
         for (command, return_code) in return_codes.items():
             return_code_trace = {}
             if return_code != 0:
@@ -157,26 +154,25 @@ class LogParser:
             self.writeObject(return_code_trace)
 
 
-
 class JSONParser(LogParser):
-    def __init__(self, basedir, name, infile, out, aggregationPolicy, symbolicateBacktraces):
-        super().__init__(basedir, name, infile, out, aggregationPolicy, symbolicateBacktraces)
+    def __init__(self, basedir, name, infile, out, aggregation_policy, symbolicate_backtraces):
+        super().__init__(basedir, name, infile, out, aggregation_policy, symbolicate_backtraces)
 
-    def processLine(self, line, linenr):
+    def process_line(self, line, linenr):
         try:
             return json.loads(line)
         except Exception as e:
             self.log_trace_parse_error(linenr, e)
 
-    def writeObject(self, obj):
+    def write_object(self, obj):
         self.write(json.dumps(obj))
         self.write('\n')
 
 
 class XMLParser(LogParser):
-
     class XMLHandler(xml.sax.handler.ContentHandler):
         def __init__(self):
+            super().__init__()
             self.result = {}
 
         def startElement(self, name, attrs):
@@ -200,22 +196,22 @@ class XMLParser(LogParser):
         def warning(self, exception):
             self.warnings.append(exception)
 
-    def __init__(self, basedir, name, infile, out, aggregationPolicy, symbolicateBacktraces):
-        super().__init__(basedir, name, infile, out, aggregationPolicy, symbolicateBacktraces)
+    def __init__(self, basedir, name, infile, out, aggregation_policy, symbolicate_backtraces):
+        super().__init__(basedir, name, infile, out, aggregation_policy, symbolicate_backtraces)
 
-    def writeHeader(self):
+    def write_header(self):
         self.write('<?xml version="1.0"?>\n<Trace>\n')
 
-    def writeFooter(self):
+    def write_footer(self):
         self.write("</Trace>")
 
-    def writeObject(self, obj):
+    def write_object(self, obj):
         self.write('<Event')
         for (key, value) in obj.items():
             self.write(' {}="{}"'.format(key, value))
         self.write('/>\n')
 
-    def processLine(self, line, linenr):
+    def process_line(self, line, linenr):
         if linenr < 3:
             # the first two lines don't need to be parsed
             return None
@@ -223,10 +219,10 @@ class XMLParser(LogParser):
             # don't parse the closing element
             return None
         handler = XMLParser.XMLHandler()
-        errorHandler = XMLParser.XMLErrorHandler()
-        xml.sax.parseString(line.encode('utf-8'), handler, errorHandler=errorHandler)
-        if len(errorHandler.fatalErrors) > 0:
-            return self.log_trace_parse_error(linenr, errorHandler.fatalErrors[0])
+        error_handler = XMLParser.XMLErrorHandler()
+        xml.sax.parseString(line.encode('utf-8'), handler, errorHandler=error_handler)
+        if len(error_handler.fatalErrors) > 0:
+            return self.log_trace_parse_error(linenr, error_handler.fatalErrors[0])
         return handler.result
 
 
@@ -246,28 +242,30 @@ def get_traces(d, log_format):
     return traces
 
 
-def process_traces(basedir, testname, path, out, aggregationPolicy, symbolicateBacktraces, log_format, return_codes, cmake_seed):
+def process_traces(basedir, testname, path, out, aggregation_policy, symbolicate_backtraces, log_format, return_codes,
+                   cmake_seed):
     res = True
     backtraces = []
     parser = None
     if log_format == 'json':
-        parser = JSONParser(basedir, testname, None, out, aggregationPolicy, symbolicateBacktraces)
+        parser = JSONParser(basedir, testname, None, out, aggregation_policy, symbolicate_backtraces)
     else:
-        parser = XMLParser(basedir, testname, None, out, aggregationPolicy, symbolicateBacktraces)
-    parser.processReturnCodes(return_codes)
+        parser = XMLParser(basedir, testname, None, out, aggregation_policy, symbolicate_backtraces)
+    parser.process_return_codes(return_codes)
     res = parser.result
     for trace in get_traces(path, log_format):
         if log_format == 'json':
-            parser = JSONParser(basedir, testname, trace, out, aggregationPolicy, symbolicateBacktraces)
+            parser = JSONParser(basedir, testname, trace, out, aggregation_policy, symbolicate_backtraces)
         else:
-            parser = XMLParser(basedir, testname, trace, out, aggregationPolicy, symbolicateBacktraces)
+            parser = XMLParser(basedir, testname, trace, out, aggregation_policy, symbolicate_backtraces)
         if not res:
             parser.fail()
-        parser.processTraces()
+        parser.process_traces()
         res = res and parser.result
-    parser.writeObject({'CMakeSEED': str(cmake_seed)})
+    parser.write_object({'CMakeSEED': str(cmake_seed)})
     return res
 
+
 class RestartTestPolicy:
     def __init__(self, name, old_binary, new_binary):
         # Default is to use the same binary for the restart test, unless constraints are satisfied.
@@ -280,7 +278,7 @@ class RestartTestPolicy:
         assert match, old_binary_version_raw
         old_binary_version = tuple(map(int, match.group(1).split('.')))
         match = re.match('.*/restarting/from_([0-9]+\.[0-9]+\.[0-9]+)/', name)
-        if match: # upgrading _from_
+        if match:  # upgrading _from_
             lower_bound = tuple(map(int, match.group(1).split('.')))
             if old_binary_version >= lower_bound:
                 self._first_binary = old_binary
@@ -288,7 +286,7 @@ class RestartTestPolicy:
             else:
                 _logger.info("Using new binary as first binary: {} < {}".format(old_binary_version, lower_bound))
         match = re.match('.*/restarting/to_([0-9]+\.[0-9]+\.[0-9]+)/', name)
-        if match: # downgrading _to_
+        if match:  # downgrading _to_
             lower_bound = tuple(map(int, match.group(1).split('.')))
             if old_binary_version >= lower_bound:
                 self._second_binary = old_binary
@@ -302,13 +300,14 @@ class RestartTestPolicy:
     def second_binary(self):
         return self._second_binary
 
+
 def run_simulation_test(basedir, options):
     config = ''
-    binaryExt = ''
+    binary_ext = ''
     if sys.platform == 'win32':
         config = options.config
-        binaryExt = '.exe'
-    fdbserver = os.path.realpath(os.path.join(basedir, 'bin', config, 'fdbserver' + binaryExt))
+        binary_ext = '.exe'
+    fdbserver = os.path.realpath(os.path.join(basedir, 'bin', config, 'fdbserver' + binary_ext))
     pargs = [fdbserver,
              '-r', options.testtype]
     seed = 0
@@ -317,7 +316,7 @@ def run_simulation_test(basedir, options):
         seed = int(options.seed, 0)
         if options.test_number:
             idx = int(options.test_number)
-            seed = ((seed + idx) % (2**32-2)) + 1
+            seed = ((seed + idx) % (2 ** 32 - 2)) + 1
         pargs.append("{}".format(seed))
     if options.testtype == 'test':
         pargs.append('-C')
@@ -337,11 +336,11 @@ def run_simulation_test(basedir, options):
         seed = int(options.seed, 0)
         if options.test_number:
             idx = int(options.test_number)
-            seed = ((seed + idx) % (2**32-2)) + 1
+            seed = ((seed + idx) % (2 ** 32 - 2)) + 1
     wd = os.path.join(test_dir,
                       'test_{}'.format(options.name.replace('/', '_')))
     os.mkdir(wd)
-    return_codes = {} # {command: return_code}
+    return_codes = {}  # {command: return_code}
     first = True
     restart_test_policy = None
     if len(options.testfile) > 1:
@@ -360,7 +359,7 @@ def run_simulation_test(basedir, options):
         if not first:
             tmp.append('-R')
             if seed is not None:
-                seed = ((seed + 1) % (2**32-2))
+                seed = ((seed + 1) % (2 ** 32 - 2))
         first = False
         if seed is not None:
             tmp.append('-s')
@@ -392,7 +391,7 @@ def run_simulation_test(basedir, options):
                                      options.log_format, return_codes, options.seed)
                 f.seek(pos)
                 os.lockf(f.fileno(), os.F_ULOCK, 0)
-        if proc.returncode != 0 or res == False:
+        if proc.returncode != 0 or not res:
             break
     if options.keep_logs == 'NONE' or options.keep_logs == 'FAILED' and res:
         print("Deleting old logs in {}".format(wd))
diff --git a/tests/TestRunner/local_cluster.py b/tests/TestRunner/local_cluster.py
index 2e56457770..d2874c46d4 100644
--- a/tests/TestRunner/local_cluster.py
+++ b/tests/TestRunner/local_cluster.py
@@ -35,8 +35,8 @@ def is_port_in_use(port):
 valid_letters_for_secret = string.ascii_letters + string.digits
 
 
-def random_secret_string(len):
-    return ''.join(random.choice(valid_letters_for_secret) for i in range(len))
+def random_secret_string(length):
+    return ''.join(random.choice(valid_letters_for_secret) for _ in range(length))
 
 
 class LocalCluster:
@@ -100,7 +100,7 @@ logdir = {logdir}
         self.process_number = process_number
         self.ip_address = '127.0.0.1' if ip_address is None else ip_address
         self.first_port = port
-        if (self.first_port is not None):
+        if self.first_port is not None:
             self.last_used_port = int(self.first_port)-1
         self.server_ports = [self.__next_port()
                              for _ in range(self.process_number)]
@@ -116,7 +116,7 @@ logdir = {logdir}
             self.save_config()
 
     def __next_port(self):
-        if (self.first_port is None):
+        if self.first_port is None:
             return get_free_port()
         else:
             self.last_used_port += 1
@@ -126,7 +126,7 @@ logdir = {logdir}
         new_conf_file = self.conf_file.parent / (self.conf_file.name + '.new')
         with open(new_conf_file, 'x') as f:
             conf_template = LocalCluster.configuration_template
-            if (self.use_legacy_conf_syntax):
+            if self.use_legacy_conf_syntax:
                 conf_template = conf_template.replace("-", "_")
             f.write(conf_template.format(
                 etcdir=self.etc,
@@ -178,7 +178,7 @@ logdir = {logdir}
 
     def ensure_ports_released(self, timeout_sec=5):
         sec = 0
-        while (sec < timeout_sec):
+        while sec < timeout_sec:
             in_use = False
             for port in self.server_ports:
                 if is_port_in_use(port):
@@ -200,7 +200,7 @@ logdir = {logdir}
 
     def create_database(self, storage='ssd', enable_tenants=True):
         db_config = 'configure new single {}'.format(storage)
-        if (enable_tenants):
+        if enable_tenants:
             db_config += " tenant_mode=optional_experimental"
         args = [self.fdbcli_binary, '-C',
                 self.cluster_file, '--exec', db_config]
diff --git a/tests/TestRunner/tmp_cluster.py b/tests/TestRunner/tmp_cluster.py
index faa221f6da..00114048e2 100755
--- a/tests/TestRunner/tmp_cluster.py
+++ b/tests/TestRunner/tmp_cluster.py
@@ -124,9 +124,11 @@ if __name__ == "__main__":
         )
 
         for line in sev40s:
-            # When running ASAN we expect to see this message. Boost coroutine should be using the correct asan annotations so that it shouldn't produce any false positives.
+            # When running ASAN we expect to see this message. Boost coroutine should be using the correct asan
+            # annotations so that it shouldn't produce any false positives.
             if line.endswith(
-                "WARNING: ASan doesn't fully support makecontext/swapcontext functions and may produce false positives in some cases!"
+                "WARNING: ASan doesn't fully support makecontext/swapcontext functions and may produce false "
+                "positives in some cases! "
             ):
                 continue
             print(">>>>>>>>>>>>>>>>>>>> Found severity 40 events - the test fails")
diff --git a/tests/TestRunner/tmp_multi_cluster.py b/tests/TestRunner/tmp_multi_cluster.py
index 2edcef29de..5e5bc0beae 100644
--- a/tests/TestRunner/tmp_multi_cluster.py
+++ b/tests/TestRunner/tmp_multi_cluster.py
@@ -23,14 +23,12 @@
 import os
 import subprocess
 import sys
-import shutil
 from pathlib import Path
 from argparse import ArgumentParser, RawDescriptionHelpFormatter
 from tmp_cluster import TempCluster
 
-
 if __name__ == '__main__':
-	parser = ArgumentParser(formatter_class=RawDescriptionHelpFormatter,description="""
+    parser = ArgumentParser(formatter_class=RawDescriptionHelpFormatter, description="""
 	This script automatically configures N temporary local clusters on the machine and then
 	calls a command while these clusters are running. As soon as the command returns, all
 	configured clusters are killed and all generated data is deleted.
@@ -38,38 +36,38 @@ if __name__ == '__main__':
 	The purpose of this is to support testing a set of integration tests using multiple clusters
 	(i.e. using the Multi-threaded client). 
 	""")
-	parser.add_argument('--build-dir','-b',metavar='BUILD_DIRECTORY',help='FDB build director',required=True)
-	parser.add_argument('--clusters','-c',metavar='NUM_CLUSTERS',type=int,help='The number of clusters to run',required=True)
-	parser.add_argument('cmd', metavar='COMMAND',nargs='+',help='The command to run')
-	args = parser.parse_args()
-	errcode = 1
+    parser.add_argument('--build-dir', '-b', metavar='BUILD_DIRECTORY', help='FDB build director', required=True)
+    parser.add_argument('--clusters', '-c', metavar='NUM_CLUSTERS', type=int, help='The number of clusters to run',
+                        required=True)
+    parser.add_argument('cmd', metavar='COMMAND', nargs='+', help='The command to run')
+    args = parser.parse_args()
+    errcode = 1
 
-	#spawn all the clusters
-	base_dir = args.build_dir
-	num_clusters = args.clusters
+    # spawn all the clusters
+    base_dir = args.build_dir
+    num_clusters = args.clusters
 
-	build_dir=Path(base_dir)
-	bin_dir=build_dir.joinpath('bin')
+    build_dir = Path(base_dir)
+    bin_dir = build_dir.joinpath('bin')
 
-	clusters = []
-	for c in range(1,num_clusters+1):
-		# now start the cluster up
-		local_c = TempCluster(args.build_dir, port="{}501".format(c))
+    clusters = []
+    for c in range(1, num_clusters + 1):
+        # now start the cluster up
+        local_c = TempCluster(args.build_dir, port="{}501".format(c))
 
-		local_c.__enter__()
-		clusters.append(local_c) 
-	
-	# all clusters should be running now, so run the subcommand
-	# TODO (bfines): pass through the proper ENV commands so that the client can find everything
-	cluster_paths = ';'.join([str(cluster.etc.joinpath('fdb.cluster')) for cluster in clusters])
-	print(cluster_paths)
-	env = dict(**os.environ)
-	env['FDB_CLUSTERS'] = env.get('FDB_CLUSTERS',cluster_paths)
-	errcode = subprocess.run(args.cmd,stdout=sys.stdout,stderr=sys.stderr,env=env).returncode
+        local_c.__enter__()
+        clusters.append(local_c)
 
-	# shutdown all the running clusters
-	for tc in clusters:
-		tc.close()
+    # all clusters should be running now, so run the subcommand
+    # TODO (bfines): pass through the proper ENV commands so that the client can find everything
+    cluster_paths = ';'.join([str(cluster.etc.joinpath('fdb.cluster')) for cluster in clusters])
+    print(cluster_paths)
+    env = dict(**os.environ)
+    env['FDB_CLUSTERS'] = env.get('FDB_CLUSTERS', cluster_paths)
+    errcode = subprocess.run(args.cmd, stdout=sys.stdout, stderr=sys.stderr, env=env).returncode
 
-	sys.exit(errcode)
-	
\ No newline at end of file
+    # shutdown all the running clusters
+    for tc in clusters:
+        tc.close()
+
+    sys.exit(errcode)
diff --git a/tests/TestRunner/upgrade_test.py b/tests/TestRunner/upgrade_test.py
index 2f63fb8a51..d11086f389 100755
--- a/tests/TestRunner/upgrade_test.py
+++ b/tests/TestRunner/upgrade_test.py
@@ -17,7 +17,6 @@ from urllib import request
 
 from local_cluster import LocalCluster, random_secret_string
 
-
 SUPPORTED_PLATFORMS = ["x86_64"]
 SUPPORTED_VERSIONS = ["7.2.0", "7.1.1", "7.1.0", "7.0.0", "6.3.24", "6.3.23",
                       "6.3.22", "6.3.18", "6.3.17", "6.3.16", "6.3.15", "6.3.13", "6.3.12", "6.3.9", "6.2.30",
@@ -53,17 +52,17 @@ def version_from_str(ver_str):
 
 def api_version_from_str(ver_str):
     ver_tuple = version_from_str(ver_str)
-    return ver_tuple[0]*100+ver_tuple[1]*10
+    return ver_tuple[0] * 100 + ver_tuple[1] * 10
 
 
 def version_before(ver_str1, ver_str2):
     return version_from_str(ver_str1) < version_from_str(ver_str2)
 
 
-def random_sleep(minSec, maxSec):
-    timeSec = random.uniform(minSec, maxSec)
-    print("Sleeping for {0:.3f}s".format(timeSec))
-    time.sleep(timeSec)
+def random_sleep(min_sec, max_sec):
+    time_sec = random.uniform(min_sec, max_sec)
+    print("Sleeping for {0:.3f}s".format(time_sec))
+    time.sleep(time_sec)
 
 
 class UpgradeTest:
@@ -111,6 +110,13 @@ class UpgradeTest:
         os.mkfifo(self.input_pipe_path)
         os.mkfifo(self.output_pipe_path)
         self.progress_event = Event()
+        self.external_lib_dir = None
+        self.cluster_version = None
+        self.api_version = None
+        self.tester_retcode = None
+        self.tester_proc = None
+        self.output_pipe = None
+        self.tester_bin = None
 
     def binary_path(self, version, bin_name):
         if version == CURRENT_VERSION:
@@ -125,9 +131,9 @@ class UpgradeTest:
             return self.download_dir.joinpath(version)
 
     # Download an old binary of a given version from a remote repository
-    def download_old_binary(self, version, target_bin_name, remote_bin_name, makeExecutable):
+    def download_old_binary(self, version, target_bin_name, remote_bin_name, make_executable):
         local_file = self.binary_path(version, target_bin_name)
-        if (local_file.exists()):
+        if local_file.exists():
             return
         self.download_dir.joinpath(version).mkdir(
             parents=True, exist_ok=True)
@@ -137,7 +143,7 @@ class UpgradeTest:
         request.urlretrieve(remote_file, local_file)
         print("Download complete")
         assert local_file.exists(), "{} does not exist".format(local_file)
-        if makeExecutable:
+        if make_executable:
             make_executable(local_file)
 
     # Download all old binaries required for testing the specified upgrade path
@@ -173,12 +179,12 @@ class UpgradeTest:
         while retries < timeout_sec:
             retries += 1
             status = self.cluster.get_status()
-            if not "processes" in status["cluster"]:
+            if "processes" not in status["cluster"]:
                 print("Health check: no processes found. Retrying")
                 time.sleep(1)
                 continue
             num_proc = len(status["cluster"]["processes"])
-            if (num_proc < self.cluster.process_number):
+            if num_proc < self.cluster.process_number:
                 print("Health check: {} of {} processes found. Retrying".format(
                     num_proc, self.cluster.process_number))
                 time.sleep(1)
@@ -200,7 +206,7 @@ class UpgradeTest:
         self.cluster.fdbserver_binary = self.binary_path(version, "fdbserver")
         self.cluster.fdbcli_binary = self.binary_path(version, "fdbcli")
         self.cluster.set_env_var = "LD_LIBRARY_PATH", self.lib_dir(version)
-        if (version_before(version, "7.1.0")):
+        if version_before(version, "7.1.0"):
             self.cluster.use_legacy_conf_syntax = True
         self.cluster.save_config()
         self.cluster_version = version
@@ -224,7 +230,7 @@ class UpgradeTest:
         self.cluster.stop_cluster()
         shutil.rmtree(self.tmp_dir)
 
-     # Determine FDB API version matching the upgrade path
+    # Determine FDB API version matching the upgrade path
     def determine_api_version(self):
         self.api_version = api_version_from_str(CURRENT_VERSION)
         for version in self.upgrade_path:
@@ -247,7 +253,7 @@ class UpgradeTest:
                         '--log',
                         '--log-dir', self.log,
                         '--transaction-retry-limit', str(TRANSACTION_RETRY_LIMIT)]
-            if (RUN_WITH_GDB):
+            if RUN_WITH_GDB:
                 cmd_args = ['gdb', '-ex', 'run', '--args'] + cmd_args
             print("Executing test command: {}".format(
                 " ".join([str(c) for c in cmd_args])))
@@ -257,7 +263,7 @@ class UpgradeTest:
             self.tester_retcode = self.tester_proc.wait()
             self.tester_proc = None
 
-            if (self.tester_retcode != 0):
+            if self.tester_retcode != 0:
                 print("Tester failed with return code {}".format(
                     self.tester_retcode))
         except Exception:
@@ -271,7 +277,7 @@ class UpgradeTest:
         os.write(ctrl_pipe, b"CHECK\n")
         self.progress_event.wait(
             None if RUN_WITH_GDB else PROGRESS_CHECK_TIMEOUT_SEC)
-        if (self.progress_event.is_set()):
+        if self.progress_event.is_set():
             print("Progress check: OK")
         else:
             assert False, "Progress check failed after upgrade to version {}".format(
@@ -286,7 +292,7 @@ class UpgradeTest:
             for line in self.output_pipe:
                 msg = line.strip()
                 print("Received {}".format(msg))
-                if (msg == "CHECK_OK"):
+                if msg == "CHECK_OK":
                     self.progress_event.set()
             self.output_pipe.close()
         except Exception as e:
@@ -319,7 +325,7 @@ class UpgradeTest:
                 print("Killing the tester process")
                 self.tester_proc.kill()
                 workload_thread.join(5)
-            except:
+            except Exception:
                 print("Failed to kill the tester process")
 
     # The main method implementing the test:
@@ -380,10 +386,11 @@ class UpgradeTest:
             # When running ASAN we expect to see this message. Boost coroutine should be using the
             # correct asan annotations so that it shouldn't produce any false positives.
             if line.endswith(
-                "WARNING: ASan doesn't fully support makecontext/swapcontext functions and may produce false positives in some cases!"
+                    "WARNING: ASan doesn't fully support makecontext/swapcontext functions and may produce false "
+                    "positives in some cases! "
             ):
                 continue
-            if (err_cnt < error_limit):
+            if err_cnt < error_limit:
                 print(line)
             err_cnt += 1
 
@@ -405,7 +412,7 @@ class UpgradeTest:
             .splitlines()
         )
 
-        if (len(sev30s) == 0):
+        if len(sev30s) == 0:
             print("No warnings found in logs")
         else:
             print(">>>>>>>>>>>>>>>>>>>> Found {} severity 30 events (warnings):".format(
@@ -471,11 +478,11 @@ if __name__ == "__main__":
         action="store_true"
     )
     args = parser.parse_args()
-    if (args.process_number == 0):
+    if args.process_number == 0:
         args.process_number = random.randint(1, 5)
         print("Testing with {} processes".format(args.process_number))
 
-    if (args.run_with_gdb):
+    if args.run_with_gdb:
         RUN_WITH_GDB = True
 
     errcode = 1

From 3205fe8ca4be818d1d73a244b79041ed3bde1817 Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Fri, 22 Apr 2022 22:27:53 +0200
Subject: [PATCH 42/84] Fix key selector handling

Also match selectors for OP_(S)GETRANGE
Add Transaction::getKey()
---
 bindings/c/test/fdb_api.hpp         | 111 +++++++++++++++-------------
 bindings/c/test/mako/operations.cpp |  32 ++++----
 2 files changed, 76 insertions(+), 67 deletions(-)

diff --git a/bindings/c/test/fdb_api.hpp b/bindings/c/test/fdb_api.hpp
index 9fc30b76d0..eee213a139 100644
--- a/bindings/c/test/fdb_api.hpp
+++ b/bindings/c/test/fdb_api.hpp
@@ -26,6 +26,14 @@
 #define FDB_API_VERSION 720
 #endif
 
+#if defined(__GNUG__)
+#define force_inline inline __attribute__((__always_inline__))
+#elif defined(_MSC_VER)
+#define force_inline __forceinline
+#else
+#error Missing force inline
+#endif
+
 #include <cassert>
 #include <cstdint>
 #include <memory>
@@ -359,15 +367,39 @@ public:
 	}
 };
 
+struct KeySelector {
+	const uint8_t* key;
+	int keyLength;
+	bool orEqual;
+	int offset;
+};
+
 namespace key_select {
 
-struct Inclusive {
-	static constexpr const bool value = true;
-};
+inline KeySelector firstGreaterThan(KeyRef key, int offset=0) {
+	return KeySelector{
+		FDB_KEYSEL_FIRST_GREATER_THAN(key.data(), intSize(key)) + offset
+	};
+}
+
+inline KeySelector firstGreaterOrEqual(KeyRef key, int offset=0) {
+	return KeySelector{
+		FDB_KEYSEL_FIRST_GREATER_OR_EQUAL(key.data(), intSize(key)) + offset
+	};
+}
+
+inline KeySelector lastLessThan(KeyRef key, int offset=0) {
+	return KeySelector{
+		FDB_KEYSEL_LAST_LESS_THAN(key.data(), intSize(key)) + offset
+	};
+}
+
+inline KeySelector lastLessOrEqual(KeyRef key, int offset=0) {
+	return KeySelector{
+		FDB_KEYSEL_LAST_LESS_OR_EQUAL(key.data(), intSize(key)) + offset
+	};
+}
 
-struct Exclusive {
-	static constexpr const bool value = false;
-};
 } // namespace key_select
 
 class Transaction {
@@ -428,62 +460,39 @@ public:
 		return out;
 	}
 
+	TypedFuture<future_var::Key> getKey(KeySelector sel, bool snapshot) {
+		return native::fdb_transaction_get_key(tr.get(), sel.key, sel.keyLength, sel.orEqual, sel.offset, snapshot);
+	}
+
 	TypedFuture<future_var::Value> get(KeyRef key, bool snapshot) {
 		return native::fdb_transaction_get(tr.get(), key.data(), intSize(key), snapshot);
 	}
 
-	// Usage: tx.getRange<key_select::Inclusive, key_select::Exclusive>(begin, end, ...);
+	// Usage: tx.getRange(key_select::firstGreaterOrEqual(firstKey), key_select::lastLessThan(lastKey), ...)
 	// gets key-value pairs in key range [begin, end)
-	template <class FirstInclusive, class LastInclusive>
-	TypedFuture<future_var::KeyValueArray> getRange(KeyRef begin,
-	                                                KeyRef end,
+	TypedFuture<future_var::KeyValueArray> getRange(KeySelector first,
+	                                                KeySelector last,
 	                                                int limit,
 	                                                int target_bytes,
 	                                                FDBStreamingMode mode,
 	                                                int iteration,
 	                                                bool snapshot,
 	                                                bool reverse) {
-		if constexpr (FirstInclusive::value && LastInclusive::value) {
-			return native::fdb_transaction_get_range(tr.get(),
-			                                         FDB_KEYSEL_FIRST_GREATER_OR_EQUAL(begin.data(), intSize(begin)),
-			                                         FDB_KEYSEL_LAST_LESS_OR_EQUAL(end.data(), intSize(end)),
-			                                         limit,
-			                                         target_bytes,
-			                                         mode,
-			                                         iteration,
-			                                         snapshot,
-			                                         reverse);
-		} else if constexpr (FirstInclusive::value && !LastInclusive::value) {
-			return native::fdb_transaction_get_range(tr.get(),
-			                                         FDB_KEYSEL_FIRST_GREATER_OR_EQUAL(begin.data(), intSize(begin)),
-			                                         FDB_KEYSEL_LAST_LESS_THAN(end.data(), intSize(end)),
-			                                         limit,
-			                                         target_bytes,
-			                                         mode,
-			                                         iteration,
-			                                         snapshot,
-			                                         reverse);
-		} else if constexpr (!FirstInclusive::value && LastInclusive::value) {
-			return native::fdb_transaction_get_range(tr.get(),
-			                                         FDB_KEYSEL_FIRST_GREATER_THAN(begin.data(), intSize(begin)),
-			                                         FDB_KEYSEL_LAST_LESS_OR_EQUAL(end.data(), intSize(end)),
-			                                         limit,
-			                                         target_bytes,
-			                                         mode,
-			                                         iteration,
-			                                         snapshot,
-			                                         reverse);
-		} else {
-			return native::fdb_transaction_get_range(tr.get(),
-			                                         FDB_KEYSEL_FIRST_GREATER_THAN(begin.data(), intSize(begin)),
-			                                         FDB_KEYSEL_LAST_LESS_THAN(end.data(), intSize(end)),
-			                                         limit,
-			                                         target_bytes,
-			                                         mode,
-			                                         iteration,
-			                                         snapshot,
-			                                         reverse);
-		}
+		return native::fdb_transaction_get_range(tr.get(),
+												 first.key,
+												 first.keyLength,
+												 first.orEqual,
+												 first.offset,
+												 last.key,
+												 last.keyLength,
+												 last.orEqual,
+												 last.offset,
+												 limit,
+												 target_bytes,
+												 mode,
+												 iteration,
+												 snapshot,
+												 reverse);
 	}
 
 	Result readBlobGranules(KeyRef begin,
diff --git a/bindings/c/test/mako/operations.cpp b/bindings/c/test/mako/operations.cpp
index 02c0d2ea8e..e75533a7c7 100644
--- a/bindings/c/test/mako/operations.cpp
+++ b/bindings/c/test/mako/operations.cpp
@@ -60,14 +60,14 @@ const std::array<Operation, MAX_OP> opTable{
 	    { { StepKind::READ,
 	        [](Transaction& tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
 	            return tx
-	                .getRange<key_select::Inclusive, key_select::Inclusive>(begin,
-	                                                                        end,
-	                                                                        0 /*limit*/,
-	                                                                        0 /*target_bytes*/,
-	                                                                        args.streaming_mode,
-	                                                                        0 /*iteration*/,
-	                                                                        false /*snapshot*/,
-	                                                                        args.txnspec.ops[OP_GETRANGE][OP_REVERSE])
+	                .getRange(key_select::firstGreaterOrEqual(begin),
+	                          key_select::lastLessOrEqual(end, 1),
+	                          0 /*limit*/,
+	                          0 /*target_bytes*/,
+	                          args.streaming_mode,
+	                          0 /*iteration*/,
+	                          false /*snapshot*/,
+	                          args.txnspec.ops[OP_GETRANGE][OP_REVERSE])
 	                .eraseType();
 	        },
 	        [](Future& f, Transaction&, Arguments const&, ByteString&, ByteString&, ByteString& val) {
@@ -95,14 +95,14 @@ const std::array<Operation, MAX_OP> opTable{
 	        StepKind::READ,
 	        [](Transaction& tx, Arguments const& args, ByteString& begin, ByteString& end, ByteString&) {
 	            return tx
-	                .getRange<key_select::Inclusive, key_select::Inclusive>(begin,
-	                                                                        end,
-	                                                                        0 /*limit*/,
-	                                                                        0 /*target_bytes*/,
-	                                                                        args.streaming_mode,
-	                                                                        0 /*iteration*/,
-	                                                                        true /*snapshot*/,
-	                                                                        args.txnspec.ops[OP_SGETRANGE][OP_REVERSE])
+	                .getRange(key_select::firstGreaterOrEqual(begin),
+	                          key_select::lastLessOrEqual(end, 1),
+	                          0 /*limit*/,
+	                          0 /*target_bytes*/,
+	                          args.streaming_mode,
+	                          0 /*iteration*/,
+	                          false /*snapshot*/,
+	                          args.txnspec.ops[OP_GETRANGE][OP_REVERSE])
 	                .eraseType();
 	        },
 	        [](Future& f, Transaction&, Arguments const&, ByteString&, ByteString&, ByteString& val) {

From 6224ea834b611da32f73ce3001eb97706078ca95 Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Mon, 25 Apr 2022 10:44:20 +0200
Subject: [PATCH 43/84] Emulate mako.c's commit behavior during populate()

---
 bindings/c/test/mako/mako.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bindings/c/test/mako/mako.cpp b/bindings/c/test/mako/mako.cpp
index b4dbe396f1..9583ac69d6 100644
--- a/bindings/c/test/mako/mako.cpp
+++ b/bindings/c/test/mako/mako.cpp
@@ -184,7 +184,7 @@ int populate(Transaction tx,
 		stats.incrOpCount(OP_INSERT);
 
 		/* commit every 100 inserts (default) or if this is the last key */
-		if (i == key_end || (i - key_begin + 1) % num_commit_every == 0) {
+		if ((i % num_commit_every == 0) || i == key_end) {
 			const auto do_sample = (stats.getOpCount(OP_TRANSACTION) % args.sampling) == 0;
 			auto watch_commit = Stopwatch(StartAtCtor{});
 			auto future_commit = tx.commit();

From 3536cab73060841ad03e5c5dea4eeaf2b1d7200d Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Mon, 25 Apr 2022 10:48:11 +0200
Subject: [PATCH 44/84] Apply clang format

---
 bindings/c/test/fdb_api.hpp | 52 ++++++++++++++++---------------------
 1 file changed, 22 insertions(+), 30 deletions(-)

diff --git a/bindings/c/test/fdb_api.hpp b/bindings/c/test/fdb_api.hpp
index eee213a139..579c0cc19d 100644
--- a/bindings/c/test/fdb_api.hpp
+++ b/bindings/c/test/fdb_api.hpp
@@ -376,28 +376,20 @@ struct KeySelector {
 
 namespace key_select {
 
-inline KeySelector firstGreaterThan(KeyRef key, int offset=0) {
-	return KeySelector{
-		FDB_KEYSEL_FIRST_GREATER_THAN(key.data(), intSize(key)) + offset
-	};
+inline KeySelector firstGreaterThan(KeyRef key, int offset = 0) {
+	return KeySelector{ FDB_KEYSEL_FIRST_GREATER_THAN(key.data(), intSize(key)) + offset };
 }
 
-inline KeySelector firstGreaterOrEqual(KeyRef key, int offset=0) {
-	return KeySelector{
-		FDB_KEYSEL_FIRST_GREATER_OR_EQUAL(key.data(), intSize(key)) + offset
-	};
+inline KeySelector firstGreaterOrEqual(KeyRef key, int offset = 0) {
+	return KeySelector{ FDB_KEYSEL_FIRST_GREATER_OR_EQUAL(key.data(), intSize(key)) + offset };
 }
 
-inline KeySelector lastLessThan(KeyRef key, int offset=0) {
-	return KeySelector{
-		FDB_KEYSEL_LAST_LESS_THAN(key.data(), intSize(key)) + offset
-	};
+inline KeySelector lastLessThan(KeyRef key, int offset = 0) {
+	return KeySelector{ FDB_KEYSEL_LAST_LESS_THAN(key.data(), intSize(key)) + offset };
 }
 
-inline KeySelector lastLessOrEqual(KeyRef key, int offset=0) {
-	return KeySelector{
-		FDB_KEYSEL_LAST_LESS_OR_EQUAL(key.data(), intSize(key)) + offset
-	};
+inline KeySelector lastLessOrEqual(KeyRef key, int offset = 0) {
+	return KeySelector{ FDB_KEYSEL_LAST_LESS_OR_EQUAL(key.data(), intSize(key)) + offset };
 }
 
 } // namespace key_select
@@ -479,20 +471,20 @@ public:
 	                                                bool snapshot,
 	                                                bool reverse) {
 		return native::fdb_transaction_get_range(tr.get(),
-												 first.key,
-												 first.keyLength,
-												 first.orEqual,
-												 first.offset,
-												 last.key,
-												 last.keyLength,
-												 last.orEqual,
-												 last.offset,
-												 limit,
-												 target_bytes,
-												 mode,
-												 iteration,
-												 snapshot,
-												 reverse);
+		                                         first.key,
+		                                         first.keyLength,
+		                                         first.orEqual,
+		                                         first.offset,
+		                                         last.key,
+		                                         last.keyLength,
+		                                         last.orEqual,
+		                                         last.offset,
+		                                         limit,
+		                                         target_bytes,
+		                                         mode,
+		                                         iteration,
+		                                         snapshot,
+		                                         reverse);
 	}
 
 	Result readBlobGranules(KeyRef begin,

From c4ac1ab9d07ef48d8e63d697d2c670e5f2728143 Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Mon, 25 Apr 2022 13:24:56 +0200
Subject: [PATCH 45/84] Fix SGETRANGE

---
 bindings/c/test/mako/operations.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bindings/c/test/mako/operations.cpp b/bindings/c/test/mako/operations.cpp
index e75533a7c7..11fe9a58a4 100644
--- a/bindings/c/test/mako/operations.cpp
+++ b/bindings/c/test/mako/operations.cpp
@@ -101,7 +101,7 @@ const std::array<Operation, MAX_OP> opTable{
 	                          0 /*target_bytes*/,
 	                          args.streaming_mode,
 	                          0 /*iteration*/,
-	                          false /*snapshot*/,
+	                          true /*snapshot*/,
 	                          args.txnspec.ops[OP_GETRANGE][OP_REVERSE])
 	                .eraseType();
 	        },

From d431a9f11b4f86e69d93fdc1b9e5145d2a56838c Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Mon, 25 Apr 2022 13:53:05 +0200
Subject: [PATCH 46/84] Wrap platform-specific PATH_MAX header in another

---
 bindings/c/CMakeLists.txt              |  1 +
 bindings/c/test/mako/blob_granules.cpp |  1 +
 bindings/c/test/mako/limit.hpp         | 32 ++++++++++++++++++++++++++
 bindings/c/test/mako/mako.cpp          | 10 --------
 bindings/c/test/mako/mako.hpp          |  8 +------
 5 files changed, 35 insertions(+), 17 deletions(-)
 create mode 100644 bindings/c/test/mako/limit.hpp

diff --git a/bindings/c/CMakeLists.txt b/bindings/c/CMakeLists.txt
index 300b899914..293e6aa322 100644
--- a/bindings/c/CMakeLists.txt
+++ b/bindings/c/CMakeLists.txt
@@ -85,6 +85,7 @@ if(NOT WIN32)
     test/mako/blob_granules.hpp
     test/mako/blob_granules.cpp
     test/mako/future.hpp
+    test/mako/limit.hpp
     test/mako/logger.hpp
     test/mako/mako.cpp
     test/mako/mako.hpp
diff --git a/bindings/c/test/mako/blob_granules.cpp b/bindings/c/test/mako/blob_granules.cpp
index 750152e19c..af805f2e56 100644
--- a/bindings/c/test/mako/blob_granules.cpp
+++ b/bindings/c/test/mako/blob_granules.cpp
@@ -19,6 +19,7 @@
  */
 
 #include "blob_granules.hpp"
+#include "limit.hpp"
 #include "logger.hpp"
 #include <cstdio>
 #include <fdb_api.hpp>
diff --git a/bindings/c/test/mako/limit.hpp b/bindings/c/test/mako/limit.hpp
new file mode 100644
index 0000000000..b703cad247
--- /dev/null
+++ b/bindings/c/test/mako/limit.hpp
@@ -0,0 +1,32 @@
+/*
+ * limit.hpp
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2013-2022 Apple Inc. and the FoundationDB project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef LIMIT_HPP
+#define LIMIT_HPP
+
+#if defined(__linux__)
+#include <linux/limits.h>
+#elif defined(__APPLE__)
+#include <sys/syslimits.h>
+#else
+#include <limits.h>
+#endif
+
+#endif
diff --git a/bindings/c/test/mako/mako.cpp b/bindings/c/test/mako/mako.cpp
index 9583ac69d6..a1ee557377 100644
--- a/bindings/c/test/mako/mako.cpp
+++ b/bindings/c/test/mako/mako.cpp
@@ -39,16 +39,6 @@
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/stat.h>
-#if defined(__linux__)
-#include <linux/limits.h>
-#elif defined(__FreeBSD__)
-#include <sys/stat.h>
-#elif defined(__APPLE__)
-#include <sys/syslimits.h>
-#else
-#include <limits.h>
-#endif
-
 #include <boost/asio.hpp>
 #include <fmt/format.h>
 #include <fmt/printf.h>
diff --git a/bindings/c/test/mako/mako.hpp b/bindings/c/test/mako/mako.hpp
index daa296db83..f4a89e52c4 100644
--- a/bindings/c/test/mako/mako.hpp
+++ b/bindings/c/test/mako/mako.hpp
@@ -36,13 +36,7 @@
 #include <pthread.h>
 #include <sys/types.h>
 #include <stdbool.h>
-#if defined(__linux__)
-#include <linux/limits.h>
-#elif defined(__APPLE__)
-#include <sys/syslimits.h>
-#else
-#include <limits.h>
-#endif
+#include "limit.hpp"
 
 namespace mako {
 

From 81f9279db203bf1cc95232ac85eaa053f4c211ae Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Mon, 25 Apr 2022 15:02:10 +0200
Subject: [PATCH 47/84] Fix GCC error about memset-ing atomic vars

---
 bindings/c/test/mako/async.hpp |  1 +
 bindings/c/test/mako/mako.hpp  |  5 -----
 bindings/c/test/mako/shm.hpp   | 15 ++++++++++-----
 3 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/bindings/c/test/mako/async.hpp b/bindings/c/test/mako/async.hpp
index 8105ed72c1..643b31081f 100644
--- a/bindings/c/test/mako/async.hpp
+++ b/bindings/c/test/mako/async.hpp
@@ -26,6 +26,7 @@
 #include <boost/asio.hpp>
 #include "logger.hpp"
 #include "mako.hpp"
+#include "shm.hpp"
 #include "stats.hpp"
 #include "time.hpp"
 
diff --git a/bindings/c/test/mako/mako.hpp b/bindings/c/test/mako/mako.hpp
index f4a89e52c4..a2185d41f2 100644
--- a/bindings/c/test/mako/mako.hpp
+++ b/bindings/c/test/mako/mako.hpp
@@ -163,11 +163,6 @@ struct Arguments {
 	char bg_file_path[PATH_MAX];
 };
 
-/* shared memory */
-constexpr const int SIGNAL_RED = 0;
-constexpr const int SIGNAL_GREEN = 1;
-constexpr const int SIGNAL_OFF = 2;
-
 } // namespace mako
 
 #endif /* MAKO_HPP */
diff --git a/bindings/c/test/mako/shm.hpp b/bindings/c/test/mako/shm.hpp
index 67adde6f24..9d37ba38d7 100644
--- a/bindings/c/test/mako/shm.hpp
+++ b/bindings/c/test/mako/shm.hpp
@@ -26,14 +26,19 @@
 #include <cstdint>
 #include "stats.hpp"
 
+/* shared memory */
+constexpr const int SIGNAL_RED = 0;
+constexpr const int SIGNAL_GREEN = 1;
+constexpr const int SIGNAL_OFF = 2;
+
 // controlled, safer access to shared memory
 namespace mako::shared_memory {
 
 struct Header {
-	std::atomic<int> signal;
-	std::atomic<int> readycount;
-	std::atomic<double> throttle_factor;
-	std::atomic<int> stopcount;
+	std::atomic<int> signal = ATOMIC_VAR_INIT(SIGNAL_OFF);
+	std::atomic<int> readycount = ATOMIC_VAR_INIT(0);
+	std::atomic<double> throttle_factor = ATOMIC_VAR_INIT(1.0);
+	std::atomic<int> stopcount = ATOMIC_VAR_INIT(0);
 };
 
 struct LayoutHelper {
@@ -71,7 +76,7 @@ public:
 	size_t size() const noexcept { return storageSize(num_processes, num_threads); }
 
 	void initMemory() noexcept {
-		memset(&header(), 0, sizeof(Header));
+		new (&header()) Header{};
 		for (auto i = 0; i < num_processes; i++)
 			for (auto j = 0; j < num_threads; j++)
 				new (&statsSlot(i, j)) ThreadStatistics();

From 81211989f136ea6f038ec1459e74125fceb1acc4 Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Tue, 26 Apr 2022 10:54:39 +0200
Subject: [PATCH 48/84] Disable new sample collection after first bad_alloc

- Add more info to --async_xacts description
- Clean up unused macro in fdb_api.hpp
---
 bindings/c/test/fdb_api.hpp    |  8 --------
 bindings/c/test/mako/mako.rst  |  3 ++-
 bindings/c/test/mako/stats.hpp | 25 +++++++++++++++++++------
 3 files changed, 21 insertions(+), 15 deletions(-)

diff --git a/bindings/c/test/fdb_api.hpp b/bindings/c/test/fdb_api.hpp
index 579c0cc19d..590c4afdb7 100644
--- a/bindings/c/test/fdb_api.hpp
+++ b/bindings/c/test/fdb_api.hpp
@@ -26,14 +26,6 @@
 #define FDB_API_VERSION 720
 #endif
 
-#if defined(__GNUG__)
-#define force_inline inline __attribute__((__always_inline__))
-#elif defined(_MSC_VER)
-#define force_inline __forceinline
-#else
-#error Missing force inline
-#endif
-
 #include <cassert>
 #include <cstdint>
 #include <memory>
diff --git a/bindings/c/test/mako/mako.rst b/bindings/c/test/mako/mako.rst
index 5ca51279ef..4b3c3d7b26 100644
--- a/bindings/c/test/mako/mako.rst
+++ b/bindings/c/test/mako/mako.rst
@@ -58,7 +58,8 @@ Arguments
 
 - | ``--async_xacts <xacts>``
   | Number of transactions per worker process to run asynchronously (Default: 0)
-  | ``<xacts>`` > 0 switches the execution mode to non-blocking (See ``-t | --threads``)
+  | ``<xacts>`` > 0 switches the execution mode to non-blocking (See ``-t | --threads``), with the exception of blob granules API
+  | Note: throttling options, e.g. ``--tpsmax``, ``--tpsmin``, ``--tpschange``, ``--tpsinterval``, are ignored in asynchronous mode
 
 - | ``-r | --rows <rows>``
   | Number of rows initially populated (Default: 100000)
diff --git a/bindings/c/test/mako/stats.hpp b/bindings/c/test/mako/stats.hpp
index 5cea6707f3..6b68d1dba2 100644
--- a/bindings/c/test/mako/stats.hpp
+++ b/bindings/c/test/mako/stats.hpp
@@ -25,6 +25,7 @@
 #include <cstdint>
 #include <cstring>
 #include <list>
+#include <new>
 #include <utility>
 #include "operations.hpp"
 #include "time.hpp"
@@ -32,14 +33,14 @@
 namespace mako {
 
 /* size of each block to get detailed latency for each operation */
-constexpr const size_t LAT_BLOCK_SIZE = 4095;
+constexpr const size_t LAT_BLOCK_SIZE = 4093;
 
 /* memory block allocated to each operation when collecting detailed latency */
 class LatencySampleBlock {
 	uint64_t samples[LAT_BLOCK_SIZE]{
 		0,
 	};
-	uint32_t index{ 0 };
+	uint64_t index{ 0 };
 
 public:
 	LatencySampleBlock() noexcept = default;
@@ -52,19 +53,31 @@ public:
 	std::pair<uint64_t const*, size_t> data() const noexcept { return { samples, index }; }
 };
 
-/* collect sampled latencies */
+/* collect sampled latencies until OOM is hit */
 class LatencySampleBin {
 	std::list<LatencySampleBlock> blocks;
+	bool noMoreAlloc{false};
+
+	bool tryAlloc() {
+		try {
+			blocks.emplace_back();
+		} catch (const std::bad_alloc&) {
+			noMoreAlloc = true;
+			return false;
+		}
+		return true;
+	}
 
 public:
 	void reserveOneBlock() {
 		if (blocks.empty())
-			blocks.emplace_back();
+			tryAlloc();
 	}
 
 	void put(timediff_t td) {
-		if (blocks.empty() || blocks.back().full())
-			blocks.emplace_back();
+		if (blocks.empty() || blocks.back().full()) {
+			if (noMoreAlloc || !tryAlloc()) return;
+		}
 		blocks.back().put(td);
 	}
 

From 2f9506f5cd83992eab57dd37eb32b037d3aa8e0a Mon Sep 17 00:00:00 2001
From: Junhyun Shim <junhyun.shim@snowflake.com>
Date: Tue, 26 Apr 2022 11:19:12 +0200
Subject: [PATCH 49/84] Introduce hard cap to latency sampling & apply clang
 format

---
 bindings/c/test/mako/stats.hpp | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/bindings/c/test/mako/stats.hpp b/bindings/c/test/mako/stats.hpp
index 6b68d1dba2..a718be3bb0 100644
--- a/bindings/c/test/mako/stats.hpp
+++ b/bindings/c/test/mako/stats.hpp
@@ -32,9 +32,15 @@
 
 namespace mako {
 
+/* rough cap on the number of samples to avoid OOM hindering benchmark */
+constexpr const size_t SAMPLE_CAP = 2000000;
+
 /* size of each block to get detailed latency for each operation */
 constexpr const size_t LAT_BLOCK_SIZE = 4093;
 
+/* hard cap on the number of sample blocks = 488 */
+constexpr const size_t MAX_LAT_BLOCKS = SAMPLE_CAP / LAT_BLOCK_SIZE;
+
 /* memory block allocated to each operation when collecting detailed latency */
 class LatencySampleBlock {
 	uint64_t samples[LAT_BLOCK_SIZE]{
@@ -56,7 +62,7 @@ public:
 /* collect sampled latencies until OOM is hit */
 class LatencySampleBin {
 	std::list<LatencySampleBlock> blocks;
-	bool noMoreAlloc{false};
+	bool noMoreAlloc{ false };
 
 	bool tryAlloc() {
 		try {
@@ -76,7 +82,8 @@ public:
 
 	void put(timediff_t td) {
 		if (blocks.empty() || blocks.back().full()) {
-			if (noMoreAlloc || !tryAlloc()) return;
+			if (blocks.size() >= MAX_LAT_BLOCKS || noMoreAlloc || !tryAlloc())
+				return;
 		}
 		blocks.back().put(td);
 	}

From 1771869167c615bf4b27eb38b135932bd50f5b83 Mon Sep 17 00:00:00 2001
From: LukasMol <lukas.molleman@ugent.be>
Date: Tue, 26 Apr 2022 15:16:50 +0200
Subject: [PATCH 50/84] made merge Pythonic + fixed func and var identical name

---
 tests/TestRunner/local_cluster.py | 17 +++++++++--------
 tests/TestRunner/upgrade_test.py  | 12 ++++++------
 2 files changed, 15 insertions(+), 14 deletions(-)

diff --git a/tests/TestRunner/local_cluster.py b/tests/TestRunner/local_cluster.py
index 09783fee2b..03e3b26f71 100644
--- a/tests/TestRunner/local_cluster.py
+++ b/tests/TestRunner/local_cluster.py
@@ -83,7 +83,8 @@ logdir = {logdir}
 """
 
     def __init__(self, basedir: str, fdbserver_binary: str, fdbmonitor_binary: str, fdbcli_binary: str,
-                 process_number: int, create_config=True, port=None, ip_address=None, blob_granules_enabled: bool=False):
+                 process_number: int, create_config=True, port=None, ip_address=None,
+                 blob_granules_enabled: bool = False):
         self.basedir = Path(basedir)
         self.etc = self.basedir.joinpath('etc')
         self.log = self.basedir.joinpath('log')
@@ -102,12 +103,12 @@ logdir = {logdir}
         self.ip_address = '127.0.0.1' if ip_address is None else ip_address
         self.first_port = port
         self.blob_granules_enabled = blob_granules_enabled
-        if (blob_granules_enabled):
+        if blob_granules_enabled:
             # add extra process for blob_worker
             self.process_number += 1
 
         if self.first_port is not None:
-            self.last_used_port = int(self.first_port)-1
+            self.last_used_port = int(self.first_port) - 1
         self.server_ports = [self.__next_port()
                              for _ in range(self.process_number)]
         self.cluster_desc = random_secret_string(8)
@@ -117,7 +118,7 @@ logdir = {logdir}
         self.process = None
         self.fdbmonitor_logfile = None
         self.use_legacy_conf_syntax = False
-        
+
         if create_config:
             self.create_cluster_file()
             self.save_config()
@@ -154,7 +155,7 @@ logdir = {logdir}
             for port in self.server_ports:
                 f.write('[fdbserver.{server_port}]\n'.format(
                     server_port=port))
-            if (self.blob_granules_enabled):
+            if self.blob_granules_enabled:
                 # make last process a blob_worker class
                 f.write('class = blob_worker')
             f.flush()
@@ -216,7 +217,7 @@ logdir = {logdir}
         db_config = 'configure new single {}'.format(storage)
         if enable_tenants:
             db_config += " tenant_mode=optional_experimental"
-        if (self.blob_granules_enabled):
+        if self.blob_granules_enabled:
             db_config += " blob_granules_enabled:=1"
         args = [self.fdbcli_binary, '-C',
                 self.cluster_file, '--exec', db_config]
@@ -225,9 +226,9 @@ logdir = {logdir}
         assert res.returncode == 0, "Create database failed with {}".format(
             res.returncode)
 
-        if (self.blob_granules_enabled):
+        if self.blob_granules_enabled:
             bg_args = [self.fdbcli_binary, '-C',
-                self.cluster_file, '--exec', 'blobrange start \\x00 \\xff']
+                       self.cluster_file, '--exec', 'blobrange start \\x00 \\xff']
             bg_res = subprocess.run(bg_args, env=self.process_env())
             assert bg_res.returncode == 0, "Start blob granules failed with {}".format(bg_res.returncode)
 
diff --git a/tests/TestRunner/upgrade_test.py b/tests/TestRunner/upgrade_test.py
index bafc1d1266..f757bd89fd 100755
--- a/tests/TestRunner/upgrade_test.py
+++ b/tests/TestRunner/upgrade_test.py
@@ -34,7 +34,7 @@ MAX_DOWNLOAD_ATTEMPTS = 5
 RUN_WITH_GDB = False
 
 
-def make_executable(path):
+def make_executable_path(path):
     st = os.stat(path)
     os.chmod(path, st.st_mode | stat.S_IEXEC)
 
@@ -68,15 +68,15 @@ def random_sleep(min_sec, max_sec):
 
 
 def compute_sha256(filename):
-    hash = hashlib.sha256()
+    hash_function = hashlib.sha256()
     with open(filename, 'rb') as f:
         while True:
             data = f.read(128*1024)
             if not data:
                 break
-            hash.update(data)
+            hash_function.update(data)
 
-    return hash.hexdigest()
+    return hash_function.hexdigest()
 
 
 def read_to_str(filename):
@@ -179,7 +179,7 @@ class UpgradeTest:
             assert local_sha256.exists(), "{} does not exist".format(local_sha256)
             expected_checksum = read_to_str(local_sha256)
             actual_checkum = compute_sha256(local_file_tmp)
-            if (expected_checksum == actual_checkum):
+            if expected_checksum == actual_checkum:
                 print("Checksum OK")
                 break
             print("Checksum mismatch. Expected: {} Actual: {}".format(
@@ -192,7 +192,7 @@ class UpgradeTest:
         os.remove(local_sha256)
 
         if make_executable:
-            make_executable(local_file)
+            make_executable_path(local_file)
 
     # Download all old binaries required for testing the specified upgrade path
     def download_old_binaries(self):

From 50ec536c1b153013bf97d58a9edfa80d3c7286b0 Mon Sep 17 00:00:00 2001
From: LukasMol <lukas.molleman@ugent.be>
Date: Tue, 26 Apr 2022 17:28:12 +0200
Subject: [PATCH 51/84] =?UTF-8?q?tests/python=C3=82=5Ftests=20make=20Pytho?=
 =?UTF-8?q?n=20files=20Pythonic?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 tests/python_tests/__init__.py             |   3 +-
 tests/python_tests/multithreaded_client.py |   3 +-
 tests/python_tests/python_correctness.py   | 411 ++++++++++-----------
 tests/python_tests/python_performance.py   |  22 +-
 tests/python_tests/ryw_benchmark.py        |  12 +-
 5 files changed, 225 insertions(+), 226 deletions(-)

diff --git a/tests/python_tests/__init__.py b/tests/python_tests/__init__.py
index 8595eaa1b7..cfaabd24ca 100644
--- a/tests/python_tests/__init__.py
+++ b/tests/python_tests/__init__.py
@@ -49,6 +49,7 @@ class Result(object):
 class PythonTest(object):
     def __init__(self):
         self.result = Result()
+        self.args = None
 
     def run_test(self):
         pass
@@ -94,7 +95,7 @@ class PythonTest(object):
 
         try:
             self.run_test()
-        except:
+        except Exception:
             self.result.add_error(traceback.format_exc())
 
         self.result.save(self.args.output_directory)
diff --git a/tests/python_tests/multithreaded_client.py b/tests/python_tests/multithreaded_client.py
index 9081e9976a..a180130db9 100755
--- a/tests/python_tests/multithreaded_client.py
+++ b/tests/python_tests/multithreaded_client.py
@@ -30,7 +30,6 @@ sys.path.append(args.build_dir + '/bindings/python')
 import fdb
 import os
 import random
-import time
 fdb.api_version(630)
 
 if not os.path.exists(args.client_log_dir):
@@ -55,6 +54,6 @@ for i in range(100):
     key = b"test_%d" % random.randrange(0, 100000000)
     val = b"value_%d" % random.randrange(0, 10000000)
     db = dbs[i % len(dbs)]
-    print ("Writing: ", key, val, db)
+    print("Writing: ", key, val, db)
     db[key] = val
     assert (val == db[key])
diff --git a/tests/python_tests/python_correctness.py b/tests/python_tests/python_correctness.py
index ffc4989006..67d8a192ff 100755
--- a/tests/python_tests/python_correctness.py
+++ b/tests/python_tests/python_correctness.py
@@ -23,7 +23,6 @@
 import os
 import sys
 import time
-import string
 import random
 import traceback
 
@@ -36,7 +35,7 @@ fdb.api_version(400)
 
 
 # A class that mimics some of the operations of the FoundationDB key-value store
-class KeyValueStore():
+class KeyValueStore:
 
     # Uses a simple dictionary to store key-value pairs
     # Any operations that depend on the order of keys first sort the data
@@ -44,42 +43,42 @@ class KeyValueStore():
 
     def get(self, key):
         if key is fdb.KeySelector:
-            key = get_key(key)
+            key = self.get_key(key)
 
         if key in self.store:
             return self.store[key]
         else:
             return None
 
-    def get_key(self, keySelector):
-        sortedKeys = list(sorted(self.store.keys()))
-        for index, key in enumerate(sortedKeys):
-            if key >= keySelector.key:
-                index += keySelector.offset
-                if (key == keySelector.key and not keySelector.or_equal) or key != keySelector.key:
+    def get_key(self, key_selector):
+        sorted_keys = list(sorted(self.store.keys()))
+        for index, key in enumerate(sorted_keys):
+            if key >= key_selector.key:
+                index += key_selector.offset
+                if (key == key_selector.key and not key_selector.or_equal) or key != key_selector.key:
                     index -= 1
 
-                if index < 0 or index >= len(sortedKeys):
+                if index < 0 or index >= len(sorted_keys):
                     return ''
                 else:
-                    return sortedKeys[index]
+                    return sorted_keys[index]
 
-        index = len(sortedKeys) + keySelector.offset - 1
-        if index < 0 or index >= len(sortedKeys):
+        index = len(sorted_keys) + key_selector.offset - 1
+        if index < 0 or index >= len(sorted_keys):
             return ''
         else:
-            return sortedKeys[index]
+            return sorted_keys[index]
 
     def get_range(self, begin, end, limit=None):
         values = []
         count = 0
 
         if begin is fdb.KeySelector:
-            begin = get_key(begin)
+            begin = self.get_key(begin)
         if end is fdb.KeySelector:
-            end = get_key(end)
+            end = self.get_key(end)
 
-        for key, value in sorted(self.store.iteritems()):
+        for key, value in sorted(self.store.items()):
             if limit is not None and count >= limit:
                 break
 
@@ -95,7 +94,7 @@ class KeyValueStore():
     def get_range_startswith(self, prefix, limit=None):
         values = []
         count = 0
-        for key, value in sorted(self.store.iteritems()):
+        for key, value in sorted(self.store.items()):
             if limit is not None and count >= limit:
                 break
 
@@ -113,7 +112,7 @@ class KeyValueStore():
 
     def clear(self, key):
         if key is fdb.KeySelector:
-            key = get_key(key)
+            key = self.get_key(key)
 
         if key in self.store:
             del self.store[key]
@@ -137,55 +136,55 @@ class PythonCorrectness(PythonTest):
             db = fdb.open(None, 'DB')
         except KeyboardInterrupt:
             raise
-        except:
-            self.result.add_error(self.getError('fdb.open failed'))
+        except Exception:
+            self.result.add_error(self.get_error('fdb.open failed'))
             return
 
         try:
             print('Testing functions...')
-            self.testFunctions(db)
+            self.test_functions(db)
 
             print('Testing correctness...')
             del db[:]
-            self.testCorrectness(db)
+            self.test_correctness(db)
         except KeyboardInterrupt:
             raise
-        except:
-            self.result.add_error(self.getError('Failed to complete all tests'))
+        except Exception:
+            self.result.add_error(self.get_error('Failed to complete all tests'))
 
     # Generates a random set of keys and values
-    def generateData(self, numKeys, minKeyLength, maxKeyLength, minValueLength, maxValueLength, prefix='', allowDuplicates=True):
+    def generate_data(self, num_keys, min_key_length, max_key_length, min_value_length, max_value_length, prefix='', allow_duplicates=True):
         data = list()
         keys = set()
-        while len(data) < numKeys:
+        while len(data) < num_keys:
             # key = prefix + ''.join(random.choice(string.ascii_lowercase)
             #                        for i in range(0, random.randint(minKeyLength - len(prefix), maxKeyLength - len(prefix))))
             key = prefix + ''.join(chr(random.randint(0, 254))
-                                   for i in range(0, random.randint(minKeyLength - len(prefix), maxKeyLength - len(prefix))))
-            if not allowDuplicates:
+                                   for _ in range(0, random.randint(min_key_length - len(prefix), max_key_length - len(prefix))))
+            if not allow_duplicates:
                 if key in keys:
                     continue
                 else:
                     keys.add(key)
 
-            value = ''.join('x' for i in range(0, random.randint(maxKeyLength, maxValueLength)))
+            value = ''.join('x' for _ in range(0, random.randint(max_key_length, max_value_length)))
             data.append([key, value])
 
         return data
 
     # Function to test the callback feature of Future objects
-    def testCallback(self, future):
+    def test_callback(self, future):
         try:
             future.wait()
         except KeyboardInterrupt:
             raise
-        except:
-            self.callbackError = getError('Callback future get failed')
+        except Exception:
+            self.callbackError = self.get_error('Callback future get failed')
 
         self.callback = True
 
     # Tests that all of the functions in the python API can be called without failing
-    def testFunctions(self, db):
+    def test_functions(self, db):
         self.callback = False
         self.callbackError = ''
 
@@ -193,8 +192,8 @@ class PythonCorrectness(PythonTest):
             tr = db.create_transaction()
         except KeyboardInterrupt:
             raise
-        except:
-            self.result.add_error(self.getError('db.create_transaction failed'))
+        except Exception:
+            self.result.add_error(self.get_error('db.create_transaction failed'))
             return
 
         try:
@@ -206,23 +205,23 @@ class PythonCorrectness(PythonTest):
 
         except KeyboardInterrupt:
             raise
-        except:
-            self.result.add_error(self.getError('Set/Get value failed (block until ready)'))
+        except Exception:
+            self.result.add_error(self.get_error('Set/Get value failed (block until ready)'))
 
         try:
             value = tr['testkey']
             value.wait()
         except KeyboardInterrupt:
             raise
-        except:
-            self.result.add_error(self.getError('Get value failed'))
+        except Exception:
+            self.result.add_error(self.get_error('Get value failed'))
 
         try:
             tr['testkey'] = 'newtestvalue'
         except KeyboardInterrupt:
             raise
-        except:
-            self.result.add_error(self.getError('Replace value failed'))
+        except Exception:
+            self.result.add_error(self.get_error('Replace value failed'))
 
         try:
             value = tr['fakekey']
@@ -231,30 +230,30 @@ class PythonCorrectness(PythonTest):
             value.wait()
         except KeyboardInterrupt:
             raise
-        except:
-            self.result.add_error(self.getError('Get non-existent key failed'))
+        except Exception:
+            self.result.add_error(self.get_error('Get non-existent key failed'))
 
         try:
             tr.commit().wait()
             tr.get_committed_version()
         except KeyboardInterrupt:
             raise
-        except:
-            self.result.add_error(self.getError('Commit failed'))
+        except Exception:
+            self.result.add_error(self.get_error('Commit failed'))
 
         try:
             tr.reset()
         except KeyboardInterrupt:
             raise
-        except:
-            self.result.add_error(self.getError('Reset failed'))
+        except Exception:
+            self.result.add_error(self.get_error('Reset failed'))
 
         try:
             version = tr.get_read_version()
         except KeyboardInterrupt:
             raise
-        except:
-            self.result.add_error(self.getError('tr.get_read_version failed'))
+        except Exception:
+            self.result.add_error(self.get_error('tr.get_read_version failed'))
 
         try:
             value = tr['testkey']
@@ -262,38 +261,38 @@ class PythonCorrectness(PythonTest):
             tr.reset()
         except KeyboardInterrupt:
             raise
-        except:
-            self.result.add_error(self.getError('Get and reset failed'))
+        except Exception:
+            self.result.add_error(self.get_error('Get and reset failed'))
 
         try:
             tr.set_read_version(version.wait())
         except KeyboardInterrupt:
             raise
-        except:
-            self.result.add_error(self.getError('Set read version failed'))
+        except Exception:
+            self.result.add_error(self.get_error('Set read version failed'))
 
         try:
             value = tr['testkey']
-            callbackTime = time.time()
-            value.on_ready(self.testCallback)
+            callback_time = time.time()
+            value.on_ready(self.test_callback)
         except KeyboardInterrupt:
             raise
-        except:
-            self.result.add_error(self.getError('Get future and set callback failed'))
+        except Exception:
+            self.result.add_error(self.get_error('Get future and set callback failed'))
 
         try:
             del tr['testkey']
         except KeyboardInterrupt:
             raise
-        except:
-            self.result.add_error(self.getError('Delete key failed'))
+        except Exception:
+            self.result.add_error(self.get_error('Delete key failed'))
 
         try:
             del tr['fakekey']
         except KeyboardInterrupt:
             raise
-        except:
-            self.result.add_error(self.getError('Delete non-existent key failed'))
+        except Exception:
+            self.result.add_error(self.get_error('Delete non-existent key failed'))
 
         try:
             tr.set('testkey', 'testvalue')
@@ -301,15 +300,15 @@ class PythonCorrectness(PythonTest):
             value.wait()
         except KeyboardInterrupt:
             raise
-        except:
-            self.result.add_error(self.getError('Future.get failed'))
+        except Exception:
+            self.result.add_error(self.get_error('Future.get failed'))
 
         try:
             tr.clear('testkey')
         except KeyboardInterrupt:
             raise
-        except:
-            self.result.add_error(self.getError('Clear key failed'))
+        except Exception:
+            self.result.add_error(self.get_error('Clear key failed'))
 
         try:
             tr['testkey1'] = 'testvalue1'
@@ -326,8 +325,8 @@ class PythonCorrectness(PythonTest):
                 v += ''
         except KeyboardInterrupt:
             raise
-        except:
-            self.result.add_error(self.getError('Get range failed'))
+        except Exception:
+            self.result.add_error(self.get_error('Get range failed'))
 
         try:
             tr['otherkey1'] = 'othervalue1'
@@ -337,22 +336,22 @@ class PythonCorrectness(PythonTest):
                 v += ''
         except KeyboardInterrupt:
             raise
-        except:
-            self.result.add_error(self.getError('Get range starts with failed'))
+        except Exception:
+            self.result.add_error(self.get_error('Get range starts with failed'))
 
         try:
             tr.clear_range_startswith('otherkey')
         except KeyboardInterrupt:
             raise
-        except:
-            self.result.add_error(self.getError('Clear range starts with failed'))
+        except Exception:
+            self.result.add_error(self.get_error('Clear range starts with failed'))
 
         try:
             tr.clear_range('testkey1', 'testkey3')
         except KeyboardInterrupt:
             raise
-        except:
-            self.result.add_error(self.getError('Clear range failed'))
+        except Exception:
+            self.result.add_error(self.get_error('Clear range failed'))
 
         try:
             tr['testkey1'] = 'testvalue1'
@@ -363,8 +362,8 @@ class PythonCorrectness(PythonTest):
             end = fdb.KeySelector('testkey2', 0, 1)
         except KeyboardInterrupt:
             raise
-        except:
-            self.result.add_error(self.getError('Create key selector failed'))
+        except Exception:
+            self.result.add_error(self.get_error('Create key selector failed'))
 
         try:
             for k, v in tr.get_range(begin, end):
@@ -377,8 +376,8 @@ class PythonCorrectness(PythonTest):
                 v += ''
         except KeyboardInterrupt:
             raise
-        except:
-            self.result.add_error(self.getError('Get range (key selectors) failed'))
+        except Exception:
+            self.result.add_error(self.get_error('Get range (key selectors) failed'))
 
         try:
             tr.clear_range(begin, end)
@@ -394,8 +393,8 @@ class PythonCorrectness(PythonTest):
             tr['testkey3'] = 'testvalue3'
         except KeyboardInterrupt:
             raise
-        except:
-            self.result.add_error(self.getError('Clear range (key selectors) failed'))
+        except Exception:
+            self.result.add_error(self.get_error('Clear range (key selectors) failed'))
 
         try:
             begin = fdb.KeySelector.last_less_than('testkey2')
@@ -411,33 +410,33 @@ class PythonCorrectness(PythonTest):
                 v += ''
         except KeyboardInterrupt:
             raise
-        except:
-            self.result.add_error(self.getError('Builtin key selectors failed'))
+        except Exception:
+            self.result.add_error(self.get_error('Builtin key selectors failed'))
 
         try:
             del tr['testkey1':'testkey3']
         except KeyboardInterrupt:
             raise
-        except:
-            self.result.add_error(self.getError('Delete key range failed'))
+        except Exception:
+            self.result.add_error(self.get_error('Delete key range failed'))
 
         try:
             tr.commit().wait()
             tr.get_committed_version()
         except KeyboardInterrupt:
             raise
-        except:
-            self.result.add_error(self.getError('Commit failed'))
+        except Exception:
+            self.result.add_error(self.get_error('Commit failed'))
 
         try:
             key = fdb.tuple.pack(('k1', 'k2', 'k3'))
-            kTuple = fdb.tuple.unpack(key)
-            if kTuple[0] != 'k1' and kTuple[1] != 'k2' and kTuple[2] != 'k3':
+            k_tuple = fdb.tuple.unpack(key)
+            if k_tuple[0] != 'k1' and k_tuple[1] != 'k2' and k_tuple[2] != 'k3':
                 self.result.add_error('Tuple <-> key conversion yielded incorrect results')
         except KeyboardInterrupt:
             raise
-        except:
-            self.result.add_error(self.getError('Tuple <-> key conversion failed'))
+        except Exception:
+            self.result.add_error(self.get_error('Tuple <-> key conversion failed'))
 
         try:
             tr[fdb.tuple.pack(('k1', 'k2'))] = 'v'
@@ -449,8 +448,8 @@ class PythonCorrectness(PythonTest):
 
         except KeyboardInterrupt:
             raise
-        except:
-            self.result.add_error(self.getError('Tuple get range failed'))
+        except Exception:
+            self.result.add_error(self.get_error('Tuple get range failed'))
 
         try:
             tr['testint'] = '10'
@@ -459,97 +458,97 @@ class PythonCorrectness(PythonTest):
                 self.result.add_error('Value retrieval yielded incorrect results')
         except KeyboardInterrupt:
             raise
-        except:
-            self.result.add_error(getError('Future value retrieval failed'))
+        except Exception:
+            self.result.add_error(self.get_error('Future value retrieval failed'))
 
         if not self.callback:
             time.sleep(5)
             if not self.callback:
-                self.result.add_error('Warning: Future callback not called after %f seconds' % (time.time() - callbackTime))
+                self.result.add_error('Warning: Future callback not called after %f seconds' % (time.time() - callback_time))
         if len(self.callbackError) > 0:
             self.result.add_error(self.callbackError)
 
     # Compares a FoundationDB database with an in-memory key-value store
-    def compareDatabaseToMemory(self, db, store):
-        dbResult = self.correctnessGetRangeTransactional(db, '\x00', '\xff')
-        storeResult = store.get_range('\x00', '\xff')
+    def compare_database_to_memory(self, db, store):
+        db_result = self.correctness_get_range_transactional(db, '\x00', '\xff')
+        store_result = store.get_range('\x00', '\xff')
 
-        return self.compareResults(dbResult, storeResult)
+        return self.compare_results(db_result, store_result)
 
     # Compares result sets coming from a FoundationDB database and an in-memory key-value store
-    def compareResults(self, dbResults, storeResults):
-        if len(dbResults) != len(storeResults):
+    def compare_results(self, db_results, store_results):
+        if len(db_results) != len(store_results):
             # print 'mismatched lengths: ' + str(len(dbResults)) + ' - ' + str(len(storeResults))
             return False
 
-        for i in range(0, len(dbResults)):
+        for i in range(0, len(db_results)):
             # if i >= len(storeResults):
             #    print 'mismatched key: ' + dbResults[i].key
             #    return False
-            if dbResults[i].key != storeResults[i][0] or dbResults[i].value != storeResults[i][1]:
+            if db_results[i].key != store_results[i][0] or db_results[i].value != store_results[i][1]:
                 # print 'mismatched key: ' + dbResults[i].key + ' - ' + storeResults[i][0]
                 return False
 
         return True
 
     # Performs the same operations on a FoundationDB database and an in-memory key-value store and compares the results
-    def testCorrectness(self, db):
-        numKeys = 5000
-        ratioShortKeys = 0.5
-        minShortKeyLength = 1
-        maxShortKeyLength = 3
-        minLongKeyLength = 1
-        maxLongKeyLength = 128
-        minValueLength = 1
-        maxValueLength = 10000
-        maxTransactionBytes = 5000000
+    def test_correctness(self, db):
+        num_keys = 5000
+        ratio_short_keys = 0.5
+        min_short_key_length = 1
+        max_short_key_length = 3
+        min_long_key_length = 1
+        max_long_key_length = 128
+        min_value_length = 1
+        max_value_length = 10000
+        max_transaction_bytes = 5000000
 
-        numReads = 100
-        numRangeReads = 100
-        numPrefixReads = 100
-        numGetKeys = 100
+        num_reads = 100
+        num_range_reads = 100
+        num_prefix_reads = 100
+        num_get_keys = 100
 
-        numClears = 100
-        numRangeClears = 10
-        numPrefixClears = 10
+        # num_clears = 100
+        num_range_clears = 10
+        num_prefix_clears = 10
 
-        maxKeysPerTransaction = max(1, maxTransactionBytes / (maxValueLength + maxLongKeyLength))
+        max_keys_per_transaction = max(1, int(max_transaction_bytes / (max_value_length + max_long_key_length)))
 
         try:
             store = KeyValueStore()
 
             # Generate some random data
-            data = self.generateData(numKeys * ratioShortKeys, minShortKeyLength, maxShortKeyLength, minValueLength, maxValueLength)
-            data.extend(self.generateData(numKeys * (1 - ratioShortKeys), minLongKeyLength, maxLongKeyLength, minValueLength, maxValueLength))
+            data = self.generate_data(num_keys * ratio_short_keys, min_short_key_length, max_short_key_length, min_value_length, max_value_length)
+            data.extend(self.generate_data(num_keys * (1 - ratio_short_keys), min_long_key_length, max_long_key_length, min_value_length, max_value_length))
 
             # Insert the data
-            self.correctnessSet(db, store, data, maxKeysPerTransaction)
-            if not self.compareDatabaseToMemory(db, store):
+            self.correctness_set(db, store, data, max_keys_per_transaction)
+            if not self.compare_database_to_memory(db, store):
                 self.result.add_error('transaction.set resulted in incorrect database')
 
             # Compare the results of single key reads
-            if not self.correctnessGet(db, store, data, numReads, maxKeysPerTransaction):
+            if not self.correctness_get(db, store, data, num_reads, max_keys_per_transaction):
                 self.result.add_error('transaction.get returned incorrect result')
 
             # Compare the results of range reads
-            for i in range(0, numRangeReads):
-                if not self.correctnessGetRange(db, store, data):
+            for i in range(0, num_range_reads):
+                if not self.correctness_get_range(db, store, data):
                     self.result.add_error('transaction.get_range returned incorrect results')
                     break
 
             # Compare the results of prefix reads
-            for i in range(0, numPrefixReads):
-                if not self.correctnessGetPrefix(db, store, data):
+            for i in range(0, num_prefix_reads):
+                if not self.correctness_get_prefix(db, store, data):
                     self.result.add_error('transaction.get_range_startswith returned incorrect results')
                     break
 
             # Compare the results of get key
-            if not self.correctnessGetKey(db, store, data, numGetKeys, maxKeysPerTransaction):
+            if not self.correctness_get_key(db, store, data, num_get_keys, max_keys_per_transaction):
                 self.result.add_error('transaction.get_key returned incorrect results')
 
             # Compare the results of clear
-            clearedKeys = self.correctnessClear(db, store, data, numClears, maxKeysPerTransaction)
-            if not self.compareDatabaseToMemory(db, store):
+            # clearedKeys = self.correctnessClear(db, store, data, num_clears, max_keys_per_transaction)
+            if not self.compare_database_to_memory(db, store):
                 self.result.add_error('transaction.clear resulted in incorrect database')
 
             #    for key in clearedKeys:
@@ -558,21 +557,21 @@ class PythonCorrectness(PythonTest):
             #     print 'successful compare'
 
             # Fill the database back up with data
-            self.correctnessSet(db, store, data, maxKeysPerTransaction)
-            if not self.compareDatabaseToMemory(db, store):
+            self.correctness_set(db, store, data, max_keys_per_transaction)
+            if not self.compare_database_to_memory(db, store):
                 self.result.add_error('transaction.set resulted in incorrect database')
 
             # Compare the results of clear_range
-            for i in range(0, numRangeClears):
-                self.correctnessClearRange(db, store, data)
+            for i in range(0, num_range_clears):
+                self.correctness_clear_range(db, store, data)
 
-                success = self.compareDatabaseToMemory(db, store)
+                success = self.compare_database_to_memory(db, store)
                 if not success:
                     self.result.add_error('transaction.clear_range resulted in incorrect database')
 
                 # Fill the database back up with data
-                self.correctnessSet(db, store, data, maxKeysPerTransaction)
-                if not self.compareDatabaseToMemory(db, store):
+                self.correctness_set(db, store, data, max_keys_per_transaction)
+                if not self.compare_database_to_memory(db, store):
                     self.result.add_error('transaction.set resulted in incorrect database')
                     break
 
@@ -580,54 +579,54 @@ class PythonCorrectness(PythonTest):
                     break
 
             # Compare the results of clear_range_startswith
-            self.correctnessClearPrefix(db, store, data, numPrefixClears)
-            if not self.compareDatabaseToMemory(db, store):
+            self.correctness_clear_prefix(db, store, data, num_prefix_clears)
+            if not self.compare_database_to_memory(db, store):
                 self.result.add_error('transaction.clear_range_startswith resulted in incorrect database')
 
         except KeyboardInterrupt:
             raise
-        except:
-            self.result.add_error(self.getError('Database error in correctness test'))
+        except Exception:
+            self.result.add_error(self.get_error('Database error in correctness test'))
 
     # Stores data in the database and a memory key-value store
-    def correctnessSet(self, db, store, data, maxKeysPerTransaction):
+    def correctness_set(self, db, store, data, max_keys_per_transaction):
         for [key, value] in data:
             store.set(key, value)
 
-        keysCommitted = 0
-        while keysCommitted < len(data):
-            self.correctnessSetTransactional(db, data[keysCommitted: keysCommitted + maxKeysPerTransaction])
-            keysCommitted += maxKeysPerTransaction
+        keys_committed = 0
+        while keys_committed < len(data):
+            self.correctness_set_transactional(db, data[keys_committed: keys_committed + max_keys_per_transaction])
+            keys_committed += max_keys_per_transaction
 
     # Stores data in the database
     @fdb.transactional
-    def correctnessSetTransactional(self, tr, data):
+    def correctness_set_transactional(self, tr, data):
         for [key, value] in data:
             tr.set(key, value)
 
     # Compares the results of the get operation from the database and a memory key-value store
-    def correctnessGet(self, db, store, data, numReads, maxKeysPerTransaction):
+    def correctness_get(self, db, store, data, num_reads, max_keys_per_transaction):
         keys = []
-        for i in range(0, numReads):
+        for i in range(0, num_reads):
             index = random.randint(0, len(data) - 1)
             keys.append(data[index][0])
 
-        keysRetrieved = 0
-        while keysRetrieved < len(keys):
-            subKeys = keys[keysRetrieved: keysRetrieved + maxKeysPerTransaction]
+        keys_retrieved = 0
+        while keys_retrieved < len(keys):
+            sub_keys = keys[keys_retrieved: keys_retrieved + max_keys_per_transaction]
 
-            values = self.correctnessGetTransactional(db, subKeys)
-            for i in range(0, numReads):
-                if values[i] != store.get(subKeys[i]):
-                    print('mismatch: %s', subKeys[i])
+            values = self.correctness_get_transactional(db, sub_keys)
+            for i in range(0, num_reads):
+                if values[i] != store.get(sub_keys[i]):
+                    print('mismatch: %s', sub_keys[i])
                     return False
-            keysRetrieved += maxKeysPerTransaction
+            keys_retrieved += max_keys_per_transaction
 
         return True
 
     # Gets the values for the specified list of keys from the database
     @fdb.transactional
-    def correctnessGetTransactional(self, tr, keys):
+    def correctness_get_transactional(self, tr, keys):
         futures = []
         for key in keys:
             futures.append(tr.get(key))
@@ -639,43 +638,43 @@ class PythonCorrectness(PythonTest):
         return values
 
     # Compares the results of the get_range operation from the database and a memory key-value store
-    def correctnessGetRange(self, db, store, data):
+    def correctness_get_range(self, db, store, data):
         index = random.randint(0, len(data) - 1)
         index2 = random.randint(0, len(data) - 1)
 
         key1 = min(data[index][0], data[index2][0])
         key2 = max(data[index][0], data[index2][0])
 
-        dbResults = self.correctnessGetRangeTransactional(db, key1, key2, data)
-        storeResults = store.get_range(key1, key2)
+        db_results = self.correctness_get_range_transactional(db, key1, key2, data)
+        store_results = store.get_range(key1, key2)
 
-        return self.compareResults(dbResults, storeResults)
+        return self.compare_results(db_results, store_results)
 
     # Gets the entries in the range [key1,key2) from the database
     @fdb.transactional
-    def correctnessGetRangeTransactional(self, tr, key1, key2, data=None):
+    def correctness_get_range_transactional(self, tr, key1, key2, data=None):
         if data is not None:
             return list(tr.get_range(key1, key2, len(data)))
         else:
             return list(tr.get_range(key1, key2))
 
     # Compares the results of the get_range_startswith operation from the database and a memory key-value store
-    def correctnessGetPrefix(self, db, store, data):
-        prefix = ''.join(chr(random.randint(0, 254)) for i in range(0, random.randint(1, 3)))
-        dbResults = self.correctnessGetPrefixTransactional(db, prefix)
-        storeResults = store.get_range_startswith(prefix)
+    def correctness_get_prefix(self, db, store, data):
+        prefix = ''.join(chr(random.randint(0, 254)) for _ in range(0, random.randint(1, 3)))
+        db_results = self.correctness_get_prefix_transactional(db, prefix)
+        store_results = store.get_range_startswith(prefix)
 
-        return self.compareResults(dbResults, storeResults)
+        return self.compare_results(db_results, store_results)
 
     # Gets the entries with a given prefix from the database
     @fdb.transactional
-    def correctnessGetPrefixTransactional(self, tr, prefix):
+    def correctness_get_prefix_transactional(self, tr, prefix):
         return list(tr.get_range_startswith(prefix))
 
     # Compares the results of the get_key operation from the database and a memory key-value store
-    def correctnessGetKey(self, db, store, data, numGetKeys, maxKeysPerTransaction):
+    def correctness_get_key(self, db, store, data, num_get_keys, max_keys_per_transaction):
         selectors = []
-        for i in range(0, numGetKeys):
+        for i in range(0, num_get_keys):
             index = random.randint(0, len(data) - 1)
             or_equal = random.randint(0, 1)
             offset = random.randint(max(-index + (1 - or_equal), -10), min(len(data) - index - 1 + or_equal, 10))
@@ -684,23 +683,23 @@ class PythonCorrectness(PythonTest):
             selector = fdb.KeySelector(key, or_equal, offset)
             selectors.append(selector)
 
-        keysRetrieved = 0
-        while keysRetrieved < len(selectors):
-            subSelectors = selectors[keysRetrieved: keysRetrieved + maxKeysPerTransaction]
-            dbKeys = self.correctnessGetKeyTransactional(db, subSelectors)
-            for i in range(0, numGetKeys):
-                if dbKeys[i] != store.get_key(subSelectors[i]):
+        keys_retrieved = 0
+        while keys_retrieved < len(selectors):
+            sub_selectors = selectors[keys_retrieved: keys_retrieved + max_keys_per_transaction]
+            db_keys = self.correctness_get_key_transactional(db, sub_selectors)
+            for i in range(0, num_get_keys):
+                if db_keys[i] != store.get_key(sub_selectors[i]):
                     return False
-            keysRetrieved += maxKeysPerTransaction
+            keys_retrieved += max_keys_per_transaction
 
         return True
 
     # Gets the keys specified by the list of key selectors
     @fdb.transactional
-    def correctnessGetKeyTransactional(self, tr, keySelectors):
+    def correctness_get_key_transactional(self, tr, key_selectors):
         futures = []
         count = 0
-        for selector in keySelectors:
+        for selector in key_selectors:
             futures.append(tr.get_key(selector))
             count += 1
 
@@ -713,63 +712,63 @@ class PythonCorrectness(PythonTest):
         return keys
 
     # Clears data from a database and a memory key-value store
-    def correctnessClear(self, db, store, data, numClears, maxKeysPerTransaction):
-        clearedKeys = []
-        for i in range(0, numClears):
+    def correctness_clear(self, db, store, data, num_clears, max_keys_per_transaction):
+        cleared_keys = []
+        for i in range(0, num_clears):
             index = random.randint(0, len(data) - 1)
-            clearedKeys.append(data[index][0])
+            cleared_keys.append(data[index][0])
             store.clear(data[index][0])
 
-        keysCleared = 0
-        while keysCleared < len(clearedKeys):
-            self.correctnessClearTransactional(db, clearedKeys[keysCleared: keysCleared + maxKeysPerTransaction])
-            keysCleared += maxKeysPerTransaction
+        keys_cleared = 0
+        while keys_cleared < len(cleared_keys):
+            self.correctness_clear_transactional(db, cleared_keys[keys_cleared: keys_cleared + max_keys_per_transaction])
+            keys_cleared += max_keys_per_transaction
 
-        return clearedKeys
+        return cleared_keys
 
     # Clears a list of keys from the database
     @fdb.transactional
-    def correctnessClearTransactional(self, tr, clearedKeys):
-        for key in clearedKeys:
+    def correctness_clear_transactional(self, tr, cleared_keys):
+        for key in cleared_keys:
             tr.clear(key)
 
     # Clears a range of data from a database and a memory key-value store
-    def correctnessClearRange(self, db, store, data):
+    def correctness_clear_range(self, db, store, data):
         index = random.randint(0, len(data) - 1)
         index2 = random.randint(0, len(data) - 1)
 
         key1 = min(data[index][0], data[index2][0])
         key2 = max(data[index][0], data[index2][0])
 
-        self.correctnessClearRangeTransactional(db, key1, key2)
+        self.correctness_clear_range_transactional(db, key1, key2)
         store.clear_range(key1, key2)
 
     # Clears a range of memory from a database
     @fdb.transactional
-    def correctnessClearRangeTransactional(self, tr, key1, key2):
+    def correctness_clear_range_transactional(self, tr, key1, key2):
         tr.clear_range(key1, key2)
 
     # Clears data with random prefixes from a database and a memory key-value store
-    def correctnessClearPrefix(self, db, store, data, numPrefixClears):
+    def correctness_clear_prefix(self, db, store, data, num_prefix_clears):
         prefixes = []
-        for i in range(0, numPrefixClears):
-            prefix = ''.join(chr(random.randint(0, 254)) for i in range(0, random.randint(1, 3)))
+        for i in range(0, num_prefix_clears):
+            prefix = ''.join(chr(random.randint(0, 254)) for _ in range(0, random.randint(1, 3)))
             prefixes.append(prefix)
             store.clear_range_startswith(prefix)
 
-        self.correctnessClearPrefixTransactional(db, prefixes)
+        self.correctness_clear_prefix_transactional(db, prefixes)
 
     # Clears keys from a database that have a prefix in the prefixes list
     @fdb.transactional
-    def correctnessClearPrefixTransactional(self, tr, prefixes):
+    def correctness_clear_prefix_transactional(self, tr, prefixes):
         for prefix in prefixes:
             tr.clear_range_startswith(prefix)
 
     # Adds the stack trace to an error message
-    def getError(self, message):
-        errorMessage = message + "\n" + traceback.format_exc()
-        print('%s', errorMessage)
-        return errorMessage
+    def get_error(self, message):
+        error_message = message + "\n" + traceback.format_exc()
+        print('%s', error_message)
+        return error_message
 
 
 if __name__ == '__main__':
diff --git a/tests/python_tests/python_performance.py b/tests/python_tests/python_performance.py
index bf36ca2d05..41fe03dc33 100755
--- a/tests/python_tests/python_performance.py
+++ b/tests/python_tests/python_performance.py
@@ -57,7 +57,7 @@ class PythonPerformance(PythonTest):
         super(PythonPerformance, self).__init__()
         self.key_count = key_count
         self.key_size = key_size
-        self.value_str = ''.join(['x' for i in range(value_size)])
+        self.value_str = ''.join(['x' for _ in range(value_size)])
 
     # Python Performance Tests (checks if functions run and yield correct results, gets performance indicators)
     def run_test(self):
@@ -65,7 +65,7 @@ class PythonPerformance(PythonTest):
             db = fdb.open(None, 'DB')
         except KeyboardInterrupt:
             raise
-        except:
+        except Exception:
             self.result.add_error(self.get_error('fdb.open failed'))
             return
 
@@ -73,7 +73,7 @@ class PythonPerformance(PythonTest):
             self.test_performance(db)
         except KeyboardInterrupt:
             raise
-        except:
+        except Exception:
             self.result.add_error(self.get_error('Failed to complete all tests'))
 
     def random_key(self):
@@ -86,12 +86,12 @@ class PythonPerformance(PythonTest):
         return self.value_str
 
     def insert_data(self, db):
-        print 'Loading database'
+        print('Loading database')
         del db[:]
         num_keys = 100000 / (self.key_size + len(self.value_str))
 
-        trs = [db.create_transaction() for i in range(int(math.ceil(float(self.key_count) / num_keys)))]
-        success = [False for i in range(len(trs))]
+        trs = [db.create_transaction() for _ in range(int(math.ceil(float(self.key_count) / num_keys)))]
+        success = [False for _ in range(len(trs))]
 
         while not all(success):
             futures = {}
@@ -142,7 +142,7 @@ class PythonPerformance(PythonTest):
                     results.append(getattr(self, fxn_name)(db))
                 except KeyboardInterrupt:
                     raise
-                except:
+                except Exception:
                     self.result.add_error(self.get_error('Performance test failed: ' + PythonPerformance.tests[test]))
                     break
 
@@ -233,7 +233,7 @@ class PythonPerformance(PythonTest):
         tr.options.set_retry_limit(5)
 
         if count > self.key_count / 2:
-            keys = [self.random_key() for i in range(count)]
+            keys = [self.random_key() for _ in range(count)]
         else:
             key_set = OrderedDict()
             while len(key_set) < count:
@@ -295,9 +295,9 @@ class PythonPerformance(PythonTest):
 
     # Adds the stack trace to an error message
     def get_error(self, message):
-        errorMessage = message + "\n" + traceback.format_exc()
-        print('%s' % errorMessage)
-        return errorMessage
+        error_message = message + "\n" + traceback.format_exc()
+        print('%s' % error_message)
+        return error_message
 
 
 if __name__ == '__main__':
diff --git a/tests/python_tests/ryw_benchmark.py b/tests/python_tests/ryw_benchmark.py
index de1524ac2f..65fdf50142 100755
--- a/tests/python_tests/ryw_benchmark.py
+++ b/tests/python_tests/ryw_benchmark.py
@@ -53,7 +53,7 @@ class RYWBenchmark(PythonTest):
             db = fdb.open(None, 'DB')
         except KeyboardInterrupt:
             raise
-        except:
+        except Exception:
             self.result.add_error(self.get_error('fdb.open failed'))
             return
 
@@ -61,7 +61,7 @@ class RYWBenchmark(PythonTest):
             self.test_performance(db)
         except KeyboardInterrupt:
             raise
-        except:
+        except Exception:
             self.result.add_error(self.get_error('Failed to complete all tests'))
 
     def key(self, num):
@@ -69,9 +69,9 @@ class RYWBenchmark(PythonTest):
 
     # Adds the stack trace to an error message
     def get_error(self, message):
-        errorMessage = message + "\n" + traceback.format_exc()
-        print(errorMessage)
-        return errorMessage
+        error_message = message + "\n" + traceback.format_exc()
+        print(error_message)
+        return error_message
 
     def test_performance(self, db):
         tr = db.create_transaction()
@@ -99,7 +99,7 @@ class RYWBenchmark(PythonTest):
                     results.append(getattr(self, fxn_name)(tr))
                 except KeyboardInterrupt:
                     raise
-                except:
+                except Exception:
                     self.result.add_error(self.get_error('Performance test failed: ' + RYWBenchmark.tests[test]))
                     break
 

From 23b51e34fd42951f69ceb720107203ca0277b5c5 Mon Sep 17 00:00:00 2001
From: Jingyu Zhou <jingyuzhou@gmail.com>
Date: Mon, 18 Apr 2022 21:57:00 -0700
Subject: [PATCH 52/84] Fix spurious test failure

The timed_out error, if happens, could cause the test to fail, even though
there is nothing wrong with the database.
---
 fdbserver/workloads/DataLossRecovery.actor.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fdbserver/workloads/DataLossRecovery.actor.cpp b/fdbserver/workloads/DataLossRecovery.actor.cpp
index 32c57f61d3..a5f7d24af2 100644
--- a/fdbserver/workloads/DataLossRecovery.actor.cpp
+++ b/fdbserver/workloads/DataLossRecovery.actor.cpp
@@ -132,7 +132,7 @@ struct DataLossRecoveryWorkload : TestWorkload {
 				} else {
 					tr.clear(key);
 				}
-				wait(timeoutError(tr.commit(), 30.0));
+				wait(tr.commit());
 				break;
 			} catch (Error& e) {
 				wait(tr.onError(e));

From 9f8e2a4517ebdfb59a7f4c56df2881ff445b6d57 Mon Sep 17 00:00:00 2001
From: Andrew Noyes <andrew.noyes@snowflake.com>
Date: Tue, 26 Apr 2022 11:54:52 -0700
Subject: [PATCH 53/84] Test compiling an fdb_c app in pkg_tester (#6940)

* Use execstack to test executable stack permissions

The output of readelf wasn't stable

* Tee output to stdout in pkg_tester "run" function

* Test compiling an app that includes fdb_c.h

Featuring both cmake and pkg_tester, since we intend to support those in
our packages.

* Fix packaging bug

The libdir in the pkg-config file in the packages was wrong
---
 cmake/FDBInstall.cmake                        |  2 +-
 .../__snapshots__/test_fdb_pkgs.ambr          | 12 +--
 contrib/pkg_tester/test_fdb_pkgs.py           | 96 +++++++++++++++++--
 3 files changed, 95 insertions(+), 15 deletions(-)

diff --git a/cmake/FDBInstall.cmake b/cmake/FDBInstall.cmake
index 2dd4be696f..52c0459bf7 100644
--- a/cmake/FDBInstall.cmake
+++ b/cmake/FDBInstall.cmake
@@ -198,7 +198,7 @@ function(fdb_configure_and_install)
       string(TOLOWER "${pkg}" package)
       string(TOUPPER "${IN_DESTINATION}" destination)
       get_install_dest(${pkg} INCLUDE INCLUDE_DIR)
-      get_install_dest(${pkg} INCLUDE LIB_DIR)
+      get_install_dest(${pkg} LIB LIB_DIR)
       get_install_dest(${pkg} ${destination} install_path)
       string(REGEX REPLACE "\.in$" "" name "${IN_FILE}")
       get_filename_component(name "${name}" NAME)
diff --git a/contrib/pkg_tester/__snapshots__/test_fdb_pkgs.ambr b/contrib/pkg_tester/__snapshots__/test_fdb_pkgs.ambr
index 91e9ee8bd1..fac2c0346f 100644
--- a/contrib/pkg_tester/__snapshots__/test_fdb_pkgs.ambr
+++ b/contrib/pkg_tester/__snapshots__/test_fdb_pkgs.ambr
@@ -48,29 +48,25 @@
 ---
 # name: test_execstack_permissions_libfdb_c[centos-versioned]
   '
-    GNU_STACK      0x0000000000000000 0x0000000000000000 0x0000000000000000
-                   0x0000000000000000 0x0000000000000000  RW     0x0
+  - /lib64/libfdb_c.so
   
   '
 ---
 # name: test_execstack_permissions_libfdb_c[centos]
   '
-    GNU_STACK      0x0000000000000000 0x0000000000000000 0x0000000000000000
-                   0x0000000000000000 0x0000000000000000  RW     0x0
+  - /lib64/libfdb_c.so
   
   '
 ---
 # name: test_execstack_permissions_libfdb_c[ubuntu-versioned]
   '
-    GNU_STACK      0x0000000000000000 0x0000000000000000 0x0000000000000000
-                   0x0000000000000000 0x0000000000000000  RW     0x0
+  - /lib/libfdb_c.so
   
   '
 ---
 # name: test_execstack_permissions_libfdb_c[ubuntu]
   '
-    GNU_STACK      0x0000000000000000 0x0000000000000000 0x0000000000000000
-                   0x0000000000000000 0x0000000000000000  RW     0x0
+  - /lib/libfdb_c.so
   
   '
 ---
diff --git a/contrib/pkg_tester/test_fdb_pkgs.py b/contrib/pkg_tester/test_fdb_pkgs.py
index db8a1ae27b..08ccd35aa6 100644
--- a/contrib/pkg_tester/test_fdb_pkgs.py
+++ b/contrib/pkg_tester/test_fdb_pkgs.py
@@ -22,6 +22,7 @@ import pathlib
 import pytest
 import shlex
 import subprocess
+import sys
 import uuid
 
 from typing import Iterator, List, Optional, Union
@@ -29,9 +30,14 @@ from typing import Iterator, List, Optional, Union
 
 def run(args: List[str]) -> str:
     print("$ {}".format(" ".join(map(shlex.quote, args))))
-    result = subprocess.check_output(args).decode("utf-8")
-    print(result, end="")
-    return result
+    result = []
+    proc = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+    while proc.poll() is None:
+        text = proc.stdout.readline().decode("utf-8")
+        result.append(text)
+        sys.stdout.write(text)
+    assert proc.returncode == 0
+    return "".join(result)
 
 
 class Image:
@@ -106,7 +112,16 @@ def ubuntu_image_with_fdb_helper(versioned: bool) -> Iterator[Optional[Image]]:
         for deb in debs:
             container.copy_to(deb, "/opt")
         container.run(["bash", "-c", "apt-get update"])
-        container.run(["bash", "-c", "apt-get install --yes binutils"]) # this is for testing libfdb_c execstack permissions
+        container.run(
+            ["bash", "-c", "apt-get install --yes execstack"]
+        )  # this is for testing libfdb_c execstack permissions
+        container.run(
+            [
+                "bash",
+                "-c",
+                "DEBIAN_FRONTEND=noninteractive DEBCONF_NONINTERACTIVE_SEEN=true apt-get install --yes gcc pkg-config cmake",
+            ]
+        )  # this is for testing building client apps
         container.run(["bash", "-c", "dpkg -i /opt/*.deb"])
         container.run(["bash", "-c", "rm /opt/*.deb"])
         image = container.commit()
@@ -151,7 +166,12 @@ def centos_image_with_fdb_helper(versioned: bool) -> Iterator[Optional[Image]]:
         for rpm in rpms:
             container.copy_to(rpm, "/opt")
         container.run(["bash", "-c", "yum update -y"])
-        container.run(["bash", "-c", "yum install -y binutils"]) # this is for testing libfdb_c execstack permissions
+        container.run(
+            ["bash", "-c", "yum install -y prelink"]
+        )  # this is for testing libfdb_c execstack permissions
+        container.run(
+            ["bash", "-c", "yum install -y gcc pkg-config cmake make"]
+        )  # this is for testing building client apps
         container.run(["bash", "-c", "yum install -y /opt/*.rpm"])
         container.run(["bash", "-c", "rm /opt/*.rpm"])
         image = container.commit()
@@ -232,6 +252,70 @@ def test_db_available(linux_container: Container):
     linux_container.run(["fdbcli", "--exec", "get x"])
 
 
+def test_client_app(linux_container: Container):
+    test_client_app_script = r"""#!/bin/bash
+
+set -euxo pipefail
+
+cat > app.c << EOF
+// FDB_API_VERSION doesn't necessarily need to be kept up to date here
+#define FDB_API_VERSION 700
+#include <foundationdb/fdb_c.h>
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+static void check(fdb_error_t e) {
+    if (e) {
+        fprintf(stderr, "%s\n", fdb_get_error(e));
+        fflush(NULL);
+        abort();
+    }
+}
+
+int result = 0;
+
+static void callback(FDBFuture* f, void* _ignored) {
+    check(fdb_stop_network());
+}
+
+int main() {
+    check(fdb_select_api_version(700));
+    check(fdb_setup_network());
+    FDBDatabase* db;
+    check(fdb_create_database(NULL, &db));
+    FDBTransaction* tr;
+    check(fdb_database_create_transaction(db, &tr));
+    FDBFuture* f = fdb_transaction_get_read_version(tr);
+    check(fdb_future_set_callback(f, callback, NULL));
+    check(fdb_run_network());
+    fdb_future_destroy(f);
+    fdb_transaction_destroy(tr);
+    fdb_database_destroy(db);
+    return 0;
+}
+EOF
+
+cc app.c `pkg-config foundationdb-client --cflags --libs`
+./a.out
+
+cat > CMakeLists.txt << EOF
+project(app C)
+find_package(FoundationDB-Client REQUIRED)
+add_executable(app app.c)
+target_link_libraries(app PRIVATE fdb_c)
+EOF
+
+mkdir build
+cd build
+cmake ..
+make
+./app
+
+"""
+    linux_container.run(["bash", "-c", test_client_app_script])
+
+
 def test_write(linux_container: Container, snapshot):
     linux_container.run(["fdbcli", "--exec", "writemode on; set x y"])
     assert snapshot == linux_container.run(["fdbcli", "--exec", "get x"])
@@ -243,7 +327,7 @@ def test_execstack_permissions_libfdb_c(linux_container: Container, snapshot):
         [
             "bash",
             "-c",
-            "readelf -l $(ldconfig -p | grep libfdb_c | awk '{print $(NF)}') | grep -A1 GNU_STACK",
+            "execstack -q $(ldconfig -p | grep libfdb_c | awk '{print $(NF)}')",
         ]
     )
 

From 35baf4d74551726df3d78dfef3006482a7e1937c Mon Sep 17 00:00:00 2001
From: Sagar Vemuri <sagar.vemuri@snowflake.com>
Date: Tue, 26 Apr 2022 09:28:38 -0700
Subject: [PATCH 54/84] Validate commit request tenant prefixes on commit proxy

---
 .../sphinx/source/api-error-codes.rst         |   2 +
 fdbserver/CommitProxyServer.actor.cpp         | 112 +++++++++++++-----
 flow/error_definitions.h                      |   1 +
 3 files changed, 86 insertions(+), 29 deletions(-)

diff --git a/documentation/sphinx/source/api-error-codes.rst b/documentation/sphinx/source/api-error-codes.rst
index 7c06dbb6df..7dac09bd9c 100644
--- a/documentation/sphinx/source/api-error-codes.rst
+++ b/documentation/sphinx/source/api-error-codes.rst
@@ -176,6 +176,8 @@ FoundationDB may return the following error codes from API functions. If you nee
 +-----------------------------------------------+-----+--------------------------------------------------------------------------------+
 | unknown_tenant                                | 2137| Tenant is not available from this server                                       |
 +-----------------------------------------------+-----+--------------------------------------------------------------------------------+
+| illegal_tenant_access                         | 2138| Tenant information mismatch                                                    |
++-----------------------------------------------+-----+--------------------------------------------------------------------------------+
 | api_version_unset                             | 2200| API version is not set                                                         |
 +-----------------------------------------------+-----+--------------------------------------------------------------------------------+
 | api_version_already_set                       | 2201| API version may be set only once                                               |
diff --git a/fdbserver/CommitProxyServer.actor.cpp b/fdbserver/CommitProxyServer.actor.cpp
index 097c6f632f..1a9d5d8706 100644
--- a/fdbserver/CommitProxyServer.actor.cpp
+++ b/fdbserver/CommitProxyServer.actor.cpp
@@ -28,6 +28,7 @@
 #include "fdbclient/Knobs.h"
 #include "fdbclient/CommitProxyInterface.h"
 #include "fdbclient/NativeAPI.actor.h"
+#include "fdbclient/StorageServerInterface.h"
 #include "fdbclient/SystemData.h"
 #include "fdbclient/TransactionLineage.h"
 #include "fdbrpc/sim_validation.h"
@@ -236,6 +237,80 @@ struct ResolutionRequestBuilder {
 	}
 };
 
+ErrorOr<Optional<TenantMapEntry>> getTenantEntry(ProxyCommitData* commitData,
+                                                 Optional<TenantNameRef> tenant,
+                                                 Optional<int64_t> tenantId,
+                                                 bool logOnFailure) {
+	if (tenant.present()) {
+		auto itr = commitData->tenantMap.find(tenant.get());
+		if (itr == commitData->tenantMap.end()) {
+			if (logOnFailure) {
+				TraceEvent(SevWarn, "CommitProxyUnknownTenant", commitData->dbgid).detail("Tenant", tenant.get());
+			}
+
+			return unknown_tenant();
+		} else if (tenantId.present() && tenantId.get() != itr->second.id) {
+			if (logOnFailure) {
+				TraceEvent(SevWarn, "CommitProxyTenantIdMismatch", commitData->dbgid)
+				    .detail("Tenant", tenant.get())
+				    .detail("TenantId", tenantId)
+				    .detail("ExistingId", itr->second.id);
+			}
+
+			return unknown_tenant();
+		}
+
+		return ErrorOr<Optional<TenantMapEntry>>(Optional<TenantMapEntry>(itr->second));
+	}
+
+	return Optional<TenantMapEntry>();
+}
+
+bool verifyPrefix(ProxyCommitData* const commitData, const CommitTransactionRequest& req) {
+	ErrorOr<Optional<TenantMapEntry>> tenantEntry =
+	    getTenantEntry(commitData, req.tenantInfo.name.castTo<TenantNameRef>(), req.tenantInfo.tenantId, true);
+
+	if (tenantEntry.isError()) {
+		return true;
+	}
+
+	auto te = tenantEntry.get();
+	if (te.present()) {
+		Key tenantPrefix = te.get().prefix;
+
+		// auto& tenantPrefix = tenantEntry.get().get().prefix;
+		for (auto& m : req.transaction.mutations) {
+			if (m.param1 != metadataVersionKey) {
+				if (!m.param1.startsWith(tenantPrefix)) {
+					return false;
+				}
+				if (m.type == MutationRef::ClearRange && !m.param2.startsWith(tenantPrefix)) {
+					return false;
+				} else if (m.type != MutationRef::SetVersionstampedKey) {
+					// TODO: How should this be handled?
+					// Maybe skip checking this for now? If so, fall-through.
+				}
+			}
+		}
+
+		for (auto& rc : req.transaction.read_conflict_ranges) {
+			if (rc.begin != metadataVersionKey &&
+			    (!rc.begin.startsWith(tenantPrefix) || !rc.end.startsWith(tenantPrefix))) {
+				return false;
+			}
+		}
+
+		for (auto& wc : req.transaction.write_conflict_ranges) {
+			if (wc.begin != metadataVersionKey &&
+			    (!wc.begin.startsWith(tenantPrefix) || !wc.end.startsWith(tenantPrefix))) {
+				return false;
+			}
+		}
+	}
+
+	return true;
+}
+
 ACTOR Future<Void> commitBatcher(ProxyCommitData* commitData,
                                  PromiseStream<std::pair<std::vector<CommitTransactionRequest>, int>> out,
                                  FutureStream<CommitTransactionRequest> in,
@@ -282,6 +357,14 @@ ACTOR Future<Void> commitBatcher(ProxyCommitData* commitData,
 						    .detail("Size", bytes)
 						    .detail("Client", req.reply.getEndpoint().getPrimaryAddress());
 					}
+
+					if (!verifyPrefix(commitData, req)) {
+						++commitData->stats.txnCommitErrors;
+						req.reply.sendError(illegal_tenant_access());
+						TraceEvent(SevWarnAlways, "TenantPrefixMismatch").suppressFor(60);
+						continue;
+					}
+
 					++commitData->stats.txnCommitIn;
 
 					if (req.debugID.present()) {
@@ -450,35 +533,6 @@ ACTOR static Future<ResolveTransactionBatchReply> trackResolutionMetrics(Referen
 	return reply;
 }
 
-ErrorOr<Optional<TenantMapEntry>> getTenantEntry(ProxyCommitData* commitData,
-                                                 Optional<TenantNameRef> tenant,
-                                                 Optional<int64_t> tenantId,
-                                                 bool logOnFailure) {
-	if (tenant.present()) {
-		auto itr = commitData->tenantMap.find(tenant.get());
-		if (itr == commitData->tenantMap.end()) {
-			if (logOnFailure) {
-				TraceEvent(SevWarn, "CommitProxyUnknownTenant", commitData->dbgid).detail("Tenant", tenant.get());
-			}
-
-			return unknown_tenant();
-		} else if (tenantId.present() && tenantId.get() != itr->second.id) {
-			if (logOnFailure) {
-				TraceEvent(SevWarn, "CommitProxyTenantIdMismatch", commitData->dbgid)
-				    .detail("Tenant", tenant.get())
-				    .detail("TenantId", tenantId)
-				    .detail("ExistingId", itr->second.id);
-			}
-
-			return unknown_tenant();
-		}
-
-		return ErrorOr<Optional<TenantMapEntry>>(Optional<TenantMapEntry>(itr->second));
-	}
-
-	return Optional<TenantMapEntry>();
-}
-
 namespace CommitBatch {
 
 struct CommitBatchContext {
diff --git a/flow/error_definitions.h b/flow/error_definitions.h
index a80bd2d3a8..e24d840602 100755
--- a/flow/error_definitions.h
+++ b/flow/error_definitions.h
@@ -226,6 +226,7 @@ ERROR( invalid_tenant_name, 2134, "Tenant name cannot begin with \\xff");
 ERROR( tenant_prefix_allocator_conflict, 2135, "The database already has keys stored at the prefix allocated for the tenant");
 ERROR( tenants_disabled, 2136, "Tenants have been disabled in the cluster");
 ERROR( unknown_tenant, 2137, "Tenant is not available from this server")
+ERROR( illegal_tenant_access, 2138, "Tenant information mismatch")
 
 // 2200 - errors from bindings and official APIs
 ERROR( api_version_unset, 2200, "API version is not set" )

From fd993df807aa5c8f3811d00e5dca7564ad5e4696 Mon Sep 17 00:00:00 2001
From: Sagar Vemuri <sagar.vemuri@snowflake.com>
Date: Tue, 26 Apr 2022 13:52:38 -0700
Subject: [PATCH 55/84] Minor cleanup

---
 fdbserver/CommitProxyServer.actor.cpp | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/fdbserver/CommitProxyServer.actor.cpp b/fdbserver/CommitProxyServer.actor.cpp
index 1a9d5d8706..2b8a6079de 100644
--- a/fdbserver/CommitProxyServer.actor.cpp
+++ b/fdbserver/CommitProxyServer.actor.cpp
@@ -274,11 +274,8 @@ bool verifyPrefix(ProxyCommitData* const commitData, const CommitTransactionRequ
 		return true;
 	}
 
-	auto te = tenantEntry.get();
-	if (te.present()) {
-		Key tenantPrefix = te.get().prefix;
-
-		// auto& tenantPrefix = tenantEntry.get().get().prefix;
+	if (tenantEntry.get().present()) {
+		Key tenantPrefix = tenantEntry.get().get().prefix;
 		for (auto& m : req.transaction.mutations) {
 			if (m.param1 != metadataVersionKey) {
 				if (!m.param1.startsWith(tenantPrefix)) {

From 508ee73f86383069edccf6972e8027aa7789b0a6 Mon Sep 17 00:00:00 2001
From: greid <gabriel.reid@gmail.com>
Date: Sun, 24 Apr 2022 11:20:56 +0200
Subject: [PATCH 56/84] Fix compile errors in Java tutorial code

Use CompletableFuture::join instead of CompletableFuture::get
when blocking on futures in java tutorial snippets. This avoids
the unreported checked exceptions which prevent the snippets from
compiling (and is in line with the full tutorial code).
---
 documentation/sphinx/source/class-scheduling-java.rst | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/documentation/sphinx/source/class-scheduling-java.rst b/documentation/sphinx/source/class-scheduling-java.rst
index 42e0e988fd..35da3c0d38 100644
--- a/documentation/sphinx/source/class-scheduling-java.rst
+++ b/documentation/sphinx/source/class-scheduling-java.rst
@@ -148,7 +148,7 @@ is equivalent to something like:
         tr.set(Tuple.from("class", "class1").pack(), encodeInt(100));
         t.commit().join();
       } catch (RuntimeException e) {
-        t = t.onError(e).get();
+        t = t.onError(e).join();
       }
     }
 
@@ -290,10 +290,10 @@ This is easy -- we simply add a condition to check that the value is non-zero. L
   private static void signup(TransactionContext db, final String s, final String c) {
     db.run((Transaction tr) -> {
       byte[] rec = Tuple.from("attends", s, c).pack();
-      if (tr.get(rec).get() != null)
+      if (tr.get(rec).join() != null)
         return null; // already signed up
 
-      int seatsLeft = decodeInt(tr.get(Tuple.from("class", c).pack()).get());
+      int seatsLeft = decodeInt(tr.get(Tuple.from("class", c).pack()).join());
       if (seatsLeft == 0)
         throw new IllegalStateException("No remaining seats");
 

From d021b404eac23c26da948bb8e9464371973cd2af Mon Sep 17 00:00:00 2001
From: Vaidas Gasiunas <vaidas.gasiunas@snowflake.com>
Date: Fri, 22 Apr 2022 14:57:04 +0200
Subject: [PATCH 57/84] ApiTester: Fix error code handing in case of a timeout

---
 bindings/c/test/apitester/run_c_api_tests.py | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/bindings/c/test/apitester/run_c_api_tests.py b/bindings/c/test/apitester/run_c_api_tests.py
index 6d487ec62a..a8503aa139 100755
--- a/bindings/c/test/apitester/run_c_api_tests.py
+++ b/bindings/c/test/apitester/run_c_api_tests.py
@@ -56,6 +56,7 @@ def run_tester(args, test_file):
         cmd += ["--external-client-library", args.external_client_library]
     if args.tmp_dir is not None:
         cmd += ["--tmp-dir", args.tmp_dir]
+
     if args.blob_granule_local_file_path is not None:
         cmd += ["--blob-granule-local-file-path",
                 args.blob_granule_local_file_path]
@@ -63,6 +64,7 @@ def run_tester(args, test_file):
     get_logger().info('\nRunning tester \'%s\'...' % ' '.join(cmd))
     proc = Popen(cmd, stdout=sys.stdout, stderr=sys.stderr)
     timed_out = False
+    ret_code = 1
     try:
         ret_code = proc.wait(args.timeout)
     except TimeoutExpired:
@@ -72,13 +74,12 @@ def run_tester(args, test_file):
         raise Exception('Unable to run tester (%s)' % e)
 
     if ret_code != 0:
-        if ret_code < 0:
+        if timed_out:
+            reason = 'timed out after %d seconds' % args.timeout
+        elif ret_code < 0:
             reason = signal.Signals(-ret_code).name
         else:
             reason = 'exit code: %d' % ret_code
-        if timed_out:
-            reason = 'timed out after %d seconds' % args.timeout
-            ret_code = 1
         get_logger().error('\n\'%s\' did not complete succesfully (%s)' %
                            (cmd[0], reason))
 

From 6f841446a530c6fd9a57a0b3c840e6d51ce9bafd Mon Sep 17 00:00:00 2001
From: Vaidas Gasiunas <vaidas.gasiunas@snowflake.com>
Date: Tue, 26 Apr 2022 13:54:33 +0200
Subject: [PATCH 58/84] API Tests: Enable client logs. Dump out the logs in
 case of an error

---
 bindings/c/CMakeLists.txt                    |  6 +++++
 bindings/c/test/apitester/run_c_api_tests.py | 26 +++++++++++++++++++-
 2 files changed, 31 insertions(+), 1 deletion(-)

diff --git a/bindings/c/CMakeLists.txt b/bindings/c/CMakeLists.txt
index 293e6aa322..9258d384d9 100644
--- a/bindings/c/CMakeLists.txt
+++ b/bindings/c/CMakeLists.txt
@@ -276,6 +276,8 @@ endif()
             ${CMAKE_SOURCE_DIR}/bindings/c/test/apitester/tests
             --tmp-dir
             @TMP_DIR@
+            --log-dir
+            @LOG_DIR@
             )
 
   add_fdbclient_test(
@@ -293,6 +295,10 @@ endif()
             ${CMAKE_SOURCE_DIR}/bindings/c/test/apitester/blobgranuletests
             --blob-granule-local-file-path
             @DATA_DIR@/fdbblob/
+            --tmp-dir
+            @TMP_DIR@
+            --log-dir
+            @LOG_DIR@
             )
 
   if(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64" AND NOT USE_SANITIZER)
diff --git a/bindings/c/test/apitester/run_c_api_tests.py b/bindings/c/test/apitester/run_c_api_tests.py
index a8503aa139..397a09f739 100755
--- a/bindings/c/test/apitester/run_c_api_tests.py
+++ b/bindings/c/test/apitester/run_c_api_tests.py
@@ -20,12 +20,19 @@
 #
 
 import sys
-import subprocess
 import argparse
 import os
 from subprocess import Popen, TimeoutExpired
 import logging
 import signal
+from pathlib import Path
+import glob
+import random
+import string
+
+
+def random_string(len):
+    return ''.join(random.choice(string.ascii_letters + string.digits) for i in range(len))
 
 
 def get_logger():
@@ -48,6 +55,14 @@ def initialize_logger_level(logging_level):
         logger.setLevel(logging.ERROR)
 
 
+def dump_client_logs(log_dir):
+    for log_file in glob.glob(os.path.join(log_dir, "*")):
+        print(">>>>>>>>>>>>>>>>>>>> Contents of {}:".format(log_file))
+        with open(log_file, "r") as f:
+            print(f.read())
+        print(">>>>>>>>>>>>>>>>>>>> End of {}:".format(log_file))
+
+
 def run_tester(args, test_file):
     cmd = [args.tester_binary,
            "--cluster-file", args.cluster_file,
@@ -56,6 +71,11 @@ def run_tester(args, test_file):
         cmd += ["--external-client-library", args.external_client_library]
     if args.tmp_dir is not None:
         cmd += ["--tmp-dir", args.tmp_dir]
+    log_dir = None
+    if args.log_dir is not None:
+        log_dir = Path(args.log_dir).joinpath(random_string(8))
+        log_dir.mkdir(exist_ok=True)
+        cmd += ['--log', "--log-dir", str(log_dir)]
 
     if args.blob_granule_local_file_path is not None:
         cmd += ["--blob-granule-local-file-path",
@@ -82,6 +102,8 @@ def run_tester(args, test_file):
             reason = 'exit code: %d' % ret_code
         get_logger().error('\n\'%s\' did not complete succesfully (%s)' %
                            (cmd[0], reason))
+        if (log_dir is not None):
+            dump_client_logs(log_dir)
 
     get_logger().info('')
     return ret_code
@@ -116,6 +138,8 @@ def parse_args(argv):
                         help='Path to a directory with test definitions. (default: ./)')
     parser.add_argument('--timeout', type=int, default=300,
                         help='The timeout in seconds for running each individual test. (default 300)')
+    parser.add_argument('--log-dir', type=str, default=None,
+                        help='The directory for storing logs (default: None)')
     parser.add_argument('--logging-level', type=str, default='INFO',
                         choices=['ERROR', 'WARNING', 'INFO', 'DEBUG'], help='Specifies the level of detail in the tester output (default=\'INFO\').')
     parser.add_argument('--tmp-dir', type=str, default=None,

From f4fb45abac6830a69486ff7067b697fcc18ab658 Mon Sep 17 00:00:00 2001
From: LukasMol <lukas.molleman@ugent.be>
Date: Wed, 27 Apr 2022 17:01:20 +0200
Subject: [PATCH 59/84] tests/ black code reformat

---
 tests/TestRunner/TestDirectory.py             |  11 +-
 tests/TestRunner/TestRunner.py                | 442 +++++++++++-------
 tests/TestRunner/fake_cluster.py              |  41 +-
 tests/TestRunner/local_cluster.py             | 133 +++---
 tests/TestRunner/tmp_cluster.py               |  36 +-
 tests/TestRunner/tmp_multi_cluster.py         |  41 +-
 tests/TestRunner/upgrade_test.py              | 277 +++++++----
 .../argument_parsing/test_argument_parsing.py |  87 ++--
 tests/python_tests/__init__.py                |  63 ++-
 tests/python_tests/multithreaded_client.py    |  37 +-
 tests/python_tests/python_correctness.py      | 358 ++++++++------
 tests/python_tests/python_performance.py      | 102 ++--
 tests/python_tests/ryw_benchmark.py           |  74 +--
 13 files changed, 1073 insertions(+), 629 deletions(-)

diff --git a/tests/TestRunner/TestDirectory.py b/tests/TestRunner/TestDirectory.py
index c3f48b09bc..befa5f0049 100755
--- a/tests/TestRunner/TestDirectory.py
+++ b/tests/TestRunner/TestDirectory.py
@@ -9,29 +9,28 @@ class TestDirectory:
         self.builddir = builddir
 
     def get_test_root(self):
-        root = os.path.join(self.builddir, 'test_runs')
+        root = os.path.join(self.builddir, "test_runs")
         if not os.path.exists(root):
             os.mkdir(root)
         return root
 
     def create_new_test_dir(self):
         t = self.get_test_root()
-        ts = datetime.now().strftime('%Y_%m_%d__%H_%M_%S')
+        ts = datetime.now().strftime("%Y_%m_%d__%H_%M_%S")
         r = os.path.join(t, ts)
         os.mkdir(r)
         return r
 
     def get_current_test_dir(self):
         r = self.get_test_root()
-        dirs = list(filter(lambda x: os.path.isdir(os.path.join(r, x)),
-                           os.listdir(r)))
+        dirs = list(filter(lambda x: os.path.isdir(os.path.join(r, x)), os.listdir(r)))
         dirs.sort()
         return os.path.join(r, dirs[-1])
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     parser = ArgumentParser()
-    parser.add_argument('builddir')
+    parser.add_argument("builddir")
     args = parser.parse_args()
     td = TestDirectory(args.builddir)
     td.create_new_test_dir()
diff --git a/tests/TestRunner/TestRunner.py b/tests/TestRunner/TestRunner.py
index 5dbecb9578..c6b405a654 100755
--- a/tests/TestRunner/TestRunner.py
+++ b/tests/TestRunner/TestRunner.py
@@ -20,14 +20,16 @@ _logger = None
 
 def init_logging(loglevel, logdir):
     global _logger
-    _logger = logging.getLogger('TestRunner')
+    _logger = logging.getLogger("TestRunner")
     _logger.setLevel(logging.DEBUG)
-    formatter = logging.Formatter('%(asctime)s - %(process)d - %(levelname)s - %(message)s')
+    formatter = logging.Formatter(
+        "%(asctime)s - %(process)d - %(levelname)s - %(message)s"
+    )
     try:
         os.makedirs(logdir)
     except OSError:
         pass
-    fh = logging.FileHandler(os.path.join(logdir, 'run_test.log'))
+    fh = logging.FileHandler(os.path.join(logdir, "run_test.log"))
     fh.setLevel(logging.DEBUG)
     fh.setFormatter(formatter)
     sh = logging.StreamHandler()
@@ -38,35 +40,37 @@ def init_logging(loglevel, logdir):
 
 
 class LogParser:
-    def __init__(self, basedir, name, infile, out, aggregation_policy, symbolicate_backtraces):
+    def __init__(
+        self, basedir, name, infile, out, aggregation_policy, symbolicate_backtraces
+    ):
         self.basedir = basedir
         self.name = name
         self.infile = infile
         self.backtraces = []
         self.result = True
-        self.address_re = re.compile(r'(0x[0-9a-f]+\s+)+')
+        self.address_re = re.compile(r"(0x[0-9a-f]+\s+)+")
         self.aggregationPolicy = aggregation_policy
         self.symbolicateBacktraces = symbolicate_backtraces
         self.outStream = None
-        if self.aggregationPolicy == 'NONE':
+        if self.aggregationPolicy == "NONE":
             self.out = None
-        elif self.aggregationPolicy != 'ALL':
+        elif self.aggregationPolicy != "ALL":
             self.out = io.StringIO()
             self.outStream = out
         else:
             self.out = out
 
     def write(self, txt):
-        if self.aggregationPolicy == 'NONE':
+        if self.aggregationPolicy == "NONE":
             pass
-        elif not self.result or self.aggregationPolicy == 'ALL':
+        elif not self.result or self.aggregationPolicy == "ALL":
             self.out.write(txt)
         else:
             self.outStream.wite(txt)
 
     def fail(self):
         self.result = False
-        if self.aggregationPolicy == 'FAILED':
+        if self.aggregationPolicy == "FAILED":
             self.out.write(self.outStream.getvalue())
             self.outStream = None
 
@@ -79,26 +83,29 @@ class LogParser:
     def apply_address_to_line(self, obj):
         addresses = self.sanitize_backtrace(obj)
         assert addresses is not None
-        binary_ext = ''
-        if sys.platform == 'win32':
+        binary_ext = ""
+        if sys.platform == "win32":
             # config = options.config
-            binary_ext = '.exe'
-        fdbbin = os.path.realpath(os.path.join(basedir, 'bin', 'Release', 'fdbserver' + binary_ext))
+            binary_ext = ".exe"
+        fdbbin = os.path.realpath(
+            os.path.join(basedir, "bin", "Release", "fdbserver" + binary_ext)
+        )
         try:
             resolved = subprocess.check_output(
-                ('addr2line -e %s -C -f -i' % fdbbin).split() + addresses.split()).splitlines()
+                ("addr2line -e %s -C -f -i" % fdbbin).split() + addresses.split()
+            ).splitlines()
             tmp = dict(**obj)
             for i, line in enumerate(resolved):
-                tmp['line%04d' % i] = line.decode('utf-8')
+                tmp["line%04d" % i] = line.decode("utf-8")
             return tmp
         except (subprocess.CalledProcessError, UnicodeDecodeError):
-            obj['FailedAddr2LineResolution'] = 'true'
+            obj["FailedAddr2LineResolution"] = "true"
             return obj
 
     def sanitize_backtrace(self, obj):
         if sys.platform != "linux" and sys.platform != "linux2":
             return None
-        raw_backtrace = obj.get('Backtrace', None)
+        raw_backtrace = obj.get("Backtrace", None)
         if raw_backtrace is None:
             return None
         match = self.address_re.search(raw_backtrace)
@@ -110,19 +117,25 @@ class LogParser:
         linenr = 0
         with open(self.infile) as f:
             line = f.readline()
-            while line != '':
+            while line != "":
                 obj = self.processLine(line, linenr)
                 line = f.readline()
                 linenr += 1
                 if obj is None:
                     continue
-                if 'Type' not in obj:
+                if "Type" not in obj:
                     continue
-                if obj['Severity'] == '40' and obj.get('ErrorIsInjectedFault', None) != '1':
+                if (
+                    obj["Severity"] == "40"
+                    and obj.get("ErrorIsInjectedFault", None) != "1"
+                ):
                     self.fail()
                 if self.name is not None:
-                    obj['testname'] = self.name
-                if self.symbolicateBacktraces and self.sanitize_backtrace(obj) is not None:
+                    obj["testname"] = self.name
+                if (
+                    self.symbolicateBacktraces
+                    and self.sanitize_backtrace(obj) is not None
+                ):
                     obj = self.apply_address_to_line(obj)
                 self.writeObject(obj)
 
@@ -131,32 +144,36 @@ class LogParser:
         _logger.error("Process trace line file {} Failed".format(self.infile))
         _logger.error("Exception {} args: {}".format(type(e), e.args))
         _logger.error("Line: '{}'".format(linenr))
-        obj['Severity'] = "warning"
-        obj['Type'] = "TestInfastructureLogLineGarbled"
-        obj['isLastLine'] = "TestFailure"
-        obj['TraceLine'] = linenr
-        obj['File'] = self.infile
+        obj["Severity"] = "warning"
+        obj["Type"] = "TestInfastructureLogLineGarbled"
+        obj["isLastLine"] = "TestFailure"
+        obj["TraceLine"] = linenr
+        obj["File"] = self.infile
         return obj
 
     def process_return_codes(self, return_codes):
         for (command, return_code) in return_codes.items():
             return_code_trace = {}
             if return_code != 0:
-                return_code_trace['Severity'] = '40'
-                return_code_trace['Type'] = 'TestFailure'
+                return_code_trace["Severity"] = "40"
+                return_code_trace["Type"] = "TestFailure"
                 self.fail()
             else:
-                return_code_trace['Severity'] = '10'
-                return_code_trace['Type'] = 'ReturnCode'
-            return_code_trace['Command'] = command
-            return_code_trace['ReturnCode'] = return_code
-            return_code_trace['testname'] = self.name
+                return_code_trace["Severity"] = "10"
+                return_code_trace["Type"] = "ReturnCode"
+            return_code_trace["Command"] = command
+            return_code_trace["ReturnCode"] = return_code
+            return_code_trace["testname"] = self.name
             self.writeObject(return_code_trace)
 
 
 class JSONParser(LogParser):
-    def __init__(self, basedir, name, infile, out, aggregation_policy, symbolicate_backtraces):
-        super().__init__(basedir, name, infile, out, aggregation_policy, symbolicate_backtraces)
+    def __init__(
+        self, basedir, name, infile, out, aggregation_policy, symbolicate_backtraces
+    ):
+        super().__init__(
+            basedir, name, infile, out, aggregation_policy, symbolicate_backtraces
+        )
 
     def process_line(self, line, linenr):
         try:
@@ -166,7 +183,7 @@ class JSONParser(LogParser):
 
     def write_object(self, obj):
         self.write(json.dumps(obj))
-        self.write('\n')
+        self.write("\n")
 
 
 class XMLParser(LogParser):
@@ -176,7 +193,7 @@ class XMLParser(LogParser):
             self.result = {}
 
         def startElement(self, name, attrs):
-            if name != 'Event':
+            if name != "Event":
                 return
             for (key, value) in attrs.items():
                 self.result[key] = value
@@ -196,8 +213,12 @@ class XMLParser(LogParser):
         def warning(self, exception):
             self.warnings.append(exception)
 
-    def __init__(self, basedir, name, infile, out, aggregation_policy, symbolicate_backtraces):
-        super().__init__(basedir, name, infile, out, aggregation_policy, symbolicate_backtraces)
+    def __init__(
+        self, basedir, name, infile, out, aggregation_policy, symbolicate_backtraces
+    ):
+        super().__init__(
+            basedir, name, infile, out, aggregation_policy, symbolicate_backtraces
+        )
 
     def write_header(self):
         self.write('<?xml version="1.0"?>\n<Trace>\n')
@@ -206,63 +227,95 @@ class XMLParser(LogParser):
         self.write("</Trace>")
 
     def write_object(self, obj):
-        self.write('<Event')
+        self.write("<Event")
         for (key, value) in obj.items():
             self.write(' {}="{}"'.format(key, value))
-        self.write('/>\n')
+        self.write("/>\n")
 
     def process_line(self, line, linenr):
         if linenr < 3:
             # the first two lines don't need to be parsed
             return None
-        if line.startswith('</'):
+        if line.startswith("</"):
             # don't parse the closing element
             return None
         handler = XMLParser.XMLHandler()
         error_handler = XMLParser.XMLErrorHandler()
-        xml.sax.parseString(line.encode('utf-8'), handler, errorHandler=error_handler)
+        xml.sax.parseString(line.encode("utf-8"), handler, errorHandler=error_handler)
         if len(error_handler.fatalErrors) > 0:
             return self.log_trace_parse_error(linenr, error_handler.fatalErrors[0])
         return handler.result
 
 
 def get_traces(d, log_format):
-    p = re.compile('^trace\\..*\\.{}$'.format(log_format))
-    traces = list(map(
-        functools.partial(os.path.join, d),
-        filter(
-            lambda f: p.match(f) is not None,
-            os.listdir(d))))
-    if os.path.isdir(os.path.join(d, 'testrunner')):
-        traces += list(map(
-            functools.partial(os.path.join, d, 'testrunner'),
-            filter(
-                lambda f: p.match(f) is not None,
-                os.listdir(os.path.join(d, 'testrunner')))))
+    p = re.compile("^trace\\..*\\.{}$".format(log_format))
+    traces = list(
+        map(
+            functools.partial(os.path.join, d),
+            filter(lambda f: p.match(f) is not None, os.listdir(d)),
+        )
+    )
+    if os.path.isdir(os.path.join(d, "testrunner")):
+        traces += list(
+            map(
+                functools.partial(os.path.join, d, "testrunner"),
+                filter(
+                    lambda f: p.match(f) is not None,
+                    os.listdir(os.path.join(d, "testrunner")),
+                ),
+            )
+        )
     return traces
 
 
-def process_traces(basedir, testname, path, out, aggregation_policy, symbolicate_backtraces, log_format, return_codes,
-                   cmake_seed):
+def process_traces(
+    basedir,
+    testname,
+    path,
+    out,
+    aggregation_policy,
+    symbolicate_backtraces,
+    log_format,
+    return_codes,
+    cmake_seed,
+):
     res = True
     backtraces = []
     parser = None
-    if log_format == 'json':
-        parser = JSONParser(basedir, testname, None, out, aggregation_policy, symbolicate_backtraces)
+    if log_format == "json":
+        parser = JSONParser(
+            basedir, testname, None, out, aggregation_policy, symbolicate_backtraces
+        )
     else:
-        parser = XMLParser(basedir, testname, None, out, aggregation_policy, symbolicate_backtraces)
+        parser = XMLParser(
+            basedir, testname, None, out, aggregation_policy, symbolicate_backtraces
+        )
     parser.process_return_codes(return_codes)
     res = parser.result
     for trace in get_traces(path, log_format):
-        if log_format == 'json':
-            parser = JSONParser(basedir, testname, trace, out, aggregation_policy, symbolicate_backtraces)
+        if log_format == "json":
+            parser = JSONParser(
+                basedir,
+                testname,
+                trace,
+                out,
+                aggregation_policy,
+                symbolicate_backtraces,
+            )
         else:
-            parser = XMLParser(basedir, testname, trace, out, aggregation_policy, symbolicate_backtraces)
+            parser = XMLParser(
+                basedir,
+                testname,
+                trace,
+                out,
+                aggregation_policy,
+                symbolicate_backtraces,
+            )
         if not res:
             parser.fail()
         parser.process_traces()
         res = res and parser.result
-    parser.write_object({'CMakeSEED': str(cmake_seed)})
+    parser.write_object({"CMakeSEED": str(cmake_seed)})
     return res
 
 
@@ -273,26 +326,46 @@ class RestartTestPolicy:
         self._second_binary = new_binary
         if old_binary is None:
             _logger.info("No old binary provided")
-        old_binary_version_raw = subprocess.check_output([old_binary, '--version']).decode('utf-8')
-        match = re.match('FoundationDB.*\(v([0-9]+\.[0-9]+\.[0-9]+)\)', old_binary_version_raw)
+        old_binary_version_raw = subprocess.check_output(
+            [old_binary, "--version"]
+        ).decode("utf-8")
+        match = re.match(
+            "FoundationDB.*\(v([0-9]+\.[0-9]+\.[0-9]+)\)", old_binary_version_raw
+        )
         assert match, old_binary_version_raw
-        old_binary_version = tuple(map(int, match.group(1).split('.')))
-        match = re.match('.*/restarting/from_([0-9]+\.[0-9]+\.[0-9]+)/', name)
+        old_binary_version = tuple(map(int, match.group(1).split(".")))
+        match = re.match(".*/restarting/from_([0-9]+\.[0-9]+\.[0-9]+)/", name)
         if match:  # upgrading _from_
-            lower_bound = tuple(map(int, match.group(1).split('.')))
+            lower_bound = tuple(map(int, match.group(1).split(".")))
             if old_binary_version >= lower_bound:
                 self._first_binary = old_binary
-                _logger.info("Using old binary as first binary: {} >= {}".format(old_binary_version, lower_bound))
+                _logger.info(
+                    "Using old binary as first binary: {} >= {}".format(
+                        old_binary_version, lower_bound
+                    )
+                )
             else:
-                _logger.info("Using new binary as first binary: {} < {}".format(old_binary_version, lower_bound))
-        match = re.match('.*/restarting/to_([0-9]+\.[0-9]+\.[0-9]+)/', name)
+                _logger.info(
+                    "Using new binary as first binary: {} < {}".format(
+                        old_binary_version, lower_bound
+                    )
+                )
+        match = re.match(".*/restarting/to_([0-9]+\.[0-9]+\.[0-9]+)/", name)
         if match:  # downgrading _to_
-            lower_bound = tuple(map(int, match.group(1).split('.')))
+            lower_bound = tuple(map(int, match.group(1).split(".")))
             if old_binary_version >= lower_bound:
                 self._second_binary = old_binary
-                _logger.info("Using old binary as second binary: {} >= {}".format(old_binary_version, lower_bound))
+                _logger.info(
+                    "Using old binary as second binary: {} >= {}".format(
+                        old_binary_version, lower_bound
+                    )
+                )
             else:
-                _logger.info("Using new binary as second binary: {} < {}".format(old_binary_version, lower_bound))
+                _logger.info(
+                    "Using new binary as second binary: {} < {}".format(
+                        old_binary_version, lower_bound
+                    )
+                )
 
     def first_binary(self):
         return self._first_binary
@@ -302,34 +375,35 @@ class RestartTestPolicy:
 
 
 def run_simulation_test(basedir, options):
-    config = ''
-    binary_ext = ''
-    if sys.platform == 'win32':
+    config = ""
+    binary_ext = ""
+    if sys.platform == "win32":
         config = options.config
-        binary_ext = '.exe'
-    fdbserver = os.path.realpath(os.path.join(basedir, 'bin', config, 'fdbserver' + binary_ext))
-    pargs = [fdbserver,
-             '-r', options.testtype]
+        binary_ext = ".exe"
+    fdbserver = os.path.realpath(
+        os.path.join(basedir, "bin", config, "fdbserver" + binary_ext)
+    )
+    pargs = [fdbserver, "-r", options.testtype]
     seed = 0
     if options.seed is not None:
-        pargs.append('-s')
+        pargs.append("-s")
         seed = int(options.seed, 0)
         if options.test_number:
             idx = int(options.test_number)
             seed = ((seed + idx) % (2 ** 32 - 2)) + 1
         pargs.append("{}".format(seed))
-    if options.testtype == 'test':
-        pargs.append('-C')
-        pargs.append(os.path.join(args.builddir, 'fdb.cluster'))
+    if options.testtype == "test":
+        pargs.append("-C")
+        pargs.append(os.path.join(args.builddir, "fdb.cluster"))
     td = TestDirectory(basedir)
     if options.buggify:
-        pargs.append('-b')
-        pargs.append('on')
+        pargs.append("-b")
+        pargs.append("on")
     if options.crash:
-        pargs.append('--crash')
+        pargs.append("--crash")
 
     # Use old style argument with underscores because old binaries don't support hyphens
-    pargs.append('--trace_format')
+    pargs.append("--trace_format")
     pargs.append(options.log_format)
     test_dir = td.get_current_test_dir()
     if options.seed is not None:
@@ -337,14 +411,15 @@ def run_simulation_test(basedir, options):
         if options.test_number:
             idx = int(options.test_number)
             seed = ((seed + idx) % (2 ** 32 - 2)) + 1
-    wd = os.path.join(test_dir,
-                      'test_{}'.format(options.name.replace('/', '_')))
+    wd = os.path.join(test_dir, "test_{}".format(options.name.replace("/", "_")))
     os.mkdir(wd)
     return_codes = {}  # {command: return_code}
     first = True
     restart_test_policy = None
     if len(options.testfile) > 1:
-        restart_test_policy = RestartTestPolicy(options.testfile[0], options.old_binary, fdbserver)
+        restart_test_policy = RestartTestPolicy(
+            options.testfile[0], options.old_binary, fdbserver
+        )
     for testfile in options.testfile:
         tmp = list(pargs)
         valgrind_args = []
@@ -355,54 +430,67 @@ def run_simulation_test(basedir, options):
                 tmp[0] = restart_test_policy.second_binary()
         # old_binary is not under test, so don't run under valgrind
         if options.use_valgrind and tmp[0] == fdbserver:
-            valgrind_args = ['valgrind', '--error-exitcode=99', '--']
+            valgrind_args = ["valgrind", "--error-exitcode=99", "--"]
         if not first:
-            tmp.append('-R')
+            tmp.append("-R")
             if seed is not None:
-                seed = ((seed + 1) % (2 ** 32 - 2))
+                seed = (seed + 1) % (2 ** 32 - 2)
         first = False
         if seed is not None:
-            tmp.append('-s')
+            tmp.append("-s")
             tmp.append("{}".format(seed))
-        tmp.append('-f')
+        tmp.append("-f")
         tmp.append(testfile)
         tmp = valgrind_args + tmp
-        command = ' '.join(tmp)
+        command = " ".join(tmp)
         _logger.info("COMMAND: {}".format(command))
-        proc = subprocess.Popen(tmp,
-                                stdout=sys.stdout,
-                                stderr=sys.stderr,
-                                cwd=wd)
+        proc = subprocess.Popen(tmp, stdout=sys.stdout, stderr=sys.stderr, cwd=wd)
         proc.wait()
         return_codes[command] = proc.returncode
-        outfile = os.path.join(test_dir, 'traces.{}'.format(options.log_format))
+        outfile = os.path.join(test_dir, "traces.{}".format(options.log_format))
         res = True
-        if options.aggregate_traces == 'NONE':
-            res = process_traces(basedir, options.name,
-                                 wd, None, 'NONE', options.symbolicate,
-                                 options.log_format, return_codes, options.seed)
+        if options.aggregate_traces == "NONE":
+            res = process_traces(
+                basedir,
+                options.name,
+                wd,
+                None,
+                "NONE",
+                options.symbolicate,
+                options.log_format,
+                return_codes,
+                options.seed,
+            )
 
         else:
-            with open(outfile, 'a') as f:
+            with open(outfile, "a") as f:
                 os.lockf(f.fileno(), os.F_LOCK, 0)
                 pos = f.tell()
-                res = process_traces(basedir, options.name,
-                                     wd, f, options.aggregate_traces, options.symbolicate,
-                                     options.log_format, return_codes, options.seed)
+                res = process_traces(
+                    basedir,
+                    options.name,
+                    wd,
+                    f,
+                    options.aggregate_traces,
+                    options.symbolicate,
+                    options.log_format,
+                    return_codes,
+                    options.seed,
+                )
                 f.seek(pos)
                 os.lockf(f.fileno(), os.F_ULOCK, 0)
         if proc.returncode != 0 or not res:
             break
-    if options.keep_logs == 'NONE' or options.keep_logs == 'FAILED' and res:
+    if options.keep_logs == "NONE" or options.keep_logs == "FAILED" and res:
         print("Deleting old logs in {}".format(wd))
         traces = get_traces(wd, options.log_format)
         for trace in traces:
             os.remove(trace)
-    if options.keep_simdirs == 'NONE' or options.keep_simdirs == 'FAILED' and res:
-        print("Delete {}".format(os.path.join(wd, 'simfdb')))
+    if options.keep_simdirs == "NONE" or options.keep_simdirs == "FAILED" and res:
+        print("Delete {}".format(os.path.join(wd, "simfdb")))
         # Don't fail if the directory doesn't exist.
         try:
-            shutil.rmtree(os.path.join(wd, 'simfdb'))
+            shutil.rmtree(os.path.join(wd, "simfdb"))
         except FileNotFoundError:
             pass
     if len(os.listdir(wd)) == 0:
@@ -411,47 +499,83 @@ def run_simulation_test(basedir, options):
     return res and proc.returncode == 0
 
 
-if __name__ == '__main__':
-    testtypes = ['simulation', 'test']
-    parser = ArgumentParser(description='Run a test preprocess trace')
-    parser.add_argument('-b', '--builddir', help='Path to build directory')
-    parser.add_argument('-s', '--sourcedir', help='Path to source directory')
-    parser.add_argument('-n', '--name', help='Name of the test')
-    parser.add_argument('-t', '--testtype', choices=testtypes,
-                        default='simulation',
-                        help='The type of test to run, choices are [{}]'.format(
-                            ', '.join(testtypes))),
-    parser.add_argument('-B', '--buggify', action='store_true',
-                        help='Enable buggify')
-    parser.add_argument('--logdir', default='logs',
-                        help='Directory for logs')
-    parser.add_argument('-l', '--loglevel',
-                        choices=['CRITICAL', 'ERROR', 'WARNING', 'INFO',
-                                 'DEBUG'],
-                        default='INFO')
-    parser.add_argument('-x', '--seed', required=False, default=None,
-                        help='The seed to use for this test')
-    parser.add_argument('-N', '--test-number', required=False, default=None,
-                        help='A unique number for this test (for seed generation)')
-    parser.add_argument('-F', '--log-format', required=False, default='xml',
-                        choices=['xml', 'json'], help='Log format (json or xml)')
-    parser.add_argument('-O', '--old-binary', required=False, default=None,
-                        help='Path to the old binary to use for upgrade tests')
-    parser.add_argument('-S', '--symbolicate', action='store_true', default=False,
-                        help='Symbolicate backtraces in trace events')
-    parser.add_argument('--config', default=None,
-                        help='Configuration type to test')
-    parser.add_argument('--crash', action='store_true', default=False,
-                        help='Test ASSERT failures should crash the test')
-    parser.add_argument('--aggregate-traces', default='NONE',
-                        choices=['NONE', 'FAILED', 'ALL'])
-    parser.add_argument('--keep-logs', default='FAILED',
-                        choices=['NONE', 'FAILED', 'ALL'])
-    parser.add_argument('--keep-simdirs', default='NONE',
-                        choices=['NONE', 'FAILED', 'ALL'])
-    parser.add_argument('testfile', nargs="+", help='The tests to run')
-    parser.add_argument('--use-valgrind', action='store_true', default=False,
-                        help='Run under valgrind')
+if __name__ == "__main__":
+    testtypes = ["simulation", "test"]
+    parser = ArgumentParser(description="Run a test preprocess trace")
+    parser.add_argument("-b", "--builddir", help="Path to build directory")
+    parser.add_argument("-s", "--sourcedir", help="Path to source directory")
+    parser.add_argument("-n", "--name", help="Name of the test")
+    parser.add_argument(
+        "-t",
+        "--testtype",
+        choices=testtypes,
+        default="simulation",
+        help="The type of test to run, choices are [{}]".format(", ".join(testtypes)),
+    ),
+    parser.add_argument("-B", "--buggify", action="store_true", help="Enable buggify")
+    parser.add_argument("--logdir", default="logs", help="Directory for logs")
+    parser.add_argument(
+        "-l",
+        "--loglevel",
+        choices=["CRITICAL", "ERROR", "WARNING", "INFO", "DEBUG"],
+        default="INFO",
+    )
+    parser.add_argument(
+        "-x",
+        "--seed",
+        required=False,
+        default=None,
+        help="The seed to use for this test",
+    )
+    parser.add_argument(
+        "-N",
+        "--test-number",
+        required=False,
+        default=None,
+        help="A unique number for this test (for seed generation)",
+    )
+    parser.add_argument(
+        "-F",
+        "--log-format",
+        required=False,
+        default="xml",
+        choices=["xml", "json"],
+        help="Log format (json or xml)",
+    )
+    parser.add_argument(
+        "-O",
+        "--old-binary",
+        required=False,
+        default=None,
+        help="Path to the old binary to use for upgrade tests",
+    )
+    parser.add_argument(
+        "-S",
+        "--symbolicate",
+        action="store_true",
+        default=False,
+        help="Symbolicate backtraces in trace events",
+    )
+    parser.add_argument("--config", default=None, help="Configuration type to test")
+    parser.add_argument(
+        "--crash",
+        action="store_true",
+        default=False,
+        help="Test ASSERT failures should crash the test",
+    )
+    parser.add_argument(
+        "--aggregate-traces", default="NONE", choices=["NONE", "FAILED", "ALL"]
+    )
+    parser.add_argument(
+        "--keep-logs", default="FAILED", choices=["NONE", "FAILED", "ALL"]
+    )
+    parser.add_argument(
+        "--keep-simdirs", default="NONE", choices=["NONE", "FAILED", "ALL"]
+    )
+    parser.add_argument("testfile", nargs="+", help="The tests to run")
+    parser.add_argument(
+        "--use-valgrind", action="store_true", default=False, help="Run under valgrind"
+    )
     args = parser.parse_args()
     init_logging(args.loglevel, args.logdir)
     basedir = os.getcwd()
diff --git a/tests/TestRunner/fake_cluster.py b/tests/TestRunner/fake_cluster.py
index bbd4b41ee9..4c389ecb57 100755
--- a/tests/TestRunner/fake_cluster.py
+++ b/tests/TestRunner/fake_cluster.py
@@ -14,14 +14,13 @@ class ClusterFileGenerator:
         self.output_dir = Path(output_dir).resolve()
         assert self.output_dir.exists(), "{} does not exist".format(output_dir)
         assert self.output_dir.is_dir(), "{} is not a directory".format(output_dir)
-        self.tmp_dir = self.output_dir.joinpath(
-            'tmp', random_secret_string(16))
+        self.tmp_dir = self.output_dir.joinpath("tmp", random_secret_string(16))
         self.tmp_dir.mkdir(parents=True)
-        self.cluster_file_path = self.tmp_dir.joinpath('fdb.cluster')
+        self.cluster_file_path = self.tmp_dir.joinpath("fdb.cluster")
 
     def __enter__(self):
-        with open(self.cluster_file_path, 'x') as f:
-            f.write('foo:bar@1.1.1.1:5678\n')
+        with open(self.cluster_file_path, "x") as f:
+            f.write("foo:bar@1.1.1.1:5678\n")
 
         return self
 
@@ -32,9 +31,10 @@ class ClusterFileGenerator:
         shutil.rmtree(self.tmp_dir)
 
 
-if __name__ == '__main__':
-    parser = ArgumentParser(formatter_class=RawDescriptionHelpFormatter,
-                            description="""
+if __name__ == "__main__":
+    parser = ArgumentParser(
+        formatter_class=RawDescriptionHelpFormatter,
+        description="""
     This script generates a cluster file that can be used to run a test and that will
     be cleaned up when the test is over. The cluster file will not correspond to a real
     cluster.
@@ -44,11 +44,16 @@ if __name__ == '__main__':
 
     The environment variable FDB_CLUSTER_FILE is set to the generated cluster file for the command if
     it is not set already.
-    """)
-    parser.add_argument('--output-dir', '-o', metavar='OUTPUT_DIRECTORY',
-                        help='Directory where output files are written', required=True)
-    parser.add_argument('cmd', metavar="COMMAND",
-                        nargs="+", help="The command to run")
+    """,
+    )
+    parser.add_argument(
+        "--output-dir",
+        "-o",
+        metavar="OUTPUT_DIRECTORY",
+        help="Directory where output files are written",
+        required=True,
+    )
+    parser.add_argument("cmd", metavar="COMMAND", nargs="+", help="The command to run")
     args = parser.parse_args()
     errcode = 1
 
@@ -56,15 +61,17 @@ if __name__ == '__main__':
         print("cluster-file: {}".format(generator.cluster_file_path))
         cmd_args = []
         for cmd in args.cmd:
-            if cmd == '@CLUSTER_FILE@':
+            if cmd == "@CLUSTER_FILE@":
                 cmd_args.append(str(generator.cluster_file_path))
             else:
                 cmd_args.append(cmd)
 
         env = dict(**os.environ)
-        env['FDB_CLUSTER_FILE'] = env.get(
-            'FDB_CLUSTER_FILE', generator.cluster_file_path)
+        env["FDB_CLUSTER_FILE"] = env.get(
+            "FDB_CLUSTER_FILE", generator.cluster_file_path
+        )
         errcode = subprocess.run(
-            cmd_args, stdout=sys.stdout, stderr=sys.stderr, env=env).returncode
+            cmd_args, stdout=sys.stdout, stderr=sys.stderr, env=env
+        ).returncode
 
     sys.exit(errcode)
diff --git a/tests/TestRunner/local_cluster.py b/tests/TestRunner/local_cluster.py
index 03e3b26f71..defdead9ec 100644
--- a/tests/TestRunner/local_cluster.py
+++ b/tests/TestRunner/local_cluster.py
@@ -10,7 +10,7 @@ import time
 
 def _get_free_port_internal():
     with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-        s.bind(('0.0.0.0', 0))
+        s.bind(("0.0.0.0", 0))
         return s.getsockname()[1]
 
 
@@ -28,15 +28,16 @@ def get_free_port():
 
 def is_port_in_use(port):
     import socket
+
     with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-        return s.connect_ex(('localhost', port)) == 0
+        return s.connect_ex(("localhost", port)) == 0
 
 
 valid_letters_for_secret = string.ascii_letters + string.digits
 
 
 def random_secret_string(length):
-    return ''.join(random.choice(valid_letters_for_secret) for _ in range(length))
+    return "".join(random.choice(valid_letters_for_secret) for _ in range(length))
 
 
 class LocalCluster:
@@ -82,15 +83,24 @@ logdir = {logdir}
 ## Parameters set here override defaults from the [fdbserver] section
 """
 
-    def __init__(self, basedir: str, fdbserver_binary: str, fdbmonitor_binary: str, fdbcli_binary: str,
-                 process_number: int, create_config=True, port=None, ip_address=None,
-                 blob_granules_enabled: bool = False):
+    def __init__(
+        self,
+        basedir: str,
+        fdbserver_binary: str,
+        fdbmonitor_binary: str,
+        fdbcli_binary: str,
+        process_number: int,
+        create_config=True,
+        port=None,
+        ip_address=None,
+        blob_granules_enabled: bool = False,
+    ):
         self.basedir = Path(basedir)
-        self.etc = self.basedir.joinpath('etc')
-        self.log = self.basedir.joinpath('log')
-        self.data = self.basedir.joinpath('data')
-        self.conf_file = self.etc.joinpath('foundationdb.conf')
-        self.cluster_file = self.etc.joinpath('fdb.cluster')
+        self.etc = self.basedir.joinpath("etc")
+        self.log = self.basedir.joinpath("log")
+        self.data = self.basedir.joinpath("data")
+        self.conf_file = self.etc.joinpath("foundationdb.conf")
+        self.cluster_file = self.etc.joinpath("fdb.cluster")
         self.fdbserver_binary = Path(fdbserver_binary)
         self.fdbmonitor_binary = Path(fdbmonitor_binary)
         self.fdbcli_binary = Path(fdbcli_binary)
@@ -100,7 +110,7 @@ logdir = {logdir}
         self.log.mkdir(exist_ok=True)
         self.data.mkdir(exist_ok=True)
         self.process_number = process_number
-        self.ip_address = '127.0.0.1' if ip_address is None else ip_address
+        self.ip_address = "127.0.0.1" if ip_address is None else ip_address
         self.first_port = port
         self.blob_granules_enabled = blob_granules_enabled
         if blob_granules_enabled:
@@ -109,8 +119,7 @@ logdir = {logdir}
 
         if self.first_port is not None:
             self.last_used_port = int(self.first_port) - 1
-        self.server_ports = [self.__next_port()
-                             for _ in range(self.process_number)]
+        self.server_ports = [self.__next_port() for _ in range(self.process_number)]
         self.cluster_desc = random_secret_string(8)
         self.cluster_secret = random_secret_string(8)
         self.env_vars = {}
@@ -131,58 +140,66 @@ logdir = {logdir}
             return self.last_used_port
 
     def save_config(self):
-        new_conf_file = self.conf_file.parent / (self.conf_file.name + '.new')
-        with open(new_conf_file, 'x') as f:
+        new_conf_file = self.conf_file.parent / (self.conf_file.name + ".new")
+        with open(new_conf_file, "x") as f:
             conf_template = LocalCluster.configuration_template
             bg_knob_line = ""
             if self.use_legacy_conf_syntax:
                 conf_template = conf_template.replace("-", "_")
             if self.blob_granules_enabled:
                 bg_knob_line = "knob_bg_url=file://" + str(self.data) + "/fdbblob/"
-            f.write(conf_template.format(
-                etcdir=self.etc,
-                fdbserver_bin=self.fdbserver_binary,
-                datadir=self.data,
-                logdir=self.log,
-                ip_address=self.ip_address,
-                bg_knob_line=bg_knob_line
-            ))
+            f.write(
+                conf_template.format(
+                    etcdir=self.etc,
+                    fdbserver_bin=self.fdbserver_binary,
+                    datadir=self.data,
+                    logdir=self.log,
+                    ip_address=self.ip_address,
+                    bg_knob_line=bg_knob_line,
+                )
+            )
             # By default, the cluster only has one process
             # If a port number is given and process_number > 1, we will use subsequent numbers
             # E.g., port = 4000, process_number = 5
             # Then 4000,4001,4002,4003,4004 will be used as ports
             # If port number is not given, we will randomly pick free ports
             for port in self.server_ports:
-                f.write('[fdbserver.{server_port}]\n'.format(
-                    server_port=port))
+                f.write("[fdbserver.{server_port}]\n".format(server_port=port))
             if self.blob_granules_enabled:
                 # make last process a blob_worker class
-                f.write('class = blob_worker')
+                f.write("class = blob_worker")
             f.flush()
             os.fsync(f.fileno())
 
         os.replace(new_conf_file, self.conf_file)
 
     def create_cluster_file(self):
-        with open(self.cluster_file, 'x') as f:
-            f.write('{desc}:{secret}@{ip_addr}:{server_port}'.format(
-                desc=self.cluster_desc,
-                secret=self.cluster_secret,
-                ip_addr=self.ip_address,
-                server_port=self.server_ports[0]
-            ))
+        with open(self.cluster_file, "x") as f:
+            f.write(
+                "{desc}:{secret}@{ip_addr}:{server_port}".format(
+                    desc=self.cluster_desc,
+                    secret=self.cluster_secret,
+                    ip_addr=self.ip_address,
+                    server_port=self.server_ports[0],
+                )
+            )
 
     def start_cluster(self):
         assert not self.running, "Can't start a server that is already running"
-        args = [str(self.fdbmonitor_binary),
-                '--conffile',
-                str(self.etc.joinpath('foundationdb.conf')),
-                '--lockfile',
-                str(self.etc.joinpath('fdbmonitor.lock'))]
-        self.fdbmonitor_logfile = open(
-            self.log.joinpath('fdbmonitor.log'), 'w')
+        args = [
+            str(self.fdbmonitor_binary),
+            "--conffile",
+            str(self.etc.joinpath("foundationdb.conf")),
+            "--lockfile",
+            str(self.etc.joinpath("fdbmonitor.lock")),
+        ]
+        self.fdbmonitor_logfile = open(self.log.joinpath("fdbmonitor.log"), "w")
         self.process = subprocess.Popen(
-            args, stdout=self.fdbmonitor_logfile, stderr=self.fdbmonitor_logfile, env=self.process_env())
+            args,
+            stdout=self.fdbmonitor_logfile,
+            stderr=self.fdbmonitor_logfile,
+            env=self.process_env(),
+        )
         self.running = True
 
     def stop_cluster(self):
@@ -213,32 +230,36 @@ logdir = {logdir}
     def __exit__(self, xc_type, exc_value, traceback):
         self.stop_cluster()
 
-    def create_database(self, storage='ssd', enable_tenants=True):
-        db_config = 'configure new single {}'.format(storage)
+    def create_database(self, storage="ssd", enable_tenants=True):
+        db_config = "configure new single {}".format(storage)
         if enable_tenants:
             db_config += " tenant_mode=optional_experimental"
         if self.blob_granules_enabled:
             db_config += " blob_granules_enabled:=1"
-        args = [self.fdbcli_binary, '-C',
-                self.cluster_file, '--exec', db_config]
+        args = [self.fdbcli_binary, "-C", self.cluster_file, "--exec", db_config]
 
         res = subprocess.run(args, env=self.process_env())
         assert res.returncode == 0, "Create database failed with {}".format(
-            res.returncode)
+            res.returncode
+        )
 
         if self.blob_granules_enabled:
-            bg_args = [self.fdbcli_binary, '-C',
-                       self.cluster_file, '--exec', 'blobrange start \\x00 \\xff']
+            bg_args = [
+                self.fdbcli_binary,
+                "-C",
+                self.cluster_file,
+                "--exec",
+                "blobrange start \\x00 \\xff",
+            ]
             bg_res = subprocess.run(bg_args, env=self.process_env())
-            assert bg_res.returncode == 0, "Start blob granules failed with {}".format(bg_res.returncode)
+            assert bg_res.returncode == 0, "Start blob granules failed with {}".format(
+                bg_res.returncode
+            )
 
     def get_status(self):
-        args = [self.fdbcli_binary, '-C', self.cluster_file, '--exec',
-                'status json']
-        res = subprocess.run(args, env=self.process_env(),
-                             stdout=subprocess.PIPE)
-        assert res.returncode == 0, "Get status failed with {}".format(
-            res.returncode)
+        args = [self.fdbcli_binary, "-C", self.cluster_file, "--exec", "status json"]
+        res = subprocess.run(args, env=self.process_env(), stdout=subprocess.PIPE)
+        assert res.returncode == 0, "Get status failed with {}".format(res.returncode)
         return json.loads(res.stdout)
 
     def process_env(self):
diff --git a/tests/TestRunner/tmp_cluster.py b/tests/TestRunner/tmp_cluster.py
index 59d48804ec..d341c759e9 100755
--- a/tests/TestRunner/tmp_cluster.py
+++ b/tests/TestRunner/tmp_cluster.py
@@ -11,14 +11,17 @@ from pathlib import Path
 
 
 class TempCluster:
-    def __init__(self, build_dir: str, process_number: int = 1, port: str = None, blob_granules_enabled: bool = False):
+    def __init__(
+        self,
+        build_dir: str,
+        process_number: int = 1,
+        port: str = None,
+        blob_granules_enabled: bool = False,
+    ):
         self.build_dir = Path(build_dir).resolve()
         assert self.build_dir.exists(), "{} does not exist".format(build_dir)
         assert self.build_dir.is_dir(), "{} is not a directory".format(build_dir)
-        tmp_dir = self.build_dir.joinpath(
-            "tmp",
-            random_secret_string(16)
-        )
+        tmp_dir = self.build_dir.joinpath("tmp", random_secret_string(16))
         tmp_dir.mkdir(parents=True)
         self.cluster = LocalCluster(
             tmp_dir,
@@ -27,7 +30,7 @@ class TempCluster:
             self.build_dir.joinpath("bin", "fdbcli"),
             process_number,
             port=port,
-            blob_granules_enabled=blob_granules_enabled
+            blob_granules_enabled=blob_granules_enabled,
         )
         self.log = self.cluster.log
         self.etc = self.cluster.etc
@@ -75,8 +78,7 @@ if __name__ == "__main__":
         help="FDB build directory",
         required=True,
     )
-    parser.add_argument("cmd", metavar="COMMAND",
-                        nargs="+", help="The command to run")
+    parser.add_argument("cmd", metavar="COMMAND", nargs="+", help="The command to run")
     parser.add_argument(
         "--process-number",
         "-p",
@@ -85,18 +87,20 @@ if __name__ == "__main__":
         default=1,
     )
     parser.add_argument(
-        '--disable-log-dump',
-        help='Do not dump cluster log on error',
-        action="store_true"
+        "--disable-log-dump",
+        help="Do not dump cluster log on error",
+        action="store_true",
     )
     parser.add_argument(
-        '--blob-granules-enabled',
-        help='Enable blob granules',
-        action="store_true"
+        "--blob-granules-enabled", help="Enable blob granules", action="store_true"
     )
     args = parser.parse_args()
     errcode = 1
-    with TempCluster(args.build_dir, args.process_number, blob_granules_enabled=args.blob_granules_enabled) as cluster:
+    with TempCluster(
+        args.build_dir,
+        args.process_number,
+        blob_granules_enabled=args.blob_granules_enabled,
+    ) as cluster:
         print("log-dir: {}".format(cluster.log))
         print("etc-dir: {}".format(cluster.etc))
         print("data-dir: {}".format(cluster.data))
@@ -114,7 +118,7 @@ if __name__ == "__main__":
             elif cmd == "@TMP_DIR@":
                 cmd_args.append(str(cluster.tmp_dir))
             elif cmd.startswith("@DATA_DIR@"):
-                cmd_args.append(str(cluster.data) + cmd[len("@DATA_DIR@"):])
+                cmd_args.append(str(cluster.data) + cmd[len("@DATA_DIR@") :])
             else:
                 cmd_args.append(cmd)
         env = dict(**os.environ)
diff --git a/tests/TestRunner/tmp_multi_cluster.py b/tests/TestRunner/tmp_multi_cluster.py
index 5e5bc0beae..40e70dd626 100644
--- a/tests/TestRunner/tmp_multi_cluster.py
+++ b/tests/TestRunner/tmp_multi_cluster.py
@@ -27,19 +27,34 @@ from pathlib import Path
 from argparse import ArgumentParser, RawDescriptionHelpFormatter
 from tmp_cluster import TempCluster
 
-if __name__ == '__main__':
-    parser = ArgumentParser(formatter_class=RawDescriptionHelpFormatter, description="""
+if __name__ == "__main__":
+    parser = ArgumentParser(
+        formatter_class=RawDescriptionHelpFormatter,
+        description="""
 	This script automatically configures N temporary local clusters on the machine and then
 	calls a command while these clusters are running. As soon as the command returns, all
 	configured clusters are killed and all generated data is deleted.
 
 	The purpose of this is to support testing a set of integration tests using multiple clusters
 	(i.e. using the Multi-threaded client). 
-	""")
-    parser.add_argument('--build-dir', '-b', metavar='BUILD_DIRECTORY', help='FDB build director', required=True)
-    parser.add_argument('--clusters', '-c', metavar='NUM_CLUSTERS', type=int, help='The number of clusters to run',
-                        required=True)
-    parser.add_argument('cmd', metavar='COMMAND', nargs='+', help='The command to run')
+	""",
+    )
+    parser.add_argument(
+        "--build-dir",
+        "-b",
+        metavar="BUILD_DIRECTORY",
+        help="FDB build director",
+        required=True,
+    )
+    parser.add_argument(
+        "--clusters",
+        "-c",
+        metavar="NUM_CLUSTERS",
+        type=int,
+        help="The number of clusters to run",
+        required=True,
+    )
+    parser.add_argument("cmd", metavar="COMMAND", nargs="+", help="The command to run")
     args = parser.parse_args()
     errcode = 1
 
@@ -48,7 +63,7 @@ if __name__ == '__main__':
     num_clusters = args.clusters
 
     build_dir = Path(base_dir)
-    bin_dir = build_dir.joinpath('bin')
+    bin_dir = build_dir.joinpath("bin")
 
     clusters = []
     for c in range(1, num_clusters + 1):
@@ -60,11 +75,15 @@ if __name__ == '__main__':
 
     # all clusters should be running now, so run the subcommand
     # TODO (bfines): pass through the proper ENV commands so that the client can find everything
-    cluster_paths = ';'.join([str(cluster.etc.joinpath('fdb.cluster')) for cluster in clusters])
+    cluster_paths = ";".join(
+        [str(cluster.etc.joinpath("fdb.cluster")) for cluster in clusters]
+    )
     print(cluster_paths)
     env = dict(**os.environ)
-    env['FDB_CLUSTERS'] = env.get('FDB_CLUSTERS', cluster_paths)
-    errcode = subprocess.run(args.cmd, stdout=sys.stdout, stderr=sys.stderr, env=env).returncode
+    env["FDB_CLUSTERS"] = env.get("FDB_CLUSTERS", cluster_paths)
+    errcode = subprocess.run(
+        args.cmd, stdout=sys.stdout, stderr=sys.stderr, env=env
+    ).returncode
 
     # shutdown all the running clusters
     for tc in clusters:
diff --git a/tests/TestRunner/upgrade_test.py b/tests/TestRunner/upgrade_test.py
index f757bd89fd..8ebfcf038d 100755
--- a/tests/TestRunner/upgrade_test.py
+++ b/tests/TestRunner/upgrade_test.py
@@ -19,12 +19,52 @@ import hashlib
 from local_cluster import LocalCluster, random_secret_string
 
 SUPPORTED_PLATFORMS = ["x86_64"]
-SUPPORTED_VERSIONS = ["7.2.0", "7.1.1", "7.1.0", "7.0.0", "6.3.24", "6.3.23",
-                      "6.3.22", "6.3.18", "6.3.17", "6.3.16", "6.3.15", "6.3.13", "6.3.12", "6.3.9", "6.2.30",
-                      "6.2.29", "6.2.28", "6.2.27", "6.2.26", "6.2.25", "6.2.24", "6.2.23", "6.2.22", "6.2.21",
-                      "6.2.20", "6.2.19", "6.2.18", "6.2.17", "6.2.16", "6.2.15", "6.2.10", "6.1.13", "6.1.12",
-                      "6.1.11", "6.1.10", "6.0.18", "6.0.17", "6.0.16", "6.0.15", "6.0.14", "5.2.8", "5.2.7",
-                      "5.1.7", "5.1.6"]
+SUPPORTED_VERSIONS = [
+    "7.2.0",
+    "7.1.1",
+    "7.1.0",
+    "7.0.0",
+    "6.3.24",
+    "6.3.23",
+    "6.3.22",
+    "6.3.18",
+    "6.3.17",
+    "6.3.16",
+    "6.3.15",
+    "6.3.13",
+    "6.3.12",
+    "6.3.9",
+    "6.2.30",
+    "6.2.29",
+    "6.2.28",
+    "6.2.27",
+    "6.2.26",
+    "6.2.25",
+    "6.2.24",
+    "6.2.23",
+    "6.2.22",
+    "6.2.21",
+    "6.2.20",
+    "6.2.19",
+    "6.2.18",
+    "6.2.17",
+    "6.2.16",
+    "6.2.15",
+    "6.2.10",
+    "6.1.13",
+    "6.1.12",
+    "6.1.11",
+    "6.1.10",
+    "6.0.18",
+    "6.0.17",
+    "6.0.16",
+    "6.0.15",
+    "6.0.14",
+    "5.2.8",
+    "5.2.7",
+    "5.1.7",
+    "5.1.6",
+]
 FDB_DOWNLOAD_ROOT = "https://github.com/apple/foundationdb/releases/download/"
 CURRENT_VERSION = "7.2.0"
 HEALTH_CHECK_TIMEOUT_SEC = 5
@@ -69,9 +109,9 @@ def random_sleep(min_sec, max_sec):
 
 def compute_sha256(filename):
     hash_function = hashlib.sha256()
-    with open(filename, 'rb') as f:
+    with open(filename, "rb") as f:
         while True:
-            data = f.read(128*1024)
+            data = f.read(128 * 1024)
             if not data:
                 break
             hash_function.update(data)
@@ -80,31 +120,33 @@ def compute_sha256(filename):
 
 
 def read_to_str(filename):
-    with open(filename, 'r') as f:
+    with open(filename, "r") as f:
         return f.read()
 
 
 class UpgradeTest:
-    def __init__(self, build_dir: str, upgrade_path: list, process_number: int = 1, port: str = None):
+    def __init__(
+        self,
+        build_dir: str,
+        upgrade_path: list,
+        process_number: int = 1,
+        port: str = None,
+    ):
         self.build_dir = Path(build_dir).resolve()
         assert self.build_dir.exists(), "{} does not exist".format(build_dir)
         assert self.build_dir.is_dir(), "{} is not a directory".format(build_dir)
         self.upgrade_path = upgrade_path
         for version in upgrade_path:
             assert version in SUPPORTED_VERSIONS, "Unsupported version {}".format(
-                version)
+                version
+            )
         self.platform = platform.machine()
         assert self.platform in SUPPORTED_PLATFORMS, "Unsupported platform {}".format(
-            self.platform)
-        self.tmp_dir = self.build_dir.joinpath(
-            "tmp",
-            random_secret_string(16)
+            self.platform
         )
+        self.tmp_dir = self.build_dir.joinpath("tmp", random_secret_string(16))
         self.tmp_dir.mkdir(parents=True)
-        self.download_dir = self.build_dir.joinpath(
-            "tmp",
-            "old_binaries"
-        )
+        self.download_dir = self.build_dir.joinpath("tmp", "old_binaries")
         self.download_old_binaries()
         self.create_external_lib_dir()
         init_version = upgrade_path[0]
@@ -115,7 +157,7 @@ class UpgradeTest:
             self.binary_path(init_version, "fdbcli"),
             process_number,
             port=port,
-            create_config=False
+            create_config=False,
         )
         self.cluster.create_cluster_file()
         self.configure_version(init_version)
@@ -123,9 +165,11 @@ class UpgradeTest:
         self.etc = self.cluster.etc
         self.data = self.cluster.data
         self.input_pipe_path = self.tmp_dir.joinpath(
-            "input.{}".format(random_secret_string(8)))
+            "input.{}".format(random_secret_string(8))
+        )
         self.output_pipe_path = self.tmp_dir.joinpath(
-            "output.{}".format(random_secret_string(8)))
+            "output.{}".format(random_secret_string(8))
+        )
         os.mkfifo(self.input_pipe_path)
         os.mkfifo(self.output_pipe_path)
         self.progress_event = Event()
@@ -150,7 +194,9 @@ class UpgradeTest:
             return self.download_dir.joinpath(version)
 
     # Download an old binary of a given version from a remote repository
-    def download_old_binary(self, version, target_bin_name, remote_bin_name, make_executable):
+    def download_old_binary(
+        self, version, target_bin_name, remote_bin_name, make_executable
+    ):
         local_file = self.binary_path(version, target_bin_name)
         if local_file.exists():
             return
@@ -158,21 +204,16 @@ class UpgradeTest:
         # Download to a temporary file and then replace the target file atomically
         # to avoid consistency errors in case of multiple tests are downloading the
         # same file in parallel
-        local_file_tmp = Path("{}.{}".format(
-            str(local_file), random_secret_string(8)))
-        self.download_dir.joinpath(version).mkdir(
-            parents=True, exist_ok=True)
-        remote_file = "{}{}/{}".format(FDB_DOWNLOAD_ROOT,
-                                       version, remote_bin_name)
+        local_file_tmp = Path("{}.{}".format(str(local_file), random_secret_string(8)))
+        self.download_dir.joinpath(version).mkdir(parents=True, exist_ok=True)
+        remote_file = "{}{}/{}".format(FDB_DOWNLOAD_ROOT, version, remote_bin_name)
         remote_sha256 = "{}.sha256".format(remote_file)
         local_sha256 = Path("{}.sha256".format(local_file_tmp))
 
         for attempt_cnt in range(MAX_DOWNLOAD_ATTEMPTS):
-            print("Downloading '{}' to '{}'...".format(
-                remote_file, local_file_tmp))
+            print("Downloading '{}' to '{}'...".format(remote_file, local_file_tmp))
             request.urlretrieve(remote_file, local_file_tmp)
-            print("Downloading '{}' to '{}'...".format(
-                remote_sha256, local_sha256))
+            print("Downloading '{}' to '{}'...".format(remote_sha256, local_sha256))
             request.urlretrieve(remote_sha256, local_sha256)
             print("Download complete")
             assert local_file_tmp.exists(), "{} does not exist".format(local_file_tmp)
@@ -182,11 +223,15 @@ class UpgradeTest:
             if expected_checksum == actual_checkum:
                 print("Checksum OK")
                 break
-            print("Checksum mismatch. Expected: {} Actual: {}".format(
-                expected_checksum, actual_checkum))
-            if attempt_cnt == MAX_DOWNLOAD_ATTEMPTS-1:
+            print(
+                "Checksum mismatch. Expected: {} Actual: {}".format(
+                    expected_checksum, actual_checkum
+                )
+            )
+            if attempt_cnt == MAX_DOWNLOAD_ATTEMPTS - 1:
                 assert False, "Failed to download {} after {} attempts".format(
-                    local_file_tmp, MAX_DOWNLOAD_ATTEMPTS)
+                    local_file_tmp, MAX_DOWNLOAD_ATTEMPTS
+                )
 
         os.rename(local_file_tmp, local_file)
         os.remove(local_sha256)
@@ -199,14 +244,18 @@ class UpgradeTest:
         for version in self.upgrade_path:
             if version == CURRENT_VERSION:
                 continue
-            self.download_old_binary(version,
-                                     "fdbserver", "fdbserver.{}".format(self.platform), True)
-            self.download_old_binary(version,
-                                     "fdbmonitor", "fdbmonitor.{}".format(self.platform), True)
-            self.download_old_binary(version,
-                                     "fdbcli", "fdbcli.{}".format(self.platform), True)
-            self.download_old_binary(version,
-                                     "libfdb_c.so", "libfdb_c.{}.so".format(self.platform), False)
+            self.download_old_binary(
+                version, "fdbserver", "fdbserver.{}".format(self.platform), True
+            )
+            self.download_old_binary(
+                version, "fdbmonitor", "fdbmonitor.{}".format(self.platform), True
+            )
+            self.download_old_binary(
+                version, "fdbcli", "fdbcli.{}".format(self.platform), True
+            )
+            self.download_old_binary(
+                version, "libfdb_c.so", "libfdb_c.{}.so".format(self.platform), False
+            )
 
     # Create a directory for external client libraries for MVC and fill it
     # with the libraries necessary for the specified upgrade path
@@ -217,7 +266,8 @@ class UpgradeTest:
             src_file_path = self.lib_dir(version).joinpath("libfdb_c.so")
             assert src_file_path.exists(), "{} does not exist".format(src_file_path)
             target_file_path = self.external_lib_dir.joinpath(
-                "libfdb_c.{}.so".format(version))
+                "libfdb_c.{}.so".format(version)
+            )
             shutil.copyfile(src_file_path, target_file_path)
 
     # Perform a health check of the cluster: Use fdbcli status command to check if the number of
@@ -233,24 +283,32 @@ class UpgradeTest:
                 continue
             num_proc = len(status["cluster"]["processes"])
             if num_proc < self.cluster.process_number:
-                print("Health check: {} of {} processes found. Retrying".format(
-                    num_proc, self.cluster.process_number))
+                print(
+                    "Health check: {} of {} processes found. Retrying".format(
+                        num_proc, self.cluster.process_number
+                    )
+                )
                 time.sleep(1)
                 continue
-            assert num_proc == self.cluster.process_number, "Number of processes: expected: {}, actual: {}".format(
-                self.cluster.process_number, num_proc)
+            assert (
+                num_proc == self.cluster.process_number
+            ), "Number of processes: expected: {}, actual: {}".format(
+                self.cluster.process_number, num_proc
+            )
             for (_, proc_stat) in status["cluster"]["processes"].items():
                 proc_ver = proc_stat["version"]
-                assert proc_ver == self.cluster_version, "Process version: expected: {}, actual: {}".format(
-                    self.cluster_version, proc_ver)
+                assert (
+                    proc_ver == self.cluster_version
+                ), "Process version: expected: {}, actual: {}".format(
+                    self.cluster_version, proc_ver
+                )
             print("Health check: OK")
             return
         assert False, "Health check: Failed"
 
     # Create and save a cluster configuration for the given version
     def configure_version(self, version):
-        self.cluster.fdbmonitor_binary = self.binary_path(
-            version, "fdbmonitor")
+        self.cluster.fdbmonitor_binary = self.binary_path(version, "fdbmonitor")
         self.cluster.fdbserver_binary = self.binary_path(version, "fdbserver")
         self.cluster.fdbcli_binary = self.binary_path(version, "fdbcli")
         self.cluster.set_env_var = "LD_LIBRARY_PATH", self.lib_dir(version)
@@ -282,39 +340,52 @@ class UpgradeTest:
     def determine_api_version(self):
         self.api_version = api_version_from_str(CURRENT_VERSION)
         for version in self.upgrade_path:
-            self.api_version = min(
-                api_version_from_str(version), self.api_version)
+            self.api_version = min(api_version_from_str(version), self.api_version)
 
     # Start the tester to generate the workload specified by the test file
     def exec_workload(self, test_file):
         self.tester_retcode = 1
         try:
             self.determine_api_version()
-            cmd_args = [self.tester_bin,
-                        '--cluster-file', self.cluster.cluster_file,
-                        '--test-file', test_file,
-                        '--external-client-dir', self.external_lib_dir,
-                        '--disable-local-client',
-                        '--input-pipe', self.input_pipe_path,
-                        '--output-pipe', self.output_pipe_path,
-                        '--api-version', str(self.api_version),
-                        '--log',
-                        '--log-dir', self.log,
-                        '--tmp-dir', self.tmp_dir,
-                        '--transaction-retry-limit', str(TRANSACTION_RETRY_LIMIT)]
+            cmd_args = [
+                self.tester_bin,
+                "--cluster-file",
+                self.cluster.cluster_file,
+                "--test-file",
+                test_file,
+                "--external-client-dir",
+                self.external_lib_dir,
+                "--disable-local-client",
+                "--input-pipe",
+                self.input_pipe_path,
+                "--output-pipe",
+                self.output_pipe_path,
+                "--api-version",
+                str(self.api_version),
+                "--log",
+                "--log-dir",
+                self.log,
+                "--tmp-dir",
+                self.tmp_dir,
+                "--transaction-retry-limit",
+                str(TRANSACTION_RETRY_LIMIT),
+            ]
             if RUN_WITH_GDB:
-                cmd_args = ['gdb', '-ex', 'run', '--args'] + cmd_args
-            print("Executing test command: {}".format(
-                " ".join([str(c) for c in cmd_args])))
+                cmd_args = ["gdb", "-ex", "run", "--args"] + cmd_args
+            print(
+                "Executing test command: {}".format(
+                    " ".join([str(c) for c in cmd_args])
+                )
+            )
 
             self.tester_proc = subprocess.Popen(
-                cmd_args, stdout=sys.stdout, stderr=sys.stderr)
+                cmd_args, stdout=sys.stdout, stderr=sys.stderr
+            )
             self.tester_retcode = self.tester_proc.wait()
             self.tester_proc = None
 
             if self.tester_retcode != 0:
-                print("Tester failed with return code {}".format(
-                    self.tester_retcode))
+                print("Tester failed with return code {}".format(self.tester_retcode))
         except Exception:
             print("Execution of test workload failed")
             print(traceback.format_exc())
@@ -324,20 +395,20 @@ class UpgradeTest:
     def progress_check(self, ctrl_pipe):
         self.progress_event.clear()
         os.write(ctrl_pipe, b"CHECK\n")
-        self.progress_event.wait(
-            None if RUN_WITH_GDB else PROGRESS_CHECK_TIMEOUT_SEC)
+        self.progress_event.wait(None if RUN_WITH_GDB else PROGRESS_CHECK_TIMEOUT_SEC)
         if self.progress_event.is_set():
             print("Progress check: OK")
         else:
             assert False, "Progress check failed after upgrade to version {}".format(
-                self.cluster_version)
+                self.cluster_version
+            )
 
     # The main function of a thread for reading and processing
     # the notifications received from the tester
     def output_pipe_reader(self):
         try:
             print("Opening pipe {} for reading".format(self.output_pipe_path))
-            self.output_pipe = open(self.output_pipe_path, 'r')
+            self.output_pipe = open(self.output_pipe_path, "r")
             for line in self.output_pipe:
                 msg = line.strip()
                 print("Received {}".format(msg))
@@ -387,8 +458,7 @@ class UpgradeTest:
         self.tester_proc = None
         test_retcode = 1
         try:
-            workload_thread = Thread(
-                target=self.exec_workload, args=(args.test_file,))
+            workload_thread = Thread(target=self.exec_workload, args=(args.test_file,))
             workload_thread.start()
 
             reader_thread = Thread(target=self.output_pipe_reader)
@@ -412,8 +482,8 @@ class UpgradeTest:
         return (
             subprocess.getoutput(
                 "grep -r 'Severity=\"{}\"' {}".format(
-                    severity,
-                    self.cluster.log.as_posix())
+                    severity, self.cluster.log.as_posix()
+                )
             )
             .rstrip()
             .splitlines()
@@ -423,8 +493,7 @@ class UpgradeTest:
     def check_cluster_logs(self, error_limit=100):
         sev40s = (
             subprocess.getoutput(
-                "grep -r 'Severity=\"40\"' {}".format(
-                    self.cluster.log.as_posix())
+                "grep -r 'Severity=\"40\"' {}".format(self.cluster.log.as_posix())
             )
             .rstrip()
             .splitlines()
@@ -435,8 +504,8 @@ class UpgradeTest:
             # When running ASAN we expect to see this message. Boost coroutine should be using the
             # correct asan annotations so that it shouldn't produce any false positives.
             if line.endswith(
-                    "WARNING: ASan doesn't fully support makecontext/swapcontext functions and may produce false "
-                    "positives in some cases! "
+                "WARNING: ASan doesn't fully support makecontext/swapcontext functions and may produce false "
+                "positives in some cases! "
             ):
                 continue
             if err_cnt < error_limit:
@@ -445,7 +514,9 @@ class UpgradeTest:
 
         if err_cnt > 0:
             print(
-                ">>>>>>>>>>>>>>>>>>>> Found {} severity 40 events - the test fails", err_cnt)
+                ">>>>>>>>>>>>>>>>>>>> Found {} severity 40 events - the test fails",
+                err_cnt,
+            )
         else:
             print("No errors found in logs")
         return err_cnt == 0
@@ -454,8 +525,7 @@ class UpgradeTest:
     def dump_warnings_in_logs(self, limit=100):
         sev30s = (
             subprocess.getoutput(
-                "grep -r 'Severity=\"30\"' {}".format(
-                    self.cluster.log.as_posix())
+                "grep -r 'Severity=\"30\"' {}".format(self.cluster.log.as_posix())
             )
             .rstrip()
             .splitlines()
@@ -464,8 +534,11 @@ class UpgradeTest:
         if len(sev30s) == 0:
             print("No warnings found in logs")
         else:
-            print(">>>>>>>>>>>>>>>>>>>> Found {} severity 30 events (warnings):".format(
-                len(sev30s)))
+            print(
+                ">>>>>>>>>>>>>>>>>>>> Found {} severity 30 events (warnings):".format(
+                    len(sev30s)
+                )
+            )
             for line in sev30s[:limit]:
                 print(line)
 
@@ -499,14 +572,14 @@ if __name__ == "__main__":
         required=True,
     )
     parser.add_argument(
-        '--upgrade-path',
-        nargs='+',
-        help='Cluster upgrade path: a space separated list of versions',
-        default=[CURRENT_VERSION]
+        "--upgrade-path",
+        nargs="+",
+        help="Cluster upgrade path: a space separated list of versions",
+        default=[CURRENT_VERSION],
     )
     parser.add_argument(
-        '--test-file',
-        help='A .toml file describing a test workload to be generated with fdb_c_api_tester',
+        "--test-file",
+        help="A .toml file describing a test workload to be generated with fdb_c_api_tester",
         required=True,
     )
     parser.add_argument(
@@ -517,14 +590,12 @@ if __name__ == "__main__":
         default=0,
     )
     parser.add_argument(
-        '--disable-log-dump',
-        help='Do not dump cluster log on error',
-        action="store_true"
+        "--disable-log-dump",
+        help="Do not dump cluster log on error",
+        action="store_true",
     )
     parser.add_argument(
-        '--run-with-gdb',
-        help='Execute the tester binary from gdb',
-        action="store_true"
+        "--run-with-gdb", help="Execute the tester binary from gdb", action="store_true"
     )
     args = parser.parse_args()
     if args.process_number == 0:
diff --git a/tests/argument_parsing/test_argument_parsing.py b/tests/argument_parsing/test_argument_parsing.py
index b1e379a6c1..8141ead836 100755
--- a/tests/argument_parsing/test_argument_parsing.py
+++ b/tests/argument_parsing/test_argument_parsing.py
@@ -24,72 +24,89 @@ import subprocess
 
 last_command_output = None
 
+
 def check(condition):
     global last_command_output
-    assert condition, 'Command output:\n' + last_command_output
+    assert condition, "Command output:\n" + last_command_output
+
 
 def run_command(command, args):
     global last_command_output
-    last_command_output = subprocess.run(command + args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode('utf-8').strip()
+    last_command_output = (
+        subprocess.run(command + args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+        .stdout.decode("utf-8")
+        .strip()
+    )
     return last_command_output
 
+
 def is_unknown_option(output):
-    return output.startswith('ERROR: unknown option')
+    return output.startswith("ERROR: unknown option")
+
 
 def is_unknown_knob(output):
-    return output.startswith('ERROR: Failed to set knob option')
+    return output.startswith("ERROR: Failed to set knob option")
+
 
 def is_cli_usage(output):
-    return output.startswith('FoundationDB CLI')
+    return output.startswith("FoundationDB CLI")
+
 
 def test_fdbserver(build_dir):
-    command = [args.build_dir + '/bin/fdbserver', '-r', 'unittests']
+    command = [args.build_dir + "/bin/fdbserver", "-r", "unittests"]
 
-    check(is_unknown_option(run_command(command, ['--unknown-option'])))
+    check(is_unknown_option(run_command(command, ["--unknown-option"])))
 
-    check(not is_unknown_option(run_command(command, ['--cluster-file', 'foo'])))
-    check( not is_unknown_option(run_command(command, ['--cluster_file', 'foo'])))
+    check(not is_unknown_option(run_command(command, ["--cluster-file", "foo"])))
+    check(not is_unknown_option(run_command(command, ["--cluster_file", "foo"])))
 
-    check(is_unknown_knob(run_command(command, ['--knob-fake-knob', 'foo'])))
+    check(is_unknown_knob(run_command(command, ["--knob-fake-knob", "foo"])))
+
+    check(not is_unknown_knob(run_command(command, ["--knob-min-trace-severity", "5"])))
+    check(not is_unknown_knob(run_command(command, ["--knob-min_trace_severity", "5"])))
+    check(not is_unknown_knob(run_command(command, ["--knob_min_trace_severity", "5"])))
+    check(not is_unknown_knob(run_command(command, ["--knob_min-trace-severity", "5"])))
 
-    check(not is_unknown_knob(run_command(command, ['--knob-min-trace-severity', '5'])))
-    check(not is_unknown_knob(run_command(command, ['--knob-min_trace_severity', '5'])))
-    check(not is_unknown_knob(run_command(command, ['--knob_min_trace_severity', '5'])))
-    check(not is_unknown_knob(run_command(command, ['--knob_min-trace-severity', '5'])))
 
 def test_fdbcli(build_dir):
-    command = [args.build_dir + '/bin/fdbcli', '--exec', 'begin']
+    command = [args.build_dir + "/bin/fdbcli", "--exec", "begin"]
 
-    check(is_cli_usage(run_command(command, ['--unknown-option'])))
+    check(is_cli_usage(run_command(command, ["--unknown-option"])))
 
-    check(not is_cli_usage(run_command(command, ['--api-version', '700'])))
-    check(not is_cli_usage(run_command(command, ['--api_version', '700'])))
+    check(not is_cli_usage(run_command(command, ["--api-version", "700"])))
+    check(not is_cli_usage(run_command(command, ["--api_version", "700"])))
 
-    check(is_unknown_knob(run_command(command, ['--knob-fake-knob', 'foo'])))
+    check(is_unknown_knob(run_command(command, ["--knob-fake-knob", "foo"])))
+
+    check(not is_unknown_knob(run_command(command, ["--knob-min-trace-severity", "5"])))
+    check(not is_unknown_knob(run_command(command, ["--knob-min_trace_severity", "5"])))
+    check(not is_unknown_knob(run_command(command, ["--knob_min_trace_severity", "5"])))
+    check(not is_unknown_knob(run_command(command, ["--knob_min-trace-severity", "5"])))
 
-    check(not is_unknown_knob(run_command(command, ['--knob-min-trace-severity', '5'])))
-    check(not is_unknown_knob(run_command(command, ['--knob-min_trace_severity', '5'])))
-    check(not is_unknown_knob(run_command(command, ['--knob_min_trace_severity', '5'])))
-    check(not is_unknown_knob(run_command(command, ['--knob_min-trace-severity', '5'])))
 
 def test_fdbbackup(build_dir):
-    command = [args.build_dir + '/bin/fdbbackup', 'list']
+    command = [args.build_dir + "/bin/fdbbackup", "list"]
 
-    check(is_unknown_option(run_command(command, ['--unknown-option'])))
+    check(is_unknown_option(run_command(command, ["--unknown-option"])))
 
-    check(not is_unknown_option(run_command(command, ['--trace-format', 'foo'])))
-    check(not is_unknown_option(run_command(command, ['--trace_format', 'foo'])))
+    check(not is_unknown_option(run_command(command, ["--trace-format", "foo"])))
+    check(not is_unknown_option(run_command(command, ["--trace_format", "foo"])))
 
-    check(is_unknown_knob(run_command(command, ['--knob-fake-knob', 'foo'])))
+    check(is_unknown_knob(run_command(command, ["--knob-fake-knob", "foo"])))
 
-    check(not is_unknown_knob(run_command(command, ['--knob-min-trace-severity', '5'])))
-    check(not is_unknown_knob(run_command(command, ['--knob-min_trace_severity', '5'])))
-    check(not is_unknown_knob(run_command(command, ['--knob_min_trace_severity', '5'])))
-    check(not is_unknown_knob(run_command(command, ['--knob_min-trace-severity', '5'])))
+    check(not is_unknown_knob(run_command(command, ["--knob-min-trace-severity", "5"])))
+    check(not is_unknown_knob(run_command(command, ["--knob-min_trace_severity", "5"])))
+    check(not is_unknown_knob(run_command(command, ["--knob_min_trace_severity", "5"])))
+    check(not is_unknown_knob(run_command(command, ["--knob_min-trace-severity", "5"])))
 
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser(description="This test checks for proper command line argument parsing.")
-    parser.add_argument('build_dir', metavar='BUILD_DIRECTORY', help='FDB build directory')
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="This test checks for proper command line argument parsing."
+    )
+    parser.add_argument(
+        "build_dir", metavar="BUILD_DIRECTORY", help="FDB build directory"
+    )
     args = parser.parse_args()
 
     test_fdbserver(args.build_dir)
diff --git a/tests/python_tests/__init__.py b/tests/python_tests/__init__.py
index cfaabd24ca..0362e621fc 100644
--- a/tests/python_tests/__init__.py
+++ b/tests/python_tests/__init__.py
@@ -27,23 +27,23 @@ import argparse
 
 class Result(object):
     def __init__(self):
-        self.id = random.randint(0, 2**63)
+        self.id = random.randint(0, 2 ** 63)
         self.kpis = {}
         self.errors = []
 
     def add_kpi(self, name, value, units):
-        self.kpis[name] = {'value': value, 'units': units}
+        self.kpis[name] = {"value": value, "units": units}
 
     def add_error(self, error):
         self.errors.append(error)
 
     def save(self, dir):
-        file = 'pyresult-%d.json' % self.id
+        file = "pyresult-%d.json" % self.id
         if dir:
             file = os.path.join(dir, file)
 
-        with open(file, 'w') as f:
-            json.dump({'kpis': self.kpis, 'errors': self.errors}, f)
+        with open(file, "w") as f:
+            json.dump({"kpis": self.kpis, "errors": self.errors}, f)
 
 
 class PythonTest(object):
@@ -56,42 +56,67 @@ class PythonTest(object):
 
     def multi_version_description(self):
         if self.args.disable_multiversion_api:
-            return 'multi-version API disabled'
+            return "multi-version API disabled"
         elif self.args.use_external_client:
             if self.args.enable_callbacks_on_external_threads:
-                return 'external client on external thread'
+                return "external client on external thread"
             else:
-                return 'external client on main thread'
+                return "external client on main thread"
         else:
-            return 'local client'
+            return "local client"
 
     def run(self, parser=None):
         import fdb
+
         # API version should already be set by the caller
 
         if parser is None:
             parser = argparse.ArgumentParser()
 
-        parser.add_argument('--output-directory', default='', type=str,
-                            help='The directory to store the output JSON in. If not set, the current directory is used')
-        parser.add_argument('--disable-multiversion-api', action='store_true', help='Disables the multi-version client API')
-        parser.add_argument('--enable-callbacks-on-external-threads', action='store_true',
-                            help='Allows callbacks to be called on threads created by the client library')
-        parser.add_argument('--use-external-client', action='store_true', help='Connect to the server using an external client')
+        parser.add_argument(
+            "--output-directory",
+            default="",
+            type=str,
+            help="The directory to store the output JSON in. If not set, the current directory is used",
+        )
+        parser.add_argument(
+            "--disable-multiversion-api",
+            action="store_true",
+            help="Disables the multi-version client API",
+        )
+        parser.add_argument(
+            "--enable-callbacks-on-external-threads",
+            action="store_true",
+            help="Allows callbacks to be called on threads created by the client library",
+        )
+        parser.add_argument(
+            "--use-external-client",
+            action="store_true",
+            help="Connect to the server using an external client",
+        )
 
         self.args = parser.parse_args()
 
         if self.args.disable_multiversion_api:
-            if self.args.enable_callbacks_on_external_threads or self.args.use_external_client:
-                raise Exception('Invalid multi-version API argument combination')
+            if (
+                self.args.enable_callbacks_on_external_threads
+                or self.args.use_external_client
+            ):
+                raise Exception("Invalid multi-version API argument combination")
             fdb.options.set_disable_multi_version_client_api()
         if self.args.enable_callbacks_on_external_threads:
             if not self.args.use_external_client:
-                raise Exception('Cannot enable callbacks on external threads without using external clients')
+                raise Exception(
+                    "Cannot enable callbacks on external threads without using external clients"
+                )
             fdb.options.set_callbacks_on_external_threads()
         if self.args.use_external_client:
             fdb.options.set_disable_local_client()
-            fdb.options.set_external_client_directory(os.path.join(os.path.dirname(__file__), '..', '..', 'external_libraries'))
+            fdb.options.set_external_client_directory(
+                os.path.join(
+                    os.path.dirname(__file__), "..", "..", "external_libraries"
+                )
+            )
 
         try:
             self.run_test()
diff --git a/tests/python_tests/multithreaded_client.py b/tests/python_tests/multithreaded_client.py
index a180130db9..a27a0c62e7 100755
--- a/tests/python_tests/multithreaded_client.py
+++ b/tests/python_tests/multithreaded_client.py
@@ -4,11 +4,31 @@ import argparse
 
 parser = argparse.ArgumentParser("Run multithreaded client tests")
 
-parser.add_argument("cluster_file", nargs='+', help='List of fdb.cluster files to connect to')
-parser.add_argument("--skip-so-files", default=False, action='store_true', help='Do not load .so files')
-parser.add_argument("--threads", metavar="N", type=int, default=3, help='Number of threads to use.  Zero implies local client')
-parser.add_argument("--build-dir", metavar="DIR", default='.', help='Path to root directory of FDB build output')
-parser.add_argument("--client-log-dir", metavar="DIR", default="client-logs", help="Path to write client logs to.  The directory will be created if it does not exist.")
+parser.add_argument(
+    "cluster_file", nargs="+", help="List of fdb.cluster files to connect to"
+)
+parser.add_argument(
+    "--skip-so-files", default=False, action="store_true", help="Do not load .so files"
+)
+parser.add_argument(
+    "--threads",
+    metavar="N",
+    type=int,
+    default=3,
+    help="Number of threads to use.  Zero implies local client",
+)
+parser.add_argument(
+    "--build-dir",
+    metavar="DIR",
+    default=".",
+    help="Path to root directory of FDB build output",
+)
+parser.add_argument(
+    "--client-log-dir",
+    metavar="DIR",
+    default="client-logs",
+    help="Path to write client logs to.  The directory will be created if it does not exist.",
+)
 args = parser.parse_args()
 
 import sys
@@ -25,11 +45,12 @@ import sys
 ## This fails (unsupported configuration):
 # ../tests/loopback_cluster/run_cluster.sh . 3 '../tests/python_tests/multithreaded_client.py loopback-cluster-*/fdb.cluster --threads 2 --skip-so-files'
 
-sys.path.append(args.build_dir + '/bindings/python')
+sys.path.append(args.build_dir + "/bindings/python")
 
 import fdb
 import os
 import random
+
 fdb.api_version(630)
 
 if not os.path.exists(args.client_log_dir):
@@ -40,7 +61,7 @@ fdb.options.set_knob("min_trace_severity=5")
 
 if not args.skip_so_files:
     print("Loading .so files")
-    fdb.options.set_external_client_directory(args.build_dir + '/lib')
+    fdb.options.set_external_client_directory(args.build_dir + "/lib")
 
 if args.threads > 0:
     fdb.options.set_client_threads_per_version(args.threads)
@@ -56,4 +77,4 @@ for i in range(100):
     db = dbs[i % len(dbs)]
     print("Writing: ", key, val, db)
     db[key] = val
-    assert (val == db[key])
+    assert val == db[key]
diff --git a/tests/python_tests/python_correctness.py b/tests/python_tests/python_correctness.py
index 67d8a192ff..aa0cdcefaa 100755
--- a/tests/python_tests/python_correctness.py
+++ b/tests/python_tests/python_correctness.py
@@ -26,11 +26,12 @@ import time
 import random
 import traceback
 
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+sys.path.append(os.path.join(os.path.dirname(__file__), ".."))
 from python_tests import PythonTest
 
 import fdb
 import fdb.tuple
+
 fdb.api_version(400)
 
 
@@ -55,17 +56,19 @@ class KeyValueStore:
         for index, key in enumerate(sorted_keys):
             if key >= key_selector.key:
                 index += key_selector.offset
-                if (key == key_selector.key and not key_selector.or_equal) or key != key_selector.key:
+                if (
+                    key == key_selector.key and not key_selector.or_equal
+                ) or key != key_selector.key:
                     index -= 1
 
                 if index < 0 or index >= len(sorted_keys):
-                    return ''
+                    return ""
                 else:
                     return sorted_keys[index]
 
         index = len(sorted_keys) + key_selector.offset - 1
         if index < 0 or index >= len(sorted_keys):
-            return ''
+            return ""
         else:
             return sorted_keys[index]
 
@@ -128,46 +131,64 @@ class KeyValueStore:
 
 class PythonCorrectness(PythonTest):
     callback = False
-    callbackError = ''
+    callbackError = ""
 
     # Python correctness tests (checks if functions run and yield correct results)
     def run_test(self):
         try:
-            db = fdb.open(None, 'DB')
+            db = fdb.open(None, "DB")
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('fdb.open failed'))
+            self.result.add_error(self.get_error("fdb.open failed"))
             return
 
         try:
-            print('Testing functions...')
+            print("Testing functions...")
             self.test_functions(db)
 
-            print('Testing correctness...')
+            print("Testing correctness...")
             del db[:]
             self.test_correctness(db)
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('Failed to complete all tests'))
+            self.result.add_error(self.get_error("Failed to complete all tests"))
 
     # Generates a random set of keys and values
-    def generate_data(self, num_keys, min_key_length, max_key_length, min_value_length, max_value_length, prefix='', allow_duplicates=True):
+    def generate_data(
+        self,
+        num_keys,
+        min_key_length,
+        max_key_length,
+        min_value_length,
+        max_value_length,
+        prefix="",
+        allow_duplicates=True,
+    ):
         data = list()
         keys = set()
         while len(data) < num_keys:
             # key = prefix + ''.join(random.choice(string.ascii_lowercase)
             #                        for i in range(0, random.randint(minKeyLength - len(prefix), maxKeyLength - len(prefix))))
-            key = prefix + ''.join(chr(random.randint(0, 254))
-                                   for _ in range(0, random.randint(min_key_length - len(prefix), max_key_length - len(prefix))))
+            key = prefix + "".join(
+                chr(random.randint(0, 254))
+                for _ in range(
+                    0,
+                    random.randint(
+                        min_key_length - len(prefix), max_key_length - len(prefix)
+                    ),
+                )
+            )
             if not allow_duplicates:
                 if key in keys:
                     continue
                 else:
                     keys.add(key)
 
-            value = ''.join('x' for _ in range(0, random.randint(max_key_length, max_value_length)))
+            value = "".join(
+                "x" for _ in range(0, random.randint(max_key_length, max_value_length))
+            )
             data.append([key, value])
 
         return data
@@ -179,26 +200,26 @@ class PythonCorrectness(PythonTest):
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.callbackError = self.get_error('Callback future get failed')
+            self.callbackError = self.get_error("Callback future get failed")
 
         self.callback = True
 
     # Tests that all of the functions in the python API can be called without failing
     def test_functions(self, db):
         self.callback = False
-        self.callbackError = ''
+        self.callbackError = ""
 
         try:
             tr = db.create_transaction()
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('db.create_transaction failed'))
+            self.result.add_error(self.get_error("db.create_transaction failed"))
             return
 
         try:
-            tr['testkey'] = 'testvalue'
-            value = tr['testkey']
+            tr["testkey"] = "testvalue"
+            value = tr["testkey"]
             value.is_ready()
             value.block_until_ready()
             value.wait()
@@ -206,32 +227,34 @@ class PythonCorrectness(PythonTest):
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('Set/Get value failed (block until ready)'))
+            self.result.add_error(
+                self.get_error("Set/Get value failed (block until ready)")
+            )
 
         try:
-            value = tr['testkey']
+            value = tr["testkey"]
             value.wait()
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('Get value failed'))
+            self.result.add_error(self.get_error("Get value failed"))
 
         try:
-            tr['testkey'] = 'newtestvalue'
+            tr["testkey"] = "newtestvalue"
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('Replace value failed'))
+            self.result.add_error(self.get_error("Replace value failed"))
 
         try:
-            value = tr['fakekey']
+            value = tr["fakekey"]
             # The following line would generate a segfault
             # value.capi.fdb_future_block_until_ready(0)
             value.wait()
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('Get non-existent key failed'))
+            self.result.add_error(self.get_error("Get non-existent key failed"))
 
         try:
             tr.commit().wait()
@@ -239,186 +262,186 @@ class PythonCorrectness(PythonTest):
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('Commit failed'))
+            self.result.add_error(self.get_error("Commit failed"))
 
         try:
             tr.reset()
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('Reset failed'))
+            self.result.add_error(self.get_error("Reset failed"))
 
         try:
             version = tr.get_read_version()
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('tr.get_read_version failed'))
+            self.result.add_error(self.get_error("tr.get_read_version failed"))
 
         try:
-            value = tr['testkey']
+            value = tr["testkey"]
             value.wait()
             tr.reset()
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('Get and reset failed'))
+            self.result.add_error(self.get_error("Get and reset failed"))
 
         try:
             tr.set_read_version(version.wait())
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('Set read version failed'))
+            self.result.add_error(self.get_error("Set read version failed"))
 
         try:
-            value = tr['testkey']
+            value = tr["testkey"]
             callback_time = time.time()
             value.on_ready(self.test_callback)
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('Get future and set callback failed'))
+            self.result.add_error(self.get_error("Get future and set callback failed"))
 
         try:
-            del tr['testkey']
+            del tr["testkey"]
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('Delete key failed'))
+            self.result.add_error(self.get_error("Delete key failed"))
 
         try:
-            del tr['fakekey']
+            del tr["fakekey"]
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('Delete non-existent key failed'))
+            self.result.add_error(self.get_error("Delete non-existent key failed"))
 
         try:
-            tr.set('testkey', 'testvalue')
-            value = tr.get('testkey')
+            tr.set("testkey", "testvalue")
+            value = tr.get("testkey")
             value.wait()
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('Future.get failed'))
+            self.result.add_error(self.get_error("Future.get failed"))
 
         try:
-            tr.clear('testkey')
+            tr.clear("testkey")
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('Clear key failed'))
+            self.result.add_error(self.get_error("Clear key failed"))
 
         try:
-            tr['testkey1'] = 'testvalue1'
-            tr['testkey2'] = 'testvalue2'
-            tr['testkey3'] = 'testvalue3'
+            tr["testkey1"] = "testvalue1"
+            tr["testkey2"] = "testvalue2"
+            tr["testkey3"] = "testvalue3"
 
-            for k, v in tr.get_range('testkey1', 'testkey3'):
-                v += ''
+            for k, v in tr.get_range("testkey1", "testkey3"):
+                v += ""
 
-            for k, v in tr.get_range('testkey1', 'testkey2', 2):
-                v += ''
+            for k, v in tr.get_range("testkey1", "testkey2", 2):
+                v += ""
 
-            for k, v in tr['testkey1':'testkey3']:
-                v += ''
+            for k, v in tr["testkey1":"testkey3"]:
+                v += ""
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('Get range failed'))
+            self.result.add_error(self.get_error("Get range failed"))
 
         try:
-            tr['otherkey1'] = 'othervalue1'
-            tr['otherkey2'] = 'othervalue2'
+            tr["otherkey1"] = "othervalue1"
+            tr["otherkey2"] = "othervalue2"
 
-            for k, v in tr.get_range_startswith('testkey'):
-                v += ''
+            for k, v in tr.get_range_startswith("testkey"):
+                v += ""
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('Get range starts with failed'))
+            self.result.add_error(self.get_error("Get range starts with failed"))
 
         try:
-            tr.clear_range_startswith('otherkey')
+            tr.clear_range_startswith("otherkey")
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('Clear range starts with failed'))
+            self.result.add_error(self.get_error("Clear range starts with failed"))
 
         try:
-            tr.clear_range('testkey1', 'testkey3')
+            tr.clear_range("testkey1", "testkey3")
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('Clear range failed'))
+            self.result.add_error(self.get_error("Clear range failed"))
 
         try:
-            tr['testkey1'] = 'testvalue1'
-            tr['testkey2'] = 'testvalue2'
-            tr['testkey3'] = 'testvalue3'
+            tr["testkey1"] = "testvalue1"
+            tr["testkey2"] = "testvalue2"
+            tr["testkey3"] = "testvalue3"
 
-            begin = fdb.KeySelector('testkey2', 0, 0)
-            end = fdb.KeySelector('testkey2', 0, 1)
+            begin = fdb.KeySelector("testkey2", 0, 0)
+            end = fdb.KeySelector("testkey2", 0, 1)
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('Create key selector failed'))
+            self.result.add_error(self.get_error("Create key selector failed"))
 
         try:
             for k, v in tr.get_range(begin, end):
-                v += ''
+                v += ""
 
             for k, v in tr.get_range(begin, end, 2):
-                v += ''
+                v += ""
 
             for k, v in tr[begin:end]:
-                v += ''
+                v += ""
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('Get range (key selectors) failed'))
+            self.result.add_error(self.get_error("Get range (key selectors) failed"))
 
         try:
             tr.clear_range(begin, end)
 
-            tr['testkey1'] = 'testvalue1'
-            tr['testkey2'] = 'testvalue2'
-            tr['testkey3'] = 'testvalue3'
+            tr["testkey1"] = "testvalue1"
+            tr["testkey2"] = "testvalue2"
+            tr["testkey3"] = "testvalue3"
 
             del tr[begin:end]
 
-            tr['testkey1'] = 'testvalue1'
-            tr['testkey2'] = 'testvalue2'
-            tr['testkey3'] = 'testvalue3'
+            tr["testkey1"] = "testvalue1"
+            tr["testkey2"] = "testvalue2"
+            tr["testkey3"] = "testvalue3"
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('Clear range (key selectors) failed'))
+            self.result.add_error(self.get_error("Clear range (key selectors) failed"))
 
         try:
-            begin = fdb.KeySelector.last_less_than('testkey2')
-            end = fdb.KeySelector.first_greater_or_equal('testkey2')
+            begin = fdb.KeySelector.last_less_than("testkey2")
+            end = fdb.KeySelector.first_greater_or_equal("testkey2")
 
             for k, v in tr.get_range(begin, end):
-                v += ''
+                v += ""
 
-            begin = fdb.KeySelector.last_less_or_equal('testkey2')
-            end = fdb.KeySelector.first_greater_than('testkey2')
+            begin = fdb.KeySelector.last_less_or_equal("testkey2")
+            end = fdb.KeySelector.first_greater_than("testkey2")
 
             for k, v in tr.get_range(begin, end):
-                v += ''
+                v += ""
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('Builtin key selectors failed'))
+            self.result.add_error(self.get_error("Builtin key selectors failed"))
 
         try:
-            del tr['testkey1':'testkey3']
+            del tr["testkey1":"testkey3"]
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('Delete key range failed'))
+            self.result.add_error(self.get_error("Delete key range failed"))
 
         try:
             tr.commit().wait()
@@ -426,52 +449,57 @@ class PythonCorrectness(PythonTest):
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('Commit failed'))
+            self.result.add_error(self.get_error("Commit failed"))
 
         try:
-            key = fdb.tuple.pack(('k1', 'k2', 'k3'))
+            key = fdb.tuple.pack(("k1", "k2", "k3"))
             k_tuple = fdb.tuple.unpack(key)
-            if k_tuple[0] != 'k1' and k_tuple[1] != 'k2' and k_tuple[2] != 'k3':
-                self.result.add_error('Tuple <-> key conversion yielded incorrect results')
+            if k_tuple[0] != "k1" and k_tuple[1] != "k2" and k_tuple[2] != "k3":
+                self.result.add_error(
+                    "Tuple <-> key conversion yielded incorrect results"
+                )
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('Tuple <-> key conversion failed'))
+            self.result.add_error(self.get_error("Tuple <-> key conversion failed"))
 
         try:
-            tr[fdb.tuple.pack(('k1', 'k2'))] = 'v'
-            tr[fdb.tuple.pack(('k1', 'k2', 'k3'))] = 'v1'
-            tr[fdb.tuple.pack(('k1', 'k2', 'k3', 'k4'))] = 'v2'
+            tr[fdb.tuple.pack(("k1", "k2"))] = "v"
+            tr[fdb.tuple.pack(("k1", "k2", "k3"))] = "v1"
+            tr[fdb.tuple.pack(("k1", "k2", "k3", "k4"))] = "v2"
 
-            for k, v in tr[fdb.tuple.range(('k1', 'k2'))]:
-                v += ''
+            for k, v in tr[fdb.tuple.range(("k1", "k2"))]:
+                v += ""
 
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('Tuple get range failed'))
+            self.result.add_error(self.get_error("Tuple get range failed"))
 
         try:
-            tr['testint'] = '10'
-            y = int(tr['testint']) + 1
+            tr["testint"] = "10"
+            y = int(tr["testint"]) + 1
             if y != 11:
-                self.result.add_error('Value retrieval yielded incorrect results')
+                self.result.add_error("Value retrieval yielded incorrect results")
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('Future value retrieval failed'))
+            self.result.add_error(self.get_error("Future value retrieval failed"))
 
         if not self.callback:
             time.sleep(5)
             if not self.callback:
-                self.result.add_error('Warning: Future callback not called after %f seconds' % (time.time() - callback_time))
+                self.result.add_error(
+                    "Warning: Future callback not called after %f seconds"
+                    % (time.time() - callback_time)
+                )
         if len(self.callbackError) > 0:
             self.result.add_error(self.callbackError)
 
     # Compares a FoundationDB database with an in-memory key-value store
     def compare_database_to_memory(self, db, store):
-        db_result = self.correctness_get_range_transactional(db, '\x00', '\xff')
-        store_result = store.get_range('\x00', '\xff')
+        db_result = self.correctness_get_range_transactional(db, "\x00", "\xff")
+        store_result = store.get_range("\x00", "\xff")
 
         return self.compare_results(db_result, store_result)
 
@@ -485,7 +513,10 @@ class PythonCorrectness(PythonTest):
             # if i >= len(storeResults):
             #    print 'mismatched key: ' + dbResults[i].key
             #    return False
-            if db_results[i].key != store_results[i][0] or db_results[i].value != store_results[i][1]:
+            if (
+                db_results[i].key != store_results[i][0]
+                or db_results[i].value != store_results[i][1]
+            ):
                 # print 'mismatched key: ' + dbResults[i].key + ' - ' + storeResults[i][0]
                 return False
 
@@ -512,44 +543,70 @@ class PythonCorrectness(PythonTest):
         num_range_clears = 10
         num_prefix_clears = 10
 
-        max_keys_per_transaction = max(1, int(max_transaction_bytes / (max_value_length + max_long_key_length)))
+        max_keys_per_transaction = max(
+            1, int(max_transaction_bytes / (max_value_length + max_long_key_length))
+        )
 
         try:
             store = KeyValueStore()
 
             # Generate some random data
-            data = self.generate_data(num_keys * ratio_short_keys, min_short_key_length, max_short_key_length, min_value_length, max_value_length)
-            data.extend(self.generate_data(num_keys * (1 - ratio_short_keys), min_long_key_length, max_long_key_length, min_value_length, max_value_length))
+            data = self.generate_data(
+                num_keys * ratio_short_keys,
+                min_short_key_length,
+                max_short_key_length,
+                min_value_length,
+                max_value_length,
+            )
+            data.extend(
+                self.generate_data(
+                    num_keys * (1 - ratio_short_keys),
+                    min_long_key_length,
+                    max_long_key_length,
+                    min_value_length,
+                    max_value_length,
+                )
+            )
 
             # Insert the data
             self.correctness_set(db, store, data, max_keys_per_transaction)
             if not self.compare_database_to_memory(db, store):
-                self.result.add_error('transaction.set resulted in incorrect database')
+                self.result.add_error("transaction.set resulted in incorrect database")
 
             # Compare the results of single key reads
-            if not self.correctness_get(db, store, data, num_reads, max_keys_per_transaction):
-                self.result.add_error('transaction.get returned incorrect result')
+            if not self.correctness_get(
+                db, store, data, num_reads, max_keys_per_transaction
+            ):
+                self.result.add_error("transaction.get returned incorrect result")
 
             # Compare the results of range reads
             for i in range(0, num_range_reads):
                 if not self.correctness_get_range(db, store, data):
-                    self.result.add_error('transaction.get_range returned incorrect results')
+                    self.result.add_error(
+                        "transaction.get_range returned incorrect results"
+                    )
                     break
 
             # Compare the results of prefix reads
             for i in range(0, num_prefix_reads):
                 if not self.correctness_get_prefix(db, store, data):
-                    self.result.add_error('transaction.get_range_startswith returned incorrect results')
+                    self.result.add_error(
+                        "transaction.get_range_startswith returned incorrect results"
+                    )
                     break
 
             # Compare the results of get key
-            if not self.correctness_get_key(db, store, data, num_get_keys, max_keys_per_transaction):
-                self.result.add_error('transaction.get_key returned incorrect results')
+            if not self.correctness_get_key(
+                db, store, data, num_get_keys, max_keys_per_transaction
+            ):
+                self.result.add_error("transaction.get_key returned incorrect results")
 
             # Compare the results of clear
             # clearedKeys = self.correctnessClear(db, store, data, num_clears, max_keys_per_transaction)
             if not self.compare_database_to_memory(db, store):
-                self.result.add_error('transaction.clear resulted in incorrect database')
+                self.result.add_error(
+                    "transaction.clear resulted in incorrect database"
+                )
 
             #    for key in clearedKeys:
             #         print 'clearing key ' + key
@@ -559,7 +616,7 @@ class PythonCorrectness(PythonTest):
             # Fill the database back up with data
             self.correctness_set(db, store, data, max_keys_per_transaction)
             if not self.compare_database_to_memory(db, store):
-                self.result.add_error('transaction.set resulted in incorrect database')
+                self.result.add_error("transaction.set resulted in incorrect database")
 
             # Compare the results of clear_range
             for i in range(0, num_range_clears):
@@ -567,12 +624,16 @@ class PythonCorrectness(PythonTest):
 
                 success = self.compare_database_to_memory(db, store)
                 if not success:
-                    self.result.add_error('transaction.clear_range resulted in incorrect database')
+                    self.result.add_error(
+                        "transaction.clear_range resulted in incorrect database"
+                    )
 
                 # Fill the database back up with data
                 self.correctness_set(db, store, data, max_keys_per_transaction)
                 if not self.compare_database_to_memory(db, store):
-                    self.result.add_error('transaction.set resulted in incorrect database')
+                    self.result.add_error(
+                        "transaction.set resulted in incorrect database"
+                    )
                     break
 
                 if not success:
@@ -581,12 +642,14 @@ class PythonCorrectness(PythonTest):
             # Compare the results of clear_range_startswith
             self.correctness_clear_prefix(db, store, data, num_prefix_clears)
             if not self.compare_database_to_memory(db, store):
-                self.result.add_error('transaction.clear_range_startswith resulted in incorrect database')
+                self.result.add_error(
+                    "transaction.clear_range_startswith resulted in incorrect database"
+                )
 
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('Database error in correctness test'))
+            self.result.add_error(self.get_error("Database error in correctness test"))
 
     # Stores data in the database and a memory key-value store
     def correctness_set(self, db, store, data, max_keys_per_transaction):
@@ -595,7 +658,9 @@ class PythonCorrectness(PythonTest):
 
         keys_committed = 0
         while keys_committed < len(data):
-            self.correctness_set_transactional(db, data[keys_committed: keys_committed + max_keys_per_transaction])
+            self.correctness_set_transactional(
+                db, data[keys_committed : keys_committed + max_keys_per_transaction]
+            )
             keys_committed += max_keys_per_transaction
 
     # Stores data in the database
@@ -613,12 +678,12 @@ class PythonCorrectness(PythonTest):
 
         keys_retrieved = 0
         while keys_retrieved < len(keys):
-            sub_keys = keys[keys_retrieved: keys_retrieved + max_keys_per_transaction]
+            sub_keys = keys[keys_retrieved : keys_retrieved + max_keys_per_transaction]
 
             values = self.correctness_get_transactional(db, sub_keys)
             for i in range(0, num_reads):
                 if values[i] != store.get(sub_keys[i]):
-                    print('mismatch: %s', sub_keys[i])
+                    print("mismatch: %s", sub_keys[i])
                     return False
             keys_retrieved += max_keys_per_transaction
 
@@ -660,7 +725,9 @@ class PythonCorrectness(PythonTest):
 
     # Compares the results of the get_range_startswith operation from the database and a memory key-value store
     def correctness_get_prefix(self, db, store, data):
-        prefix = ''.join(chr(random.randint(0, 254)) for _ in range(0, random.randint(1, 3)))
+        prefix = "".join(
+            chr(random.randint(0, 254)) for _ in range(0, random.randint(1, 3))
+        )
         db_results = self.correctness_get_prefix_transactional(db, prefix)
         store_results = store.get_range_startswith(prefix)
 
@@ -672,12 +739,17 @@ class PythonCorrectness(PythonTest):
         return list(tr.get_range_startswith(prefix))
 
     # Compares the results of the get_key operation from the database and a memory key-value store
-    def correctness_get_key(self, db, store, data, num_get_keys, max_keys_per_transaction):
+    def correctness_get_key(
+        self, db, store, data, num_get_keys, max_keys_per_transaction
+    ):
         selectors = []
         for i in range(0, num_get_keys):
             index = random.randint(0, len(data) - 1)
             or_equal = random.randint(0, 1)
-            offset = random.randint(max(-index + (1 - or_equal), -10), min(len(data) - index - 1 + or_equal, 10))
+            offset = random.randint(
+                max(-index + (1 - or_equal), -10),
+                min(len(data) - index - 1 + or_equal, 10),
+            )
 
             key = sorted(data)[index][0]
             selector = fdb.KeySelector(key, or_equal, offset)
@@ -685,7 +757,9 @@ class PythonCorrectness(PythonTest):
 
         keys_retrieved = 0
         while keys_retrieved < len(selectors):
-            sub_selectors = selectors[keys_retrieved: keys_retrieved + max_keys_per_transaction]
+            sub_selectors = selectors[
+                keys_retrieved : keys_retrieved + max_keys_per_transaction
+            ]
             db_keys = self.correctness_get_key_transactional(db, sub_selectors)
             for i in range(0, num_get_keys):
                 if db_keys[i] != store.get_key(sub_selectors[i]):
@@ -721,7 +795,9 @@ class PythonCorrectness(PythonTest):
 
         keys_cleared = 0
         while keys_cleared < len(cleared_keys):
-            self.correctness_clear_transactional(db, cleared_keys[keys_cleared: keys_cleared + max_keys_per_transaction])
+            self.correctness_clear_transactional(
+                db, cleared_keys[keys_cleared : keys_cleared + max_keys_per_transaction]
+            )
             keys_cleared += max_keys_per_transaction
 
         return cleared_keys
@@ -752,7 +828,9 @@ class PythonCorrectness(PythonTest):
     def correctness_clear_prefix(self, db, store, data, num_prefix_clears):
         prefixes = []
         for i in range(0, num_prefix_clears):
-            prefix = ''.join(chr(random.randint(0, 254)) for _ in range(0, random.randint(1, 3)))
+            prefix = "".join(
+                chr(random.randint(0, 254)) for _ in range(0, random.randint(1, 3))
+            )
             prefixes.append(prefix)
             store.clear_range_startswith(prefix)
 
@@ -767,12 +845,20 @@ class PythonCorrectness(PythonTest):
     # Adds the stack trace to an error message
     def get_error(self, message):
         error_message = message + "\n" + traceback.format_exc()
-        print('%s', error_message)
+        print("%s", error_message)
         return error_message
 
 
-if __name__ == '__main__':
-    print("Running PythonCorrectness test on Python version %d.%d.%d%s%d" %
-          (sys.version_info[0], sys.version_info[1], sys.version_info[2], sys.version_info[3][0], sys.version_info[4]))
+if __name__ == "__main__":
+    print(
+        "Running PythonCorrectness test on Python version %d.%d.%d%s%d"
+        % (
+            sys.version_info[0],
+            sys.version_info[1],
+            sys.version_info[2],
+            sys.version_info[3][0],
+            sys.version_info[4],
+        )
+    )
 
     PythonCorrectness().run()
diff --git a/tests/python_tests/python_performance.py b/tests/python_tests/python_performance.py
index 41fe03dc33..bc0888dd36 100755
--- a/tests/python_tests/python_performance.py
+++ b/tests/python_tests/python_performance.py
@@ -30,43 +30,44 @@ import traceback
 
 from collections import OrderedDict
 
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+sys.path.append(os.path.join(os.path.dirname(__file__), ".."))
 from python_tests import PythonTest
 
 import fdb
 import fdb.tuple
+
 fdb.api_version(400)
 
 
 class PythonPerformance(PythonTest):
     tests = {
-        'future_latency': 'Python API future throughput',
-        'set': 'Python API set throughput',
-        'clear': 'Python API clear throughput',
-        'clear_range': 'Python API clear_range throughput',
-        'parallel_get': 'Python API parallel get throughput',
-        'serial_get': 'Python API serial get throughput',
-        'get_range': 'Python API get_range throughput',
-        'get_key': 'Python API get_key throughput',
-        'get_single_key_range': 'Python API get_single_key_range throughput',
-        'alternating_get_set': 'Python API alternating get and set throughput',
-        'write_transaction': 'Python API single-key transaction throughput',
+        "future_latency": "Python API future throughput",
+        "set": "Python API set throughput",
+        "clear": "Python API clear throughput",
+        "clear_range": "Python API clear_range throughput",
+        "parallel_get": "Python API parallel get throughput",
+        "serial_get": "Python API serial get throughput",
+        "get_range": "Python API get_range throughput",
+        "get_key": "Python API get_key throughput",
+        "get_single_key_range": "Python API get_single_key_range throughput",
+        "alternating_get_set": "Python API alternating get and set throughput",
+        "write_transaction": "Python API single-key transaction throughput",
     }
 
     def __init__(self, key_count=1000000, key_size=16, value_size=100):
         super(PythonPerformance, self).__init__()
         self.key_count = key_count
         self.key_size = key_size
-        self.value_str = ''.join(['x' for _ in range(value_size)])
+        self.value_str = "".join(["x" for _ in range(value_size)])
 
     # Python Performance Tests (checks if functions run and yield correct results, gets performance indicators)
     def run_test(self):
         try:
-            db = fdb.open(None, 'DB')
+            db = fdb.open(None, "DB")
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('fdb.open failed'))
+            self.result.add_error(self.get_error("fdb.open failed"))
             return
 
         try:
@@ -74,23 +75,26 @@ class PythonPerformance(PythonTest):
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('Failed to complete all tests'))
+            self.result.add_error(self.get_error("Failed to complete all tests"))
 
     def random_key(self):
         return self.key(random.randint(0, self.key_count - 1))
 
     def key(self, num):
-        return '%0*d' % (self.key_size, num)
+        return "%0*d" % (self.key_size, num)
 
     def value(self, key):
         return self.value_str
 
     def insert_data(self, db):
-        print('Loading database')
+        print("Loading database")
         del db[:]
         num_keys = 100000 / (self.key_size + len(self.value_str))
 
-        trs = [db.create_transaction() for _ in range(int(math.ceil(float(self.key_count) / num_keys)))]
+        trs = [
+            db.create_transaction()
+            for _ in range(int(math.ceil(float(self.key_count) / num_keys)))
+        ]
         success = [False for _ in range(len(trs))]
 
         while not all(success):
@@ -130,11 +134,13 @@ class PythonPerformance(PythonTest):
         # Run each test
         for test in self.args.tests_to_run:
             time.sleep(5)
-            print('Running test %s' % test)
+            print("Running test %s" % test)
             results = []
 
-            fxn_name = 'run_%s' % test
-            assert hasattr(self, fxn_name), 'Test function %s not implemented' % fxn_name
+            fxn_name = "run_%s" % test
+            assert hasattr(self, fxn_name), (
+                "Test function %s not implemented" % fxn_name
+            )
 
             # Perform each test several times
             for x in range(0, num_runs):
@@ -143,12 +149,21 @@ class PythonPerformance(PythonTest):
                 except KeyboardInterrupt:
                     raise
                 except Exception:
-                    self.result.add_error(self.get_error('Performance test failed: ' + PythonPerformance.tests[test]))
+                    self.result.add_error(
+                        self.get_error(
+                            "Performance test failed: " + PythonPerformance.tests[test]
+                        )
+                    )
                     break
 
             if len(results) == num_runs:
                 median = sorted(results)[num_runs / 2]
-                self.result.add_kpi("%s (%s)" % (PythonPerformance.tests[test], self.multi_version_description()), int(median), 'keys/s')
+                self.result.add_kpi(
+                    "%s (%s)"
+                    % (PythonPerformance.tests[test], self.multi_version_description()),
+                    int(median),
+                    "keys/s",
+                )
 
     @fdb.transactional
     def run_future_latency(self, tr, count=100000):
@@ -179,7 +194,7 @@ class PythonPerformance(PythonTest):
 
         for i in range(count):
             key = self.random_key()
-            del tr[key: self.key(int(key) + 1)]
+            del tr[key : self.key(int(key) + 1)]
 
         return count / (time.time() - s)
 
@@ -237,7 +252,7 @@ class PythonPerformance(PythonTest):
         else:
             key_set = OrderedDict()
             while len(key_set) < count:
-                key_set[self.random_key()] = ''
+                key_set[self.random_key()] = ""
             keys = key_set.keys()
 
         s = time.time()
@@ -254,7 +269,7 @@ class PythonPerformance(PythonTest):
         b = random.randint(0, self.key_count - count)
         s = time.time()
 
-        list(tr[self.key(b): self.key(b + count)])
+        list(tr[self.key(b) : self.key(b + count)])
 
         return count / (time.time() - s)
 
@@ -265,7 +280,9 @@ class PythonPerformance(PythonTest):
         s = time.time()
 
         for i in range(count):
-            tr.get_key(fdb.KeySelector(self.random_key(), True, random.randint(-10, 10))).wait()
+            tr.get_key(
+                fdb.KeySelector(self.random_key(), True, random.randint(-10, 10))
+            ).wait()
 
         return count / (time.time() - s)
 
@@ -296,23 +313,36 @@ class PythonPerformance(PythonTest):
     # Adds the stack trace to an error message
     def get_error(self, message):
         error_message = message + "\n" + traceback.format_exc()
-        print('%s' % error_message)
+        print("%s" % error_message)
         return error_message
 
 
-if __name__ == '__main__':
-    print("Running PythonPerformance test on Python version %d.%d.%d%s%d" %
-          (sys.version_info[0], sys.version_info[1], sys.version_info[2], sys.version_info[3][0], sys.version_info[4]))
+if __name__ == "__main__":
+    print(
+        "Running PythonPerformance test on Python version %d.%d.%d%s%d"
+        % (
+            sys.version_info[0],
+            sys.version_info[1],
+            sys.version_info[2],
+            sys.version_info[3][0],
+            sys.version_info[4],
+        )
+    )
 
     parser = argparse.ArgumentParser()
 
     tests = sorted(PythonPerformance.tests.keys())
-    assert len(tests) > 0, 'Python performance test has no test functions'
-    test_string = ', '.join(tests[:-1])
+    assert len(tests) > 0, "Python performance test has no test functions"
+    test_string = ", ".join(tests[:-1])
     if len(tests) > 1:
-        test_string += ', and '
+        test_string += ", and "
 
     test_string += tests[-1]
 
-    parser.add_argument("--tests-to-run", nargs="*", help="Names of tests to run. Can be any of %s. By default, all tests are run." % test_string)
+    parser.add_argument(
+        "--tests-to-run",
+        nargs="*",
+        help="Names of tests to run. Can be any of %s. By default, all tests are run."
+        % test_string,
+    )
     PythonPerformance().run(parser=parser)
diff --git a/tests/python_tests/ryw_benchmark.py b/tests/python_tests/ryw_benchmark.py
index 65fdf50142..9090ec2dfe 100755
--- a/tests/python_tests/ryw_benchmark.py
+++ b/tests/python_tests/ryw_benchmark.py
@@ -26,21 +26,22 @@ import sys
 import time
 import traceback
 
-sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+sys.path.append(os.path.join(os.path.dirname(__file__), ".."))
 from python_tests import PythonTest
 
 import fdb
+
 fdb.api_version(400)
 
 
 class RYWBenchmark(PythonTest):
     tests = {
-        'get_single': "RYW: get single cached value throughput",
-        'get_many_sequential': "RYW: get sequential cached values throughput",
-        'get_range_basic': "RYW: get range cached values throughput",
-        'single_clear_get_range': "RYW: get range cached values with clears throughput",
-        'clear_range_get_range': "RYW: get range cached values with clear ranges throughput",
-        'interleaved_sets_gets': "RYW: interleaved sets and gets on a single key throughput",
+        "get_single": "RYW: get single cached value throughput",
+        "get_many_sequential": "RYW: get sequential cached values throughput",
+        "get_range_basic": "RYW: get range cached values throughput",
+        "single_clear_get_range": "RYW: get range cached values with clears throughput",
+        "clear_range_get_range": "RYW: get range cached values with clear ranges throughput",
+        "interleaved_sets_gets": "RYW: interleaved sets and gets on a single key throughput",
     }
 
     def __init__(self, key_count=10000, key_size=16):
@@ -50,11 +51,11 @@ class RYWBenchmark(PythonTest):
 
     def run_test(self):
         try:
-            db = fdb.open(None, 'DB')
+            db = fdb.open(None, "DB")
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('fdb.open failed'))
+            self.result.add_error(self.get_error("fdb.open failed"))
             return
 
         try:
@@ -62,10 +63,10 @@ class RYWBenchmark(PythonTest):
         except KeyboardInterrupt:
             raise
         except Exception:
-            self.result.add_error(self.get_error('Failed to complete all tests'))
+            self.result.add_error(self.get_error("Failed to complete all tests"))
 
     def key(self, num):
-        return '%0*d' % (self.key_size, num)
+        return "%0*d" % (self.key_size, num)
 
     # Adds the stack trace to an error message
     def get_error(self, message):
@@ -88,11 +89,13 @@ class RYWBenchmark(PythonTest):
 
         for test in self.args.tests_to_run:
             time.sleep(5)
-            print('Running test %s' % test)
+            print("Running test %s" % test)
             results = []
 
-            fxn_name = 'run_%s' % test
-            assert hasattr(self, fxn_name), 'Test function %s is not implemented' % fxn_name
+            fxn_name = "run_%s" % test
+            assert hasattr(self, fxn_name), (
+                "Test function %s is not implemented" % fxn_name
+            )
 
             for x in range(0, num_runs):
                 try:
@@ -100,17 +103,21 @@ class RYWBenchmark(PythonTest):
                 except KeyboardInterrupt:
                     raise
                 except Exception:
-                    self.result.add_error(self.get_error('Performance test failed: ' + RYWBenchmark.tests[test]))
+                    self.result.add_error(
+                        self.get_error(
+                            "Performance test failed: " + RYWBenchmark.tests[test]
+                        )
+                    )
                     break
 
             if len(results) == num_runs:
                 median = sorted(results)[num_runs / 2]
-                self.result.add_kpi(RYWBenchmark.tests[test], int(median), 'keys/s')
+                self.result.add_kpi(RYWBenchmark.tests[test], int(median), "keys/s")
 
     def insert_data(self, tr):
         del tr[:]
         for i in range(0, 10000):
-            tr[self.key(i)] = 'foo'
+            tr[self.key(i)] = "foo"
 
     def run_get_single(self, tr, count=10000):
         start = time.time()
@@ -152,26 +159,39 @@ class RYWBenchmark(PythonTest):
 
     def run_interleaved_sets_gets(self, tr, count=10000):
         start = time.time()
-        tr['foo'] = str(1)
+        tr["foo"] = str(1)
         for i in range(count):
-            old = int(tr.get('foo').wait())
-            tr.set('foo', str(old + 1))
+            old = int(tr.get("foo").wait())
+            tr.set("foo", str(old + 1))
         return count / (time.time() - start)
 
 
-if __name__ == '__main__':
-    print("Running RYW Benchmark test on Python version %d.%d.%d%s%d" %
-          (sys.version_info[0], sys.version_info[1], sys.version_info[2], sys.version_info[3][0], sys.version_info[4]))
+if __name__ == "__main__":
+    print(
+        "Running RYW Benchmark test on Python version %d.%d.%d%s%d"
+        % (
+            sys.version_info[0],
+            sys.version_info[1],
+            sys.version_info[2],
+            sys.version_info[3][0],
+            sys.version_info[4],
+        )
+    )
 
     parser = argparse.ArgumentParser()
 
     tests = sorted(RYWBenchmark.tests.keys())
-    assert len(tests) > 0, 'RYW benchmark test has no test_functions'
-    test_string = ', '.join(tests[:-1])
+    assert len(tests) > 0, "RYW benchmark test has no test_functions"
+    test_string = ", ".join(tests[:-1])
     if len(tests) > 1:
-        test_string += ', and '
+        test_string += ", and "
 
     test_string += tests[-1]
 
-    parser.add_argument('--tests-to-run', nargs='*', help='Names of tests to run. Can be any of %s. By default, all tests are run.' % test_string)
+    parser.add_argument(
+        "--tests-to-run",
+        nargs="*",
+        help="Names of tests to run. Can be any of %s. By default, all tests are run."
+        % test_string,
+    )
     RYWBenchmark().run(parser=parser)

From ed60afc96435bdf15231cf03415e178ba0ad36ef Mon Sep 17 00:00:00 2001
From: Sagar Vemuri <sagar.vemuri@snowflake.com>
Date: Wed, 27 Apr 2022 11:12:01 -0700
Subject: [PATCH 60/84] Handle versionstamped keys, and include additonal trace
 information

---
 .../sphinx/source/api-error-codes.rst         |  2 --
 fdbserver/CommitProxyServer.actor.cpp         | 36 ++++++++++++++++---
 flow/error_definitions.h                      |  2 +-
 3 files changed, 33 insertions(+), 7 deletions(-)

diff --git a/documentation/sphinx/source/api-error-codes.rst b/documentation/sphinx/source/api-error-codes.rst
index 7dac09bd9c..7c06dbb6df 100644
--- a/documentation/sphinx/source/api-error-codes.rst
+++ b/documentation/sphinx/source/api-error-codes.rst
@@ -176,8 +176,6 @@ FoundationDB may return the following error codes from API functions. If you nee
 +-----------------------------------------------+-----+--------------------------------------------------------------------------------+
 | unknown_tenant                                | 2137| Tenant is not available from this server                                       |
 +-----------------------------------------------+-----+--------------------------------------------------------------------------------+
-| illegal_tenant_access                         | 2138| Tenant information mismatch                                                    |
-+-----------------------------------------------+-----+--------------------------------------------------------------------------------+
 | api_version_unset                             | 2200| API version is not set                                                         |
 +-----------------------------------------------+-----+--------------------------------------------------------------------------------+
 | api_version_already_set                       | 2201| API version may be set only once                                               |
diff --git a/fdbserver/CommitProxyServer.actor.cpp b/fdbserver/CommitProxyServer.actor.cpp
index 2b8a6079de..2ced6949ef 100644
--- a/fdbserver/CommitProxyServer.actor.cpp
+++ b/fdbserver/CommitProxyServer.actor.cpp
@@ -279,13 +279,32 @@ bool verifyPrefix(ProxyCommitData* const commitData, const CommitTransactionRequ
 		for (auto& m : req.transaction.mutations) {
 			if (m.param1 != metadataVersionKey) {
 				if (!m.param1.startsWith(tenantPrefix)) {
+					TraceEvent(SevWarnAlways, "TenantPrefixMismatch")
+					    .suppressFor(60)
+					    .detail("Prefix", tenantPrefix.toHexString())
+					    .detail("Key", m.param1.toHexString())
+					    .detail("KeyType", "Key");
 					return false;
 				}
+
 				if (m.type == MutationRef::ClearRange && !m.param2.startsWith(tenantPrefix)) {
+					TraceEvent(SevWarnAlways, "TenantPrefixMismatch")
+					    .suppressFor(60)
+					    .detail("Prefix", tenantPrefix.toHexString())
+					    .detail("Key", m.param2.toHexString())
+					    .detail("KeyType", "ClearRangeKey");
 					return false;
-				} else if (m.type != MutationRef::SetVersionstampedKey) {
-					// TODO: How should this be handled?
-					// Maybe skip checking this for now? If so, fall-through.
+				} else if (m.type == MutationRef::SetVersionstampedKey) {
+					uint8_t* key = const_cast<uint8_t*>(m.param1.begin());
+					int* offset = reinterpret_cast<int*>(&key[m.param1.size() - 4]);
+					if (*offset <= tenantPrefix.size()) {
+						TraceEvent(SevWarnAlways, "TenantPrefixMismatch")
+						    .suppressFor(60)
+						    .detail("Prefix", tenantPrefix.toHexString())
+						    .detail("Key", m.param1.toHexString())
+						    .detail("KeyType", "VersionstampedKey");
+						return false;
+					}
 				}
 			}
 		}
@@ -293,6 +312,11 @@ bool verifyPrefix(ProxyCommitData* const commitData, const CommitTransactionRequ
 		for (auto& rc : req.transaction.read_conflict_ranges) {
 			if (rc.begin != metadataVersionKey &&
 			    (!rc.begin.startsWith(tenantPrefix) || !rc.end.startsWith(tenantPrefix))) {
+				TraceEvent(SevWarnAlways, "TenantPrefixMismatch")
+				    .suppressFor(60)
+				    .detail("Prefix", tenantPrefix.toHexString())
+				    .detail("BeginKey", rc.begin.toHexString())
+				    .detail("EndKey", rc.end.toHexString());
 				return false;
 			}
 		}
@@ -300,6 +324,11 @@ bool verifyPrefix(ProxyCommitData* const commitData, const CommitTransactionRequ
 		for (auto& wc : req.transaction.write_conflict_ranges) {
 			if (wc.begin != metadataVersionKey &&
 			    (!wc.begin.startsWith(tenantPrefix) || !wc.end.startsWith(tenantPrefix))) {
+				TraceEvent(SevWarnAlways, "TenantPrefixMismatch")
+				    .suppressFor(60)
+				    .detail("Prefix", tenantPrefix.toHexString())
+				    .detail("BeginKey", wc.begin.toHexString())
+				    .detail("EndKey", wc.end.toHexString());
 				return false;
 			}
 		}
@@ -358,7 +387,6 @@ ACTOR Future<Void> commitBatcher(ProxyCommitData* commitData,
 					if (!verifyPrefix(commitData, req)) {
 						++commitData->stats.txnCommitErrors;
 						req.reply.sendError(illegal_tenant_access());
-						TraceEvent(SevWarnAlways, "TenantPrefixMismatch").suppressFor(60);
 						continue;
 					}
 
diff --git a/flow/error_definitions.h b/flow/error_definitions.h
index e24d840602..7147164749 100755
--- a/flow/error_definitions.h
+++ b/flow/error_definitions.h
@@ -226,7 +226,7 @@ ERROR( invalid_tenant_name, 2134, "Tenant name cannot begin with \\xff");
 ERROR( tenant_prefix_allocator_conflict, 2135, "The database already has keys stored at the prefix allocated for the tenant");
 ERROR( tenants_disabled, 2136, "Tenants have been disabled in the cluster");
 ERROR( unknown_tenant, 2137, "Tenant is not available from this server")
-ERROR( illegal_tenant_access, 2138, "Tenant information mismatch")
+ERROR( illegal_tenant_access, 2138, "Illegal tenant access")
 
 // 2200 - errors from bindings and official APIs
 ERROR( api_version_unset, 2200, "API version is not set" )

From d013ff7457faa2e9e729d9bfd33eb0d909518ab5 Mon Sep 17 00:00:00 2001
From: Sagar Vemuri <sagar.vemuri@snowflake.com>
Date: Wed, 27 Apr 2022 11:27:19 -0700
Subject: [PATCH 61/84] Remove unnecessary include

---
 fdbserver/CommitProxyServer.actor.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/fdbserver/CommitProxyServer.actor.cpp b/fdbserver/CommitProxyServer.actor.cpp
index 2ced6949ef..70e998e6cf 100644
--- a/fdbserver/CommitProxyServer.actor.cpp
+++ b/fdbserver/CommitProxyServer.actor.cpp
@@ -28,7 +28,6 @@
 #include "fdbclient/Knobs.h"
 #include "fdbclient/CommitProxyInterface.h"
 #include "fdbclient/NativeAPI.actor.h"
-#include "fdbclient/StorageServerInterface.h"
 #include "fdbclient/SystemData.h"
 #include "fdbclient/TransactionLineage.h"
 #include "fdbrpc/sim_validation.h"

From 333aadb903de57beebd9ac44cb9b184dcf680295 Mon Sep 17 00:00:00 2001
From: Ata E Husain Bohra <ata.husain@snowflake.com>
Date: Wed, 27 Apr 2022 12:17:52 -0700
Subject: [PATCH 62/84] Interface to enable clients to send/receive REST
 requests/responses (#6866)

* Interface to enable clients to send/receive REST requests/responses

Description

Major changes:
1. Add RESTClient interface enabling client to send/receive REST HTTP
   requests. Support REST APIs are: get, head, put, post, delete, trace
2. Add RESTUtil file introducing below interfaces:
 2.1. RESTUrl - Extract URI information: host, service, request-parameters.
 2.2. RESTConnectionPool-
      Connection establishment, life-cycle management, connection-pool (TTL)
 2.3. RESTClientKnobs - supports REST Knob parameter management and updates

Testing

Unit test - fdbrpc/RESTClient, fdbrpc/RESTUtils
---
 fdbclient/CMakeLists.txt                |   1 -
 fdbclient/S3BlobStore.h                 |   2 +-
 fdbrpc/CMakeLists.txt                   |   5 +
 {fdbclient => fdbrpc}/HTTP.actor.cpp    |   4 +-
 {fdbclient => fdbrpc}/HTTP.h            |  28 ++
 fdbrpc/RESTClient.actor.cpp             | 363 ++++++++++++++++++++++++
 fdbrpc/RESTClient.h                     |  97 +++++++
 fdbrpc/RESTUtils.actor.cpp              | 276 ++++++++++++++++++
 fdbrpc/RESTUtils.h                      | 113 ++++++++
 fdbserver/workloads/UnitTests.actor.cpp |   6 +-
 flow/Knobs.cpp                          |   8 +
 flow/Knobs.h                            |   8 +
 flow/error_definitions.h                |   4 +
 13 files changed, 911 insertions(+), 4 deletions(-)
 rename {fdbclient => fdbrpc}/HTTP.actor.cpp (99%)
 rename {fdbclient => fdbrpc}/HTTP.h (74%)
 create mode 100644 fdbrpc/RESTClient.actor.cpp
 create mode 100644 fdbrpc/RESTClient.h
 create mode 100644 fdbrpc/RESTUtils.actor.cpp
 create mode 100644 fdbrpc/RESTUtils.h

diff --git a/fdbclient/CMakeLists.txt b/fdbclient/CMakeLists.txt
index a21a235fde..bdf008b37c 100644
--- a/fdbclient/CMakeLists.txt
+++ b/fdbclient/CMakeLists.txt
@@ -65,7 +65,6 @@ set(FDBCLIENT_SRCS
   GlobalConfig.actor.cpp
   GrvProxyInterface.h
   HighContentionPrefixAllocator.actor.h
-  HTTP.actor.cpp
   IClientApi.h
   IConfigTransaction.cpp
   IConfigTransaction.h
diff --git a/fdbclient/S3BlobStore.h b/fdbclient/S3BlobStore.h
index bd29675bae..a61a5958d8 100644
--- a/fdbclient/S3BlobStore.h
+++ b/fdbclient/S3BlobStore.h
@@ -26,7 +26,7 @@
 #include "flow/Net2Packet.h"
 #include "fdbclient/Knobs.h"
 #include "fdbrpc/IRateControl.h"
-#include "fdbclient/HTTP.h"
+#include "fdbrpc/HTTP.h"
 #include "fdbclient/JSONDoc.h"
 
 // Representation of all the things you need to connect to a blob store instance with some credentials.
diff --git a/fdbrpc/CMakeLists.txt b/fdbrpc/CMakeLists.txt
index 077640e629..3be4954666 100644
--- a/fdbrpc/CMakeLists.txt
+++ b/fdbrpc/CMakeLists.txt
@@ -15,6 +15,7 @@ set(FDBRPC_SRCS
   genericactors.actor.h
   genericactors.actor.cpp
   HealthMonitor.actor.cpp
+  HTTP.actor.cpp
   IAsyncFile.actor.cpp
   IPAllowList.cpp
   LoadBalance.actor.cpp
@@ -28,6 +29,10 @@ set(FDBRPC_SRCS
   ReplicationPolicy.cpp
   ReplicationTypes.cpp
   ReplicationUtils.cpp
+  RESTClient.h
+  RESTClient.actor.cpp
+  RESTUtils.h
+  RESTUtils.actor.cpp
   SimExternalConnection.actor.cpp
   SimExternalConnection.h
   Stats.actor.cpp
diff --git a/fdbclient/HTTP.actor.cpp b/fdbrpc/HTTP.actor.cpp
similarity index 99%
rename from fdbclient/HTTP.actor.cpp
rename to fdbrpc/HTTP.actor.cpp
index 70964e7dbc..56607a0b95 100644
--- a/fdbclient/HTTP.actor.cpp
+++ b/fdbrpc/HTTP.actor.cpp
@@ -18,10 +18,12 @@
  * limitations under the License.
  */
 
-#include "fdbclient/HTTP.h"
+#include "fdbrpc/HTTP.h"
+
 #include "fdbclient/md5/md5.h"
 #include "fdbclient/libb64/encode.h"
 #include <cctype>
+
 #include "flow/actorcompiler.h" // has to be last include
 
 namespace HTTP {
diff --git a/fdbclient/HTTP.h b/fdbrpc/HTTP.h
similarity index 74%
rename from fdbclient/HTTP.h
rename to fdbrpc/HTTP.h
index d012c30ce8..d076b529fe 100644
--- a/fdbclient/HTTP.h
+++ b/fdbrpc/HTTP.h
@@ -18,6 +18,11 @@
  * limitations under the License.
  */
 
+#ifndef FDBRPC_HTTP_H
+#define FDBRPC_HTTP_H
+
+#pragma once
+
 #include "flow/flow.h"
 #include "flow/Net2Packet.h"
 #include "fdbrpc/IRateControl.h"
@@ -63,4 +68,27 @@ Future<Reference<Response>> doRequest(Reference<IConnection> const& conn,
                                       int64_t* const& pSent,
                                       Reference<IRateControl> const& recvRate,
                                       const std::string& requestHeader = std::string());
+
+constexpr int HTTP_STATUS_CODE_OK = 200;
+constexpr int HTTP_STATUS_CODE_CREATED = 201;
+constexpr int HTTP_STATUS_CODE_ACCEPTED = 202;
+constexpr int HTTP_STATUS_CODE_NO_CONTENT = 204;
+constexpr int HTTP_STATUS_CODE_UNAUTHORIZED = 401;
+constexpr int HTTP_STATUS_CODE_NOT_ACCEPTABLE = 406;
+constexpr int HTTP_STATUS_CODE_TOO_MANY_REQUESTS = 429;
+constexpr int HTTP_STATUS_CODE_INTERNAL_SERVER_ERROR = 500;
+constexpr int HTTP_STATUS_CODE_BAD_GATEWAY = 502;
+constexpr int HTTP_STATUS_CODE_SERVICE_UNAVAILABLE = 503;
+
+constexpr int HTTP_RETRYAFTER_DELAY_SECS = 300;
+
+const std::string HTTP_VERB_GET = "GET";
+const std::string HTTP_VERB_HEAD = "HEAD";
+const std::string HTTP_VERB_DELETE = "DELETE";
+const std::string HTTP_VERB_TRACE = "TRACE";
+const std::string HTTP_VERB_PUT = "PUT";
+const std::string HTTP_VERB_POST = "POST";
+
 } // namespace HTTP
+
+#endif
diff --git a/fdbrpc/RESTClient.actor.cpp b/fdbrpc/RESTClient.actor.cpp
new file mode 100644
index 0000000000..855018051f
--- /dev/null
+++ b/fdbrpc/RESTClient.actor.cpp
@@ -0,0 +1,363 @@
+/*
+ * RESTClient.actor.cpp
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2013-2022 Apple Inc. and the FoundationDB project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "fdbrpc/RESTClient.h"
+
+#include "fdbrpc/HTTP.h"
+#include "fdbrpc/IRateControl.h"
+#include "fdbrpc/RESTUtils.h"
+#include "flow/Arena.h"
+#include "flow/Error.h"
+#include "flow/FastRef.h"
+#include "flow/Knobs.h"
+#include "flow/Net2Packet.h"
+#include "flow/flow.h"
+#include "flow/network.h"
+#include "flow/serialize.h"
+#include "flow/Trace.h"
+#include "flow/UnitTest.h"
+
+#include <memory>
+#include <unordered_map>
+
+#include "flow/actorcompiler.h" // always the last include
+
+json_spirit::mObject RESTClient::Stats::getJSON() {
+	json_spirit::mObject o;
+
+	o["host_service"] = host_service;
+	o["requests_failed"] = requests_failed;
+	o["requests_successful"] = requests_successful;
+	o["bytes_sent"] = bytes_sent;
+
+	return o;
+}
+
+RESTClient::Stats RESTClient::Stats::operator-(const Stats& rhs) {
+	Stats r(host_service);
+
+	r.requests_failed = requests_failed - rhs.requests_failed;
+	r.requests_successful = requests_successful - rhs.requests_successful;
+	r.bytes_sent = bytes_sent - rhs.bytes_sent;
+
+	return r;
+}
+
+RESTClient::RESTClient() {}
+
+RESTClient::RESTClient(std::unordered_map<std::string, int>& knobSettings) {
+	knobs.set(knobSettings);
+}
+
+void RESTClient::setKnobs(const std::unordered_map<std::string, int>& knobSettings) {
+	knobs.set(knobSettings);
+}
+
+std::unordered_map<std::string, int> RESTClient::getKnobs() const {
+	return knobs.get();
+}
+
+ACTOR Future<Reference<HTTP::Response>> doRequest_impl(Reference<RESTClient> client,
+                                                       std::string verb,
+                                                       HTTP::Headers headers,
+                                                       RESTUrl* url,
+                                                       std::set<unsigned int> successCodes) {
+	state UnsentPacketQueue content;
+	state int contentLen = url->body.size();
+
+	if (url->body.size() > 0) {
+		PacketWriter pw(content.getWriteBuffer(url->body.size()), nullptr, Unversioned());
+		pw.serializeBytes(url->body);
+	}
+
+	std::string statsKey = RESTClient::getStatsKey(url->service, url->service);
+	auto sItr = client->statsMap.find(statsKey);
+	if (sItr == client->statsMap.end()) {
+		client->statsMap.emplace(statsKey, std::make_unique<RESTClient::Stats>(statsKey));
+	}
+
+	headers["Content-Length"] = format("%d", contentLen);
+	headers["Host"] = url->host;
+
+	state int maxTries = std::min(client->knobs.request_tries, client->knobs.connect_tries);
+	state int thisTry = 1;
+	state double nextRetryDelay = 2.0;
+	state Reference<IRateControl> sendReceiveRate = makeReference<Unlimited>();
+	state double reqTimeout = (client->knobs.request_timeout_secs * 1.0) / 60;
+	state RESTConnectionPoolKey connectPoolKey = RESTConnectionPool::getConnectionPoolKey(url->host, url->service);
+	state RESTClient::Stats* statsPtr = client->statsMap[statsKey].get();
+
+	loop {
+		state Optional<Error> err;
+		state Optional<NetworkAddress> remoteAddress;
+		state bool connectionEstablished = false;
+		state Reference<HTTP::Response> r;
+
+		try {
+			// Start connecting
+			Future<RESTConnectionPool::ReusableConnection> frconn = client->conectionPool->connect(
+			    connectPoolKey, client->knobs.secure_connection, client->knobs.max_connection_life);
+
+			// Finish connecting, do request
+			state RESTConnectionPool::ReusableConnection rconn =
+			    wait(timeoutError(frconn, client->knobs.connect_timeout));
+			connectionEstablished = true;
+
+			remoteAddress = rconn.conn->getPeerAddress();
+			Reference<HTTP::Response> _r = wait(timeoutError(HTTP::doRequest(rconn.conn,
+			                                                                 verb,
+			                                                                 url->resource,
+			                                                                 headers,
+			                                                                 contentLen > 0 ? &content : nullptr,
+			                                                                 contentLen,
+			                                                                 sendReceiveRate,
+			                                                                 &statsPtr->bytes_sent,
+			                                                                 sendReceiveRate),
+			                                                 reqTimeout));
+			r = _r;
+
+			// Since the response was parsed successfully (which is why we are here) reuse the connection unless we
+			// received the "Connection: close" header.
+			if (r->headers["Connection"] != "close") {
+				client->conectionPool->returnConnection(connectPoolKey, rconn, client->knobs.connection_pool_size);
+			}
+			rconn.conn.clear();
+		} catch (Error& e) {
+			if (e.code() == error_code_actor_cancelled) {
+				throw;
+			}
+			err = e;
+		}
+
+		// If err is not present then r is valid.
+		// If r->code is in successCodes then record the successful request and return r.
+		if (!err.present() && successCodes.count(r->code) != 0) {
+			statsPtr->requests_successful++;
+			return r;
+		}
+
+		// Otherwise, this request is considered failed.  Update failure count.
+		statsPtr->requests_failed++;
+
+		// All errors in err are potentially retryable as well as certain HTTP response codes...
+		bool retryable = err.present() || r->code == HTTP::HTTP_STATUS_CODE_INTERNAL_SERVER_ERROR ||
+		                 r->code == HTTP::HTTP_STATUS_CODE_BAD_GATEWAY ||
+		                 r->code == HTTP::HTTP_STATUS_CODE_SERVICE_UNAVAILABLE ||
+		                 r->code == HTTP::HTTP_STATUS_CODE_TOO_MANY_REQUESTS;
+
+		// But only if our previous attempt was not the last allowable try.
+		retryable = retryable && (thisTry < maxTries);
+
+		TraceEvent event(SevWarn, retryable ? "RESTClient_FailedRetryable" : "RESTClient_RequestFailed");
+
+		// Attach err to trace event if present, otherwise extract some stuff from the response
+		if (err.present()) {
+			event.errorUnsuppressed(err.get());
+		}
+		event.suppressFor(60);
+		if (!err.present()) {
+			event.detail("ResponseCode", r->code);
+		}
+
+		event.detail("ConnectionEstablished", connectionEstablished);
+
+		if (remoteAddress.present())
+			event.detail("RemoteEndpoint", remoteAddress.get());
+		else
+			event.detail("RemoteHost", url->host);
+
+		event.detail("Verb", verb).detail("Resource", url->resource).detail("ThisTry", thisTry);
+
+		// If r is not valid or not code TOO_MANY_REQUESTS then increment the try count.
+		// TOO_MANY_REQUEST's will not count against the attempt limit.
+		if (!r || r->code != HTTP::HTTP_STATUS_CODE_TOO_MANY_REQUESTS) {
+			++thisTry;
+		}
+
+		// We will wait delay seconds before the next retry, start with nextRetryDelay.
+		double delay = nextRetryDelay;
+		// Double but limit the *next* nextRetryDelay.
+		nextRetryDelay = std::min(nextRetryDelay * 2, 60.0);
+
+		if (retryable) {
+			// If r is valid then obey the Retry-After response header if present.
+			if (r) {
+				auto iRetryAfter = r->headers.find("Retry-After");
+				if (iRetryAfter != r->headers.end()) {
+					event.detail("RetryAfterHeader", iRetryAfter->second);
+					char* pEnd;
+					double retryAfter = strtod(iRetryAfter->second.c_str(), &pEnd);
+					if (*pEnd) {
+						// If there were other characters then don't trust the parsed value
+						retryAfter = HTTP::HTTP_RETRYAFTER_DELAY_SECS;
+					}
+					// Update delay
+					delay = std::max(delay, retryAfter);
+				}
+			}
+
+			// Log the delay then wait.
+			event.detail("RetryDelay", delay);
+			wait(::delay(delay));
+		} else {
+			// We can't retry, so throw something.
+
+			// This error code means the authentication header was not accepted, likely the account or key is wrong.
+			if (r && r->code == HTTP::HTTP_STATUS_CODE_NOT_ACCEPTABLE) {
+				throw http_not_accepted();
+			}
+
+			if (r && r->code == HTTP::HTTP_STATUS_CODE_UNAUTHORIZED) {
+				throw http_auth_failed();
+			}
+
+			// Recognize and throw specific errors
+			if (err.present()) {
+				int code = err.get().code();
+
+				// If we get a timed_out error during the the connect() phase, we'll call that connection_failed despite
+				// the fact that there was technically never a 'connection' to begin with.  It differentiates between an
+				// active connection timing out vs a connection timing out, though not between an active connection
+				// failing vs connection attempt failing.
+				// TODO:  Add more error types?
+				if (code == error_code_timed_out && !connectionEstablished) {
+					throw connection_failed();
+				}
+
+				if (code == error_code_timed_out || code == error_code_connection_failed ||
+				    code == error_code_lookup_failed) {
+					throw err.get();
+				}
+			}
+
+			throw http_request_failed();
+		}
+	}
+}
+
+Future<Reference<HTTP::Response>> RESTClient::doPutOrPost(const std::string& verb,
+                                                          Optional<HTTP::Headers> optHeaders,
+                                                          RESTUrl* url,
+                                                          std::set<unsigned int> successCodes) {
+	HTTP::Headers headers;
+	if (optHeaders.present()) {
+		headers = optHeaders.get();
+	}
+
+	return doRequest_impl(Reference<RESTClient>::addRef(this), verb, headers, url, successCodes);
+}
+
+Future<Reference<HTTP::Response>> RESTClient::doPost(const std::string& fullUrl,
+                                                     const std::string& requestBody,
+                                                     Optional<HTTP::Headers> optHeaders) {
+	RESTUrl url(fullUrl, requestBody, knobs.secure_connection);
+	return doPutOrPost(HTTP::HTTP_VERB_POST, optHeaders, std::addressof(url), { HTTP::HTTP_STATUS_CODE_OK });
+}
+
+Future<Reference<HTTP::Response>> RESTClient::doPut(const std::string& fullUrl,
+                                                    const std::string& requestBody,
+                                                    Optional<HTTP::Headers> optHeaders) {
+	RESTUrl url(fullUrl, requestBody, knobs.secure_connection);
+	return doPutOrPost(
+	    HTTP::HTTP_VERB_PUT,
+	    optHeaders,
+	    std::addressof(url),
+	    // 201 - on successful resource create
+	    // 200 / 204 - if target resource representation was successfully modified with the desired state
+	    { HTTP::HTTP_STATUS_CODE_OK, HTTP::HTTP_STATUS_CODE_CREATED, HTTP::HTTP_STATUS_CODE_NO_CONTENT });
+}
+
+Future<Reference<HTTP::Response>> RESTClient::doGetHeadDeleteOrTrace(const std::string& verb,
+                                                                     Optional<HTTP::Headers> optHeaders,
+                                                                     RESTUrl* url,
+                                                                     std::set<unsigned int> successCodes) {
+	HTTP::Headers headers;
+	if (optHeaders.present()) {
+		headers = optHeaders.get();
+	}
+
+	return doRequest_impl(Reference<RESTClient>::addRef(this), HTTP::HTTP_VERB_GET, headers, url, successCodes);
+}
+
+Future<Reference<HTTP::Response>> RESTClient::doGet(const std::string& fullUrl, Optional<HTTP::Headers> optHeaders) {
+	RESTUrl url(fullUrl, knobs.secure_connection);
+	return doGetHeadDeleteOrTrace(HTTP::HTTP_VERB_GET, optHeaders, std::addressof(url), { HTTP::HTTP_STATUS_CODE_OK });
+}
+
+Future<Reference<HTTP::Response>> RESTClient::doHead(const std::string& fullUrl, Optional<HTTP::Headers> optHeaders) {
+	RESTUrl url(fullUrl, knobs.secure_connection);
+	return doGetHeadDeleteOrTrace(HTTP::HTTP_VERB_HEAD, optHeaders, std::addressof(url), { HTTP::HTTP_STATUS_CODE_OK });
+}
+
+Future<Reference<HTTP::Response>> RESTClient::doDelete(const std::string& fullUrl, Optional<HTTP::Headers> optHeaders) {
+	RESTUrl url(fullUrl, knobs.secure_connection);
+	return doGetHeadDeleteOrTrace(
+	    HTTP::HTTP_VERB_DELETE,
+	    optHeaders,
+	    std::addressof(url),
+	    // 200 - action has been enacted.
+	    // 202 - action will likely succeed, but, has not yet been enacted.
+	    // 204 - action has been enated, no further information is to supplied.
+	    { HTTP::HTTP_STATUS_CODE_OK, HTTP::HTTP_STATUS_CODE_NO_CONTENT, HTTP::HTTP_STATUS_CODE_ACCEPTED });
+}
+
+Future<Reference<HTTP::Response>> RESTClient::doTrace(const std::string& fullUrl, Optional<HTTP::Headers> optHeaders) {
+	RESTUrl url(fullUrl, knobs.secure_connection);
+	return doGetHeadDeleteOrTrace(
+	    HTTP::HTTP_VERB_TRACE, optHeaders, std::addressof(url), { HTTP::HTTP_STATUS_CODE_OK });
+}
+
+// Only used to link unit tests
+void forceLinkRESTClientTests() {}
+
+TEST_CASE("fdbrpc/RESTClient") {
+	RESTClient r;
+	std::unordered_map<std::string, int> knobs = r.getKnobs();
+	ASSERT_EQ(knobs["secure_connection"], RESTClientKnobs::SECURE_CONNECTION);
+	ASSERT_EQ(knobs["connection_pool_size"], FLOW_KNOBS->RESTCLIENT_MAX_CONNECTIONPOOL_SIZE);
+	ASSERT_EQ(knobs["connect_tries"], FLOW_KNOBS->RESTCLIENT_CONNECT_TRIES);
+	ASSERT_EQ(knobs["connect_timeout"], FLOW_KNOBS->RESTCLIENT_CONNECT_TIMEOUT);
+	ASSERT_EQ(knobs["max_connection_life"], FLOW_KNOBS->RESTCLIENT_MAX_CONNECTION_LIFE);
+	ASSERT_EQ(knobs["request_tries"], FLOW_KNOBS->RESTCLIENT_REQUEST_TRIES);
+	ASSERT_EQ(knobs["request_timeout_secs"], FLOW_KNOBS->RESTCLIENT_REQUEST_TIMEOUT_SEC);
+
+	for (auto& itr : knobs) {
+		itr.second++;
+	}
+	r.setKnobs(knobs);
+
+	std::unordered_map<std::string, int> updated = r.getKnobs();
+	for (auto& itr : updated) {
+		ASSERT_EQ(knobs[itr.first], itr.second);
+	}
+
+	// invalid client knob
+	knobs["foo"] = 100;
+	try {
+		r.setKnobs(knobs);
+		ASSERT(false);
+	} catch (Error& e) {
+		if (e.code() != error_code_rest_invalid_rest_client_knob) {
+			throw e;
+		}
+	}
+
+	return Void();
+}
diff --git a/fdbrpc/RESTClient.h b/fdbrpc/RESTClient.h
new file mode 100644
index 0000000000..9ad8e895ac
--- /dev/null
+++ b/fdbrpc/RESTClient.h
@@ -0,0 +1,97 @@
+/*
+ * RESTClient.h
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2013-2022 Apple Inc. and the FoundationDB project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FDBRPC_RESTCLIENT_H
+#define FDBRPC_RESTCLIENT_H
+
+#include <memory>
+#pragma once
+
+#include "fdbclient/JSONDoc.h"
+#include "fdbrpc/HTTP.h"
+#include "fdbrpc/RESTUtils.h"
+#include "flow/Arena.h"
+#include "flow/FastRef.h"
+#include "flow/flow.h"
+#include "flow/Net2Packet.h"
+
+// This interface enables sending REST HTTP requests and receiving REST HTTP responses from a resource identified by a
+// URI.
+
+class RESTClient : public ReferenceCounted<RESTClient> {
+public:
+	struct Stats {
+		explicit Stats(const std::string& hService)
+		  : host_service(hService), requests_successful(0), requests_failed(0), bytes_sent(0) {}
+		Stats operator-(const Stats& rhs);
+		void clear() { requests_failed = requests_successful = bytes_sent = 0; }
+		json_spirit::mObject getJSON();
+
+		std::string host_service;
+		int64_t requests_successful;
+		int64_t requests_failed;
+		int64_t bytes_sent;
+	};
+
+	RESTClientKnobs knobs;
+	Reference<RESTConnectionPool> conectionPool;
+	// Connection stats maintained per "host:service"
+	std::unordered_map<std::string, std::unique_ptr<Stats>> statsMap;
+
+	RESTClient();
+	explicit RESTClient(std::unordered_map<std::string, int>& params);
+
+	void setKnobs(const std::unordered_map<std::string, int>& knobSettings);
+	std::unordered_map<std::string, int> getKnobs() const;
+
+	// Supports common REST APIs.
+	// On invocation of below methods, input 'fullUrl' is parsed using RESTUrl interface,
+	// RESTConnectionPool is used to leverage cached connection if any for 'host:service' pair. API then leverage
+	// HTTP::doRequest to accomplish the specified operation
+
+	Future<Reference<HTTP::Response>> doGet(const std::string& fullUrl,
+	                                        Optional<HTTP::Headers> optHeaders = Optional<HTTP::Headers>());
+	Future<Reference<HTTP::Response>> doHead(const std::string& fullUrl,
+	                                         Optional<HTTP::Headers> optHeaders = Optional<HTTP::Headers>());
+	Future<Reference<HTTP::Response>> doDelete(const std::string& fullUrl,
+	                                           Optional<HTTP::Headers> optHeaders = Optional<HTTP::Headers>());
+	Future<Reference<HTTP::Response>> doTrace(const std::string& fullUrl,
+	                                          Optional<HTTP::Headers> optHeaders = Optional<HTTP::Headers>());
+	Future<Reference<HTTP::Response>> doPut(const std::string& fullUrl,
+	                                        const std::string& requestBody,
+	                                        Optional<HTTP::Headers> optHeaders = Optional<HTTP::Headers>());
+	Future<Reference<HTTP::Response>> doPost(const std::string& fullUrl,
+	                                         const std::string& requestBody,
+	                                         Optional<HTTP::Headers> optHeaders = Optional<HTTP::Headers>());
+
+	static std::string getStatsKey(const std::string& host, const std::string& service) { return host + ":" + service; }
+
+private:
+	Future<Reference<HTTP::Response>> doGetHeadDeleteOrTrace(const std::string& verb,
+	                                                         Optional<HTTP::Headers> optHeaders,
+	                                                         RESTUrl* url,
+	                                                         std::set<unsigned int> successCodes);
+	Future<Reference<HTTP::Response>> doPutOrPost(const std::string& verb,
+	                                              Optional<HTTP::Headers> headers,
+	                                              RESTUrl* url,
+	                                              std::set<unsigned int> successCodes);
+};
+
+#endif
diff --git a/fdbrpc/RESTUtils.actor.cpp b/fdbrpc/RESTUtils.actor.cpp
new file mode 100644
index 0000000000..43f661224d
--- /dev/null
+++ b/fdbrpc/RESTUtils.actor.cpp
@@ -0,0 +1,276 @@
+/*
+ * RESTUtils.actor.cpp
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2013-2022 Apple Inc. and the FoundationDB project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "fdbrpc/RESTUtils.h"
+
+#include "flow/flat_buffers.h"
+#include "flow/UnitTest.h"
+
+#include <boost/algorithm/string.hpp>
+
+#include "flow/actorcompiler.h" // always the last include
+
+namespace {
+std::unordered_set<std::string> protocols = { "http", "https" };
+
+bool isProtocolSupported(const std::string& protocol) {
+	return protocols.find(protocol) != protocols.end();
+}
+
+bool isSecurePrototol(const std::string& protocol) {
+	return protocol.compare("https") == 0;
+}
+} // namespace
+
+RESTClientKnobs::RESTClientKnobs() {
+	secure_connection = RESTClientKnobs::SECURE_CONNECTION;
+	connection_pool_size = FLOW_KNOBS->RESTCLIENT_MAX_CONNECTIONPOOL_SIZE;
+	connect_tries = FLOW_KNOBS->RESTCLIENT_CONNECT_TRIES;
+	connect_timeout = FLOW_KNOBS->RESTCLIENT_CONNECT_TIMEOUT;
+	max_connection_life = FLOW_KNOBS->RESTCLIENT_MAX_CONNECTION_LIFE;
+	request_tries = FLOW_KNOBS->RESTCLIENT_REQUEST_TRIES;
+	request_timeout_secs = FLOW_KNOBS->RESTCLIENT_REQUEST_TIMEOUT_SEC;
+
+	knobMap["connection_pool_size"] = std::addressof(connection_pool_size);
+	knobMap["pz"] = std::addressof(connection_pool_size);
+	knobMap["secure_connection"] = std::addressof(secure_connection);
+	knobMap["sc"] = std::addressof(secure_connection);
+	knobMap["connect_tries"] = std::addressof(connect_tries);
+	knobMap["ct"] = std::addressof(connect_tries);
+	knobMap["connect_timeout"] = std::addressof(connect_timeout);
+	knobMap["cto"] = std::addressof(connect_timeout);
+	knobMap["max_connection_life"] = std::addressof(max_connection_life);
+	knobMap["mcl"] = std::addressof(max_connection_life);
+	knobMap["request_tries"] = std::addressof(request_tries);
+	knobMap["rt"] = std::addressof(request_tries);
+	knobMap["request_timeout_secs"] = std::addressof(request_timeout_secs);
+	knobMap["rtom"] = std::addressof(request_timeout_secs);
+}
+
+void RESTClientKnobs::set(const std::unordered_map<std::string, int>& knobSettings) {
+	TraceEvent trace = TraceEvent("RESTClient_SetKnobs");
+
+	for (const auto& itr : knobSettings) {
+		const auto& kItr = RESTClientKnobs::knobMap.find(itr.first);
+		if (kItr == RESTClientKnobs::knobMap.end()) {
+			trace.detail("RESTClient_InvalidKnobName", itr.first);
+			throw rest_invalid_rest_client_knob();
+		}
+		*(kItr->second) = itr.second;
+		trace.detail(itr.first.c_str(), itr.second);
+	}
+}
+
+std::unordered_map<std::string, int> RESTClientKnobs::get() const {
+	std::unordered_map<std::string, int> details = {
+		{ "connection_pool_size", connection_pool_size },
+		{ "secure_connection", secure_connection },
+		{ "connect_tries", connect_tries },
+		{ "connect_timeout", connect_timeout },
+		{ "max_connection_life", max_connection_life },
+		{ "request_tries", request_tries },
+		{ "request_timeout_secs", request_timeout_secs },
+	};
+
+	return details;
+}
+
+ACTOR Future<RESTConnectionPool::ReusableConnection> connect_impl(Reference<RESTConnectionPool> connectionPool,
+                                                                  RESTConnectionPoolKey connectKey,
+                                                                  bool isSecure,
+                                                                  int maxConnLife) {
+	auto poolItr = connectionPool->connectionPoolMap.find(connectKey);
+	if (poolItr == connectionPool->connectionPoolMap.end()) {
+		throw rest_connectpool_key_not_found();
+	}
+
+	while (!poolItr->second.empty()) {
+		RESTConnectionPool::ReusableConnection rconn = poolItr->second.front();
+		poolItr->second.pop();
+
+		if (rconn.expirationTime > now()) {
+			TraceEvent("RESTClient_ReusableConnection")
+			    .suppressFor(60)
+			    .detail("RemoteEndpoint", rconn.conn->getPeerAddress())
+			    .detail("ExpireIn", rconn.expirationTime - now());
+			return rconn;
+		}
+	}
+
+	state Reference<IConnection> conn =
+	    wait(INetworkConnections::net()->connect(connectKey.first, connectKey.second, isSecure));
+	wait(conn->connectHandshake());
+
+	return RESTConnectionPool::ReusableConnection({ conn, now() + maxConnLife });
+}
+
+Future<RESTConnectionPool::ReusableConnection> RESTConnectionPool::connect(RESTConnectionPoolKey connectKey,
+                                                                           const bool isSecure,
+                                                                           const int maxConnLife) {
+	return connect_impl(Reference<RESTConnectionPool>::addRef(this), connectKey, isSecure, maxConnLife);
+}
+
+void RESTConnectionPool::returnConnection(RESTConnectionPoolKey connectKey,
+                                          ReusableConnection& rconn,
+                                          const int maxConnections) {
+	auto poolItr = connectionPoolMap.find(connectKey);
+	if (poolItr == connectionPoolMap.end()) {
+		throw rest_connectpool_key_not_found();
+	}
+
+	// If it expires in the future then add it to the pool in the front iff connection pool size is not maxed
+	if (rconn.expirationTime > now() && poolItr->second.size() < maxConnections) {
+		poolItr->second.push(rconn);
+	}
+	rconn.conn = Reference<IConnection>();
+}
+
+RESTUrl::RESTUrl(const std::string& fUrl, const bool isSecure) {
+	parseUrl(fUrl, isSecure);
+}
+
+RESTUrl::RESTUrl(const std::string& fullUrl, const std::string& b, const bool isSecure) : body(b) {
+	parseUrl(fullUrl, isSecure);
+}
+
+void RESTUrl::parseUrl(const std::string& fullUrl, const bool isSecure) {
+	// Sample valid URIs
+	// 1. With 'host' & 'resource' := '<protocol>://<host>/<resource>'
+	// 2. With 'host', 'service' & 'resource' := '<protocol>://<host>:port/<resource>'
+	// 3. With 'host', 'service', 'resource' & 'reqParameters' := '<protocol>://<host>:port/<resource>?<parameter-list>'
+
+	try {
+		StringRef t(fullUrl);
+		StringRef p = t.eat("://");
+		std::string protocol = p.toString();
+		boost::algorithm::to_lower(protocol);
+		if (!isProtocolSupported(protocol)) {
+			throw format("Invalid REST URI protocol '%s'", protocol.c_str());
+		}
+
+		// Ensure connection secure knob setting matches with the input URI
+		if ((isSecurePrototol(protocol) && !isSecure) || (!isSecurePrototol(protocol) && isSecure)) {
+			throw format("Invalid REST URI protocol secure knob '%s'", fullUrl.c_str());
+		}
+
+		// extract 'resource' and optional 'parameter list' if supplied in the URL
+		uint8_t foundSeparator = 0;
+		StringRef hostPort = t.eatAny("/?", &foundSeparator);
+		if (foundSeparator == '/') {
+			resource = t.eat("?").toString();
+			reqParameters = t.eat().toString();
+		}
+
+		// hostPort is at least a host or IP address, optionally followed by :portNumber or :serviceName
+		StringRef hRef(hostPort);
+		StringRef h = hRef.eat(":");
+		if (h.size() == 0) {
+			throw std::string("host cannot be empty");
+		}
+		host = h.toString();
+		service = hRef.eat().toString();
+
+		TraceEvent("RESTClient_ParseURI")
+		    .detail("URI", fullUrl)
+		    .detail("Host", host)
+		    .detail("Service", service)
+		    .detail("Resource", resource)
+		    .detail("ReqParameters", reqParameters);
+	} catch (std::string& err) {
+		TraceEvent("RESTClient_ParseError").detail("URI", fullUrl).detail("Error", err);
+		throw rest_invalid_uri();
+	}
+}
+
+// Only used to link unit tests
+void forceLinkRESTUtilsTests() {}
+
+TEST_CASE("fdbrpc/RESTUtils") {
+	// invalid protocol
+	try {
+		std::string uri("httpx://foo/bar");
+		RESTUrl r(uri, false);
+		ASSERT(false);
+	} catch (Error& e) {
+		if (e.code() != error_code_rest_invalid_uri) {
+			throw e;
+		}
+	}
+
+	// mismatch protocol and knob values
+	try {
+		std::string uri("http://foo/bar");
+		RESTUrl r(uri, true);
+		ASSERT(false);
+	} catch (Error& e) {
+		if (e.code() != error_code_rest_invalid_uri) {
+			throw e;
+		}
+	}
+
+	// missing host
+	try {
+		std::string uri("https://:/bar");
+		RESTUrl r(uri, true);
+		ASSERT(false);
+	} catch (Error& e) {
+		if (e.code() != error_code_rest_invalid_uri) {
+			throw e;
+		}
+	}
+
+	// valid URI with service
+	try {
+		std::string uri("https://host:80/foo/bar");
+		RESTUrl r(uri, true);
+		ASSERT_EQ(r.host.compare("host"), 0);
+		ASSERT_EQ(r.service.compare("80"), 0);
+		ASSERT_EQ(r.resource.compare("foo/bar"), 0);
+	} catch (Error& e) {
+		throw e;
+	}
+
+	// valid URI with-out service
+	try {
+		std::string uri("https://host/foo/bar");
+		RESTUrl r(uri, true);
+		ASSERT_EQ(r.host.compare("host"), 0);
+		ASSERT(r.service.empty());
+		ASSERT_EQ(r.resource.compare("foo/bar"), 0);
+	} catch (Error& e) {
+		throw e;
+	}
+
+	// valid URI with parameters
+	try {
+		std::string uri("https://host/foo/bar?param1,param2");
+		RESTUrl r(uri, true);
+		ASSERT_EQ(r.host.compare("host"), 0);
+		ASSERT(r.service.empty());
+		ASSERT_EQ(r.resource.compare("foo/bar"), 0);
+		ASSERT_EQ(r.reqParameters.compare("param1,param2"), 0);
+	} catch (Error& e) {
+		throw e;
+	}
+
+	// ensure RESTClient::Knob default values and updates
+
+	return Void();
+}
\ No newline at end of file
diff --git a/fdbrpc/RESTUtils.h b/fdbrpc/RESTUtils.h
new file mode 100644
index 0000000000..ac9932422d
--- /dev/null
+++ b/fdbrpc/RESTUtils.h
@@ -0,0 +1,113 @@
+/*
+ * RESTUtils.h
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2013-2022 Apple Inc. and the FoundationDB project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FDRPC_REST_UTILS_H
+#define FDRPC_REST_UTILS_H
+
+#pragma once
+
+#include "flow/flow.h"
+#include "flow/FastRef.h"
+#include "flow/Net2Packet.h"
+
+#include <unordered_map>
+#include <utility>
+
+// Util interface managing REST active connection pool.
+// The interface internally constructs and maintains map {"host:service" -> activeConnection}; any new connection
+// request would first access cached connection if possible (not expired), if none exists, it would establish a new
+// connection and return to the caller. Caller on accomplishing the task at-hand, should return the connection back to
+// the pool.
+
+using RESTConnectionPoolKey = std::pair<std::string, std::string>;
+
+class RESTConnectionPool : public ReferenceCounted<RESTConnectionPool> {
+public:
+	struct ReusableConnection {
+		Reference<IConnection> conn;
+		double expirationTime;
+	};
+
+	// Maximum number of connections cached in the connection-pool.
+	int maxConnPerConnectKey;
+	std::map<RESTConnectionPoolKey, std::queue<ReusableConnection>> connectionPoolMap;
+
+	RESTConnectionPool(const int maxConnsPerKey) : maxConnPerConnectKey(maxConnsPerKey) {}
+
+	// Routine is responsible to provide an usable TCP connection object; it reuses an active connection from
+	// connection-pool if availalbe, otherwise, establish a new TCP connection
+	Future<ReusableConnection> connect(RESTConnectionPoolKey connectKey, const bool isSecure, const int maxConnLife);
+	void returnConnection(RESTConnectionPoolKey connectKey, ReusableConnection& conn, const int maxConnections);
+
+	static RESTConnectionPoolKey getConnectionPoolKey(const std::string& host, const std::string& service) {
+		return std::make_pair(host, service);
+	}
+};
+
+// Util interface facilitating management and update for RESTClient knob parameters
+struct RESTClientKnobs {
+	int connection_pool_size, secure_connection, connect_timeout, connect_tries, max_connection_life, request_tries,
+	    request_timeout_secs;
+
+	constexpr static int SECURE_CONNECTION = 1;
+	constexpr static int NOT_SECURE_CONNECTION = 0;
+
+	RESTClientKnobs();
+
+	void set(const std::unordered_map<std::string, int>& knobSettings);
+	std::unordered_map<std::string, int> get() const;
+	std::unordered_map<std::string, int*> knobMap;
+
+	static std::vector<std::string> getKnobDescriptions() {
+		return {
+			"connection_pool_size (pz)             Maximum numbers of active connections in the connection-pool",
+			"secure_connection (or sc)             Set 1 for secure connection and 0 for insecure connection.",
+			"connect_tries (or ct)                 Number of times to try to connect for each request.",
+			"connect_timeout (or cto)              Number of seconds to wait for a connect request to succeed.",
+			"max_connection_life (or mcl)          Maximum number of seconds to use a single TCP connection.",
+			"request_tries (or rt)                 Number of times to try each request until a parsable HTTP "
+			"response other than 429 is received.",
+			"request_timeout_secs (or rtom)        Number of seconds to wait for a request to succeed after a "
+			"connection is established.",
+		};
+	}
+};
+
+// Util interface facilitating parsing of an input REST 'full_url'
+struct RESTUrl {
+public:
+	// Connection resources - host and port details
+	std::string host;
+	std::string service;
+	// resource identified by URI
+	std::string resource;
+	// optional REST request parameters
+	std::string reqParameters;
+	// Request 'body' payload
+	std::string body;
+
+	explicit RESTUrl(const std::string& fullUrl, const bool isSecure);
+	explicit RESTUrl(const std::string& fullUrl, const std::string& body, const bool isSecure);
+
+private:
+	void parseUrl(const std::string& fullUrl, bool isSecure);
+};
+
+#endif
\ No newline at end of file
diff --git a/fdbserver/workloads/UnitTests.actor.cpp b/fdbserver/workloads/UnitTests.actor.cpp
index 25f2ed135a..96433181f5 100644
--- a/fdbserver/workloads/UnitTests.actor.cpp
+++ b/fdbserver/workloads/UnitTests.actor.cpp
@@ -30,7 +30,7 @@ void forceLinkMemcpyTests();
 void forceLinkMemcpyPerfTests();
 #if (!defined(TLS_DISABLED) && !defined(_WIN32))
 void forceLinkStreamCipherTests();
-void forceLinkBLockCiherTests();
+void forceLinkBlobCipherTests();
 #endif
 void forceLinkParallelStreamTests();
 void forceLinkSimExternalConnectionTests();
@@ -39,6 +39,8 @@ void forceLinkSimKmsConnectorTests();
 void forceLinkIThreadPoolTests();
 void forceLinkTokenSignTests();
 void forceLinkVersionVectorTests();
+void forceLinkRESTClientTests();
+void forceLinkRESTUtilsTests();
 
 struct UnitTestWorkload : TestWorkload {
 	bool enabled;
@@ -88,6 +90,8 @@ struct UnitTestWorkload : TestWorkload {
 		forceLinkIThreadPoolTests();
 		forceLinkTokenSignTests();
 		forceLinkVersionVectorTests();
+		forceLinkRESTClientTests();
+		forceLinkRESTUtilsTests();
 	}
 
 	std::string description() const override { return "UnitTests"; }
diff --git a/flow/Knobs.cpp b/flow/Knobs.cpp
index 08f392ed9a..b309861d59 100644
--- a/flow/Knobs.cpp
+++ b/flow/Knobs.cpp
@@ -276,6 +276,14 @@ void FlowKnobs::initialize(Randomize randomize, IsSimulated isSimulated) {
 	if ( randomize && BUGGIFY) { ENCRYPT_CIPHER_KEY_CACHE_TTL = deterministicRandom()->randomInt(50, 100); }
 	init( ENCRYPT_KEY_REFRESH_INTERVAL,   isSimulated ? 60 : 8 * 60 );
 	if ( randomize && BUGGIFY) { ENCRYPT_KEY_REFRESH_INTERVAL = deterministicRandom()->randomInt(20, 40); }
+
+	// REST Client
+	init( RESTCLIENT_MAX_CONNECTIONPOOL_SIZE,                   10 );
+	init( RESTCLIENT_CONNECT_TRIES,                             10 );
+	init( RESTCLIENT_CONNECT_TIMEOUT,                           10 );
+	init( RESTCLIENT_MAX_CONNECTION_LIFE,                      120 );
+	init( RESTCLIENT_REQUEST_TRIES,                             10 );
+	init( RESTCLIENT_REQUEST_TIMEOUT_SEC,                      120 );
 }
 // clang-format on
 
diff --git a/flow/Knobs.h b/flow/Knobs.h
index 09231a1098..5bbb3ca8e8 100644
--- a/flow/Knobs.h
+++ b/flow/Knobs.h
@@ -344,6 +344,14 @@ public:
 	int64_t ENCRYPT_CIPHER_KEY_CACHE_TTL;
 	int64_t ENCRYPT_KEY_REFRESH_INTERVAL;
 
+	// RESTClient
+	int RESTCLIENT_MAX_CONNECTIONPOOL_SIZE;
+	int RESTCLIENT_CONNECT_TRIES;
+	int RESTCLIENT_CONNECT_TIMEOUT;
+	int RESTCLIENT_MAX_CONNECTION_LIFE;
+	int RESTCLIENT_REQUEST_TRIES;
+	int RESTCLIENT_REQUEST_TIMEOUT_SEC;
+
 	FlowKnobs(class Randomize, class IsSimulated);
 	void initialize(class Randomize, class IsSimulated);
 };
diff --git a/flow/error_definitions.h b/flow/error_definitions.h
index a80bd2d3a8..a26d288598 100755
--- a/flow/error_definitions.h
+++ b/flow/error_definitions.h
@@ -146,6 +146,10 @@ ERROR( file_corrupt, 1522, "A structurally corrupt data file was detected" )
 ERROR( http_request_failed, 1523, "HTTP response code not received or indicated failure" )
 ERROR( http_auth_failed, 1524, "HTTP request failed due to bad credentials" )
 ERROR( http_bad_request_id, 1525, "HTTP response contained an unexpected X-Request-ID header" )
+ERROR( rest_invalid_uri, 1526, "Invalid REST URI")
+ERROR( rest_invalid_rest_client_knob, 1527, "Invalid RESTClient knob")
+ERROR( rest_connectpool_key_not_found, 1528, "ConnectKey not found in connection pool")
+
 
 // 2xxx Attempt (presumably by a _client_) to do something illegal.  If an error is known to
 // be internally caused, it should be 41xx

From 1f046e4be5a755ff41e2d481d0f1c2ffd9155140 Mon Sep 17 00:00:00 2001
From: Xiaoxi Wang <xiaoxi.wang@snowflake.com>
Date: Wed, 27 Apr 2022 12:17:11 -0700
Subject: [PATCH 63/84] fix excludedServer overwritten bug; change some trace
 event field

---
 fdbserver/DDTeamCollection.actor.cpp | 45 ++++++++++++++--------------
 1 file changed, 22 insertions(+), 23 deletions(-)

diff --git a/fdbserver/DDTeamCollection.actor.cpp b/fdbserver/DDTeamCollection.actor.cpp
index ed1d232e43..72cf7710d4 100644
--- a/fdbserver/DDTeamCollection.actor.cpp
+++ b/fdbserver/DDTeamCollection.actor.cpp
@@ -718,18 +718,19 @@ public:
 				bool recheck = !healthy && (lastReady != self->initialFailureReactionDelay.isReady() ||
 				                            (lastZeroHealthy && !self->zeroHealthyTeams->get()) || containsFailed);
 
-				// TraceEvent("TeamHealthChangeDetected", self->distributorId)
-				//     .detail("Team", team->getDesc())
-				//     .detail("ServersLeft", serversLeft)
-				//     .detail("LastServersLeft", lastServersLeft)
-				//     .detail("AnyUndesired", anyUndesired)
-				//     .detail("LastAnyUndesired", lastAnyUndesired)
-				//     .detail("AnyWrongConfiguration", anyWrongConfiguration)
-				//     .detail("LastWrongConfiguration", lastWrongConfiguration)
-				//     .detail("Recheck", recheck)
-				//     .detail("BadTeam", badTeam)
-				//     .detail("LastZeroHealthy", lastZeroHealthy)
-				//     .detail("ZeroHealthyTeam", self->zeroHealthyTeams->get());
+				//TraceEvent("TeamHealthChangeDetected", self->distributorId)
+				//    .detail("Team", team->getDesc())
+				//    .detail("ServersLeft", serversLeft)
+				//    .detail("LastServersLeft", lastServersLeft)
+				//    .detail("AnyUndesired", anyUndesired)
+				//    .detail("LastAnyUndesired", lastAnyUndesired)
+				//    .detail("AnyWrongConfiguration", anyWrongConfiguration)
+				//    .detail("LastWrongConfiguration", lastWrongConfiguration)
+				//    .detail("ContainsWigglingServer", anyWigglingServer)
+				//    .detail("Recheck", recheck)
+				//    .detail("BadTeam", badTeam)
+				//    .detail("LastZeroHealthy", lastZeroHealthy)
+				//    .detail("ZeroHealthyTeam", self->zeroHealthyTeams->get());
 
 				lastReady = self->initialFailureReactionDelay.isReady();
 				lastZeroHealthy = self->zeroHealthyTeams->get();
@@ -1103,9 +1104,8 @@ public:
 				if (worstStatus == DDTeamCollection::Status::WIGGLING && invalidWiggleServer(worstAddr, self, server)) {
 					TraceEvent(SevInfo, "InvalidWiggleServer", self->distributorId)
 					    .detail("Address", worstAddr.toString())
-					    .detail("ProcessId", server->getLastKnownInterface().locality.processId())
-					    .detail("WigglingId", self->wigglingId.present());
-					self->excludedServers.set(worstAddr, DDTeamCollection::Status::NONE);
+					    .detail("ServerId", server->getId())
+					    .detail("WigglingId", self->wigglingId.present() ? self->wigglingId.get().toString() : "");
 					worstStatus = DDTeamCollection::Status::NONE;
 				}
 				otherChanges.push_back(self->excludedServers.onChange(worstAddr));
@@ -1127,10 +1127,9 @@ public:
 					if (testStatus == DDTeamCollection::Status::WIGGLING &&
 					    invalidWiggleServer(testAddr, self, server)) {
 						TraceEvent(SevInfo, "InvalidWiggleServer", self->distributorId)
-						    .detail("Address", testAddr.toString())
-						    .detail("ProcessId", server->getLastKnownInterface().locality.processId())
-						    .detail("ValidWigglingId", self->wigglingId.present());
-						self->excludedServers.set(testAddr, DDTeamCollection::Status::NONE);
+						    .detail("Address", worstAddr.toString())
+						    .detail("ServerId", server->getId())
+						    .detail("WigglingId", self->wigglingId.present() ? self->wigglingId.get().toString() : "");
 						testStatus = DDTeamCollection::Status::NONE;
 					}
 
@@ -2052,7 +2051,7 @@ public:
 					           "PerpetualStorageWigglePause",
 					           self->distributorId)
 					    .detail("Primary", self->primary)
-					    .detail("ProcessId", id)
+					    .detail("ServerId", id)
 					    .detail("BestTeamKeepStuckCount", self->bestTeamKeepStuckCount)
 					    .detail("ExtraHealthyTeamCount", extraTeamCount)
 					    .detail("HealthyTeamCount", self->healthyTeamCount);
@@ -2065,7 +2064,7 @@ public:
 							moveFinishFuture = fv;
 							TraceEvent("PerpetualStorageWiggleStart", self->distributorId)
 							    .detail("Primary", self->primary)
-							    .detail("ProcessId", id)
+							    .detail("ServerId", id)
 							    .detail("ExtraHealthyTeamCount", extraTeamCount)
 							    .detail("HealthyTeamCount", self->healthyTeamCount);
 						}
@@ -2091,7 +2090,7 @@ public:
 					self->includeStorageServersForWiggle();
 					TraceEvent("PerpetualStorageWiggleFinish", self->distributorId)
 					    .detail("Primary", self->primary)
-					    .detail("ProcessId", self->wigglingId.get());
+					    .detail("ServerId", self->wigglingId.get());
 
 					wait(self->eraseStorageWiggleMap(&metadataMap, self->wigglingId.get()) &&
 					     self->storageWiggler->finishWiggle());
@@ -2112,7 +2111,7 @@ public:
 			self->includeStorageServersForWiggle();
 			TraceEvent("PerpetualStorageWiggleExitingPause", self->distributorId)
 			    .detail("Primary", self->primary)
-			    .detail("ProcessId", self->wigglingId.get());
+			    .detail("ServerId", self->wigglingId.get());
 			self->wigglingId.reset();
 		}
 

From 1bd72dc99e91fae02326e44d99544bab080a4fdb Mon Sep 17 00:00:00 2001
From: Josh Slocum <josh.slocum@snowflake.com>
Date: Wed, 27 Apr 2022 10:25:58 -0500
Subject: [PATCH 64/84] Allowing for blob granules to initialize at start of
 TesterBlobGranuleCorrectness

---
 .../TesterBlobGranuleCorrectnessWorkload.cpp  | 22 +++++++++++++++----
 1 file changed, 18 insertions(+), 4 deletions(-)

diff --git a/bindings/c/test/apitester/TesterBlobGranuleCorrectnessWorkload.cpp b/bindings/c/test/apitester/TesterBlobGranuleCorrectnessWorkload.cpp
index 7a77c732c5..d2f567135a 100644
--- a/bindings/c/test/apitester/TesterBlobGranuleCorrectnessWorkload.cpp
+++ b/bindings/c/test/apitester/TesterBlobGranuleCorrectnessWorkload.cpp
@@ -37,6 +37,10 @@ private:
 	enum OpType { OP_INSERT, OP_CLEAR, OP_CLEAR_RANGE, OP_READ, OP_GET_RANGES, OP_LAST = OP_GET_RANGES };
 	std::vector<OpType> excludedOpTypes;
 
+	// Allow reads at the start to get blob_granule_transaction_too_old if BG data isn't initialized yet
+	// FIXME: should still guarantee a read succeeds eventually somehow
+	bool seenReadSuccess = false;
+
 	void randomReadOp(TTaskFct cont) {
 		std::string begin = randomKeyName();
 		std::string end = randomKeyName();
@@ -45,15 +49,23 @@ private:
 			std::swap(begin, end);
 		}
 		execTransaction(
-		    [begin, end, results](auto ctx) {
+		    [this, begin, end, results](auto ctx) {
 			    ctx->tx()->setOption(FDB_TR_OPTION_READ_YOUR_WRITES_DISABLE);
 			    KeyValuesResult res = ctx->tx()->readBlobGranules(begin, end, ctx->getBGBasePath());
 			    bool more;
 			    (*results) = res.getKeyValues(&more);
 			    ASSERT(!more);
+			    if (res.getError() == error_code_blob_granule_transaction_too_old) {
+				    ASSERT(!seenReadSuccess);
+				    ctx->done();
+			    }
 			    if (res.getError() != error_code_success) {
 				    ctx->onError(res.getError());
 			    } else {
+				    if (!seenReadSuccess) {
+					    info("BlobGranuleCorrectness::randomReadOp first success\n");
+				    }
+				    seenReadSuccess = true;
 				    ctx->done();
 			    }
 		    },
@@ -110,9 +122,11 @@ private:
 			        true);
 		    },
 		    [this, begin, end, results, cont]() {
-			    ASSERT(results->size() > 0);
-			    ASSERT(results->front().key <= begin);
-			    ASSERT(results->back().value >= end);
+			    if (seenReadSuccess) {
+				    ASSERT(results->size() > 0);
+				    ASSERT(results->front().key <= begin);
+				    ASSERT(results->back().value >= end);
+			    }
 
 			    for (int i = 0; i < results->size(); i++) {
 				    // no empty or inverted ranges

From 92da9d12d432ba23dbf5026c2f7393e6d6c2ea68 Mon Sep 17 00:00:00 2001
From: Josh Slocum <josh.slocum@snowflake.com>
Date: Wed, 27 Apr 2022 10:40:39 -0500
Subject: [PATCH 65/84] Improvements to fix

---
 .../TesterBlobGranuleCorrectnessWorkload.cpp  | 59 ++++++++++---------
 1 file changed, 32 insertions(+), 27 deletions(-)

diff --git a/bindings/c/test/apitester/TesterBlobGranuleCorrectnessWorkload.cpp b/bindings/c/test/apitester/TesterBlobGranuleCorrectnessWorkload.cpp
index d2f567135a..0cd4f96580 100644
--- a/bindings/c/test/apitester/TesterBlobGranuleCorrectnessWorkload.cpp
+++ b/bindings/c/test/apitester/TesterBlobGranuleCorrectnessWorkload.cpp
@@ -45,18 +45,21 @@ private:
 		std::string begin = randomKeyName();
 		std::string end = randomKeyName();
 		auto results = std::make_shared<std::vector<KeyValue>>();
+		auto tooOld = std::make_shared<bool>(false);
 		if (begin > end) {
 			std::swap(begin, end);
 		}
 		execTransaction(
-		    [this, begin, end, results](auto ctx) {
+		    [this, begin, end, results, tooOld](auto ctx) {
 			    ctx->tx()->setOption(FDB_TR_OPTION_READ_YOUR_WRITES_DISABLE);
 			    KeyValuesResult res = ctx->tx()->readBlobGranules(begin, end, ctx->getBGBasePath());
 			    bool more;
 			    (*results) = res.getKeyValues(&more);
 			    ASSERT(!more);
 			    if (res.getError() == error_code_blob_granule_transaction_too_old) {
+				    info("BlobGranuleCorrectness::randomReadOp bg too old\n");
 				    ASSERT(!seenReadSuccess);
+				    *tooOld = true;
 				    ctx->done();
 			    }
 			    if (res.getError() != error_code_success) {
@@ -69,35 +72,37 @@ private:
 				    ctx->done();
 			    }
 		    },
-		    [this, begin, end, results, cont]() {
-			    std::vector<KeyValue> expected = store.getRange(begin, end, store.size(), false);
-			    if (results->size() != expected.size()) {
-				    error(fmt::format("randomReadOp result size mismatch. expected: {} actual: {}",
-				                      expected.size(),
-				                      results->size()));
-			    }
-			    ASSERT(results->size() == expected.size());
-
-			    for (int i = 0; i < results->size(); i++) {
-				    if ((*results)[i].key != expected[i].key) {
-					    error(fmt::format("randomReadOp key mismatch at {}/{}. expected: {} actual: {}",
-					                      i,
-					                      results->size(),
-					                      expected[i].key,
-					                      (*results)[i].key));
+		    [this, begin, end, results, tooOld, cont]() {
+			    if (!*tooOld) {
+				    std::vector<KeyValue> expected = store.getRange(begin, end, store.size(), false);
+				    if (results->size() != expected.size()) {
+					    error(fmt::format("randomReadOp result size mismatch. expected: {} actual: {}",
+					                      expected.size(),
+					                      results->size()));
 				    }
-				    ASSERT((*results)[i].key == expected[i].key);
+				    ASSERT(results->size() == expected.size());
 
-				    if ((*results)[i].value != expected[i].value) {
-					    error(
-					        fmt::format("randomReadOp value mismatch at {}/{}. key: {} expected: {:.80} actual: {:.80}",
-					                    i,
-					                    results->size(),
-					                    expected[i].key,
-					                    expected[i].value,
-					                    (*results)[i].value));
+				    for (int i = 0; i < results->size(); i++) {
+					    if ((*results)[i].key != expected[i].key) {
+						    error(fmt::format("randomReadOp key mismatch at {}/{}. expected: {} actual: {}",
+						                      i,
+						                      results->size(),
+						                      expected[i].key,
+						                      (*results)[i].key));
+					    }
+					    ASSERT((*results)[i].key == expected[i].key);
+
+					    if ((*results)[i].value != expected[i].value) {
+						    error(fmt::format(
+						        "randomReadOp value mismatch at {}/{}. key: {} expected: {:.80} actual: {:.80}",
+						        i,
+						        results->size(),
+						        expected[i].key,
+						        expected[i].value,
+						        (*results)[i].value));
+					    }
+					    ASSERT((*results)[i].value == expected[i].value);
 				    }
-				    ASSERT((*results)[i].value == expected[i].value);
 			    }
 			    schedule(cont);
 		    });

From 14e773845517b7fd9995a3acdc0d106898c27c5b Mon Sep 17 00:00:00 2001
From: Josh Slocum <josh.slocum@snowflake.com>
Date: Wed, 27 Apr 2022 12:29:34 -0500
Subject: [PATCH 66/84] review comments

---
 .../c/test/apitester/TesterBlobGranuleCorrectnessWorkload.cpp  | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/bindings/c/test/apitester/TesterBlobGranuleCorrectnessWorkload.cpp b/bindings/c/test/apitester/TesterBlobGranuleCorrectnessWorkload.cpp
index 0cd4f96580..e8221780fa 100644
--- a/bindings/c/test/apitester/TesterBlobGranuleCorrectnessWorkload.cpp
+++ b/bindings/c/test/apitester/TesterBlobGranuleCorrectnessWorkload.cpp
@@ -61,8 +61,7 @@ private:
 				    ASSERT(!seenReadSuccess);
 				    *tooOld = true;
 				    ctx->done();
-			    }
-			    if (res.getError() != error_code_success) {
+			    } else if (res.getError() != error_code_success) {
 				    ctx->onError(res.getError());
 			    } else {
 				    if (!seenReadSuccess) {

From 79063d5fc4a4e080194bbff849fd6935810bab63 Mon Sep 17 00:00:00 2001
From: "A.J. Beamon" <aj.beamon@snowflake.com>
Date: Wed, 27 Apr 2022 14:38:59 -0700
Subject: [PATCH 67/84] Better accounting for tenant prefixes when working with
 key size limits (#6973)

* Consider tenant prefix sizes when doing key size limit checks

* Fix formatting
---
 fdbclient/ClientKnobs.cpp                     |   2 +
 fdbclient/ClientKnobs.h                       |   1 +
 fdbclient/FDBTypes.cpp                        |  15 ++-
 fdbclient/GenericManagementAPI.actor.h        |  11 ++
 fdbclient/NativeAPI.actor.cpp                 | 103 +++++++++---------
 fdbclient/NativeAPI.actor.h                   |  14 +++
 fdbclient/ReadYourWrites.actor.cpp            |  89 +++++++--------
 fdbclient/Tenant.h                            |   2 +
 .../workloads/FuzzApiCorrectness.actor.cpp    |  57 +++++-----
 fdbserver/workloads/WriteDuringRead.actor.cpp |  65 +++--------
 10 files changed, 172 insertions(+), 187 deletions(-)

diff --git a/fdbclient/ClientKnobs.cpp b/fdbclient/ClientKnobs.cpp
index 5464e63185..7f7f58a8bc 100644
--- a/fdbclient/ClientKnobs.cpp
+++ b/fdbclient/ClientKnobs.cpp
@@ -21,6 +21,7 @@
 #include "fdbclient/Knobs.h"
 #include "fdbclient/FDBTypes.h"
 #include "fdbclient/SystemData.h"
+#include "fdbclient/Tenant.h"
 #include "flow/UnitTest.h"
 
 #define init(...) KNOB_FN(__VA_ARGS__, INIT_ATOMIC_KNOB, INIT_KNOB)(__VA_ARGS__)
@@ -82,6 +83,7 @@ void ClientKnobs::initialize(Randomize randomize) {
 	init( CHANGE_FEED_CACHE_SIZE,               100000 ); if( randomize && BUGGIFY ) CHANGE_FEED_CACHE_SIZE = 1;
 	init( CHANGE_FEED_POP_TIMEOUT,                 5.0 );
 	init( CHANGE_FEED_STREAM_MIN_BYTES,            1e4 ); if( randomize && BUGGIFY ) CHANGE_FEED_STREAM_MIN_BYTES = 1;
+	init( TENANT_PREFIX_SIZE_LIMIT,                 28 ); ASSERT(TENANT_PREFIX_SIZE_LIMIT >= TenantMapEntry::ROOT_PREFIX_SIZE); // includes 8-byte ID and optional tenant subspace
 
 	init( MAX_BATCH_SIZE,                         1000 ); if( randomize && BUGGIFY ) MAX_BATCH_SIZE = 1;
 	init( GRV_BATCH_TIMEOUT,                     0.005 ); if( randomize && BUGGIFY ) GRV_BATCH_TIMEOUT = 0.1;
diff --git a/fdbclient/ClientKnobs.h b/fdbclient/ClientKnobs.h
index 3378fd01e5..ca3dd1494e 100644
--- a/fdbclient/ClientKnobs.h
+++ b/fdbclient/ClientKnobs.h
@@ -81,6 +81,7 @@ public:
 	int64_t CHANGE_FEED_CACHE_SIZE;
 	double CHANGE_FEED_POP_TIMEOUT;
 	int64_t CHANGE_FEED_STREAM_MIN_BYTES;
+	int64_t TENANT_PREFIX_SIZE_LIMIT;
 
 	int MAX_BATCH_SIZE;
 	double GRV_BATCH_TIMEOUT;
diff --git a/fdbclient/FDBTypes.cpp b/fdbclient/FDBTypes.cpp
index 85b90313e5..ff268075bd 100644
--- a/fdbclient/FDBTypes.cpp
+++ b/fdbclient/FDBTypes.cpp
@@ -20,6 +20,7 @@
 
 #include "fdbclient/FDBTypes.h"
 #include "fdbclient/Knobs.h"
+#include "fdbclient/NativeAPI.actor.h"
 
 KeyRef keyBetween(const KeyRangeRef& keys) {
 	int pos = 0; // will be the position of the first difference between keys.begin and keys.end
@@ -40,16 +41,14 @@ KeyRef keyBetween(const KeyRangeRef& keys) {
 }
 
 void KeySelectorRef::setKey(KeyRef const& key) {
-	// There are no keys in the database with size greater than KEY_SIZE_LIMIT, so if this key selector has a key
+	// There are no keys in the database with size greater than the max key size, so if this key selector has a key
 	// which is large, then we can translate it to an equivalent key selector with a smaller key
-	if (key.size() >
-	    (key.startsWith(LiteralStringRef("\xff")) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT))
-		this->key = key.substr(0,
-		                       (key.startsWith(LiteralStringRef("\xff")) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT
-		                                                                 : CLIENT_KNOBS->KEY_SIZE_LIMIT) +
-		                           1);
-	else
+	int64_t maxKeySize = getMaxKeySize(key);
+	if (key.size() > maxKeySize) {
+		this->key = key.substr(0, maxKeySize + 1);
+	} else {
 		this->key = key;
+	}
 }
 
 void KeySelectorRef::setKeyUnlimited(KeyRef const& key) {
diff --git a/fdbclient/GenericManagementAPI.actor.h b/fdbclient/GenericManagementAPI.actor.h
index 92fc3ca88e..d1128f79b3 100644
--- a/fdbclient/GenericManagementAPI.actor.h
+++ b/fdbclient/GenericManagementAPI.actor.h
@@ -746,6 +746,17 @@ Future<Optional<TenantMapEntry>> createTenantTransaction(Transaction tr, TenantN
 	state Optional<Value> lastIdVal = wait(safeThreadFutureToFuture(lastIdFuture));
 	Optional<Value> tenantDataPrefix = wait(safeThreadFutureToFuture(tenantDataPrefixFuture));
 
+	if (tenantDataPrefix.present() &&
+	    tenantDataPrefix.get().size() + TenantMapEntry::ROOT_PREFIX_SIZE > CLIENT_KNOBS->TENANT_PREFIX_SIZE_LIMIT) {
+		TraceEvent(SevWarnAlways, "TenantPrefixTooLarge")
+		    .detail("TenantSubspace", tenantDataPrefix.get())
+		    .detail("TenantSubspaceLength", tenantDataPrefix.get().size())
+		    .detail("RootPrefixLength", TenantMapEntry::ROOT_PREFIX_SIZE)
+		    .detail("MaxTenantPrefixSize", CLIENT_KNOBS->TENANT_PREFIX_SIZE_LIMIT);
+
+		throw client_invalid_operation();
+	}
+
 	state TenantMapEntry newTenant(lastIdVal.present() ? TenantMapEntry::prefixToId(lastIdVal.get()) + 1 : 0,
 	                               tenantDataPrefix.present() ? (KeyRef)tenantDataPrefix.get() : ""_sr);
 
diff --git a/fdbclient/NativeAPI.actor.cpp b/fdbclient/NativeAPI.actor.cpp
index 6148e9ad4b..61c68bc18e 100644
--- a/fdbclient/NativeAPI.actor.cpp
+++ b/fdbclient/NativeAPI.actor.cpp
@@ -5100,10 +5100,10 @@ Future<Optional<Value>> Transaction::get(const Key& key, Snapshot snapshot) {
 	++trState->cx->transactionGetValueRequests;
 	// ASSERT (key < allKeys.end);
 
-	// There are no keys in the database with size greater than KEY_SIZE_LIMIT
-	if (key.size() >
-	    (key.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT))
+	// There are no keys in the database with size greater than the max key size
+	if (key.size() > getMaxReadKeySize(key)) {
 		return Optional<Value>();
+	}
 
 	auto ver = getReadVersion();
 
@@ -5484,23 +5484,19 @@ Future<Void> Transaction::getRangeStream(const PromiseStream<RangeResult>& resul
 void Transaction::addReadConflictRange(KeyRangeRef const& keys) {
 	ASSERT(!keys.empty());
 
-	// There aren't any keys in the database with size larger than KEY_SIZE_LIMIT, so if range contains large keys
+	// There aren't any keys in the database with size larger than the max key size, so if range contains large keys
 	// we can translate it to an equivalent one with smaller keys
 	KeyRef begin = keys.begin;
 	KeyRef end = keys.end;
 
-	if (begin.size() >
-	    (begin.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT))
-		begin = begin.substr(
-		    0,
-		    (begin.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT) +
-		        1);
-	if (end.size() >
-	    (end.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT))
-		end = end.substr(
-		    0,
-		    (end.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT) +
-		        1);
+	int64_t beginMaxSize = getMaxReadKeySize(begin);
+	int64_t endMaxSize = getMaxReadKeySize(end);
+	if (begin.size() > beginMaxSize) {
+		begin = begin.substr(0, beginMaxSize + 1);
+	}
+	if (end.size() > endMaxSize) {
+		end = end.substr(0, endMaxSize + 1);
+	}
 
 	KeyRangeRef r = KeyRangeRef(begin, end);
 
@@ -5522,8 +5518,7 @@ void Transaction::makeSelfConflicting() {
 
 void Transaction::set(const KeyRef& key, const ValueRef& value, AddConflictRange addConflictRange) {
 	++trState->cx->transactionSetMutations;
-	if (key.size() >
-	    (key.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT))
+	if (key.size() > getMaxWriteKeySize(key, trState->options.rawAccess))
 		throw key_too_large();
 	if (value.size() > CLIENT_KNOBS->VALUE_SIZE_LIMIT)
 		throw value_too_large();
@@ -5544,8 +5539,7 @@ void Transaction::atomicOp(const KeyRef& key,
                            MutationRef::Type operationType,
                            AddConflictRange addConflictRange) {
 	++trState->cx->transactionAtomicMutations;
-	if (key.size() >
-	    (key.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT))
+	if (key.size() > getMaxWriteKeySize(key, trState->options.rawAccess))
 		throw key_too_large();
 	if (operand.size() > CLIENT_KNOBS->VALUE_SIZE_LIMIT)
 		throw value_too_large();
@@ -5578,20 +5572,16 @@ void Transaction::clear(const KeyRangeRef& range, AddConflictRange addConflictRa
 	KeyRef begin = range.begin;
 	KeyRef end = range.end;
 
-	// There aren't any keys in the database with size larger than KEY_SIZE_LIMIT, so if range contains large keys
+	// There aren't any keys in the database with size larger than the max key size, so if range contains large keys
 	// we can translate it to an equivalent one with smaller keys
-	if (begin.size() >
-	    (begin.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT))
-		begin = begin.substr(
-		    0,
-		    (begin.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT) +
-		        1);
-	if (end.size() >
-	    (end.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT))
-		end = end.substr(
-		    0,
-		    (end.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT) +
-		        1);
+	int64_t beginMaxSize = getMaxClearKeySize(begin);
+	int64_t endMaxSize = getMaxClearKeySize(end);
+	if (begin.size() > beginMaxSize) {
+		begin = begin.substr(0, beginMaxSize + 1);
+	}
+	if (end.size() > endMaxSize) {
+		end = end.substr(0, endMaxSize + 1);
+	}
 
 	auto r = KeyRangeRef(req.arena, KeyRangeRef(begin, end));
 	if (r.empty())
@@ -5604,10 +5594,10 @@ void Transaction::clear(const KeyRangeRef& range, AddConflictRange addConflictRa
 }
 void Transaction::clear(const KeyRef& key, AddConflictRange addConflictRange) {
 	++trState->cx->transactionClearMutations;
-	// There aren't any keys in the database with size larger than KEY_SIZE_LIMIT
-	if (key.size() >
-	    (key.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT))
+	// There aren't any keys in the database with size larger than the max key size
+	if (key.size() > getMaxClearKeySize(key)) {
 		return;
+	}
 
 	auto& req = tr;
 	auto& t = req.transaction;
@@ -5626,24 +5616,19 @@ void Transaction::addWriteConflictRange(const KeyRangeRef& keys) {
 	auto& req = tr;
 	auto& t = req.transaction;
 
-	// There aren't any keys in the database with size larger than KEY_SIZE_LIMIT, so if range contains large keys
+	// There aren't any keys in the database with size larger than the max key size, so if range contains large keys
 	// we can translate it to an equivalent one with smaller keys
 	KeyRef begin = keys.begin;
 	KeyRef end = keys.end;
 
-	if (begin.size() >
-	    (begin.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT))
-		begin = begin.substr(
-		    0,
-		    (begin.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT) +
-		        1);
-	if (end.size() >
-	    (end.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT))
-		end = end.substr(
-		    0,
-		    (end.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT) +
-		        1);
-
+	int64_t beginMaxSize = getMaxKeySize(begin);
+	int64_t endMaxSize = getMaxKeySize(end);
+	if (begin.size() > beginMaxSize) {
+		begin = begin.substr(0, beginMaxSize + 1);
+	}
+	if (end.size() > endMaxSize) {
+		end = end.substr(0, endMaxSize + 1);
+	}
 	KeyRangeRef r = KeyRangeRef(begin, end);
 
 	if (r.empty()) {
@@ -9395,3 +9380,21 @@ ACTOR Future<Void> waitPurgeGranulesCompleteActor(Reference<DatabaseContext> db,
 Future<Void> DatabaseContext::waitPurgeGranulesComplete(Key purgeKey) {
 	return waitPurgeGranulesCompleteActor(Reference<DatabaseContext>::addRef(this), purgeKey);
 }
+
+int64_t getMaxKeySize(KeyRef const& key) {
+	return getMaxWriteKeySize(key, true);
+}
+
+int64_t getMaxReadKeySize(KeyRef const& key) {
+	return getMaxKeySize(key);
+}
+
+int64_t getMaxWriteKeySize(KeyRef const& key, bool hasRawAccess) {
+	int64_t tenantSize = hasRawAccess ? CLIENT_KNOBS->TENANT_PREFIX_SIZE_LIMIT : 0;
+	return key.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT
+	                                        : CLIENT_KNOBS->KEY_SIZE_LIMIT + tenantSize;
+}
+
+int64_t getMaxClearKeySize(KeyRef const& key) {
+	return getMaxKeySize(key);
+}
\ No newline at end of file
diff --git a/fdbclient/NativeAPI.actor.h b/fdbclient/NativeAPI.actor.h
index 456af4c746..988e64aaf1 100644
--- a/fdbclient/NativeAPI.actor.h
+++ b/fdbclient/NativeAPI.actor.h
@@ -539,5 +539,19 @@ ACTOR Future<std::vector<std::pair<UID, StorageWiggleValue>>> readStorageWiggleV
                                                                                       bool primary,
                                                                                       bool use_system_priority);
 
+// Returns the maximum legal size of a key. This size will be determined by the prefix of the passed in key
+// (system keys have a larger maximum size). This should be used for generic max key size requests.
+int64_t getMaxKeySize(KeyRef const& key);
+
+// Returns the maximum legal size of a key that can be read. Keys larger than this will be assumed not to exist.
+int64_t getMaxReadKeySize(KeyRef const& key);
+
+// Returns the maximum legal size of a key that can be written. If using raw access, writes to normal keys will
+// be allowed to be slighly larger to accommodate the prefix.
+int64_t getMaxWriteKeySize(KeyRef const& key, bool hasRawAccess);
+
+// Returns the maximum legal size of a key that can be cleared. Keys larger than this will be assumed not to exist.
+int64_t getMaxClearKeySize(KeyRef const& key);
+
 #include "flow/unactorcompiler.h"
 #endif
diff --git a/fdbclient/ReadYourWrites.actor.cpp b/fdbclient/ReadYourWrites.actor.cpp
index a16034963b..c651adad32 100644
--- a/fdbclient/ReadYourWrites.actor.cpp
+++ b/fdbclient/ReadYourWrites.actor.cpp
@@ -19,6 +19,7 @@
  */
 
 #include "fdbclient/ReadYourWrites.h"
+#include "fdbclient/NativeAPI.actor.h"
 #include "fdbclient/Atomic.h"
 #include "fdbclient/DatabaseContext.h"
 #include "fdbclient/SpecialKeySpace.actor.h"
@@ -1578,10 +1579,10 @@ Future<Optional<Value>> ReadYourWritesTransaction::get(const Key& key, Snapshot
 	if (key >= getMaxReadKey() && key != metadataVersionKey)
 		return key_outside_legal_range();
 
-	// There are no keys in the database with size greater than KEY_SIZE_LIMIT
-	if (key.size() >
-	    (key.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT))
+	// There are no keys in the database with size greater than the max key size
+	if (key.size() > getMaxReadKeySize(key)) {
 		return Optional<Value>();
+	}
 
 	Future<Optional<Value>> result = RYWImpl::readWithConflictRange(this, RYWImpl::GetValueReq(key), snapshot);
 	reading.add(success(result));
@@ -1822,23 +1823,19 @@ void ReadYourWritesTransaction::addReadConflictRange(KeyRangeRef const& keys) {
 		}
 	}
 
-	// There aren't any keys in the database with size larger than KEY_SIZE_LIMIT, so if range contains large keys
+	// There aren't any keys in the database with size larger than max key size, so if range contains large keys
 	// we can translate it to an equivalent one with smaller keys
 	KeyRef begin = keys.begin;
 	KeyRef end = keys.end;
 
-	if (begin.size() >
-	    (begin.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT))
-		begin = begin.substr(
-		    0,
-		    (begin.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT) +
-		        1);
-	if (end.size() >
-	    (end.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT))
-		end = end.substr(
-		    0,
-		    (end.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT) +
-		        1);
+	int64_t beginMaxSize = getMaxReadKeySize(begin);
+	int64_t endMaxSize = getMaxReadKeySize(end);
+	if (begin.size() > beginMaxSize) {
+		begin = begin.substr(0, beginMaxSize + 1);
+	}
+	if (end.size() > endMaxSize) {
+		end = end.substr(0, endMaxSize + 1);
+	}
 
 	KeyRangeRef r = KeyRangeRef(begin, end);
 
@@ -2111,9 +2108,9 @@ void ReadYourWritesTransaction::atomicOp(const KeyRef& key, const ValueRef& oper
 	if (!isValidMutationType(operationType) || !isAtomicOp((MutationRef::Type)operationType))
 		throw invalid_mutation_type();
 
-	if (key.size() >
-	    (key.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT))
+	if (key.size() > getMaxWriteKeySize(key, getTransactionState()->options.rawAccess)) {
 		throw key_too_large();
+	}
 	if (operand.size() > CLIENT_KNOBS->VALUE_SIZE_LIMIT)
 		throw value_too_large();
 
@@ -2218,9 +2215,9 @@ void ReadYourWritesTransaction::set(const KeyRef& key, const ValueRef& value) {
 	}
 
 	// TODO: check transaction size here
-	if (key.size() >
-	    (key.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT))
+	if (key.size() > getMaxWriteKeySize(key, getTransactionState()->options.rawAccess)) {
 		throw key_too_large();
+	}
 	if (value.size() > CLIENT_KNOBS->VALUE_SIZE_LIMIT)
 		throw value_too_large();
 
@@ -2254,23 +2251,19 @@ void ReadYourWritesTransaction::clear(const KeyRangeRef& range) {
 		return tr.clear(range, addWriteConflict);
 	}
 
-	// There aren't any keys in the database with size larger than KEY_SIZE_LIMIT, so if range contains large keys
+	// There aren't any keys in the database with size larger than the max key size, so if range contains large keys
 	// we can translate it to an equivalent one with smaller keys
 	KeyRef begin = range.begin;
 	KeyRef end = range.end;
 
-	if (begin.size() >
-	    (begin.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT))
-		begin = begin.substr(
-		    0,
-		    (begin.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT) +
-		        1);
-	if (end.size() >
-	    (end.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT))
-		end = end.substr(
-		    0,
-		    (end.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT) +
-		        1);
+	int64_t beginMaxSize = getMaxClearKeySize(begin);
+	int64_t endMaxSize = getMaxClearKeySize(end);
+	if (begin.size() > beginMaxSize) {
+		begin = begin.substr(0, beginMaxSize + 1);
+	}
+	if (end.size() > endMaxSize) {
+		end = end.substr(0, endMaxSize + 1);
+	}
 
 	KeyRangeRef r = KeyRangeRef(begin, end);
 
@@ -2300,9 +2293,9 @@ void ReadYourWritesTransaction::clear(const KeyRef& key) {
 	if (key >= getMaxWriteKey())
 		throw key_outside_legal_range();
 
-	if (key.size() >
-	    (key.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT))
+	if (key.size() > getMaxClearKeySize(key)) {
 		return;
+	}
 
 	if (options.readYourWritesDisabled) {
 		return tr.clear(key, addWriteConflict);
@@ -2332,9 +2325,9 @@ Future<Void> ReadYourWritesTransaction::watch(const Key& key) {
 	if (key >= allKeys.end || (key >= getMaxReadKey() && key != metadataVersionKey && tr.apiVersionAtLeast(300)))
 		return key_outside_legal_range();
 
-	if (key.size() >
-	    (key.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT))
+	if (key.size() > getMaxWriteKeySize(key, getTransactionState()->options.rawAccess)) {
 		return key_too_large();
+	}
 
 	return RYWImpl::watch(this, key);
 }
@@ -2350,23 +2343,19 @@ void ReadYourWritesTransaction::addWriteConflictRange(KeyRangeRef const& keys) {
 		}
 	}
 
-	// There aren't any keys in the database with size larger than KEY_SIZE_LIMIT, so if range contains large keys
+	// There aren't any keys in the database with size larger than the max key size, so if range contains large keys
 	// we can translate it to an equivalent one with smaller keys
 	KeyRef begin = keys.begin;
 	KeyRef end = keys.end;
 
-	if (begin.size() >
-	    (begin.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT))
-		begin = begin.substr(
-		    0,
-		    (begin.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT) +
-		        1);
-	if (end.size() >
-	    (end.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT))
-		end = end.substr(
-		    0,
-		    (end.startsWith(systemKeys.begin) ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT : CLIENT_KNOBS->KEY_SIZE_LIMIT) +
-		        1);
+	int64_t beginMaxSize = getMaxKeySize(begin);
+	int64_t endMaxSize = getMaxKeySize(end);
+	if (begin.size() > beginMaxSize) {
+		begin = begin.substr(0, beginMaxSize + 1);
+	}
+	if (end.size() > endMaxSize) {
+		end = end.substr(0, endMaxSize + 1);
+	}
 
 	KeyRangeRef r = KeyRangeRef(begin, end);
 
diff --git a/fdbclient/Tenant.h b/fdbclient/Tenant.h
index 221ae451bb..f7e69e6d44 100644
--- a/fdbclient/Tenant.h
+++ b/fdbclient/Tenant.h
@@ -48,6 +48,8 @@ struct TenantMapEntry {
 	int64_t id;
 	Key prefix;
 
+	constexpr static int ROOT_PREFIX_SIZE = sizeof(id);
+
 private:
 	void initPrefix(KeyRef subspace) {
 		ASSERT(id >= 0);
diff --git a/fdbserver/workloads/FuzzApiCorrectness.actor.cpp b/fdbserver/workloads/FuzzApiCorrectness.actor.cpp
index 7f3e5d41e1..bd2abff7c3 100644
--- a/fdbserver/workloads/FuzzApiCorrectness.actor.cpp
+++ b/fdbserver/workloads/FuzzApiCorrectness.actor.cpp
@@ -329,9 +329,7 @@ struct FuzzApiCorrectnessWorkload : TestWorkload {
 								for (int j = i; j < end; j++) {
 									if (deterministicRandom()->random01() < self->initialKeyDensity) {
 										Key key = self->getKeyForIndex(tenantNum, j);
-										if (key.size() <= (key.startsWith(systemKeys.begin)
-										                       ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT
-										                       : CLIENT_KNOBS->KEY_SIZE_LIMIT)) {
+										if (key.size() <= getMaxWriteKeySize(key, false)) {
 											Value value = self->getRandomValue();
 											value = value.substr(
 											    0, std::min<int>(value.size(), CLIENT_KNOBS->VALUE_SIZE_LIMIT));
@@ -1091,24 +1089,22 @@ struct FuzzApiCorrectnessWorkload : TestWorkload {
 				pos = littleEndian32(*(int32_t*)&value.end()[-4]);
 			}
 
-			contract = {
-				std::make_pair(error_code_key_too_large,
-				               ExceptionContract::requiredIf(key.size() > (key.startsWith(systemKeys.begin)
-				                                                               ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT
-				                                                               : CLIENT_KNOBS->KEY_SIZE_LIMIT))),
-				std::make_pair(error_code_value_too_large,
-				               ExceptionContract::requiredIf(value.size() > CLIENT_KNOBS->VALUE_SIZE_LIMIT)),
-				std::make_pair(
-				    error_code_invalid_mutation_type,
-				    ExceptionContract::requiredIf(!isValidMutationType(op) || !isAtomicOp((MutationRef::Type)op))),
-				std::make_pair(error_code_key_outside_legal_range,
-				               ExceptionContract::requiredIf((key >= workload->getMaxKey(tr)))),
-				std::make_pair(
-				    error_code_client_invalid_operation,
-				    ExceptionContract::requiredIf(
-				        (op == MutationRef::SetVersionstampedKey && (pos < 0 || pos + 10 > key.size() - 4)) ||
-				        (op == MutationRef::SetVersionstampedValue && (pos < 0 || pos + 10 > value.size() - 4))))
-			};
+			contract = { std::make_pair(error_code_key_too_large,
+				                        key.size() > getMaxWriteKeySize(key, true)    ? ExceptionContract::Always
+				                        : key.size() > getMaxWriteKeySize(key, false) ? ExceptionContract::Possible
+				                                                                      : ExceptionContract::Never),
+				         std::make_pair(error_code_value_too_large,
+				                        ExceptionContract::requiredIf(value.size() > CLIENT_KNOBS->VALUE_SIZE_LIMIT)),
+				         std::make_pair(error_code_invalid_mutation_type,
+				                        ExceptionContract::requiredIf(!isValidMutationType(op) ||
+				                                                      !isAtomicOp((MutationRef::Type)op))),
+				         std::make_pair(error_code_key_outside_legal_range,
+				                        ExceptionContract::requiredIf((key >= workload->getMaxKey(tr)))),
+				         std::make_pair(error_code_client_invalid_operation,
+				                        ExceptionContract::requiredIf((op == MutationRef::SetVersionstampedKey &&
+				                                                       (pos < 0 || pos + 10 > key.size() - 4)) ||
+				                                                      (op == MutationRef::SetVersionstampedValue &&
+				                                                       (pos < 0 || pos + 10 > value.size() - 4)))) };
 		}
 
 		void callback(Reference<ITransaction> tr) override { tr->atomicOp(key, value, (FDBMutationTypes::Option)op); }
@@ -1131,11 +1127,10 @@ struct FuzzApiCorrectnessWorkload : TestWorkload {
 				key = makeKey();
 			}
 			value = makeValue();
-			contract = { std::make_pair(
-				             error_code_key_too_large,
-				             ExceptionContract::requiredIf(key.size() > (key.startsWith(systemKeys.begin)
-				                                                             ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT
-				                                                             : CLIENT_KNOBS->KEY_SIZE_LIMIT))),
+			contract = { std::make_pair(error_code_key_too_large,
+				                        key.size() > getMaxWriteKeySize(key, true)    ? ExceptionContract::Always
+				                        : key.size() > getMaxWriteKeySize(key, false) ? ExceptionContract::Possible
+				                                                                      : ExceptionContract::Never),
 				         std::make_pair(error_code_value_too_large,
 				                        ExceptionContract::requiredIf(value.size() > CLIENT_KNOBS->VALUE_SIZE_LIMIT)),
 				         std::make_pair(error_code_key_outside_legal_range,
@@ -1268,11 +1263,11 @@ struct FuzzApiCorrectnessWorkload : TestWorkload {
 		TestWatch(unsigned int id, FuzzApiCorrectnessWorkload* workload, Reference<ITransaction> tr)
 		  : BaseTest(id, workload, "TestWatch") {
 			key = makeKey();
-			contract = { std::make_pair(
-				             error_code_key_too_large,
-				             ExceptionContract::requiredIf(key.size() > (key.startsWith(systemKeys.begin)
-				                                                             ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT
-				                                                             : CLIENT_KNOBS->KEY_SIZE_LIMIT))),
+			printf("Watching: %d %s\n", key.size(), printable(key.substr(0, std::min(key.size(), 20))).c_str());
+			contract = { std::make_pair(error_code_key_too_large,
+				                        key.size() > getMaxWriteKeySize(key, true)    ? ExceptionContract::Always
+				                        : key.size() > getMaxWriteKeySize(key, false) ? ExceptionContract::Possible
+				                                                                      : ExceptionContract::Never),
 				         std::make_pair(error_code_watches_disabled, ExceptionContract::Possible),
 				         std::make_pair(error_code_key_outside_legal_range,
 				                        ExceptionContract::requiredIf((key >= workload->getMaxKey(tr)))),
diff --git a/fdbserver/workloads/WriteDuringRead.actor.cpp b/fdbserver/workloads/WriteDuringRead.actor.cpp
index b2f627284e..64581f49db 100644
--- a/fdbserver/workloads/WriteDuringRead.actor.cpp
+++ b/fdbserver/workloads/WriteDuringRead.actor.cpp
@@ -653,9 +653,7 @@ struct WriteDuringReadWorkload : TestWorkload {
 						for (int j = i; j < end; j++) {
 							if (deterministicRandom()->random01() < self->initialKeyDensity) {
 								Key key = self->getKeyForIndex(j);
-								if (key.size() <= (key.startsWith(systemKeys.begin)
-								                       ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT
-								                       : CLIENT_KNOBS->KEY_SIZE_LIMIT)) {
+								if (key.size() <= getMaxWriteKeySize(key, false)) {
 									Value value = self->getRandomValue();
 									value =
 									    value.substr(0, std::min<int>(value.size(), CLIENT_KNOBS->VALUE_SIZE_LIMIT));
@@ -898,18 +896,10 @@ struct WriteDuringReadWorkload : TestWorkload {
 								tr.clear(range);
 								if (!noConflict) {
 									KeyRangeRef conflict(
-									    range.begin.substr(0,
-									                       std::min<int>(range.begin.size(),
-									                                     (range.begin.startsWith(systemKeys.begin)
-									                                          ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT
-									                                          : CLIENT_KNOBS->KEY_SIZE_LIMIT) +
-									                                         1)),
-									    range.end.substr(0,
-									                     std::min<int>(range.end.size(),
-									                                   (range.end.startsWith(systemKeys.begin)
-									                                        ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT
-									                                        : CLIENT_KNOBS->KEY_SIZE_LIMIT) +
-									                                       1)));
+									    range.begin.substr(
+									        0, std::min<int>(range.begin.size(), getMaxClearKeySize(range.begin) + 1)),
+									    range.end.substr(
+									        0, std::min<int>(range.end.size(), getMaxClearKeySize(range.end) + 1)));
 									self->addedConflicts.insert(conflict, true);
 								}
 								self->memoryDatabase.erase(self->memoryDatabase.lower_bound(range.begin),
@@ -922,9 +912,7 @@ struct WriteDuringReadWorkload : TestWorkload {
 								if (noConflict)
 									tr.setOption(FDBTransactionOptions::NEXT_WRITE_NO_WRITE_CONFLICT_RANGE);
 								tr.clear(key);
-								if (!noConflict && key.size() <= (key.startsWith(systemKeys.begin)
-								                                      ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT
-								                                      : CLIENT_KNOBS->KEY_SIZE_LIMIT)) {
+								if (!noConflict && key.size() <= getMaxClearKeySize(key)) {
 									self->addedConflicts.insert(key, true);
 								}
 								self->memoryDatabase.erase(key);
@@ -936,18 +924,9 @@ struct WriteDuringReadWorkload : TestWorkload {
 								//TraceEvent("WDRAddWriteConflict").detail("Range", range);
 								tr.addWriteConflictRange(range);
 								KeyRangeRef conflict(
-								    range.begin.substr(0,
-								                       std::min<int>(range.begin.size(),
-								                                     (range.begin.startsWith(systemKeys.begin)
-								                                          ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT
-								                                          : CLIENT_KNOBS->KEY_SIZE_LIMIT) +
-								                                         1)),
-								    range.end.substr(0,
-								                     std::min<int>(range.end.size(),
-								                                   (range.end.startsWith(systemKeys.begin)
-								                                        ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT
-								                                        : CLIENT_KNOBS->KEY_SIZE_LIMIT) +
-								                                       1)));
+								    range.begin.substr(
+								        0, std::min<int>(range.begin.size(), getMaxKeySize(range.begin) + 1)),
+								    range.end.substr(0, std::min<int>(range.end.size(), getMaxKeySize(range.end) + 1)));
 								self->addedConflicts.insert(conflict, true);
 							} else if (operationType == 8 && !disableDelay) {
 								double maxTime = 6.0;
@@ -991,18 +970,10 @@ struct WriteDuringReadWorkload : TestWorkload {
 									tr.atomicOp(versionStampKey, value, MutationRef::SetVersionstampedKey);
 									tr.clear(range);
 									KeyRangeRef conflict(
-									    range.begin.substr(0,
-									                       std::min<int>(range.begin.size(),
-									                                     (range.begin.startsWith(systemKeys.begin)
-									                                          ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT
-									                                          : CLIENT_KNOBS->KEY_SIZE_LIMIT) +
-									                                         1)),
-									    range.end.substr(0,
-									                     std::min<int>(range.end.size(),
-									                                   (range.end.startsWith(systemKeys.begin)
-									                                        ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT
-									                                        : CLIENT_KNOBS->KEY_SIZE_LIMIT) +
-									                                       1)));
+									    range.begin.substr(
+									        0, std::min<int>(range.begin.size(), getMaxClearKeySize(range.begin) + 1)),
+									    range.end.substr(
+									        0, std::min<int>(range.end.size(), getMaxClearKeySize(range.end) + 1)));
 									self->addedConflicts.insert(conflict, true);
 									self->memoryDatabase.erase(self->memoryDatabase.lower_bound(range.begin),
 									                           self->memoryDatabase.lower_bound(range.end));
@@ -1043,10 +1014,9 @@ struct WriteDuringReadWorkload : TestWorkload {
 										tr.setOption(FDBTransactionOptions::NEXT_WRITE_NO_WRITE_CONFLICT_RANGE);
 									tr.atomicOp(key, value, opType);
 									//TraceEvent("WDRAtomicOpSuccess").detail("Key", key).detail("Value", value.size());
-									if (!noConflict && key.size() <= (key.startsWith(systemKeys.begin)
-									                                      ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT
-									                                      : CLIENT_KNOBS->KEY_SIZE_LIMIT))
+									if (!noConflict && key.size() <= getMaxWriteKeySize(key, false)) {
 										self->addedConflicts.insert(key, true);
+									}
 									Optional<Value> existing = self->memoryGet(&self->memoryDatabase, key);
 									self->memoryDatabase[key] =
 									    self->applyAtomicOp(existing.present() ? Optional<StringRef>(existing.get())
@@ -1063,10 +1033,9 @@ struct WriteDuringReadWorkload : TestWorkload {
 								if (noConflict)
 									tr.setOption(FDBTransactionOptions::NEXT_WRITE_NO_WRITE_CONFLICT_RANGE);
 								tr.set(key, value);
-								if (!noConflict && key.size() <= (key.startsWith(systemKeys.begin)
-								                                      ? CLIENT_KNOBS->SYSTEM_KEY_SIZE_LIMIT
-								                                      : CLIENT_KNOBS->KEY_SIZE_LIMIT))
+								if (!noConflict && key.size() <= getMaxWriteKeySize(key, false)) {
 									self->addedConflicts.insert(key, true);
+								}
 								//TraceEvent("WDRSetSuccess").detail("Key", key).detail("Value", value.size());
 								self->memoryDatabase[key] = value;
 							}

From ed0732a012dc199c6cd14f0dfc81c97a4461536c Mon Sep 17 00:00:00 2001
From: Sagar Vemuri <sagar.vemuri@snowflake.com>
Date: Wed, 27 Apr 2022 15:20:41 -0700
Subject: [PATCH 68/84] Address review comments: Update TraceEvents and an
 assert in versionstampkey check

---
 fdbserver/CommitProxyServer.actor.cpp | 23 +++++++++++------------
 1 file changed, 11 insertions(+), 12 deletions(-)

diff --git a/fdbserver/CommitProxyServer.actor.cpp b/fdbserver/CommitProxyServer.actor.cpp
index 70e998e6cf..a931566ac7 100644
--- a/fdbserver/CommitProxyServer.actor.cpp
+++ b/fdbserver/CommitProxyServer.actor.cpp
@@ -265,7 +265,7 @@ ErrorOr<Optional<TenantMapEntry>> getTenantEntry(ProxyCommitData* commitData,
 	return Optional<TenantMapEntry>();
 }
 
-bool verifyPrefix(ProxyCommitData* const commitData, const CommitTransactionRequest& req) {
+bool verifyTenantPrefix(ProxyCommitData* const commitData, const CommitTransactionRequest& req) {
 	ErrorOr<Optional<TenantMapEntry>> tenantEntry =
 	    getTenantEntry(commitData, req.tenantInfo.name.castTo<TenantNameRef>(), req.tenantInfo.tenantId, true);
 
@@ -281,27 +281,26 @@ bool verifyPrefix(ProxyCommitData* const commitData, const CommitTransactionRequ
 					TraceEvent(SevWarnAlways, "TenantPrefixMismatch")
 					    .suppressFor(60)
 					    .detail("Prefix", tenantPrefix.toHexString())
-					    .detail("Key", m.param1.toHexString())
-					    .detail("KeyType", "Key");
+					    .detail("Key", m.param1.toHexString());
 					return false;
 				}
 
 				if (m.type == MutationRef::ClearRange && !m.param2.startsWith(tenantPrefix)) {
-					TraceEvent(SevWarnAlways, "TenantPrefixMismatch")
+					TraceEvent(SevWarnAlways, "TenantClearRangePrefixMismatch")
 					    .suppressFor(60)
 					    .detail("Prefix", tenantPrefix.toHexString())
-					    .detail("Key", m.param2.toHexString())
-					    .detail("KeyType", "ClearRangeKey");
+					    .detail("Key", m.param2.toHexString());
 					return false;
 				} else if (m.type == MutationRef::SetVersionstampedKey) {
+					ASSERT(m.param1.size() >= 4);
 					uint8_t* key = const_cast<uint8_t*>(m.param1.begin());
 					int* offset = reinterpret_cast<int*>(&key[m.param1.size() - 4]);
-					if (*offset <= tenantPrefix.size()) {
-						TraceEvent(SevWarnAlways, "TenantPrefixMismatch")
+					if (*offset < tenantPrefix.size()) {
+						TraceEvent(SevWarnAlways, "TenantVersionstampInvalidOffset")
 						    .suppressFor(60)
 						    .detail("Prefix", tenantPrefix.toHexString())
 						    .detail("Key", m.param1.toHexString())
-						    .detail("KeyType", "VersionstampedKey");
+						    .detail("Offset", *offset);
 						return false;
 					}
 				}
@@ -311,7 +310,7 @@ bool verifyPrefix(ProxyCommitData* const commitData, const CommitTransactionRequ
 		for (auto& rc : req.transaction.read_conflict_ranges) {
 			if (rc.begin != metadataVersionKey &&
 			    (!rc.begin.startsWith(tenantPrefix) || !rc.end.startsWith(tenantPrefix))) {
-				TraceEvent(SevWarnAlways, "TenantPrefixMismatch")
+				TraceEvent(SevWarnAlways, "TenantReadConflictPrefixMismatch")
 				    .suppressFor(60)
 				    .detail("Prefix", tenantPrefix.toHexString())
 				    .detail("BeginKey", rc.begin.toHexString())
@@ -323,7 +322,7 @@ bool verifyPrefix(ProxyCommitData* const commitData, const CommitTransactionRequ
 		for (auto& wc : req.transaction.write_conflict_ranges) {
 			if (wc.begin != metadataVersionKey &&
 			    (!wc.begin.startsWith(tenantPrefix) || !wc.end.startsWith(tenantPrefix))) {
-				TraceEvent(SevWarnAlways, "TenantPrefixMismatch")
+				TraceEvent(SevWarnAlways, "TenantWriteConflictPrefixMismatch")
 				    .suppressFor(60)
 				    .detail("Prefix", tenantPrefix.toHexString())
 				    .detail("BeginKey", wc.begin.toHexString())
@@ -383,7 +382,7 @@ ACTOR Future<Void> commitBatcher(ProxyCommitData* commitData,
 						    .detail("Client", req.reply.getEndpoint().getPrimaryAddress());
 					}
 
-					if (!verifyPrefix(commitData, req)) {
+					if (!verifyTenantPrefix(commitData, req)) {
 						++commitData->stats.txnCommitErrors;
 						req.reply.sendError(illegal_tenant_access());
 						continue;

From c69a07a8583b50152859a35a6e2d3f670c3c18e2 Mon Sep 17 00:00:00 2001
From: Renxuan Wang <renxuan@apple.com>
Date: Wed, 27 Apr 2022 21:54:13 -0700
Subject: [PATCH 69/84] Check in the new Hostname logic. (#6926)

* Revert #6655.

20220407-031010-renxuan-c101052c21da8346           compressed=True data_size=31004844 duration=4310801 ended=100000 fail_fast=10 max_runs=100000 pass=100000 priority=100 remaining=0 runtime=1:04:15 sanity=False started=100047 stopped=20220407-041425 submitted=20220407-031010 timeout=5400 username=renxuan

* Revert #6271.

20220407-051532-renxuan-470f0fe6aac1c217           compressed=True data_size=30982370 duration=3491067 ended=100002 fail_fast=10 max_runs=100000 pass=100002 priority=100 remaining=0 runtime=0:59:57 sanity=False started=100141 stopped=20220407-061529 submitted=20220407-051532 timeout=5400 username=renxuan

* Revert #6266.

Remove resolving-related functionalities in connection string. Connection string will be used for storing purpose only, and non-mutable.

20220407-175119-renxuan-55d30ee1a4b42c2f           compressed=True data_size=30970443 duration=5437659 ended=100000 fail_fast=10 max_runs=100000 pass=100000 priority=100 remaining=0 runtime=0:59:31 sanity=False started=100154 stopped=20220407-185050 submitted=20220407-175119 timeout=5400 username=renxuan

* Add hostname to coordinator interfaces.

* Turn on the new hostname logic.

* Add the corresponding change in config txns.

The most notable change is before calling basicLoadBalance(), we need to call tryInitializeRequestStream() to initialize request streams first.

Passed correctness tests.

* Return error when hostnames cannot be resolved in coordinators command.

* Minor fixes.
---
 fdbcli/fdbcli.actor.cpp                       |   1 -
 fdbclient/AutoPublicAddress.cpp               |  54 +-
 fdbclient/CoordinationInterface.h             |  49 +-
 fdbclient/ManagementAPI.actor.cpp             |  59 ++-
 fdbclient/ManagementAPI.actor.h               |   4 +-
 fdbclient/MonitorLeader.actor.cpp             | 495 +++++++-----------
 fdbclient/MonitorLeader.h                     |   4 +-
 fdbclient/NativeAPI.actor.cpp                 |  48 +-
 fdbclient/PaxosConfigTransaction.actor.cpp    |  81 ++-
 fdbclient/SimpleConfigTransaction.actor.cpp   |  66 ++-
 fdbclient/SpecialKeySpace.actor.cpp           |  45 +-
 fdbclient/StatusClient.actor.cpp              |  36 +-
 fdbrpc/genericactors.actor.h                  |  14 +
 fdbserver/ClusterController.actor.cpp         |  21 +-
 fdbserver/ClusterRecovery.actor.cpp           |   3 +-
 fdbserver/CoordinatedState.actor.cpp          |  25 +-
 fdbserver/Coordination.actor.cpp              |  60 +--
 fdbserver/CoordinationInterface.h             |  10 +-
 fdbserver/LeaderElection.actor.cpp            | 113 ++--
 fdbserver/LeaderElection.h                    |   8 +-
 fdbserver/PaxosConfigConsumer.actor.cpp       |  64 ++-
 fdbserver/QuietDatabase.actor.cpp             |   5 +-
 fdbserver/SimpleConfigConsumer.actor.cpp      |  47 +-
 fdbserver/SimulatedCluster.actor.cpp          |   4 +-
 fdbserver/Status.actor.cpp                    |  17 +-
 fdbserver/fdbserver.actor.cpp                 |  23 +-
 fdbserver/worker.actor.cpp                    |  61 ++-
 .../workloads/ConsistencyCheck.actor.cpp      |   5 +-
 .../workloads/RemoveServersSafely.actor.cpp   |   7 +-
 .../SpecialKeySpaceCorrectness.actor.cpp      |  17 +-
 30 files changed, 764 insertions(+), 682 deletions(-)

diff --git a/fdbcli/fdbcli.actor.cpp b/fdbcli/fdbcli.actor.cpp
index 97827aca6d..5f5f7d25fc 100644
--- a/fdbcli/fdbcli.actor.cpp
+++ b/fdbcli/fdbcli.actor.cpp
@@ -1189,7 +1189,6 @@ ACTOR Future<int> cli(CLIOptions opt, LineNoise* plinenoise) {
 	    ClusterConnectionFile::lookupClusterFileName(opt.clusterFile);
 	try {
 		ccf = makeReference<ClusterConnectionFile>(resolvedClusterFile.first);
-		wait(ccf->resolveHostnames());
 	} catch (Error& e) {
 		if (e.code() == error_code_operation_cancelled) {
 			throw;
diff --git a/fdbclient/AutoPublicAddress.cpp b/fdbclient/AutoPublicAddress.cpp
index c77414ded3..9b94d89e2c 100644
--- a/fdbclient/AutoPublicAddress.cpp
+++ b/fdbclient/AutoPublicAddress.cpp
@@ -28,28 +28,46 @@
 
 #include "fdbclient/CoordinationInterface.h"
 
-// Determine public IP address by calling the first coordinator.
+// Determine public IP address by calling the first available coordinator.
+// If fail connecting all coordinators, throw bind_failed().
 IPAddress determinePublicIPAutomatically(ClusterConnectionString& ccs) {
-	try {
-		using namespace boost::asio;
+	int size = ccs.coordinators().size() + ccs.hostnames.size();
+	int index = 0;
+	loop {
+		try {
+			using namespace boost::asio;
 
-		io_service ioService;
-		ip::udp::socket socket(ioService);
+			io_service ioService;
+			ip::udp::socket socket(ioService);
 
-		ccs.resolveHostnamesBlocking();
-		const auto& coordAddr = ccs.coordinators()[0];
-		const auto boostIp = coordAddr.ip.isV6() ? ip::address(ip::address_v6(coordAddr.ip.toV6()))
-		                                         : ip::address(ip::address_v4(coordAddr.ip.toV4()));
+			NetworkAddress coordAddr;
+			// Try coords first, because they don't need to be resolved.
+			if (index < ccs.coordinators().size()) {
+				coordAddr = ccs.coordinators()[index];
+			} else {
+				Hostname& h = ccs.hostnames[index - ccs.coordinators().size()];
+				Optional<NetworkAddress> resolvedAddr = h.resolveBlocking();
+				if (!resolvedAddr.present()) {
+					throw lookup_failed();
+				}
+				coordAddr = resolvedAddr.get();
+			}
+			const auto boostIp = coordAddr.ip.isV6() ? ip::address(ip::address_v6(coordAddr.ip.toV6()))
+			                                         : ip::address(ip::address_v4(coordAddr.ip.toV4()));
 
-		ip::udp::endpoint endpoint(boostIp, coordAddr.port);
-		socket.connect(endpoint);
-		IPAddress ip = coordAddr.ip.isV6() ? IPAddress(socket.local_endpoint().address().to_v6().to_bytes())
-		                                   : IPAddress(socket.local_endpoint().address().to_v4().to_ulong());
-		socket.close();
+			ip::udp::endpoint endpoint(boostIp, coordAddr.port);
+			socket.connect(endpoint);
+			IPAddress ip = coordAddr.ip.isV6() ? IPAddress(socket.local_endpoint().address().to_v6().to_bytes())
+			                                   : IPAddress(socket.local_endpoint().address().to_v4().to_ulong());
+			socket.close();
 
-		return ip;
-	} catch (boost::system::system_error e) {
-		fprintf(stderr, "Error determining public address: %s\n", e.what());
-		throw bind_failed();
+			return ip;
+		} catch (...) {
+			++index;
+			if (index == size) {
+				fprintf(stderr, "Error determining public address.\n");
+				throw bind_failed();
+			}
+		}
 	}
 }
diff --git a/fdbclient/CoordinationInterface.h b/fdbclient/CoordinationInterface.h
index 3f2f8bd385..65a18cfa7c 100644
--- a/fdbclient/CoordinationInterface.h
+++ b/fdbclient/CoordinationInterface.h
@@ -61,61 +61,31 @@ struct ClientLeaderRegInterface {
 //  - There is no address present more than once
 class ClusterConnectionString {
 public:
-	enum ConnectionStringStatus { RESOLVED, RESOLVING, UNRESOLVED };
-
 	ClusterConnectionString() {}
-	ClusterConnectionString(const std::string& connStr);
+	ClusterConnectionString(const std::string& connectionString);
 	ClusterConnectionString(const std::vector<NetworkAddress>& coordinators, Key key);
 	ClusterConnectionString(const std::vector<Hostname>& hosts, Key key);
 
-	ClusterConnectionString(const ClusterConnectionString& rhs) { operator=(rhs); }
-	ClusterConnectionString& operator=(const ClusterConnectionString& rhs) {
-		// Copy everything except AsyncTrigger resolveFinish.
-		status = rhs.status;
-		coords = rhs.coords;
-		hostnames = rhs.hostnames;
-		networkAddressToHostname = rhs.networkAddressToHostname;
-		key = rhs.key;
-		keyDesc = rhs.keyDesc;
-		connectionString = rhs.connectionString;
-		return *this;
-	}
-
 	std::vector<NetworkAddress> const& coordinators() const { return coords; }
-	void addResolved(const Hostname& hostname, const NetworkAddress& address) {
-		coords.push_back(address);
-		networkAddressToHostname.emplace(address, hostname);
-	}
 	Key clusterKey() const { return key; }
 	Key clusterKeyName() const {
 		return keyDesc;
 	} // Returns the "name" or "description" part of the clusterKey (the part before the ':')
 	std::string toString() const;
 	static std::string getErrorString(std::string const& source, Error const& e);
-	Future<Void> resolveHostnames();
-	// This one should only be used when resolving asynchronously is impossible. For all other cases, resolveHostnames()
-	// should be preferred.
-	void resolveHostnamesBlocking();
-	// This function derives the member connectionString from the current key, coordinators and hostnames.
-	void resetConnectionString();
 
-	void resetToUnresolved();
 	void parseKey(const std::string& key);
 
-	ConnectionStringStatus status = RESOLVED;
-	AsyncTrigger resolveFinish;
 	// This function tries to resolve all hostnames once, and return them with coords.
 	// Best effort, does not guarantee that the resolves succeed.
 	Future<std::vector<NetworkAddress>> tryResolveHostnames();
 
 	std::vector<NetworkAddress> coords;
 	std::vector<Hostname> hostnames;
-	std::unordered_map<NetworkAddress, Hostname> networkAddressToHostname;
 
 private:
 	void parseConnString();
 	Key key, keyDesc;
-	std::string connectionString;
 };
 
 FDB_DECLARE_BOOLEAN_PARAM(ConnectionStringNeedsPersisted);
@@ -165,12 +135,6 @@ public:
 	// Signals to the connection record that it was successfully used to connect to a cluster.
 	void notifyConnected();
 
-	ClusterConnectionString::ConnectionStringStatus connectionStringStatus() const;
-	Future<Void> resolveHostnames();
-	// This one should only be used when resolving asynchronously is impossible. For all other cases, resolveHostnames()
-	// should be preferred.
-	void resolveHostnamesBlocking();
-
 	virtual void addref() = 0;
 	virtual void delref() = 0;
 
@@ -275,12 +239,21 @@ struct OpenDatabaseCoordRequest {
 	Standalone<VectorRef<ClientVersionRef>> supportedVersions;
 	UID knownClientInfoID;
 	Key clusterKey;
+	std::vector<Hostname> hostnames;
 	std::vector<NetworkAddress> coordinators;
 	ReplyPromise<CachedSerialization<struct ClientDBInfo>> reply;
 
 	template <class Ar>
 	void serialize(Ar& ar) {
-		serializer(ar, issues, supportedVersions, traceLogGroup, knownClientInfoID, clusterKey, coordinators, reply);
+		serializer(ar,
+		           issues,
+		           supportedVersions,
+		           traceLogGroup,
+		           knownClientInfoID,
+		           clusterKey,
+		           hostnames,
+		           coordinators,
+		           reply);
 	}
 };
 
diff --git a/fdbclient/ManagementAPI.actor.cpp b/fdbclient/ManagementAPI.actor.cpp
index 1fcfbd1bc9..894e2ebd9d 100644
--- a/fdbclient/ManagementAPI.actor.cpp
+++ b/fdbclient/ManagementAPI.actor.cpp
@@ -782,7 +782,7 @@ ACTOR Future<std::vector<ProcessData>> getWorkers(Database cx) {
 	}
 }
 
-ACTOR Future<std::vector<NetworkAddress>> getCoordinators(Database cx) {
+ACTOR Future<Optional<ClusterConnectionString>> getConnectionString(Database cx) {
 	state Transaction tr(cx);
 	loop {
 		try {
@@ -790,9 +790,8 @@ ACTOR Future<std::vector<NetworkAddress>> getCoordinators(Database cx) {
 			tr.setOption(FDBTransactionOptions::READ_SYSTEM_KEYS);
 			Optional<Value> currentKey = wait(tr.get(coordinatorsKey));
 			if (!currentKey.present())
-				return std::vector<NetworkAddress>();
-
-			return ClusterConnectionString(currentKey.get().toString()).coordinators();
+				return Optional<ClusterConnectionString>();
+			return ClusterConnectionString(currentKey.get().toString());
 		} catch (Error& e) {
 			wait(tr.onError(e));
 		}
@@ -801,7 +800,7 @@ ACTOR Future<std::vector<NetworkAddress>> getCoordinators(Database cx) {
 
 ACTOR Future<Optional<CoordinatorsResult>> changeQuorumChecker(Transaction* tr,
                                                                Reference<IQuorumChange> change,
-                                                               ClusterConnectionString* conn) {
+                                                               std::vector<NetworkAddress> desiredCoordinators) {
 	tr->setOption(FDBTransactionOptions::LOCK_AWARE);
 	tr->setOption(FDBTransactionOptions::ACCESS_SYSTEM_KEYS);
 	tr->setOption(FDBTransactionOptions::USE_PROVISIONAL_PROXIES);
@@ -812,47 +811,45 @@ ACTOR Future<Optional<CoordinatorsResult>> changeQuorumChecker(Transaction* tr,
 		return CoordinatorsResult::BAD_DATABASE_STATE; // Someone deleted this key entirely?
 
 	state ClusterConnectionString old(currentKey.get().toString());
-	wait(old.resolveHostnames());
 	if (tr->getDatabase()->getConnectionRecord() &&
 	    old.clusterKeyName().toString() !=
 	        tr->getDatabase()->getConnectionRecord()->getConnectionString().clusterKeyName())
 		return CoordinatorsResult::BAD_DATABASE_STATE; // Someone changed the "name" of the database??
 
+	state std::vector<NetworkAddress> oldCoordinators = wait(old.tryResolveHostnames());
 	state CoordinatorsResult result = CoordinatorsResult::SUCCESS;
-	if (!conn->coords.size()) {
-		std::vector<NetworkAddress> desiredCoordinatorAddresses = wait(change->getDesiredCoordinators(
+	if (!desiredCoordinators.size()) {
+		std::vector<NetworkAddress> _desiredCoordinators = wait(change->getDesiredCoordinators(
 		    tr,
-		    old.coordinators(),
+		    oldCoordinators,
 		    Reference<ClusterConnectionMemoryRecord>(new ClusterConnectionMemoryRecord(old)),
 		    result));
-		conn->coords = desiredCoordinatorAddresses;
+		desiredCoordinators = _desiredCoordinators;
 	}
 
 	if (result != CoordinatorsResult::SUCCESS)
 		return result;
 
-	if (!conn->coordinators().size())
+	if (!desiredCoordinators.size())
 		return CoordinatorsResult::INVALID_NETWORK_ADDRESSES;
 
-	std::sort(conn->coords.begin(), conn->coords.end());
-	std::sort(conn->hostnames.begin(), conn->hostnames.end());
+	std::sort(desiredCoordinators.begin(), desiredCoordinators.end());
 
 	std::string newName = change->getDesiredClusterKeyName();
 	if (newName.empty())
 		newName = old.clusterKeyName().toString();
 
-	if (old.coordinators() == conn->coordinators() && old.clusterKeyName() == newName)
+	if (oldCoordinators == desiredCoordinators && old.clusterKeyName() == newName)
 		return CoordinatorsResult::SAME_NETWORK_ADDRESSES;
 
-	std::string key(newName + ':' + deterministicRandom()->randomAlphaNumeric(32));
-	conn->parseKey(key);
-	conn->resetConnectionString();
+	state ClusterConnectionString conn(desiredCoordinators,
+	                                   StringRef(newName + ':' + deterministicRandom()->randomAlphaNumeric(32)));
 
 	if (g_network->isSimulated()) {
 		int i = 0;
 		int protectedCount = 0;
-		while ((protectedCount < ((conn->coordinators().size() / 2) + 1)) && (i < conn->coordinators().size())) {
-			auto process = g_simulator.getProcessByAddress(conn->coordinators()[i]);
+		while ((protectedCount < ((desiredCoordinators.size() / 2) + 1)) && (i < desiredCoordinators.size())) {
+			auto process = g_simulator.getProcessByAddress(desiredCoordinators[i]);
 			auto addresses = process->addresses;
 
 			if (!process->isReliable()) {
@@ -864,14 +861,14 @@ ACTOR Future<Optional<CoordinatorsResult>> changeQuorumChecker(Transaction* tr,
 			if (addresses.secondaryAddress.present()) {
 				g_simulator.protectedAddresses.insert(process->addresses.secondaryAddress.get());
 			}
-			TraceEvent("ProtectCoordinator").detail("Address", conn->coordinators()[i]).backtrace();
+			TraceEvent("ProtectCoordinator").detail("Address", desiredCoordinators[i]).backtrace();
 			protectedCount++;
 			i++;
 		}
 	}
 
 	std::vector<Future<Optional<LeaderInfo>>> leaderServers;
-	ClientCoordinators coord(Reference<ClusterConnectionMemoryRecord>(new ClusterConnectionMemoryRecord(*conn)));
+	ClientCoordinators coord(Reference<ClusterConnectionMemoryRecord>(new ClusterConnectionMemoryRecord(conn)));
 
 	leaderServers.reserve(coord.clientLeaderServers.size());
 	for (int i = 0; i < coord.clientLeaderServers.size(); i++)
@@ -883,7 +880,7 @@ ACTOR Future<Optional<CoordinatorsResult>> changeQuorumChecker(Transaction* tr,
 		when(wait(waitForAll(leaderServers))) {}
 		when(wait(delay(5.0))) { return CoordinatorsResult::COORDINATOR_UNREACHABLE; }
 	}
-	tr->set(coordinatorsKey, conn->toString());
+	tr->set(coordinatorsKey, conn.toString());
 	return Optional<CoordinatorsResult>();
 }
 
@@ -909,11 +906,12 @@ ACTOR Future<CoordinatorsResult> changeQuorum(Database cx, Reference<IQuorumChan
 			    old.clusterKeyName().toString() != cx->getConnectionRecord()->getConnectionString().clusterKeyName())
 				return CoordinatorsResult::BAD_DATABASE_STATE; // Someone changed the "name" of the database??
 
+			state std::vector<NetworkAddress> oldCoordinators = wait(old.tryResolveHostnames());
 			state CoordinatorsResult result = CoordinatorsResult::SUCCESS;
 			if (!desiredCoordinators.size()) {
 				std::vector<NetworkAddress> _desiredCoordinators = wait(change->getDesiredCoordinators(
 				    &tr,
-				    old.coordinators(),
+				    oldCoordinators,
 				    Reference<ClusterConnectionMemoryRecord>(new ClusterConnectionMemoryRecord(old)),
 				    result));
 				desiredCoordinators = _desiredCoordinators;
@@ -937,7 +935,7 @@ ACTOR Future<CoordinatorsResult> changeQuorum(Database cx, Reference<IQuorumChan
 			if (newName.empty())
 				newName = old.clusterKeyName().toString();
 
-			if (old.coordinators() == desiredCoordinators && old.clusterKeyName() == newName)
+			if (oldCoordinators == desiredCoordinators && old.clusterKeyName() == newName)
 				return retries ? CoordinatorsResult::SUCCESS : CoordinatorsResult::SAME_NETWORK_ADDRESSES;
 
 			state ClusterConnectionString conn(
@@ -1075,9 +1073,16 @@ struct AutoQuorumChange final : IQuorumChange {
 		std::vector<Future<Optional<LeaderInfo>>> leaderServers;
 		leaderServers.reserve(coord.clientLeaderServers.size());
 		for (int i = 0; i < coord.clientLeaderServers.size(); i++) {
-			leaderServers.push_back(retryBrokenPromise(coord.clientLeaderServers[i].getLeader,
-			                                           GetLeaderRequest(coord.clusterKey, UID()),
-			                                           TaskPriority::CoordinationReply));
+			if (coord.clientLeaderServers[i].hostname.present()) {
+				leaderServers.push_back(retryGetReplyFromHostname(GetLeaderRequest(coord.clusterKey, UID()),
+				                                                  coord.clientLeaderServers[i].hostname.get(),
+				                                                  WLTOKEN_CLIENTLEADERREG_GETLEADER,
+				                                                  TaskPriority::CoordinationReply));
+			} else {
+				leaderServers.push_back(retryBrokenPromise(coord.clientLeaderServers[i].getLeader,
+				                                           GetLeaderRequest(coord.clusterKey, UID()),
+				                                           TaskPriority::CoordinationReply));
+			}
 		}
 		Optional<std::vector<Optional<LeaderInfo>>> results =
 		    wait(timeout(getAll(leaderServers), CLIENT_KNOBS->IS_ACCEPTABLE_DELAY));
diff --git a/fdbclient/ManagementAPI.actor.h b/fdbclient/ManagementAPI.actor.h
index 64c54447a7..82c8bb4ee9 100644
--- a/fdbclient/ManagementAPI.actor.h
+++ b/fdbclient/ManagementAPI.actor.h
@@ -56,7 +56,7 @@ struct IQuorumChange : ReferenceCounted<IQuorumChange> {
 // Change to use the given set of coordination servers
 ACTOR Future<Optional<CoordinatorsResult>> changeQuorumChecker(Transaction* tr,
                                                                Reference<IQuorumChange> change,
-                                                               ClusterConnectionString* conn);
+                                                               std::vector<NetworkAddress> desiredCoordinators);
 ACTOR Future<CoordinatorsResult> changeQuorum(Database cx, Reference<IQuorumChange> change);
 Reference<IQuorumChange> autoQuorumChange(int desired = -1);
 Reference<IQuorumChange> noQuorumChange();
@@ -146,7 +146,7 @@ ACTOR Future<bool> setHealthyZone(Database cx, StringRef zoneId, double seconds,
 ACTOR Future<Void> waitForPrimaryDC(Database cx, StringRef dcId);
 
 // Gets the cluster connection string
-ACTOR Future<std::vector<NetworkAddress>> getCoordinators(Database cx);
+ACTOR Future<Optional<ClusterConnectionString>> getConnectionString(Database cx);
 
 void schemaCoverage(std::string const& spath, bool covered = true);
 bool schemaMatch(json_spirit::mValue const& schema,
diff --git a/fdbclient/MonitorLeader.actor.cpp b/fdbclient/MonitorLeader.actor.cpp
index 0b80e5076c..ad08c8ba3d 100644
--- a/fdbclient/MonitorLeader.actor.cpp
+++ b/fdbclient/MonitorLeader.actor.cpp
@@ -77,18 +77,6 @@ void IClusterConnectionRecord::setPersisted() {
 	connectionStringNeedsPersisted = false;
 }
 
-ClusterConnectionString::ConnectionStringStatus IClusterConnectionRecord::connectionStringStatus() const {
-	return cs.status;
-}
-
-Future<Void> IClusterConnectionRecord::resolveHostnames() {
-	return cs.resolveHostnames();
-}
-
-void IClusterConnectionRecord::resolveHostnamesBlocking() {
-	cs.resolveHostnamesBlocking();
-}
-
 std::string ClusterConnectionString::getErrorString(std::string const& source, Error const& e) {
 	if (e.code() == error_code_connection_string_invalid) {
 		return format("Invalid connection string `%s: %d %s", source.c_str(), e.code(), e.what());
@@ -97,101 +85,19 @@ std::string ClusterConnectionString::getErrorString(std::string const& source, E
 	}
 }
 
-ACTOR Future<Void> resolveHostnamesImpl(ClusterConnectionString* self) {
-	loop {
-		if (self->status == ClusterConnectionString::UNRESOLVED) {
-			self->status = ClusterConnectionString::RESOLVING;
-			std::vector<Future<Void>> fs;
-			for (auto const& hostname : self->hostnames) {
-				fs.push_back(map(INetworkConnections::net()->resolveTCPEndpoint(hostname.host, hostname.service),
-				                 [=](std::vector<NetworkAddress> const& addresses) -> Void {
-					                 NetworkAddress address =
-					                     addresses[deterministicRandom()->randomInt(0, addresses.size())];
-					                 address.flags = 0; // Reset the parsed address to public
-					                 address.fromHostname = NetworkAddressFromHostname::True;
-					                 if (hostname.isTLS) {
-						                 address.flags |= NetworkAddress::FLAG_TLS;
-					                 }
-					                 self->addResolved(hostname, address);
-					                 return Void();
-				                 }));
-			}
-			wait(waitForAll(fs));
-			std::sort(self->coords.begin(), self->coords.end());
-			if (std::unique(self->coords.begin(), self->coords.end()) != self->coords.end()) {
-				self->status = ClusterConnectionString::UNRESOLVED;
-				self->resolveFinish.trigger();
-				throw connection_string_invalid();
-			}
-			self->status = ClusterConnectionString::RESOLVED;
-			self->resolveFinish.trigger();
-			break;
-		} else if (self->status == ClusterConnectionString::RESOLVING) {
-			wait(self->resolveFinish.onTrigger());
-			if (self->status == ClusterConnectionString::RESOLVED) {
-				break;
-			}
-			// Otherwise, this means other threads failed on resolve, so here we go back to the loop and try to resolve
-			// again.
-		} else {
-			// status is RESOLVED, nothing to do.
-			break;
-		}
-	}
-	return Void();
-}
-
-Future<Void> ClusterConnectionString::resolveHostnames() {
-	return resolveHostnamesImpl(this);
-}
-
-void ClusterConnectionString::resolveHostnamesBlocking() {
-	if (status != RESOLVED) {
-		status = RESOLVING;
-		for (auto const& hostname : hostnames) {
-			std::vector<NetworkAddress> addresses =
-			    INetworkConnections::net()->resolveTCPEndpointBlocking(hostname.host, hostname.service);
-			NetworkAddress address = addresses[deterministicRandom()->randomInt(0, addresses.size())];
-			address.flags = 0; // Reset the parsed address to public
-			address.fromHostname = NetworkAddressFromHostname::True;
-			if (hostname.isTLS) {
-				address.flags |= NetworkAddress::FLAG_TLS;
-			}
-			addResolved(hostname, address);
-		}
-		std::sort(coords.begin(), coords.end());
-		if (std::unique(coords.begin(), coords.end()) != coords.end()) {
-			status = UNRESOLVED;
-			throw connection_string_invalid();
-		}
-		status = RESOLVED;
-	}
-}
-
-void ClusterConnectionString::resetToUnresolved() {
-	if (status == RESOLVED && hostnames.size() > 0) {
-		coords.clear();
-		hostnames.clear();
-		networkAddressToHostname.clear();
-		status = UNRESOLVED;
-		parseConnString();
-	}
-}
-
-void ClusterConnectionString::resetConnectionString() {
-	connectionString = toString();
-}
-
-void ClusterConnectionString::parseConnString() {
+ClusterConnectionString::ClusterConnectionString(const std::string& connectionString) {
+	auto trimmed = trim(connectionString);
 	// Split on '@' into key@addrs
-	int pAt = connectionString.find_first_of('@');
-	if (pAt == connectionString.npos) {
+	int pAt = trimmed.find_first_of('@');
+	if (pAt == trimmed.npos) {
 		throw connection_string_invalid();
 	}
-	std::string key = connectionString.substr(0, pAt);
-	std::string addrs = connectionString.substr(pAt + 1);
+	std::string key = trimmed.substr(0, pAt);
+	std::string addrs = trimmed.substr(pAt + 1);
 
 	parseKey(key);
+	std::set<Hostname> hostnameSet;
+	std::set<NetworkAddress> addressSet;
 	std::string curAddr;
 	for (int p = 0; p <= addrs.size();) {
 		int pComma = addrs.find_first_of(',', p);
@@ -199,31 +105,29 @@ void ClusterConnectionString::parseConnString() {
 			pComma = addrs.size();
 		curAddr = addrs.substr(p, pComma - p);
 		if (Hostname::isHostname(curAddr)) {
+			Hostname h = Hostname::parse(curAddr);
+			// Check that there are no duplicate hostnames
+			if (hostnameSet.find(h) != hostnameSet.end()) {
+				throw connection_string_invalid();
+			}
 			hostnames.push_back(Hostname::parse(curAddr));
+			hostnameSet.insert(h);
 		} else {
-			coords.push_back(NetworkAddress::parse(curAddr));
+			NetworkAddress n = NetworkAddress::parse(curAddr);
+			// Check that there are no duplicate addresses
+			if (addressSet.find(n) != addressSet.end()) {
+				throw connection_string_invalid();
+			}
+			coords.push_back(n);
+			addressSet.insert(n);
 		}
 		p = pComma + 1;
 	}
-	if (hostnames.size() > 0) {
-		status = UNRESOLVED;
-	}
 	ASSERT((coords.size() + hostnames.size()) > 0);
-
-	std::sort(coords.begin(), coords.end());
-	// Check that there are no duplicate addresses
-	if (std::unique(coords.begin(), coords.end()) != coords.end()) {
-		throw connection_string_invalid();
-	}
-}
-
-ClusterConnectionString::ClusterConnectionString(const std::string& connStr) {
-	connectionString = trim(connStr);
-	parseConnString();
 }
 
 TEST_CASE("/fdbclient/MonitorLeader/parseConnectionString/addresses") {
-	std::string input;
+	state std::string input;
 
 	{
 		input = "asdf:2345@1.1.1.1:345";
@@ -231,6 +135,15 @@ TEST_CASE("/fdbclient/MonitorLeader/parseConnectionString/addresses") {
 		ASSERT(input == cs.toString());
 	}
 
+	{
+		input = "asdf:2345@1.1.1.1:345,1.1.1.1:345";
+		try {
+			ClusterConnectionString cs(input);
+		} catch (Error& e) {
+			ASSERT(e.code() == error_code_connection_string_invalid);
+		}
+	}
+
 	{
 		input = "0xxdeadbeef:100100100@1.1.1.1:34534,5.1.5.3:23443";
 		ClusterConnectionString cs(input);
@@ -274,20 +187,27 @@ TEST_CASE("/fdbclient/MonitorLeader/parseConnectionString/addresses") {
 }
 
 TEST_CASE("/fdbclient/MonitorLeader/parseConnectionString/hostnames") {
-	std::string input;
+	state std::string input;
 
 	{
 		input = "asdf:2345@localhost:1234";
 		ClusterConnectionString cs(input);
-		ASSERT(cs.status == ClusterConnectionString::UNRESOLVED);
 		ASSERT(cs.hostnames.size() == 1);
 		ASSERT(input == cs.toString());
 	}
 
+	{
+		input = "asdf:2345@localhost:1234,localhost:1234";
+		try {
+			ClusterConnectionString cs(input);
+		} catch (Error& e) {
+			ASSERT(e.code() == error_code_connection_string_invalid);
+		}
+	}
+
 	{
 		input = "0xxdeadbeef:100100100@localhost:34534,host-name:23443";
 		ClusterConnectionString cs(input);
-		ASSERT(cs.status == ClusterConnectionString::UNRESOLVED);
 		ASSERT(cs.hostnames.size() == 2);
 		ASSERT(input == cs.toString());
 	}
@@ -300,7 +220,6 @@ TEST_CASE("/fdbclient/MonitorLeader/parseConnectionString/hostnames") {
 		commented += "# asdfasdf ##";
 
 		ClusterConnectionString cs(commented);
-		ASSERT(cs.status == ClusterConnectionString::UNRESOLVED);
 		ASSERT(cs.hostnames.size() == 2);
 		ASSERT(input == cs.toString());
 	}
@@ -313,7 +232,6 @@ TEST_CASE("/fdbclient/MonitorLeader/parseConnectionString/hostnames") {
 		commented += "# asdfasdf ##";
 
 		ClusterConnectionString cs(commented);
-		ASSERT(cs.status == ClusterConnectionString::UNRESOLVED);
 		ASSERT(cs.hostnames.size() == 2);
 		ASSERT(input == cs.toString());
 	}
@@ -321,44 +239,30 @@ TEST_CASE("/fdbclient/MonitorLeader/parseConnectionString/hostnames") {
 	return Void();
 }
 
-TEST_CASE("/fdbclient/MonitorLeader/ConnectionString") {
-	state std::string connectionString = "TestCluster:0@localhost:1234,host-name:5678";
-	std::string hn1 = "localhost", port1 = "1234";
-	state std::string hn2 = "host-name";
-	state std::string port2 = "5678";
-	state std::vector<Hostname> hostnames;
-	hostnames.push_back(Hostname::parse(hn1 + ":" + port1));
-	hostnames.push_back(Hostname::parse(hn2 + ":" + port2));
+TEST_CASE("/fdbclient/MonitorLeader/ConnectionString/hostname") {
+	std::string connectionString = "TestCluster:0@localhost:1234,host-name:5678";
+	std::string hn1 = "localhost", port1 = "1234", hn2 = "host-name", port2 = "5678";
+	std::vector<Hostname> hostnames;
 
-	NetworkAddress address1 = NetworkAddress::parse("127.0.0.0:1234");
-	NetworkAddress address2 = NetworkAddress::parse("127.0.0.1:5678");
+	{
+		hostnames.push_back(Hostname::parse(hn1 + ":" + port1));
+		hostnames.push_back(Hostname::parse(hn2 + ":" + port2));
 
-	INetworkConnections::net()->addMockTCPEndpoint(hn1, port1, { address1 });
-	INetworkConnections::net()->addMockTCPEndpoint(hn2, port2, { address2 });
+		ClusterConnectionString cs(hostnames, LiteralStringRef("TestCluster:0"));
+		ASSERT(cs.hostnames.size() == 2);
+		ASSERT(cs.coordinators().size() == 0);
+		ASSERT(cs.toString() == connectionString);
+	}
 
-	state ClusterConnectionString cs(hostnames, LiteralStringRef("TestCluster:0"));
-	ASSERT(cs.status == ClusterConnectionString::UNRESOLVED);
-	ASSERT(cs.hostnames.size() == 2);
-	ASSERT(cs.coordinators().size() == 0);
-	wait(cs.resolveHostnames());
-	ASSERT(cs.status == ClusterConnectionString::RESOLVED);
-	ASSERT(cs.hostnames.size() == 2);
-	ASSERT(cs.coordinators().size() == 2);
-	ASSERT(cs.toString() == connectionString);
-	cs.resetToUnresolved();
-	ASSERT(cs.status == ClusterConnectionString::UNRESOLVED);
-	ASSERT(cs.hostnames.size() == 2);
-	ASSERT(cs.coordinators().size() == 0);
-	ASSERT(cs.toString() == connectionString);
-
-	INetworkConnections::net()->removeMockTCPEndpoint(hn2, port2);
-	NetworkAddress address3 = NetworkAddress::parse("127.0.0.0:5678");
-	INetworkConnections::net()->addMockTCPEndpoint(hn2, port2, { address3 });
-
-	try {
-		wait(cs.resolveHostnames());
-	} catch (Error& e) {
-		ASSERT(e.code() == error_code_connection_string_invalid);
+	{
+		hostnames.clear();
+		hostnames.push_back(Hostname::parse(hn1 + ":" + port1));
+		hostnames.push_back(Hostname::parse(hn1 + ":" + port1));
+		try {
+			ClusterConnectionString cs(hostnames, LiteralStringRef("TestCluster:0"));
+		} catch (Error& e) {
+			ASSERT(e.code() == error_code_connection_string_invalid);
+		}
 	}
 
 	return Void();
@@ -380,6 +284,7 @@ ACTOR Future<std::vector<NetworkAddress>> tryResolveHostnamesImpl(ClusterConnect
 		allCoordinatorsSet.insert(coord);
 	}
 	std::vector<NetworkAddress> allCoordinators(allCoordinatorsSet.begin(), allCoordinatorsSet.end());
+	std::sort(allCoordinators.begin(), allCoordinators.end());
 	return allCoordinators;
 }
 
@@ -484,17 +389,22 @@ TEST_CASE("/fdbclient/MonitorLeader/parseConnectionString/fuzz") {
 }
 
 ClusterConnectionString::ClusterConnectionString(const std::vector<NetworkAddress>& servers, Key key)
-  : status(RESOLVED), coords(servers) {
+  : coords(servers) {
+	std::set<NetworkAddress> s(servers.begin(), servers.end());
+	if (s.size() != servers.size()) {
+		throw connection_string_invalid();
+	}
 	std::string keyString = key.toString();
 	parseKey(keyString);
-	resetConnectionString();
 }
 
-ClusterConnectionString::ClusterConnectionString(const std::vector<Hostname>& hosts, Key key)
-  : status(UNRESOLVED), hostnames(hosts) {
+ClusterConnectionString::ClusterConnectionString(const std::vector<Hostname>& hosts, Key key) : hostnames(hosts) {
+	std::set<Hostname> h(hosts.begin(), hosts.end());
+	if (h.size() != hosts.size()) {
+		throw connection_string_invalid();
+	}
 	std::string keyString = key.toString();
 	parseKey(keyString);
-	resetConnectionString();
 }
 
 void ClusterConnectionString::parseKey(const std::string& key) {
@@ -529,13 +439,11 @@ void ClusterConnectionString::parseKey(const std::string& key) {
 std::string ClusterConnectionString::toString() const {
 	std::string s = key.toString();
 	s += '@';
-	for (int i = 0; i < coords.size(); i++) {
-		if (networkAddressToHostname.find(coords[i]) == networkAddressToHostname.end()) {
-			if (s.find('@') != s.length() - 1) {
-				s += ',';
-			}
-			s += coords[i].toString();
+	for (auto const& coord : coords) {
+		if (s.find('@') != s.length() - 1) {
+			s += ',';
 		}
+		s += coord.toString();
 	}
 	for (auto const& host : hostnames) {
 		if (s.find('@') != s.length() - 1) {
@@ -547,11 +455,14 @@ std::string ClusterConnectionString::toString() const {
 }
 
 ClientCoordinators::ClientCoordinators(Reference<IClusterConnectionRecord> ccr) : ccr(ccr) {
-	ASSERT(ccr->connectionStringStatus() == ClusterConnectionString::RESOLVED);
 	ClusterConnectionString cs = ccr->getConnectionString();
-	for (auto s = cs.coordinators().begin(); s != cs.coordinators().end(); ++s)
-		clientLeaderServers.push_back(ClientLeaderRegInterface(*s));
 	clusterKey = cs.clusterKey();
+	for (auto h : cs.hostnames) {
+		clientLeaderServers.push_back(ClientLeaderRegInterface(h));
+	}
+	for (auto s : cs.coordinators()) {
+		clientLeaderServers.push_back(ClientLeaderRegInterface(s));
+	}
 }
 
 ClientCoordinators::ClientCoordinators(Key clusterKey, std::vector<NetworkAddress> coordinators)
@@ -576,49 +487,32 @@ ClientLeaderRegInterface::ClientLeaderRegInterface(INetwork* local) {
 
 // Nominee is the worker among all workers that are considered as leader by one coordinator
 // This function contacts a coordinator coord to ask who is its nominee.
-// Note: for coordinators whose NetworkAddress is parsed out of a hostname, a connection failure will cause this actor
-// to throw `coordinators_changed()` error
 ACTOR Future<Void> monitorNominee(Key key,
                                   ClientLeaderRegInterface coord,
                                   AsyncTrigger* nomineeChange,
-                                  Optional<LeaderInfo>* info,
-                                  Optional<Hostname> hostname = Optional<Hostname>()) {
+                                  Optional<LeaderInfo>* info) {
 	loop {
 		state Optional<LeaderInfo> li;
-
-		if (coord.getLeader.getEndpoint().getPrimaryAddress().fromHostname) {
-			state ErrorOr<Optional<LeaderInfo>> rep =
-			    wait(coord.getLeader.tryGetReply(GetLeaderRequest(key, info->present() ? info->get().changeID : UID()),
-			                                     TaskPriority::CoordinationReply));
-			if (rep.isError()) {
-				// Connecting to nominee failed, most likely due to connection failed.
-				TraceEvent("MonitorNomineeError")
-				    .error(rep.getError())
-				    .detail("Hostname", hostname.present() ? hostname.get().toString() : "UnknownHostname")
-				    .detail("OldAddr", coord.getLeader.getEndpoint().getPrimaryAddress().toString());
-				if (rep.getError().code() == error_code_request_maybe_delivered) {
-					// Delay to prevent tight resolving loop due to outdated DNS cache
-					wait(delay(FLOW_KNOBS->HOSTNAME_RECONNECT_INIT_INTERVAL));
-					throw coordinators_changed();
-				} else {
-					throw rep.getError();
-				}
-			} else if (rep.present()) {
-				li = rep.get();
-			}
+		if (coord.hostname.present()) {
+			wait(store(li,
+			           retryGetReplyFromHostname(GetLeaderRequest(key, info->present() ? info->get().changeID : UID()),
+			                                     coord.hostname.get(),
+			                                     WLTOKEN_CLIENTLEADERREG_GETLEADER,
+			                                     TaskPriority::CoordinationReply)));
 		} else {
-			Optional<LeaderInfo> tmp =
-			    wait(retryBrokenPromise(coord.getLeader,
-			                            GetLeaderRequest(key, info->present() ? info->get().changeID : UID()),
-			                            TaskPriority::CoordinationReply));
-			li = tmp;
+			wait(store(li,
+			           retryBrokenPromise(coord.getLeader,
+			                              GetLeaderRequest(key, info->present() ? info->get().changeID : UID()),
+			                              TaskPriority::CoordinationReply)));
 		}
 
 		wait(Future<Void>(Void())); // Make sure we weren't cancelled
 
 		TraceEvent("GetLeaderReply")
 		    .suppressFor(1.0)
-		    .detail("Coordinator", coord.getLeader.getEndpoint().getPrimaryAddress())
+		    .detail("Coordinator",
+		            coord.hostname.present() ? coord.hostname.get().toString()
+		                                     : coord.getLeader.getEndpoint().getPrimaryAddress().toString())
 		    .detail("Nominee", li.present() ? li.get().changeID : UID())
 		    .detail("ClusterKey", key.printable());
 
@@ -687,74 +581,54 @@ Optional<std::pair<LeaderInfo, bool>> getLeader(const std::vector<Optional<Leade
 ACTOR Future<MonitorLeaderInfo> monitorLeaderOneGeneration(Reference<IClusterConnectionRecord> connRecord,
                                                            Reference<AsyncVar<Value>> outSerializedLeaderInfo,
                                                            MonitorLeaderInfo info) {
+	state ClientCoordinators coordinators(info.intermediateConnRecord);
+	state AsyncTrigger nomineeChange;
+	state std::vector<Optional<LeaderInfo>> nominees;
+	state Future<Void> allActors;
+
+	nominees.resize(coordinators.clientLeaderServers.size());
+
+	state std::vector<Future<Void>> actors;
+	// Ask all coordinators if the worker is considered as a leader (leader nominee) by the coordinator.
+	actors.reserve(coordinators.clientLeaderServers.size());
+	for (int i = 0; i < coordinators.clientLeaderServers.size(); i++) {
+		actors.push_back(
+		    monitorNominee(coordinators.clusterKey, coordinators.clientLeaderServers[i], &nomineeChange, &nominees[i]));
+	}
+	allActors = waitForAll(actors);
+
 	loop {
-		wait(connRecord->resolveHostnames());
-		wait(info.intermediateConnRecord->resolveHostnames());
-		state ClientCoordinators coordinators(info.intermediateConnRecord);
-		state AsyncTrigger nomineeChange;
-		state std::vector<Optional<LeaderInfo>> nominees;
-		state Future<Void> allActors;
-
-		nominees.resize(coordinators.clientLeaderServers.size());
-
-		state std::vector<Future<Void>> actors;
-		// Ask all coordinators if the worker is considered as a leader (leader nominee) by the coordinator.
-		actors.reserve(coordinators.clientLeaderServers.size());
-		for (int i = 0; i < coordinators.clientLeaderServers.size(); i++) {
-			Optional<Hostname> hostname;
-			auto r = connRecord->getConnectionString().networkAddressToHostname.find(
-			    coordinators.clientLeaderServers[i].getLeader.getEndpoint().getPrimaryAddress());
-			if (r != connRecord->getConnectionString().networkAddressToHostname.end()) {
-				hostname = r->second;
-			}
-			actors.push_back(monitorNominee(
-			    coordinators.clusterKey, coordinators.clientLeaderServers[i], &nomineeChange, &nominees[i], hostname));
-		}
-		allActors = waitForAll(actors);
-
-		loop {
-			Optional<std::pair<LeaderInfo, bool>> leader = getLeader(nominees);
-			TraceEvent("MonitorLeaderChange")
-			    .detail("NewLeader", leader.present() ? leader.get().first.changeID : UID(1, 1));
-			if (leader.present()) {
-				if (leader.get().first.forward) {
-					TraceEvent("MonitorLeaderForwarding")
-					    .detail("NewConnStr", leader.get().first.serializedInfo.toString())
-					    .detail("OldConnStr", info.intermediateConnRecord->getConnectionString().toString())
-					    .trackLatest("MonitorLeaderForwarding");
-					info.intermediateConnRecord = connRecord->makeIntermediateRecord(
-					    ClusterConnectionString(leader.get().first.serializedInfo.toString()));
-					return info;
-				}
-				if (connRecord != info.intermediateConnRecord) {
-					if (!info.hasConnected) {
-						TraceEvent(SevWarnAlways, "IncorrectClusterFileContentsAtConnection")
-						    .detail("ClusterFile", connRecord->toString())
-						    .detail("StoredConnectionString", connRecord->getConnectionString().toString())
-						    .detail("CurrentConnectionString",
-						            info.intermediateConnRecord->getConnectionString().toString());
-					}
-					connRecord->setAndPersistConnectionString(info.intermediateConnRecord->getConnectionString());
-					info.intermediateConnRecord = connRecord;
-				}
-
-				info.hasConnected = true;
-				connRecord->notifyConnected();
-
-				outSerializedLeaderInfo->set(leader.get().first.serializedInfo);
-			}
-			try {
-				wait(nomineeChange.onTrigger() || allActors);
-			} catch (Error& e) {
-				if (e.code() == error_code_coordinators_changed) {
-					TraceEvent("MonitorLeaderCoordinatorsChanged").suppressFor(1.0);
-					connRecord->getConnectionString().resetToUnresolved();
-					break;
-				} else {
-					throw e;
-				}
+		Optional<std::pair<LeaderInfo, bool>> leader = getLeader(nominees);
+		TraceEvent("MonitorLeaderChange")
+		    .detail("NewLeader", leader.present() ? leader.get().first.changeID : UID(1, 1));
+		if (leader.present()) {
+			if (leader.get().first.forward) {
+				TraceEvent("MonitorLeaderForwarding")
+				    .detail("NewConnStr", leader.get().first.serializedInfo.toString())
+				    .detail("OldConnStr", info.intermediateConnRecord->getConnectionString().toString())
+				    .trackLatest("MonitorLeaderForwarding");
+				info.intermediateConnRecord = connRecord->makeIntermediateRecord(
+				    ClusterConnectionString(leader.get().first.serializedInfo.toString()));
+				return info;
 			}
+			if (connRecord != info.intermediateConnRecord) {
+				if (!info.hasConnected) {
+					TraceEvent(SevWarnAlways, "IncorrectClusterFileContentsAtConnection")
+					    .detail("ClusterFile", connRecord->toString())
+					    .detail("StoredConnectionString", connRecord->getConnectionString().toString())
+					    .detail("CurrentConnectionString",
+					            info.intermediateConnRecord->getConnectionString().toString());
+				}
+				connRecord->setAndPersistConnectionString(info.intermediateConnRecord->getConnectionString());
+				info.intermediateConnRecord = connRecord;
+			}
+
+			info.hasConnected = true;
+			connRecord->notifyConnected();
+
+			outSerializedLeaderInfo->set(leader.get().first.serializedInfo);
 		}
+		wait(nomineeChange.onTrigger() || allActors);
 	}
 }
 
@@ -885,10 +759,10 @@ ACTOR Future<Void> getClientInfoFromLeader(Reference<AsyncVar<Optional<ClusterCo
 }
 
 ACTOR Future<Void> monitorLeaderAndGetClientInfo(Key clusterKey,
+                                                 std::vector<Hostname> hostnames,
                                                  std::vector<NetworkAddress> coordinators,
                                                  ClientData* clientData,
-                                                 Reference<AsyncVar<Optional<LeaderInfo>>> leaderInfo,
-                                                 Reference<AsyncVar<Void>> coordinatorsChanged) {
+                                                 Reference<AsyncVar<Optional<LeaderInfo>>> leaderInfo) {
 	state std::vector<ClientLeaderRegInterface> clientLeaderServers;
 	state AsyncTrigger nomineeChange;
 	state std::vector<Optional<LeaderInfo>> nominees;
@@ -896,8 +770,12 @@ ACTOR Future<Void> monitorLeaderAndGetClientInfo(Key clusterKey,
 	state Reference<AsyncVar<Optional<ClusterControllerClientInterface>>> knownLeader(
 	    new AsyncVar<Optional<ClusterControllerClientInterface>>{});
 
-	for (auto s = coordinators.begin(); s != coordinators.end(); ++s) {
-		clientLeaderServers.push_back(ClientLeaderRegInterface(*s));
+	clientLeaderServers.reserve(hostnames.size() + coordinators.size());
+	for (auto h : hostnames) {
+		clientLeaderServers.push_back(ClientLeaderRegInterface(h));
+	}
+	for (auto s : coordinators) {
+		clientLeaderServers.push_back(ClientLeaderRegInterface(s));
 	}
 
 	nominees.resize(clientLeaderServers.size());
@@ -936,14 +814,7 @@ ACTOR Future<Void> monitorLeaderAndGetClientInfo(Key clusterKey,
 				leaderInfo->set(leader.get().first);
 			}
 		}
-		try {
-			wait(nomineeChange.onTrigger() || allActors);
-		} catch (Error& e) {
-			if (e.code() == error_code_coordinators_changed) {
-				coordinatorsChanged->trigger();
-			}
-			throw e;
-		}
+		wait(nomineeChange.onTrigger() || allActors);
 	}
 }
 
@@ -995,7 +866,8 @@ ACTOR Future<MonitorLeaderInfo> monitorProxiesOneGeneration(
     Reference<ReferencedObject<Standalone<VectorRef<ClientVersionRef>>>> supportedVersions,
     Key traceLogGroup) {
 	state ClusterConnectionString cs = info.intermediateConnRecord->getConnectionString();
-	state std::vector<NetworkAddress> addrs = cs.coordinators();
+	state std::vector<Hostname> hostnames = cs.hostnames;
+	state int coordinatorsSize = hostnames.size() + cs.coordinators().size();
 	state int index = 0;
 	state int successIndex = 0;
 	state Optional<double> incorrectTime;
@@ -1003,15 +875,26 @@ ACTOR Future<MonitorLeaderInfo> monitorProxiesOneGeneration(
 	state std::vector<CommitProxyInterface> lastCommitProxies;
 	state std::vector<UID> lastGrvProxyUIDs;
 	state std::vector<GrvProxyInterface> lastGrvProxies;
+	state std::vector<ClientLeaderRegInterface> clientLeaderServers;
+
+	clientLeaderServers.reserve(coordinatorsSize);
+	for (const auto& h : hostnames) {
+		clientLeaderServers.push_back(ClientLeaderRegInterface(h));
+	}
+	for (const auto& c : cs.coordinators()) {
+		clientLeaderServers.push_back(ClientLeaderRegInterface(c));
+	}
+
+	deterministicRandom()->randomShuffle(clientLeaderServers);
 
-	deterministicRandom()->randomShuffle(addrs);
 	loop {
-		state ClientLeaderRegInterface clientLeaderServer(addrs[index]);
+		state ClientLeaderRegInterface clientLeaderServer = clientLeaderServers[index];
 		state OpenDatabaseCoordRequest req;
 
 		coordinator->set(clientLeaderServer);
 
 		req.clusterKey = cs.clusterKey();
+		req.hostnames = hostnames;
 		req.coordinators = cs.coordinators();
 		req.knownClientInfoID = clientInfo->get().id;
 		req.supportedVersions = supportedVersions->get();
@@ -1040,8 +923,16 @@ ACTOR Future<MonitorLeaderInfo> monitorProxiesOneGeneration(
 			incorrectTime = Optional<double>();
 		}
 
-		state ErrorOr<CachedSerialization<ClientDBInfo>> rep =
-		    wait(clientLeaderServer.openDatabase.tryGetReply(req, TaskPriority::CoordinationReply));
+		state ErrorOr<CachedSerialization<ClientDBInfo>> rep;
+		if (clientLeaderServer.hostname.present()) {
+			wait(store(rep,
+			           tryGetReplyFromHostname(req,
+			                                   clientLeaderServer.hostname.get(),
+			                                   WLTOKEN_CLIENTLEADERREG_OPENDATABASE,
+			                                   TaskPriority::CoordinationReply)));
+		} else {
+			wait(store(rep, clientLeaderServer.openDatabase.tryGetReply(req, TaskPriority::CoordinationReply)));
+		}
 		if (rep.present()) {
 			if (rep.get().read().forward.present()) {
 				TraceEvent("MonitorProxiesForwarding")
@@ -1072,15 +963,10 @@ ACTOR Future<MonitorLeaderInfo> monitorProxiesOneGeneration(
 			successIndex = index;
 		} else {
 			TEST(rep.getError().code() == error_code_failed_to_progress); // Coordinator cant talk to cluster controller
-			if (rep.getError().code() == error_code_coordinators_changed) {
-				throw coordinators_changed();
-			}
-			index = (index + 1) % addrs.size();
+			TEST(rep.getError().code() == error_code_lookup_failed); // Coordinator hostname resolving failure
+			index = (index + 1) % coordinatorsSize;
 			if (index == successIndex) {
 				wait(delay(CLIENT_KNOBS->COORDINATOR_RECONNECTION_DELAY));
-				// When the client fails talking to all coordinators, we throw coordinators_changed() and let the caller
-				// re-resolve the connection string and retry.
-				throw coordinators_changed();
 			}
 		}
 	}
@@ -1092,27 +978,16 @@ ACTOR Future<Void> monitorProxies(
     Reference<AsyncVar<Optional<ClientLeaderRegInterface>>> coordinator,
     Reference<ReferencedObject<Standalone<VectorRef<ClientVersionRef>>>> supportedVersions,
     Key traceLogGroup) {
-	wait(connRecord->get()->resolveHostnames());
 	state MonitorLeaderInfo info(connRecord->get());
 	loop {
-		try {
-			wait(info.intermediateConnRecord->resolveHostnames());
-			choose {
-				when(MonitorLeaderInfo _info = wait(monitorProxiesOneGeneration(
-				         connRecord->get(), clientInfo, coordinator, info, supportedVersions, traceLogGroup))) {
-					info = _info;
-				}
-				when(wait(connRecord->onChange())) {
-					info.hasConnected = false;
-					info.intermediateConnRecord = connRecord->get();
-				}
+		choose {
+			when(MonitorLeaderInfo _info = wait(monitorProxiesOneGeneration(
+			         connRecord->get(), clientInfo, coordinator, info, supportedVersions, traceLogGroup))) {
+				info = _info;
 			}
-		} catch (Error& e) {
-			if (e.code() == error_code_coordinators_changed) {
-				TraceEvent("MonitorProxiesCoordinatorsChanged").suppressFor(1.0);
-				info.intermediateConnRecord->getConnectionString().resetToUnresolved();
-			} else {
-				throw e;
+			when(wait(connRecord->onChange())) {
+				info.hasConnected = false;
+				info.intermediateConnRecord = connRecord->get();
 			}
 		}
 	}
diff --git a/fdbclient/MonitorLeader.h b/fdbclient/MonitorLeader.h
index 6ceed69a63..8819b5702b 100644
--- a/fdbclient/MonitorLeader.h
+++ b/fdbclient/MonitorLeader.h
@@ -75,10 +75,10 @@ Future<Void> monitorLeader(Reference<IClusterConnectionRecord> const& connFile,
 // nominees, the nominee with the most nomination is the leader, and collects client data from the leader. This function
 // also monitors the change of the leader.
 Future<Void> monitorLeaderAndGetClientInfo(Key const& clusterKey,
+                                           std::vector<Hostname> const& hostnames,
                                            std::vector<NetworkAddress> const& coordinators,
                                            ClientData* const& clientData,
-                                           Reference<AsyncVar<Optional<LeaderInfo>>> const& leaderInfo,
-                                           Reference<AsyncVar<Void>> const& coordinatorsChanged);
+                                           Reference<AsyncVar<Optional<LeaderInfo>>> const& leaderInfo);
 
 Future<Void> monitorProxies(
     Reference<AsyncVar<Reference<IClusterConnectionRecord>>> const& connRecord,
diff --git a/fdbclient/NativeAPI.actor.cpp b/fdbclient/NativeAPI.actor.cpp
index 61c68bc18e..ec8409ac91 100644
--- a/fdbclient/NativeAPI.actor.cpp
+++ b/fdbclient/NativeAPI.actor.cpp
@@ -6927,11 +6927,18 @@ Future<Standalone<StringRef>> Transaction::getVersionstamp() {
 }
 
 // Gets the protocol version reported by a coordinator via the protocol info interface
-ACTOR Future<ProtocolVersion> getCoordinatorProtocol(NetworkAddressList coordinatorAddresses) {
-	RequestStream<ProtocolInfoRequest> requestStream{ Endpoint::wellKnown({ coordinatorAddresses },
-		                                                                  WLTOKEN_PROTOCOL_INFO) };
-	ProtocolInfoReply reply = wait(retryBrokenPromise(requestStream, ProtocolInfoRequest{}));
-
+ACTOR Future<ProtocolVersion> getCoordinatorProtocol(
+    Reference<AsyncVar<Optional<ClientLeaderRegInterface>> const> coordinator) {
+	state ProtocolInfoReply reply;
+	if (coordinator->get().get().hostname.present()) {
+		wait(store(reply,
+		           retryGetReplyFromHostname(
+		               ProtocolInfoRequest{}, coordinator->get().get().hostname.get(), WLTOKEN_PROTOCOL_INFO)));
+	} else {
+		RequestStream<ProtocolInfoRequest> requestStream(
+		    Endpoint::wellKnown({ coordinator->get().get().getLeader.getEndpoint().addresses }, WLTOKEN_PROTOCOL_INFO));
+		wait(store(reply, retryBrokenPromise(requestStream, ProtocolInfoRequest{})));
+	}
 	return reply.version;
 }
 
@@ -6940,8 +6947,16 @@ ACTOR Future<ProtocolVersion> getCoordinatorProtocol(NetworkAddressList coordina
 // function will return with an unset result.
 // If an expected version is given, this future won't return if the actual protocol version matches the expected version
 ACTOR Future<Optional<ProtocolVersion>> getCoordinatorProtocolFromConnectPacket(
-    NetworkAddress coordinatorAddress,
+    Reference<AsyncVar<Optional<ClientLeaderRegInterface>> const> coordinator,
     Optional<ProtocolVersion> expectedVersion) {
+	state NetworkAddress coordinatorAddress;
+	if (coordinator->get().get().hostname.present()) {
+		Hostname h = coordinator->get().get().hostname.get();
+		wait(store(coordinatorAddress, h.resolveWithRetry()));
+	} else {
+		coordinatorAddress = coordinator->get().get().getLeader.getEndpoint().getPrimaryAddress();
+	}
+
 	state Reference<AsyncVar<Optional<ProtocolVersion>> const> protocolVersion =
 	    FlowTransport::transport().getPeerProtocolAsyncVar(coordinatorAddress);
 
@@ -6976,11 +6991,10 @@ ACTOR Future<ProtocolVersion> getClusterProtocolImpl(
 		if (!coordinator->get().present()) {
 			wait(coordinator->onChange());
 		} else {
-			Endpoint coordinatorEndpoint = coordinator->get().get().getLeader.getEndpoint();
 			if (needToConnect) {
 				// Even though we typically rely on the connect packet to get the protocol version, we need to send some
 				// request in order to start a connection. This protocol version request serves that purpose.
-				protocolVersion = getCoordinatorProtocol(coordinatorEndpoint.addresses);
+				protocolVersion = getCoordinatorProtocol(coordinator);
 				needToConnect = false;
 			}
 			choose {
@@ -6996,8 +7010,8 @@ ACTOR Future<ProtocolVersion> getClusterProtocolImpl(
 
 				// Older versions of FDB don't have an endpoint to return the protocol version, so we get this info from
 				// the connect packet
-				when(Optional<ProtocolVersion> pv = wait(getCoordinatorProtocolFromConnectPacket(
-				         coordinatorEndpoint.getPrimaryAddress(), expectedVersion))) {
+				when(Optional<ProtocolVersion> pv =
+				         wait(getCoordinatorProtocolFromConnectPacket(coordinator, expectedVersion))) {
 					if (pv.present()) {
 						return pv.get();
 					} else {
@@ -8171,14 +8185,20 @@ ACTOR Future<bool> checkSafeExclusions(Database cx, std::vector<AddressExclusion
 		throw;
 	}
 	TraceEvent("ExclusionSafetyCheckCoordinators").log();
-	wait(cx->getConnectionRecord()->resolveHostnames());
 	state ClientCoordinators coordinatorList(cx->getConnectionRecord());
 	state std::vector<Future<Optional<LeaderInfo>>> leaderServers;
 	leaderServers.reserve(coordinatorList.clientLeaderServers.size());
 	for (int i = 0; i < coordinatorList.clientLeaderServers.size(); i++) {
-		leaderServers.push_back(retryBrokenPromise(coordinatorList.clientLeaderServers[i].getLeader,
-		                                           GetLeaderRequest(coordinatorList.clusterKey, UID()),
-		                                           TaskPriority::CoordinationReply));
+		if (coordinatorList.clientLeaderServers[i].hostname.present()) {
+			leaderServers.push_back(retryGetReplyFromHostname(GetLeaderRequest(coordinatorList.clusterKey, UID()),
+			                                                  coordinatorList.clientLeaderServers[i].hostname.get(),
+			                                                  WLTOKEN_CLIENTLEADERREG_GETLEADER,
+			                                                  TaskPriority::CoordinationReply));
+		} else {
+			leaderServers.push_back(retryBrokenPromise(coordinatorList.clientLeaderServers[i].getLeader,
+			                                           GetLeaderRequest(coordinatorList.clusterKey, UID()),
+			                                           TaskPriority::CoordinationReply));
+		}
 	}
 	// Wait for quorum so we don't dismiss live coordinators as unreachable by acting too fast
 	choose {
diff --git a/fdbclient/PaxosConfigTransaction.actor.cpp b/fdbclient/PaxosConfigTransaction.actor.cpp
index b6fc75fec9..50ebbd1a4c 100644
--- a/fdbclient/PaxosConfigTransaction.actor.cpp
+++ b/fdbclient/PaxosConfigTransaction.actor.cpp
@@ -59,8 +59,14 @@ class CommitQuorum {
 	                                          ConfigGeneration generation,
 	                                          ConfigTransactionInterface cti) {
 		try {
-			wait(timeoutError(cti.commit.getReply(self->getCommitRequest(generation)),
-			                  CLIENT_KNOBS->COMMIT_QUORUM_TIMEOUT));
+			if (cti.hostname.present()) {
+				wait(timeoutError(retryGetReplyFromHostname(
+				                      self->getCommitRequest(generation), cti.hostname.get(), WLTOKEN_CONFIGTXN_COMMIT),
+				                  CLIENT_KNOBS->COMMIT_QUORUM_TIMEOUT));
+			} else {
+				wait(timeoutError(cti.commit.getReply(self->getCommitRequest(generation)),
+				                  CLIENT_KNOBS->COMMIT_QUORUM_TIMEOUT));
+			}
 			++self->successful;
 		} catch (Error& e) {
 			// self might be destroyed if this actor is cancelled
@@ -122,9 +128,20 @@ class GetGenerationQuorum {
 	ACTOR static Future<Void> addRequestActor(GetGenerationQuorum* self, ConfigTransactionInterface cti) {
 		loop {
 			try {
-				ConfigTransactionGetGenerationReply reply = wait(timeoutError(
-				    cti.getGeneration.getReply(ConfigTransactionGetGenerationRequest{ self->lastSeenLiveVersion }),
-				    CLIENT_KNOBS->GET_GENERATION_QUORUM_TIMEOUT));
+				state ConfigTransactionGetGenerationReply reply;
+				if (cti.hostname.present()) {
+					wait(timeoutError(store(reply,
+					                        retryGetReplyFromHostname(
+					                            ConfigTransactionGetGenerationRequest{ self->lastSeenLiveVersion },
+					                            cti.hostname.get(),
+					                            WLTOKEN_CONFIGTXN_GETGENERATION)),
+					                  CLIENT_KNOBS->GET_GENERATION_QUORUM_TIMEOUT));
+				} else {
+					wait(timeoutError(store(reply,
+					                        cti.getGeneration.getReply(
+					                            ConfigTransactionGetGenerationRequest{ self->lastSeenLiveVersion })),
+					                  CLIENT_KNOBS->GET_GENERATION_QUORUM_TIMEOUT));
+				}
 
 				++self->totalRepliesReceived;
 				auto gen = reply.generation;
@@ -225,9 +242,18 @@ class PaxosConfigTransactionImpl {
 		state ConfigKey configKey = ConfigKey::decodeKey(key);
 		loop {
 			try {
-				ConfigGeneration generation = wait(self->getGenerationQuorum.getGeneration());
-				state Reference<ConfigTransactionInfo> configNodes(
-				    new ConfigTransactionInfo(self->getGenerationQuorum.getReadReplicas()));
+				state ConfigGeneration generation = wait(self->getGenerationQuorum.getGeneration());
+				state std::vector<ConfigTransactionInterface> readReplicas =
+				    self->getGenerationQuorum.getReadReplicas();
+				std::vector<Future<Void>> fs;
+				for (ConfigTransactionInterface& readReplica : readReplicas) {
+					if (readReplica.hostname.present()) {
+						fs.push_back(tryInitializeRequestStream(
+						    &readReplica.get, readReplica.hostname.get(), WLTOKEN_CONFIGTXN_GET));
+					}
+				}
+				wait(waitForAll(fs));
+				state Reference<ConfigTransactionInfo> configNodes(new ConfigTransactionInfo(readReplicas));
 				ConfigTransactionGetReply reply =
 				    wait(timeoutError(basicLoadBalance(configNodes,
 				                                       &ConfigTransactionInterface::get,
@@ -248,9 +274,17 @@ class PaxosConfigTransactionImpl {
 	}
 
 	ACTOR static Future<RangeResult> getConfigClasses(PaxosConfigTransactionImpl* self) {
-		ConfigGeneration generation = wait(self->getGenerationQuorum.getGeneration());
-		state Reference<ConfigTransactionInfo> configNodes(
-		    new ConfigTransactionInfo(self->getGenerationQuorum.getReadReplicas()));
+		state ConfigGeneration generation = wait(self->getGenerationQuorum.getGeneration());
+		state std::vector<ConfigTransactionInterface> readReplicas = self->getGenerationQuorum.getReadReplicas();
+		std::vector<Future<Void>> fs;
+		for (ConfigTransactionInterface& readReplica : readReplicas) {
+			if (readReplica.hostname.present()) {
+				fs.push_back(tryInitializeRequestStream(
+				    &readReplica.getClasses, readReplica.hostname.get(), WLTOKEN_CONFIGTXN_GETCLASSES));
+			}
+		}
+		wait(waitForAll(fs));
+		state Reference<ConfigTransactionInfo> configNodes(new ConfigTransactionInfo(readReplicas));
 		ConfigTransactionGetConfigClassesReply reply =
 		    wait(basicLoadBalance(configNodes,
 		                          &ConfigTransactionInterface::getClasses,
@@ -264,9 +298,17 @@ class PaxosConfigTransactionImpl {
 	}
 
 	ACTOR static Future<RangeResult> getKnobs(PaxosConfigTransactionImpl* self, Optional<Key> configClass) {
-		ConfigGeneration generation = wait(self->getGenerationQuorum.getGeneration());
-		state Reference<ConfigTransactionInfo> configNodes(
-		    new ConfigTransactionInfo(self->getGenerationQuorum.getReadReplicas()));
+		state ConfigGeneration generation = wait(self->getGenerationQuorum.getGeneration());
+		state std::vector<ConfigTransactionInterface> readReplicas = self->getGenerationQuorum.getReadReplicas();
+		std::vector<Future<Void>> fs;
+		for (ConfigTransactionInterface& readReplica : readReplicas) {
+			if (readReplica.hostname.present()) {
+				fs.push_back(tryInitializeRequestStream(
+				    &readReplica.getKnobs, readReplica.hostname.get(), WLTOKEN_CONFIGTXN_GETKNOBS));
+			}
+		}
+		wait(waitForAll(fs));
+		state Reference<ConfigTransactionInfo> configNodes(new ConfigTransactionInfo(readReplicas));
 		ConfigTransactionGetKnobsReply reply =
 		    wait(basicLoadBalance(configNodes,
 		                          &ConfigTransactionInterface::getKnobs,
@@ -366,10 +408,13 @@ public:
 	Future<Void> commit() { return commit(this); }
 
 	PaxosConfigTransactionImpl(Database const& cx) : cx(cx) {
-		auto coordinators = cx->getConnectionRecord()->getConnectionString().coordinators();
-		ctis.reserve(coordinators.size());
-		for (const auto& coordinator : coordinators) {
-			ctis.emplace_back(coordinator);
+		const ClusterConnectionString& cs = cx->getConnectionRecord()->getConnectionString();
+		ctis.reserve(cs.hostnames.size() + cs.coordinators().size());
+		for (const auto& h : cs.hostnames) {
+			ctis.emplace_back(h);
+		}
+		for (const auto& c : cs.coordinators()) {
+			ctis.emplace_back(c);
 		}
 		getGenerationQuorum = GetGenerationQuorum{ ctis };
 		commitQuorum = CommitQuorum{ ctis };
diff --git a/fdbclient/SimpleConfigTransaction.actor.cpp b/fdbclient/SimpleConfigTransaction.actor.cpp
index ecb8380d4c..2e71cd73c4 100644
--- a/fdbclient/SimpleConfigTransaction.actor.cpp
+++ b/fdbclient/SimpleConfigTransaction.actor.cpp
@@ -41,9 +41,15 @@ class SimpleConfigTransactionImpl {
 		if (self->dID.present()) {
 			TraceEvent("SimpleConfigTransactionGettingReadVersion", self->dID.get());
 		}
-		ConfigTransactionGetGenerationRequest req;
-		ConfigTransactionGetGenerationReply reply =
-		    wait(retryBrokenPromise(self->cti.getGeneration, ConfigTransactionGetGenerationRequest{}));
+		state ConfigTransactionGetGenerationReply reply;
+		if (self->cti.hostname.present()) {
+			wait(store(reply,
+			           retryGetReplyFromHostname(ConfigTransactionGetGenerationRequest{},
+			                                     self->cti.hostname.get(),
+			                                     WLTOKEN_CONFIGTXN_GETGENERATION)));
+		} else {
+			wait(store(reply, retryBrokenPromise(self->cti.getGeneration, ConfigTransactionGetGenerationRequest{})));
+		}
 		if (self->dID.present()) {
 			TraceEvent("SimpleConfigTransactionGotReadVersion", self->dID.get())
 			    .detail("Version", reply.generation.liveVersion);
@@ -62,8 +68,15 @@ class SimpleConfigTransactionImpl {
 			    .detail("ConfigClass", configKey.configClass)
 			    .detail("KnobName", configKey.knobName);
 		}
-		ConfigTransactionGetReply reply =
-		    wait(retryBrokenPromise(self->cti.get, ConfigTransactionGetRequest{ generation, configKey }));
+		state ConfigTransactionGetReply reply;
+		if (self->cti.hostname.present()) {
+			wait(store(reply,
+			           retryGetReplyFromHostname(ConfigTransactionGetRequest{ generation, configKey },
+			                                     self->cti.hostname.get(),
+			                                     WLTOKEN_CONFIGTXN_GET)));
+		} else {
+			wait(store(reply, retryBrokenPromise(self->cti.get, ConfigTransactionGetRequest{ generation, configKey })));
+		}
 		if (self->dID.present()) {
 			TraceEvent("SimpleConfigTransactionGotValue", self->dID.get())
 			    .detail("Value", reply.value.get().toString());
@@ -80,8 +93,17 @@ class SimpleConfigTransactionImpl {
 			self->getGenerationFuture = getGeneration(self);
 		}
 		ConfigGeneration generation = wait(self->getGenerationFuture);
-		ConfigTransactionGetConfigClassesReply reply =
-		    wait(retryBrokenPromise(self->cti.getClasses, ConfigTransactionGetConfigClassesRequest{ generation }));
+		state ConfigTransactionGetConfigClassesReply reply;
+		if (self->cti.hostname.present()) {
+			wait(store(reply,
+			           retryGetReplyFromHostname(ConfigTransactionGetConfigClassesRequest{ generation },
+			                                     self->cti.hostname.get(),
+			                                     WLTOKEN_CONFIGTXN_GETCLASSES)));
+		} else {
+			wait(store(
+			    reply,
+			    retryBrokenPromise(self->cti.getClasses, ConfigTransactionGetConfigClassesRequest{ generation })));
+		}
 		RangeResult result;
 		for (const auto& configClass : reply.configClasses) {
 			result.push_back_deep(result.arena(), KeyValueRef(configClass, ""_sr));
@@ -94,8 +116,17 @@ class SimpleConfigTransactionImpl {
 			self->getGenerationFuture = getGeneration(self);
 		}
 		ConfigGeneration generation = wait(self->getGenerationFuture);
-		ConfigTransactionGetKnobsReply reply =
-		    wait(retryBrokenPromise(self->cti.getKnobs, ConfigTransactionGetKnobsRequest{ generation, configClass }));
+		state ConfigTransactionGetKnobsReply reply;
+		if (self->cti.hostname.present()) {
+			wait(store(reply,
+			           retryGetReplyFromHostname(ConfigTransactionGetKnobsRequest{ generation, configClass },
+			                                     self->cti.hostname.get(),
+			                                     WLTOKEN_CONFIGTXN_GETKNOBS)));
+		} else {
+			wait(store(
+			    reply,
+			    retryBrokenPromise(self->cti.getKnobs, ConfigTransactionGetKnobsRequest{ generation, configClass })));
+		}
 		RangeResult result;
 		for (const auto& knobName : reply.knobNames) {
 			result.push_back_deep(result.arena(), KeyValueRef(knobName, ""_sr));
@@ -109,7 +140,11 @@ class SimpleConfigTransactionImpl {
 		}
 		wait(store(self->toCommit.generation, self->getGenerationFuture));
 		self->toCommit.annotation.timestamp = now();
-		wait(retryBrokenPromise(self->cti.commit, self->toCommit));
+		if (self->cti.hostname.present()) {
+			wait(retryGetReplyFromHostname(self->toCommit, self->cti.hostname.get(), WLTOKEN_CONFIGTXN_COMMIT));
+		} else {
+			wait(retryBrokenPromise(self->cti.commit, self->toCommit));
+		}
 		self->committed = true;
 		return Void();
 	}
@@ -126,9 +161,14 @@ class SimpleConfigTransactionImpl {
 
 public:
 	SimpleConfigTransactionImpl(Database const& cx) : cx(cx) {
-		auto coordinators = cx->getConnectionRecord()->getConnectionString().coordinators();
-		std::sort(coordinators.begin(), coordinators.end());
-		cti = ConfigTransactionInterface(coordinators[0]);
+		const ClusterConnectionString& cs = cx->getConnectionRecord()->getConnectionString();
+		if (cs.coordinators().size()) {
+			std::vector<NetworkAddress> coordinators = cs.coordinators();
+			std::sort(coordinators.begin(), coordinators.end());
+			cti = ConfigTransactionInterface(coordinators[0]);
+		} else {
+			cti = ConfigTransactionInterface(cs.hostnames[0]);
+		}
 	}
 
 	SimpleConfigTransactionImpl(ConfigTransactionInterface const& cti) : cti(cti) {}
diff --git a/fdbclient/SpecialKeySpace.actor.cpp b/fdbclient/SpecialKeySpace.actor.cpp
index 7c95e3aa02..f018c0fc2b 100644
--- a/fdbclient/SpecialKeySpace.actor.cpp
+++ b/fdbclient/SpecialKeySpace.actor.cpp
@@ -1644,13 +1644,10 @@ void TracingOptionsImpl::clear(ReadYourWritesTransaction* ryw, const KeyRef& key
 
 CoordinatorsImpl::CoordinatorsImpl(KeyRangeRef kr) : SpecialKeyRangeRWImpl(kr) {}
 
-Future<RangeResult> CoordinatorsImpl::getRange(ReadYourWritesTransaction* ryw,
-                                               KeyRangeRef kr,
-                                               GetRangeLimits limitsHint) const {
+ACTOR Future<RangeResult> coordinatorsGetRangeActor(ReadYourWritesTransaction* ryw, KeyRef prefix, KeyRangeRef kr) {
+	state ClusterConnectionString cs = ryw->getDatabase()->getConnectionRecord()->getConnectionString();
+	state std::vector<NetworkAddress> coordinator_processes = wait(cs.tryResolveHostnames());
 	RangeResult result;
-	KeyRef prefix(getKeyRange().begin);
-	auto cs = ryw->getDatabase()->getConnectionRecord()->getConnectionString();
-	auto coordinator_processes = cs.coordinators();
 	Key cluster_decription_key = prefix.withSuffix(LiteralStringRef("cluster_description"));
 	if (kr.contains(cluster_decription_key)) {
 		result.push_back_deep(result.arena(), KeyValueRef(cluster_decription_key, cs.clusterKeyName()));
@@ -1673,10 +1670,16 @@ Future<RangeResult> CoordinatorsImpl::getRange(ReadYourWritesTransaction* ryw,
 	return rywGetRange(ryw, kr, result);
 }
 
+Future<RangeResult> CoordinatorsImpl::getRange(ReadYourWritesTransaction* ryw,
+                                               KeyRangeRef kr,
+                                               GetRangeLimits limitsHint) const {
+	KeyRef prefix(getKeyRange().begin);
+	return coordinatorsGetRangeActor(ryw, prefix, kr);
+}
+
 ACTOR static Future<Optional<std::string>> coordinatorsCommitActor(ReadYourWritesTransaction* ryw, KeyRangeRef kr) {
 	state Reference<IQuorumChange> change;
-	state ClusterConnectionString
-	    conn; // We don't care about the Key here, it will be overrode in changeQuorumChecker().
+	state ClusterConnectionString conn; // We don't care about the Key here.
 	state std::vector<std::string> process_address_or_hostname_strs;
 	state Optional<std::string> msg;
 	state int index;
@@ -1700,7 +1703,6 @@ ACTOR static Future<Optional<std::string>> coordinatorsCommitActor(ReadYourWrite
 			try {
 				if (Hostname::isHostname(process_address_or_hostname_strs[index])) {
 					conn.hostnames.push_back(Hostname::parse(process_address_or_hostname_strs[index]));
-					conn.status = ClusterConnectionString::ConnectionStringStatus::UNRESOLVED;
 				} else {
 					NetworkAddress a = NetworkAddress::parse(process_address_or_hostname_strs[index]);
 					if (!a.isValid()) {
@@ -1717,18 +1719,19 @@ ACTOR static Future<Optional<std::string>> coordinatorsCommitActor(ReadYourWrite
 			if (parse_error) {
 				std::string error = "ERROR: \'" + process_address_or_hostname_strs[index] +
 				                    "\' is not a valid network endpoint address\n";
-				if (process_address_or_hostname_strs[index].find(":tls") != std::string::npos)
-					error += "        Do not include the `:tls' suffix when naming a process\n";
 				return ManagementAPIError::toJsonString(false, "coordinators", error);
 			}
 		}
 	}
 
-	wait(conn.resolveHostnames());
-	if (conn.coordinators().size())
-		change = specifiedQuorumChange(conn.coordinators());
-	else
+	std::vector<NetworkAddress> addressesVec = wait(conn.tryResolveHostnames());
+	if (addressesVec.size() != conn.hostnames.size() + conn.coordinators().size()) {
+		return ManagementAPIError::toJsonString(false, "coordinators", "One or more hostnames are not resolvable.");
+	} else if (addressesVec.size()) {
+		change = specifiedQuorumChange(addressesVec);
+	} else {
 		change = noQuorumChange();
+	}
 
 	// check update for cluster_description
 	Key cluster_decription_key = LiteralStringRef("cluster_description").withPrefix(kr.begin);
@@ -1740,19 +1743,18 @@ ACTOR static Future<Optional<std::string>> coordinatorsCommitActor(ReadYourWrite
 			change = nameQuorumChange(entry.second.get().toString(), change);
 		} else {
 			// throw the error
-			return Optional<std::string>(ManagementAPIError::toJsonString(
-			    false, "coordinators", "Cluster description must match [A-Za-z0-9_]+"));
+			return ManagementAPIError::toJsonString(
+			    false, "coordinators", "Cluster description must match [A-Za-z0-9_]+");
 		}
 	}
 
 	ASSERT(change.isValid());
 
 	TraceEvent(SevDebug, "SKSChangeCoordinatorsStart")
-	    .detail("NewHostnames", conn.hostnames.size() ? describe(conn.hostnames) : "N/A")
-	    .detail("NewAddresses", describe(conn.coordinators()))
+	    .detail("NewAddresses", describe(addressesVec))
 	    .detail("Description", entry.first ? entry.second.get().toString() : "");
 
-	Optional<CoordinatorsResult> r = wait(changeQuorumChecker(&ryw->getTransaction(), change, &conn));
+	Optional<CoordinatorsResult> r = wait(changeQuorumChecker(&ryw->getTransaction(), change, addressesVec));
 
 	TraceEvent(SevDebug, "SKSChangeCoordinatorsFinish")
 	    .detail("Result", r.present() ? static_cast<int>(r.get()) : -1); // -1 means success
@@ -1804,9 +1806,10 @@ ACTOR static Future<RangeResult> CoordinatorsAutoImplActor(ReadYourWritesTransac
 	state ClusterConnectionString old(currentKey.get().toString());
 	state CoordinatorsResult result = CoordinatorsResult::SUCCESS;
 
+	std::vector<NetworkAddress> oldCoordinators = wait(old.tryResolveHostnames());
 	std::vector<NetworkAddress> _desiredCoordinators = wait(autoQuorumChange()->getDesiredCoordinators(
 	    &tr,
-	    old.coordinators(),
+	    oldCoordinators,
 	    Reference<ClusterConnectionMemoryRecord>(new ClusterConnectionMemoryRecord(old)),
 	    result));
 
diff --git a/fdbclient/StatusClient.actor.cpp b/fdbclient/StatusClient.actor.cpp
index 6b329ba1b9..653b8496e8 100644
--- a/fdbclient/StatusClient.actor.cpp
+++ b/fdbclient/StatusClient.actor.cpp
@@ -307,23 +307,35 @@ ACTOR Future<Optional<StatusObject>> clientCoordinatorsStatusFetcher(Reference<I
                                                                      bool* quorum_reachable,
                                                                      int* coordinatorsFaultTolerance) {
 	try {
-		wait(connRecord->resolveHostnames());
 		state ClientCoordinators coord(connRecord);
 		state StatusObject statusObj;
 
 		state std::vector<Future<Optional<LeaderInfo>>> leaderServers;
 		leaderServers.reserve(coord.clientLeaderServers.size());
-		for (int i = 0; i < coord.clientLeaderServers.size(); i++)
-			leaderServers.push_back(retryBrokenPromise(coord.clientLeaderServers[i].getLeader,
-			                                           GetLeaderRequest(coord.clusterKey, UID()),
-			                                           TaskPriority::CoordinationReply));
+		for (int i = 0; i < coord.clientLeaderServers.size(); i++) {
+			if (coord.clientLeaderServers[i].hostname.present()) {
+				leaderServers.push_back(retryGetReplyFromHostname(GetLeaderRequest(coord.clusterKey, UID()),
+				                                                  coord.clientLeaderServers[i].hostname.get(),
+				                                                  WLTOKEN_CLIENTLEADERREG_GETLEADER,
+				                                                  TaskPriority::CoordinationReply));
+			} else {
+				leaderServers.push_back(retryBrokenPromise(coord.clientLeaderServers[i].getLeader,
+				                                           GetLeaderRequest(coord.clusterKey, UID()),
+				                                           TaskPriority::CoordinationReply));
+			}
+		}
 
 		state std::vector<Future<ProtocolInfoReply>> coordProtocols;
 		coordProtocols.reserve(coord.clientLeaderServers.size());
 		for (int i = 0; i < coord.clientLeaderServers.size(); i++) {
-			RequestStream<ProtocolInfoRequest> requestStream{ Endpoint::wellKnown(
-				{ coord.clientLeaderServers[i].getLeader.getEndpoint().addresses }, WLTOKEN_PROTOCOL_INFO) };
-			coordProtocols.push_back(retryBrokenPromise(requestStream, ProtocolInfoRequest{}));
+			if (coord.clientLeaderServers[i].hostname.present()) {
+				coordProtocols.push_back(retryGetReplyFromHostname(
+				    ProtocolInfoRequest{}, coord.clientLeaderServers[i].hostname.get(), WLTOKEN_PROTOCOL_INFO));
+			} else {
+				RequestStream<ProtocolInfoRequest> requestStream{ Endpoint::wellKnown(
+					{ coord.clientLeaderServers[i].getLeader.getEndpoint().addresses }, WLTOKEN_PROTOCOL_INFO) };
+				coordProtocols.push_back(retryBrokenPromise(requestStream, ProtocolInfoRequest{}));
+			}
 		}
 
 		wait(smartQuorum(leaderServers, leaderServers.size() / 2 + 1, 1.5) &&
@@ -337,8 +349,12 @@ ACTOR Future<Optional<StatusObject>> clientCoordinatorsStatusFetcher(Reference<I
 		int coordinatorsUnavailable = 0;
 		for (int i = 0; i < leaderServers.size(); i++) {
 			StatusObject coordStatus;
-			coordStatus["address"] =
-			    coord.clientLeaderServers[i].getLeader.getEndpoint().getPrimaryAddress().toString();
+			if (coord.clientLeaderServers[i].hostname.present()) {
+				coordStatus["address"] = coord.clientLeaderServers[i].hostname.get().toString();
+			} else {
+				coordStatus["address"] =
+				    coord.clientLeaderServers[i].getLeader.getEndpoint().getPrimaryAddress().toString();
+			}
 
 			if (leaderServers[i].isReady()) {
 				coordStatus["reachable"] = true;
diff --git a/fdbrpc/genericactors.actor.h b/fdbrpc/genericactors.actor.h
index 955d3f913e..05f7c150ee 100644
--- a/fdbrpc/genericactors.actor.h
+++ b/fdbrpc/genericactors.actor.h
@@ -72,6 +72,20 @@ Future<REPLY_TYPE(Req)> retryBrokenPromise(RequestStream<Req, P> to, Req request
 	}
 }
 
+ACTOR template <class Req>
+Future<Void> tryInitializeRequestStream(RequestStream<Req>* stream, Hostname hostname, WellKnownEndpoints token) {
+	Optional<NetworkAddress> address = wait(hostname.resolve());
+	if (!address.present()) {
+		return Void();
+	}
+	if (stream == nullptr) {
+		stream = new RequestStream<Req>(Endpoint::wellKnown({ address.get() }, token));
+	} else {
+		*stream = RequestStream<Req>(Endpoint::wellKnown({ address.get() }, token));
+	}
+	return Void();
+}
+
 ACTOR template <class Req>
 Future<ErrorOr<REPLY_TYPE(Req)>> tryGetReplyFromHostname(Req request, Hostname hostname, WellKnownEndpoints token) {
 	// A wrapper of tryGetReply(request), except that the request is sent to an address resolved from a hostname.
diff --git a/fdbserver/ClusterController.actor.cpp b/fdbserver/ClusterController.actor.cpp
index a8160f82a5..4be2faca3f 100644
--- a/fdbserver/ClusterController.actor.cpp
+++ b/fdbserver/ClusterController.actor.cpp
@@ -1110,10 +1110,10 @@ ACTOR Future<Void> registerWorker(RegisterWorkerRequest req,
 	newPriorityInfo.processClassFitness = newProcessClass.machineClassFitness(ProcessClass::ClusterController);
 
 	bool isCoordinator =
-	    (std::find(coordinatorAddresses.begin(), coordinatorAddresses.end(), req.wi.address()) !=
+	    (std::find(coordinatorAddresses.begin(), coordinatorAddresses.end(), w.address()) !=
 	     coordinatorAddresses.end()) ||
-	    (req.wi.secondaryAddress().present() &&
-	     std::find(coordinatorAddresses.begin(), coordinatorAddresses.end(), req.wi.secondaryAddress().get()) !=
+	    (w.secondaryAddress().present() &&
+	     std::find(coordinatorAddresses.begin(), coordinatorAddresses.end(), w.secondaryAddress().get()) !=
 	         coordinatorAddresses.end());
 
 	for (auto it : req.incompatiblePeers) {
@@ -2481,12 +2481,11 @@ ACTOR Future<Void> workerHealthMonitor(ClusterControllerData* self) {
 	}
 }
 
-ACTOR Future<Void> clusterControllerCore(Reference<IClusterConnectionRecord> connRecord,
-                                         ClusterControllerFullInterface interf,
+ACTOR Future<Void> clusterControllerCore(ClusterControllerFullInterface interf,
                                          Future<Void> leaderFail,
+                                         ServerCoordinators coordinators,
                                          LocalityData locality,
                                          ConfigDBType configDBType) {
-	state ServerCoordinators coordinators(connRecord);
 	state ClusterControllerData self(interf, locality, coordinators);
 	state ConfigBroadcaster configBroadcaster(coordinators, configDBType);
 	state Future<Void> coordinationPingDelay = delay(SERVER_KNOBS->WORKER_COORDINATION_PING_DELAY);
@@ -2621,7 +2620,7 @@ ACTOR Future<Void> replaceInterface(ClusterControllerFullInterface interf) {
 	}
 }
 
-ACTOR Future<Void> clusterController(Reference<IClusterConnectionRecord> connRecord,
+ACTOR Future<Void> clusterController(ServerCoordinators coordinators,
                                      Reference<AsyncVar<Optional<ClusterControllerFullInterface>>> currentCC,
                                      bool hasConnected,
                                      Reference<AsyncVar<ClusterControllerPriorityInfo>> asyncPriorityInfo,
@@ -2632,10 +2631,9 @@ ACTOR Future<Void> clusterController(Reference<IClusterConnectionRecord> connRec
 		state bool inRole = false;
 		cci.initEndpoints();
 		try {
-			wait(connRecord->resolveHostnames());
 			// Register as a possible leader; wait to be elected
 			state Future<Void> leaderFail =
-			    tryBecomeLeader(connRecord, cci, currentCC, hasConnected, asyncPriorityInfo);
+			    tryBecomeLeader(coordinators, cci, currentCC, hasConnected, asyncPriorityInfo);
 			state Future<Void> shouldReplace = replaceInterface(cci);
 
 			while (!currentCC->get().present() || currentCC->get().get() != cci) {
@@ -2654,7 +2652,7 @@ ACTOR Future<Void> clusterController(Reference<IClusterConnectionRecord> connRec
 				startRole(Role::CLUSTER_CONTROLLER, cci.id(), UID());
 				inRole = true;
 
-				wait(clusterControllerCore(connRecord, cci, leaderFail, locality, configDBType));
+				wait(clusterControllerCore(cci, leaderFail, coordinators, locality, configDBType));
 			}
 		} catch (Error& e) {
 			if (inRole)
@@ -2683,7 +2681,8 @@ ACTOR Future<Void> clusterController(Reference<IClusterConnectionRecord> connRec
 	state bool hasConnected = false;
 	loop {
 		try {
-			wait(clusterController(connRecord, currentCC, hasConnected, asyncPriorityInfo, locality, configDBType));
+			ServerCoordinators coordinators(connRecord);
+			wait(clusterController(coordinators, currentCC, hasConnected, asyncPriorityInfo, locality, configDBType));
 			hasConnected = true;
 		} catch (Error& e) {
 			if (e.code() != error_code_coordinators_changed)
diff --git a/fdbserver/ClusterRecovery.actor.cpp b/fdbserver/ClusterRecovery.actor.cpp
index 10ed726809..86e22f7776 100644
--- a/fdbserver/ClusterRecovery.actor.cpp
+++ b/fdbserver/ClusterRecovery.actor.cpp
@@ -537,8 +537,7 @@ ACTOR Future<Void> changeCoordinators(Reference<ClusterRecoveryData> self) {
 		}
 
 		try {
-			state ClusterConnectionString conn(changeCoordinatorsRequest.newConnectionString.toString());
-			wait(conn.resolveHostnames());
+			ClusterConnectionString conn(changeCoordinatorsRequest.newConnectionString.toString());
 			wait(self->cstate.move(conn));
 		} catch (Error& e) {
 			if (e.code() != error_code_actor_cancelled)
diff --git a/fdbserver/CoordinatedState.actor.cpp b/fdbserver/CoordinatedState.actor.cpp
index 7a2c5e028c..72e75bf3be 100644
--- a/fdbserver/CoordinatedState.actor.cpp
+++ b/fdbserver/CoordinatedState.actor.cpp
@@ -26,21 +26,29 @@
 #include "fdbserver/LeaderElection.h"
 #include "flow/actorcompiler.h" // has to be last include
 
-ACTOR Future<GenerationRegReadReply> waitAndSendRead(RequestStream<GenerationRegReadRequest> to,
-                                                     GenerationRegReadRequest req) {
+ACTOR Future<GenerationRegReadReply> waitAndSendRead(GenerationRegInterface stateServer, GenerationRegReadRequest req) {
 	if (SERVER_KNOBS->BUGGIFY_ALL_COORDINATION || BUGGIFY)
 		wait(delay(SERVER_KNOBS->BUGGIFIED_EVENTUAL_CONSISTENCY * deterministicRandom()->random01()));
-	state GenerationRegReadReply reply = wait(retryBrokenPromise(to, req));
+	state GenerationRegReadReply reply;
+	if (stateServer.hostname.present()) {
+		wait(store(reply, retryGetReplyFromHostname(req, stateServer.hostname.get(), WLTOKEN_GENERATIONREG_READ)));
+	} else {
+		wait(store(reply, retryBrokenPromise(stateServer.read, req)));
+	}
 	if (SERVER_KNOBS->BUGGIFY_ALL_COORDINATION || BUGGIFY)
 		wait(delay(SERVER_KNOBS->BUGGIFIED_EVENTUAL_CONSISTENCY * deterministicRandom()->random01()));
 	return reply;
 }
 
-ACTOR Future<UniqueGeneration> waitAndSendWrite(RequestStream<GenerationRegWriteRequest> to,
-                                                GenerationRegWriteRequest req) {
+ACTOR Future<UniqueGeneration> waitAndSendWrite(GenerationRegInterface stateServer, GenerationRegWriteRequest req) {
 	if (SERVER_KNOBS->BUGGIFY_ALL_COORDINATION || BUGGIFY)
 		wait(delay(SERVER_KNOBS->BUGGIFIED_EVENTUAL_CONSISTENCY * deterministicRandom()->random01()));
-	state UniqueGeneration reply = wait(retryBrokenPromise(to, req));
+	state UniqueGeneration reply;
+	if (stateServer.hostname.present()) {
+		wait(store(reply, retryGetReplyFromHostname(req, stateServer.hostname.get(), WLTOKEN_GENERATIONREG_WRITE)));
+	} else {
+		wait(store(reply, retryBrokenPromise(stateServer.write, req)));
+	}
 	if (SERVER_KNOBS->BUGGIFY_ALL_COORDINATION || BUGGIFY)
 		wait(delay(SERVER_KNOBS->BUGGIFIED_EVENTUAL_CONSISTENCY * deterministicRandom()->random01()));
 	return reply;
@@ -152,7 +160,7 @@ struct CoordinatedStateImpl {
 		state std::vector<Future<GenerationRegReadReply>> rep_reply;
 		for (int i = 0; i < replicas.size(); i++) {
 			Future<GenerationRegReadReply> reply =
-			    waitAndSendRead(replicas[i].read, GenerationRegReadRequest(req.key, req.gen));
+			    waitAndSendRead(replicas[i], GenerationRegReadRequest(req.key, req.gen));
 			rep_empty_reply.push_back(nonemptyToNever(reply));
 			rep_reply.push_back(emptyToNever(reply));
 			self->ac.add(success(reply));
@@ -192,8 +200,7 @@ struct CoordinatedStateImpl {
 		state std::vector<GenerationRegInterface>& replicas = self->coordinators.stateServers;
 		state std::vector<Future<UniqueGeneration>> wrep_reply;
 		for (int i = 0; i < replicas.size(); i++) {
-			Future<UniqueGeneration> reply =
-			    waitAndSendWrite(replicas[i].write, GenerationRegWriteRequest(req.kv, req.gen));
+			Future<UniqueGeneration> reply = waitAndSendWrite(replicas[i], GenerationRegWriteRequest(req.kv, req.gen));
 			wrep_reply.push_back(reply);
 			self->ac.add(success(reply));
 		}
diff --git a/fdbserver/Coordination.actor.cpp b/fdbserver/Coordination.actor.cpp
index 53086e5516..a3746c4f5e 100644
--- a/fdbserver/Coordination.actor.cpp
+++ b/fdbserver/Coordination.actor.cpp
@@ -98,12 +98,16 @@ LeaderElectionRegInterface::LeaderElectionRegInterface(INetwork* local) : Client
 }
 
 ServerCoordinators::ServerCoordinators(Reference<IClusterConnectionRecord> ccr) : ClientCoordinators(ccr) {
-	ASSERT(ccr->connectionStringStatus() == ClusterConnectionString::RESOLVED);
 	ClusterConnectionString cs = ccr->getConnectionString();
-	for (auto s = cs.coordinators().begin(); s != cs.coordinators().end(); ++s) {
-		leaderElectionServers.emplace_back(*s);
-		stateServers.emplace_back(*s);
-		configServers.emplace_back(*s);
+	for (auto h : cs.hostnames) {
+		leaderElectionServers.emplace_back(h);
+		stateServers.emplace_back(h);
+		configServers.emplace_back(h);
+	}
+	for (auto s : cs.coordinators()) {
+		leaderElectionServers.emplace_back(s);
+		stateServers.emplace_back(s);
+		configServers.emplace_back(s);
 	}
 }
 
@@ -208,10 +212,8 @@ ACTOR Future<Void> openDatabase(ClientData* db,
                                 int* clientCount,
                                 Reference<AsyncVar<bool>> hasConnectedClients,
                                 OpenDatabaseCoordRequest req,
-                                Future<Void> checkStuck,
-                                Reference<AsyncVar<Void>> coordinatorsChanged) {
+                                Future<Void> checkStuck) {
 	state ErrorOr<CachedSerialization<ClientDBInfo>> replyContents;
-	state Future<Void> coordinatorsChangedOnChange = coordinatorsChanged->onChange();
 	state Future<Void> clientInfoOnChange = db->clientInfo->onChange();
 
 	++(*clientCount);
@@ -233,11 +235,6 @@ ACTOR Future<Void> openDatabase(ClientData* db,
 				clientInfoOnChange = db->clientInfo->onChange();
 				replyContents = db->clientInfo->get();
 			}
-			when(wait(coordinatorsChangedOnChange)) {
-				coordinatorsChangedOnChange = coordinatorsChanged->onChange();
-				replyContents = coordinators_changed();
-				break;
-			}
 			when(wait(delayJittered(SERVER_KNOBS->CLIENT_REGISTER_INTERVAL))) {
 				if (db->clientInfo->get().read().id.isValid()) {
 					replyContents = db->clientInfo->get();
@@ -268,10 +265,7 @@ ACTOR Future<Void> openDatabase(ClientData* db,
 ACTOR Future<Void> remoteMonitorLeader(int* clientCount,
                                        Reference<AsyncVar<bool>> hasConnectedClients,
                                        Reference<AsyncVar<Optional<LeaderInfo>>> currentElectedLeader,
-                                       ElectionResultRequest req,
-                                       Reference<AsyncVar<Void>> coordinatorsChanged) {
-	state bool coordinatorsChangeDetected = false;
-	state Future<Void> coordinatorsChangedOnChange = coordinatorsChanged->onChange();
+                                       ElectionResultRequest req) {
 	state Future<Void> currentElectedLeaderOnChange = currentElectedLeader->onChange();
 	++(*clientCount);
 	hasConnectedClients->set(true);
@@ -281,20 +275,11 @@ ACTOR Future<Void> remoteMonitorLeader(int* clientCount,
 			when(wait(yieldedFuture(currentElectedLeaderOnChange))) {
 				currentElectedLeaderOnChange = currentElectedLeader->onChange();
 			}
-			when(wait(coordinatorsChangedOnChange)) {
-				coordinatorsChangedOnChange = coordinatorsChanged->onChange();
-				coordinatorsChangeDetected = true;
-				break;
-			}
 			when(wait(delayJittered(SERVER_KNOBS->CLIENT_REGISTER_INTERVAL))) { break; }
 		}
 	}
 
-	if (coordinatorsChangeDetected) {
-		req.reply.sendError(coordinators_changed());
-	} else {
-		req.reply.send(currentElectedLeader->get());
-	}
+	req.reply.send(currentElectedLeader->get());
 
 	if (--(*clientCount) == 0) {
 		hasConnectedClients->set(false);
@@ -325,8 +310,6 @@ ACTOR Future<Void> leaderRegister(LeaderElectionRegInterface interf, Key key) {
 	state Reference<AsyncVar<Optional<LeaderInfo>>> currentElectedLeader =
 	    makeReference<AsyncVar<Optional<LeaderInfo>>>();
 	state LivenessChecker canConnectToLeader(SERVER_KNOBS->COORDINATOR_LEADER_CONNECTION_TIMEOUT);
-	state Reference<AsyncVar<Void>> coordinatorsChanged = makeReference<AsyncVar<Void>>();
-	state Future<Void> coordinatorsChangedOnChange = coordinatorsChanged->onChange();
 	state Future<Void> hasConnectedClientsOnChange = hasConnectedClients->onChange();
 
 	loop choose {
@@ -338,14 +321,10 @@ ACTOR Future<Void> leaderRegister(LeaderElectionRegInterface interf, Key key) {
 			} else {
 				if (!leaderMon.isValid()) {
 					leaderMon = monitorLeaderAndGetClientInfo(
-					    req.clusterKey, req.coordinators, &clientData, currentElectedLeader, coordinatorsChanged);
+					    req.clusterKey, req.hostnames, req.coordinators, &clientData, currentElectedLeader);
 				}
-				actors.add(openDatabase(&clientData,
-				                        &clientCount,
-				                        hasConnectedClients,
-				                        req,
-				                        canConnectToLeader.checkStuck(),
-				                        coordinatorsChanged));
+				actors.add(
+				    openDatabase(&clientData, &clientCount, hasConnectedClients, req, canConnectToLeader.checkStuck()));
 			}
 		}
 		when(ElectionResultRequest req = waitNext(interf.electionResult.getFuture())) {
@@ -355,10 +334,9 @@ ACTOR Future<Void> leaderRegister(LeaderElectionRegInterface interf, Key key) {
 			} else {
 				if (!leaderMon.isValid()) {
 					leaderMon = monitorLeaderAndGetClientInfo(
-					    req.key, req.coordinators, &clientData, currentElectedLeader, coordinatorsChanged);
+					    req.key, req.hostnames, req.coordinators, &clientData, currentElectedLeader);
 				}
-				actors.add(remoteMonitorLeader(
-				    &clientCount, hasConnectedClients, currentElectedLeader, req, coordinatorsChanged));
+				actors.add(remoteMonitorLeader(&clientCount, hasConnectedClients, currentElectedLeader, req));
 			}
 		}
 		when(GetLeaderRequest req = waitNext(interf.getLeader.getFuture())) {
@@ -499,10 +477,6 @@ ACTOR Future<Void> leaderRegister(LeaderElectionRegInterface interf, Key key) {
 			}
 		}
 		when(wait(actors.getResult())) {}
-		when(wait(coordinatorsChangedOnChange)) {
-			leaderMon = Future<Void>();
-			coordinatorsChangedOnChange = coordinatorsChanged->onChange();
-		}
 	}
 }
 
diff --git a/fdbserver/CoordinationInterface.h b/fdbserver/CoordinationInterface.h
index b966678cc6..2c8c037afa 100644
--- a/fdbserver/CoordinationInterface.h
+++ b/fdbserver/CoordinationInterface.h
@@ -153,17 +153,21 @@ struct CandidacyRequest {
 struct ElectionResultRequest {
 	constexpr static FileIdentifier file_identifier = 11815465;
 	Key key;
+	std::vector<Hostname> hostnames;
 	std::vector<NetworkAddress> coordinators;
 	UID knownLeader;
 	ReplyPromise<Optional<LeaderInfo>> reply;
 
 	ElectionResultRequest() = default;
-	ElectionResultRequest(Key key, std::vector<NetworkAddress> coordinators, UID knownLeader)
-	  : key(key), coordinators(std::move(coordinators)), knownLeader(knownLeader) {}
+	ElectionResultRequest(Key key,
+	                      std::vector<Hostname> hostnames,
+	                      std::vector<NetworkAddress> coordinators,
+	                      UID knownLeader)
+	  : key(key), hostnames(std::move(hostnames)), coordinators(std::move(coordinators)), knownLeader(knownLeader) {}
 
 	template <class Ar>
 	void serialize(Ar& ar) {
-		serializer(ar, key, coordinators, knownLeader, reply);
+		serializer(ar, key, hostnames, coordinators, knownLeader, reply);
 	}
 };
 
diff --git a/fdbserver/LeaderElection.actor.cpp b/fdbserver/LeaderElection.actor.cpp
index 272e07c1ec..3c23827e71 100644
--- a/fdbserver/LeaderElection.actor.cpp
+++ b/fdbserver/LeaderElection.actor.cpp
@@ -27,44 +27,29 @@
 
 // Keep trying to become a leader by submitting itself to all coordinators.
 // Monitor the health of all coordinators at the same time.
-// Note: for coordinators whose NetworkAddress is parsed out of a hostname, a connection failure will cause this actor
-// to throw `coordinators_changed()` error
 ACTOR Future<Void> submitCandidacy(Key key,
                                    LeaderElectionRegInterface coord,
                                    LeaderInfo myInfo,
                                    UID prevChangeID,
                                    AsyncTrigger* nomineeChange,
-                                   Optional<LeaderInfo>* nominee,
-                                   Optional<Hostname> hostname = Optional<Hostname>()) {
+                                   Optional<LeaderInfo>* nominee) {
 	loop {
 		state Optional<LeaderInfo> li;
-
-		if (coord.candidacy.getEndpoint().getPrimaryAddress().fromHostname) {
-			state ErrorOr<Optional<LeaderInfo>> rep = wait(coord.candidacy.tryGetReply(
-			    CandidacyRequest(key, myInfo, nominee->present() ? nominee->get().changeID : UID(), prevChangeID),
-			    TaskPriority::CoordinationReply));
-			if (rep.isError()) {
-				// Connecting to nominee failed, most likely due to connection failed.
-				TraceEvent("SubmitCandadicyError")
-				    .error(rep.getError())
-				    .detail("Hostname", hostname.present() ? hostname.get().toString() : "UnknownHostname")
-				    .detail("OldAddr", coord.candidacy.getEndpoint().getPrimaryAddress().toString());
-				if (rep.getError().code() == error_code_request_maybe_delivered) {
-					// Delay to prevent tight resolving loop due to outdated DNS cache
-					wait(delay(FLOW_KNOBS->HOSTNAME_RECONNECT_INIT_INTERVAL));
-					throw coordinators_changed();
-				} else {
-					throw rep.getError();
-				}
-			} else if (rep.present()) {
-				li = rep.get();
-			}
+		if (coord.hostname.present()) {
+			wait(store(
+			    li,
+			    retryGetReplyFromHostname(
+			        CandidacyRequest(key, myInfo, nominee->present() ? nominee->get().changeID : UID(), prevChangeID),
+			        coord.hostname.get(),
+			        WLTOKEN_LEADERELECTIONREG_CANDIDACY,
+			        TaskPriority::CoordinationReply)));
 		} else {
-			Optional<LeaderInfo> tmp = wait(retryBrokenPromise(
-			    coord.candidacy,
-			    CandidacyRequest(key, myInfo, nominee->present() ? nominee->get().changeID : UID(), prevChangeID),
-			    TaskPriority::CoordinationReply));
-			li = tmp;
+			wait(store(
+			    li,
+			    retryBrokenPromise(
+			        coord.candidacy,
+			        CandidacyRequest(key, myInfo, nominee->present() ? nominee->get().changeID : UID(), prevChangeID),
+			        TaskPriority::CoordinationReply)));
 		}
 
 		wait(Future<Void>(Void())); // Make sure we weren't cancelled
@@ -104,20 +89,26 @@ Future<Void> buggifyDelayedAsyncVar(Reference<AsyncVar<T>>& var) {
 ACTOR Future<Void> changeLeaderCoordinators(ServerCoordinators coordinators, Value forwardingInfo) {
 	std::vector<Future<Void>> forwardRequests;
 	forwardRequests.reserve(coordinators.leaderElectionServers.size());
-	for (int i = 0; i < coordinators.leaderElectionServers.size(); i++)
-		forwardRequests.push_back(retryBrokenPromise(coordinators.leaderElectionServers[i].forward,
-		                                             ForwardRequest(coordinators.clusterKey, forwardingInfo)));
+	for (int i = 0; i < coordinators.leaderElectionServers.size(); i++) {
+		if (coordinators.leaderElectionServers[i].hostname.present()) {
+			forwardRequests.push_back(retryGetReplyFromHostname(ForwardRequest(coordinators.clusterKey, forwardingInfo),
+			                                                    coordinators.leaderElectionServers[i].hostname.get(),
+			                                                    WLTOKEN_LEADERELECTIONREG_FORWARD));
+		} else {
+			forwardRequests.push_back(retryBrokenPromise(coordinators.leaderElectionServers[i].forward,
+			                                             ForwardRequest(coordinators.clusterKey, forwardingInfo)));
+		}
+	}
 	int quorum_size = forwardRequests.size() / 2 + 1;
 	wait(quorum(forwardRequests, quorum_size));
 	return Void();
 }
 
-ACTOR Future<Void> tryBecomeLeaderInternal(Reference<IClusterConnectionRecord> connRecord,
+ACTOR Future<Void> tryBecomeLeaderInternal(ServerCoordinators coordinators,
                                            Value proposedSerializedInterface,
                                            Reference<AsyncVar<Value>> outSerializedLeader,
                                            bool hasConnected,
                                            Reference<AsyncVar<ClusterControllerPriorityInfo>> asyncPriorityInfo) {
-	state ServerCoordinators coordinators(connRecord);
 	state AsyncTrigger nomineeChange;
 	state std::vector<Optional<LeaderInfo>> nominees;
 	state LeaderInfo myInfo;
@@ -134,6 +125,8 @@ ACTOR Future<Void> tryBecomeLeaderInternal(Reference<IClusterConnectionRecord> c
 		wait(delay(SERVER_KNOBS->WAIT_FOR_GOOD_RECRUITMENT_DELAY));
 	}
 
+	nominees.resize(coordinators.leaderElectionServers.size());
+
 	myInfo.serializedInfo = proposedSerializedInterface;
 	outSerializedLeader->set(Value());
 
@@ -141,9 +134,6 @@ ACTOR Future<Void> tryBecomeLeaderInternal(Reference<IClusterConnectionRecord> c
 	    (SERVER_KNOBS->BUGGIFY_ALL_COORDINATION || BUGGIFY) ? buggifyDelayedAsyncVar(outSerializedLeader) : Void();
 
 	while (!iAmLeader) {
-		wait(connRecord->resolveHostnames());
-		coordinators = ServerCoordinators(connRecord);
-		nominees.resize(coordinators.leaderElectionServers.size());
 		state Future<Void> badCandidateTimeout;
 
 		myInfo.changeID = deterministicRandom()->randomUniqueID();
@@ -153,19 +143,12 @@ ACTOR Future<Void> tryBecomeLeaderInternal(Reference<IClusterConnectionRecord> c
 		std::vector<Future<Void>> cand;
 		cand.reserve(coordinators.leaderElectionServers.size());
 		for (int i = 0; i < coordinators.leaderElectionServers.size(); i++) {
-			Optional<Hostname> hostname;
-			auto r = connRecord->getConnectionString().networkAddressToHostname.find(
-			    coordinators.leaderElectionServers[i].candidacy.getEndpoint().getPrimaryAddress());
-			if (r != connRecord->getConnectionString().networkAddressToHostname.end()) {
-				hostname = r->second;
-			}
 			cand.push_back(submitCandidacy(coordinators.clusterKey,
 			                               coordinators.leaderElectionServers[i],
 			                               myInfo,
 			                               prevChangeID,
 			                               &nomineeChange,
-			                               &nominees[i],
-			                               hostname));
+			                               &nominees[i]));
 		}
 		candidacies = waitForAll(cand);
 
@@ -220,24 +203,15 @@ ACTOR Future<Void> tryBecomeLeaderInternal(Reference<IClusterConnectionRecord> c
 			} else
 				badCandidateTimeout = Future<Void>();
 
-			try {
-				choose {
-					when(wait(nomineeChange.onTrigger())) {}
-					when(wait(badCandidateTimeout.isValid() ? badCandidateTimeout : Never())) {
-						TEST(true); // Bad candidate timeout
-						TraceEvent("LeaderBadCandidateTimeout", myInfo.changeID).log();
-						break;
-					}
-					when(wait(candidacies)) { ASSERT(false); }
-					when(wait(asyncPriorityInfo->onChange())) { break; }
-				}
-			} catch (Error& e) {
-				if (e.code() == error_code_coordinators_changed) {
-					connRecord->getConnectionString().resetToUnresolved();
+			choose {
+				when(wait(nomineeChange.onTrigger())) {}
+				when(wait(badCandidateTimeout.isValid() ? badCandidateTimeout : Never())) {
+					TEST(true); // Bad candidate timeout
+					TraceEvent("LeaderBadCandidateTimeout", myInfo.changeID).log();
 					break;
-				} else {
-					throw e;
 				}
+				when(wait(candidacies)) { ASSERT(false); }
+				when(wait(asyncPriorityInfo->onChange())) { break; }
 			}
 		}
 
@@ -258,10 +232,17 @@ ACTOR Future<Void> tryBecomeLeaderInternal(Reference<IClusterConnectionRecord> c
 		state std::vector<Future<Void>> true_heartbeats;
 		state std::vector<Future<Void>> false_heartbeats;
 		for (int i = 0; i < coordinators.leaderElectionServers.size(); i++) {
-			Future<LeaderHeartbeatReply> hb =
-			    retryBrokenPromise(coordinators.leaderElectionServers[i].leaderHeartbeat,
-			                       LeaderHeartbeatRequest(coordinators.clusterKey, myInfo, prevChangeID),
-			                       TaskPriority::CoordinationReply);
+			Future<LeaderHeartbeatReply> hb;
+			if (coordinators.leaderElectionServers[i].hostname.present()) {
+				hb = retryGetReplyFromHostname(LeaderHeartbeatRequest(coordinators.clusterKey, myInfo, prevChangeID),
+				                               coordinators.leaderElectionServers[i].hostname.get(),
+				                               WLTOKEN_LEADERELECTIONREG_LEADERHEARTBEAT,
+				                               TaskPriority::CoordinationReply);
+			} else {
+				hb = retryBrokenPromise(coordinators.leaderElectionServers[i].leaderHeartbeat,
+				                        LeaderHeartbeatRequest(coordinators.clusterKey, myInfo, prevChangeID),
+				                        TaskPriority::CoordinationReply);
+			}
 			true_heartbeats.push_back(onEqual(hb, LeaderHeartbeatReply{ true }));
 			false_heartbeats.push_back(onEqual(hb, LeaderHeartbeatReply{ false }));
 		}
diff --git a/fdbserver/LeaderElection.h b/fdbserver/LeaderElection.h
index 9639116ec5..ad5d959ce5 100644
--- a/fdbserver/LeaderElection.h
+++ b/fdbserver/LeaderElection.h
@@ -37,7 +37,7 @@ class ServerCoordinators;
 // eventually be set.  If the return value is cancelled, the candidacy or leadership of the proposedInterface
 // will eventually end.
 template <class LeaderInterface>
-Future<Void> tryBecomeLeader(Reference<IClusterConnectionRecord> const& connRecord,
+Future<Void> tryBecomeLeader(ServerCoordinators const& coordinators,
                              LeaderInterface const& proposedInterface,
                              Reference<AsyncVar<Optional<LeaderInterface>>> const& outKnownLeader,
                              bool hasConnected,
@@ -50,20 +50,20 @@ Future<Void> changeLeaderCoordinators(ServerCoordinators const& coordinators, Va
 #pragma region Implementation
 #endif // __INTEL_COMPILER
 
-Future<Void> tryBecomeLeaderInternal(Reference<IClusterConnectionRecord> const& connRecord,
+Future<Void> tryBecomeLeaderInternal(ServerCoordinators const& coordinators,
                                      Value const& proposedSerializedInterface,
                                      Reference<AsyncVar<Value>> const& outSerializedLeader,
                                      bool const& hasConnected,
                                      Reference<AsyncVar<ClusterControllerPriorityInfo>> const& asyncPriorityInfo);
 
 template <class LeaderInterface>
-Future<Void> tryBecomeLeader(Reference<IClusterConnectionRecord> const& connRecord,
+Future<Void> tryBecomeLeader(ServerCoordinators const& coordinators,
                              LeaderInterface const& proposedInterface,
                              Reference<AsyncVar<Optional<LeaderInterface>>> const& outKnownLeader,
                              bool hasConnected,
                              Reference<AsyncVar<ClusterControllerPriorityInfo>> const& asyncPriorityInfo) {
 	auto serializedInfo = makeReference<AsyncVar<Value>>();
-	Future<Void> m = tryBecomeLeaderInternal(connRecord,
+	Future<Void> m = tryBecomeLeaderInternal(coordinators,
 	                                         ObjectWriter::toValue(proposedInterface, IncludeVersion()),
 	                                         serializedInfo,
 	                                         hasConnected,
diff --git a/fdbserver/PaxosConfigConsumer.actor.cpp b/fdbserver/PaxosConfigConsumer.actor.cpp
index 934efccfa3..eb8e4f70f3 100644
--- a/fdbserver/PaxosConfigConsumer.actor.cpp
+++ b/fdbserver/PaxosConfigConsumer.actor.cpp
@@ -99,8 +99,17 @@ class GetCommittedVersionQuorum {
 
 			// Now roll node forward to match the largest committed version of
 			// the replies.
-			state Reference<ConfigFollowerInfo> quorumCfi(new ConfigFollowerInfo(self->replies[target]));
 			try {
+				state std::vector<ConfigFollowerInterface> interfs = self->replies[target];
+				std::vector<Future<Void>> fs;
+				for (ConfigFollowerInterface& interf : interfs) {
+					if (interf.hostname.present()) {
+						fs.push_back(tryInitializeRequestStream(
+						    &interf.getChanges, interf.hostname.get(), WLTOKEN_CONFIGFOLLOWER_GETCHANGES));
+					}
+				}
+				wait(waitForAll(fs));
+				state Reference<ConfigFollowerInfo> quorumCfi(new ConfigFollowerInfo(interfs));
 				state Version lastSeenVersion = std::max(
 				    rollback.present() ? rollback.get() : nodeVersion.lastCommitted, self->largestCompactedResponse);
 				ConfigFollowerGetChangesReply reply =
@@ -129,9 +138,18 @@ class GetCommittedVersionQuorum {
 
 	ACTOR static Future<Void> getCommittedVersionActor(GetCommittedVersionQuorum* self, ConfigFollowerInterface cfi) {
 		try {
-			ConfigFollowerGetCommittedVersionReply reply =
-			    wait(timeoutError(cfi.getCommittedVersion.getReply(ConfigFollowerGetCommittedVersionRequest{}),
-			                      SERVER_KNOBS->GET_COMMITTED_VERSION_TIMEOUT));
+			state ConfigFollowerGetCommittedVersionReply reply;
+			if (cfi.hostname.present()) {
+				wait(timeoutError(store(reply,
+				                        retryGetReplyFromHostname(ConfigFollowerGetCommittedVersionRequest{},
+				                                                  cfi.hostname.get(),
+				                                                  WLTOKEN_CONFIGFOLLOWER_GETCOMMITTEDVERSION)),
+				                  SERVER_KNOBS->GET_COMMITTED_VERSION_TIMEOUT));
+			} else {
+				wait(timeoutError(
+				    store(reply, cfi.getCommittedVersion.getReply(ConfigFollowerGetCommittedVersionRequest{})),
+				    SERVER_KNOBS->GET_COMMITTED_VERSION_TIMEOUT));
+			}
 
 			++self->totalRepliesReceived;
 			self->largestCompactedResponse = std::max(self->largestCompactedResponse, reply.lastCompacted);
@@ -279,7 +297,15 @@ class PaxosConfigConsumerImpl {
 			std::vector<Future<Void>> compactionRequests;
 			compactionRequests.reserve(compactionRequests.size());
 			for (const auto& cfi : self->cfis) {
-				compactionRequests.push_back(cfi.compact.getReply(ConfigFollowerCompactRequest{ compactionVersion }));
+				if (cfi.hostname.present()) {
+					compactionRequests.push_back(
+					    retryGetReplyFromHostname(ConfigFollowerCompactRequest{ compactionVersion },
+					                              cfi.hostname.get(),
+					                              WLTOKEN_CONFIGFOLLOWER_COMPACT));
+				} else {
+					compactionRequests.push_back(
+					    cfi.compact.getReply(ConfigFollowerCompactRequest{ compactionVersion }));
+				}
 			}
 			try {
 				wait(timeoutError(waitForAll(compactionRequests), 1.0));
@@ -294,8 +320,18 @@ class PaxosConfigConsumerImpl {
 			self->resetCommittedVersionQuorum(); // TODO: This seems to fix a segfault, investigate more
 			try {
 				state Version committedVersion = wait(getCommittedVersion(self));
-				state Reference<ConfigFollowerInfo> configNodes(
-				    new ConfigFollowerInfo(self->getCommittedVersionQuorum.getReadReplicas()));
+				state std::vector<ConfigFollowerInterface> readReplicas =
+				    self->getCommittedVersionQuorum.getReadReplicas();
+				std::vector<Future<Void>> fs;
+				for (ConfigFollowerInterface& readReplica : readReplicas) {
+					if (readReplica.hostname.present()) {
+						fs.push_back(tryInitializeRequestStream(&readReplica.getSnapshotAndChanges,
+						                                        readReplica.hostname.get(),
+						                                        WLTOKEN_CONFIGFOLLOWER_GETSNAPSHOTANDCHANGES));
+					}
+				}
+				wait(waitForAll(fs));
+				state Reference<ConfigFollowerInfo> configNodes(new ConfigFollowerInfo(readReplicas));
 				ConfigFollowerGetSnapshotAndChangesReply reply =
 				    wait(timeoutError(basicLoadBalance(configNodes,
 				                                       &ConfigFollowerInterface::getSnapshotAndChanges,
@@ -349,8 +385,18 @@ class PaxosConfigConsumerImpl {
 				// returned would be 1.
 				if (committedVersion > self->lastSeenVersion) {
 					ASSERT(self->getCommittedVersionQuorum.getReadReplicas().size() >= self->cfis.size() / 2 + 1);
-					state Reference<ConfigFollowerInfo> configNodes(
-					    new ConfigFollowerInfo(self->getCommittedVersionQuorum.getReadReplicas()));
+					state std::vector<ConfigFollowerInterface> readReplicas =
+					    self->getCommittedVersionQuorum.getReadReplicas();
+					std::vector<Future<Void>> fs;
+					for (ConfigFollowerInterface& readReplica : readReplicas) {
+						if (readReplica.hostname.present()) {
+							fs.push_back(tryInitializeRequestStream(&readReplica.getChanges,
+							                                        readReplica.hostname.get(),
+							                                        WLTOKEN_CONFIGFOLLOWER_GETCHANGES));
+						}
+					}
+					wait(waitForAll(fs));
+					state Reference<ConfigFollowerInfo> configNodes(new ConfigFollowerInfo(readReplicas));
 					ConfigFollowerGetChangesReply reply = wait(timeoutError(
 					    basicLoadBalance(configNodes,
 					                     &ConfigFollowerInterface::getChanges,
diff --git a/fdbserver/QuietDatabase.actor.cpp b/fdbserver/QuietDatabase.actor.cpp
index b69d7930ee..014e091b79 100644
--- a/fdbserver/QuietDatabase.actor.cpp
+++ b/fdbserver/QuietDatabase.actor.cpp
@@ -161,9 +161,8 @@ ACTOR Future<std::vector<WorkerInterface>> getCoordWorkers(Database cx,
 	if (!coordinators.present()) {
 		throw operation_failed();
 	}
-	state ClusterConnectionString ccs(coordinators.get().toString());
-	wait(ccs.resolveHostnames());
-	std::vector<NetworkAddress> coordinatorsAddr = ccs.coordinators();
+	ClusterConnectionString ccs(coordinators.get().toString());
+	std::vector<NetworkAddress> coordinatorsAddr = wait(ccs.tryResolveHostnames());
 	std::set<NetworkAddress> coordinatorsAddrSet;
 	for (const auto& addr : coordinatorsAddr) {
 		TraceEvent(SevDebug, "CoordinatorAddress").detail("Addr", addr);
diff --git a/fdbserver/SimpleConfigConsumer.actor.cpp b/fdbserver/SimpleConfigConsumer.actor.cpp
index a2cbfba9db..ddad99c80d 100644
--- a/fdbserver/SimpleConfigConsumer.actor.cpp
+++ b/fdbserver/SimpleConfigConsumer.actor.cpp
@@ -44,15 +44,29 @@ class SimpleConfigConsumerImpl {
 		loop {
 			state Version compactionVersion = self->lastSeenVersion;
 			wait(delayJittered(self->compactionInterval.get()));
-			wait(self->cfi.compact.getReply(ConfigFollowerCompactRequest{ compactionVersion }));
+			if (self->cfi.hostname.present()) {
+				wait(retryGetReplyFromHostname(ConfigFollowerCompactRequest{ compactionVersion },
+				                               self->cfi.hostname.get(),
+				                               WLTOKEN_CONFIGFOLLOWER_COMPACT));
+			} else {
+				wait(self->cfi.compact.getReply(ConfigFollowerCompactRequest{ compactionVersion }));
+			}
 			++self->compactRequest;
 			broadcaster->compact(compactionVersion);
 		}
 	}
 
 	ACTOR static Future<Version> getCommittedVersion(SimpleConfigConsumerImpl* self) {
-		ConfigFollowerGetCommittedVersionReply committedVersionReply =
-		    wait(self->cfi.getCommittedVersion.getReply(ConfigFollowerGetCommittedVersionRequest{}));
+		state ConfigFollowerGetCommittedVersionReply committedVersionReply;
+		if (self->cfi.hostname.present()) {
+			wait(store(committedVersionReply,
+			           retryGetReplyFromHostname(ConfigFollowerGetCommittedVersionRequest{},
+			                                     self->cfi.hostname.get(),
+			                                     WLTOKEN_CONFIGFOLLOWER_GETCOMMITTEDVERSION)));
+		} else {
+			wait(store(committedVersionReply,
+			           self->cfi.getCommittedVersion.getReply(ConfigFollowerGetCommittedVersionRequest{})));
+		}
 		return committedVersionReply.lastCommitted;
 	}
 
@@ -63,8 +77,18 @@ class SimpleConfigConsumerImpl {
 				state Version committedVersion = wait(getCommittedVersion(self));
 				ASSERT_GE(committedVersion, self->lastSeenVersion);
 				if (committedVersion > self->lastSeenVersion) {
-					ConfigFollowerGetChangesReply reply = wait(self->cfi.getChanges.getReply(
-					    ConfigFollowerGetChangesRequest{ self->lastSeenVersion, committedVersion }));
+					state ConfigFollowerGetChangesReply reply;
+					if (self->cfi.hostname.present()) {
+						wait(store(reply,
+						           retryGetReplyFromHostname(
+						               ConfigFollowerGetChangesRequest{ self->lastSeenVersion, committedVersion },
+						               self->cfi.hostname.get(),
+						               WLTOKEN_CONFIGFOLLOWER_GETCHANGES)));
+					} else {
+						wait(store(reply,
+						           self->cfi.getChanges.getReply(
+						               ConfigFollowerGetChangesRequest{ self->lastSeenVersion, committedVersion })));
+					}
 					++self->successfulChangeRequest;
 					for (const auto& versionedMutation : reply.changes) {
 						TraceEvent te(SevDebug, "ConsumerFetchedMutation", self->id);
@@ -96,8 +120,17 @@ class SimpleConfigConsumerImpl {
 
 	ACTOR static Future<Void> getSnapshotAndChanges(SimpleConfigConsumerImpl* self, ConfigBroadcaster* broadcaster) {
 		state Version committedVersion = wait(getCommittedVersion(self));
-		ConfigFollowerGetSnapshotAndChangesReply reply = wait(
-		    self->cfi.getSnapshotAndChanges.getReply(ConfigFollowerGetSnapshotAndChangesRequest{ committedVersion }));
+		state ConfigFollowerGetSnapshotAndChangesReply reply;
+		if (self->cfi.hostname.present()) {
+			wait(store(reply,
+			           retryGetReplyFromHostname(ConfigFollowerGetSnapshotAndChangesRequest{ committedVersion },
+			                                     self->cfi.hostname.get(),
+			                                     WLTOKEN_CONFIGFOLLOWER_GETSNAPSHOTANDCHANGES)));
+		} else {
+			wait(store(reply,
+			           self->cfi.getSnapshotAndChanges.getReply(
+			               ConfigFollowerGetSnapshotAndChangesRequest{ committedVersion })));
+		}
 		++self->snapshotRequest;
 		TraceEvent(SevDebug, "ConfigConsumerGotSnapshotAndChanges", self->id)
 		    .detail("SnapshotVersion", reply.snapshotVersion)
diff --git a/fdbserver/SimulatedCluster.actor.cpp b/fdbserver/SimulatedCluster.actor.cpp
index 4a183ac1de..9e825aa276 100644
--- a/fdbserver/SimulatedCluster.actor.cpp
+++ b/fdbserver/SimulatedCluster.actor.cpp
@@ -1980,8 +1980,8 @@ void setupSimulatedSystem(std::vector<Future<Void>>* systemActors,
 	TEST(useIPv6); // Use IPv6
 	TEST(!useIPv6); // Use IPv4
 
-	// TODO(renxuan): Use hostname 25% of the time, unless it is disabled
-	bool useHostname = false; // !testConfig.disableHostname && deterministicRandom()->random01() < 0.25;
+	// Use hostname 25% of the time, unless it is disabled
+	bool useHostname = !testConfig.disableHostname && deterministicRandom()->random01() < 0.25;
 	TEST(useHostname); // Use hostname
 	TEST(!useHostname); // Use IP address
 	NetworkAddressFromHostname fromHostname =
diff --git a/fdbserver/Status.actor.cpp b/fdbserver/Status.actor.cpp
index f086265d49..52ef7c20b5 100644
--- a/fdbserver/Status.actor.cpp
+++ b/fdbserver/Status.actor.cpp
@@ -831,7 +831,8 @@ ACTOR static Future<JsonBuilderObject> processStatusFetcher(
 		}
 	}
 
-	for (auto& coordinator : coordinators.ccr->getConnectionString().coordinators()) {
+	std::vector<NetworkAddress> addressVec = wait(coordinators.ccr->getConnectionString().tryResolveHostnames());
+	for (const auto& coordinator : addressVec) {
 		roles.addCoordinatorRole(coordinator);
 	}
 
@@ -1689,8 +1690,7 @@ static JsonBuilderObject configurationFetcher(Optional<DatabaseConfiguration> co
 			}
 			statusObj["excluded_servers"] = excludedServersArr;
 		}
-		std::vector<ClientLeaderRegInterface> coordinatorLeaderServers = coordinators.clientLeaderServers;
-		int count = coordinatorLeaderServers.size();
+		int count = coordinators.clientLeaderServers.size();
 		statusObj["coordinators_count"] = count;
 	} catch (Error&) {
 		incomplete_reasons->insert("Could not retrieve all configuration status information.");
@@ -2505,7 +2505,8 @@ static JsonBuilderArray tlogFetcher(int* logFaultTolerance,
 
 static JsonBuilderObject faultToleranceStatusFetcher(DatabaseConfiguration configuration,
                                                      ServerCoordinators coordinators,
-                                                     std::vector<WorkerDetails>& workers,
+                                                     const std::vector<NetworkAddress>& coordinatorAddresses,
+                                                     const std::vector<WorkerDetails>& workers,
                                                      int extraTlogEligibleZones,
                                                      int minStorageReplicasRemaining,
                                                      int oldLogFaultTolerance,
@@ -2521,11 +2522,11 @@ static JsonBuilderObject faultToleranceStatusFetcher(DatabaseConfiguration confi
 	int maxCoordinatorFailures = (coordinators.clientLeaderServers.size() - 1) / 2;
 
 	std::map<NetworkAddress, StringRef> workerZones;
-	for (auto& worker : workers) {
+	for (const auto& worker : workers) {
 		workerZones[worker.interf.address()] = worker.interf.locality.zoneId().orDefault(LiteralStringRef(""));
 	}
 	std::map<StringRef, int> coordinatorZoneCounts;
-	for (auto& coordinator : coordinators.ccr->getConnectionString().coordinators()) {
+	for (const auto& coordinator : coordinatorAddresses) {
 		auto zone = workerZones[coordinator];
 		coordinatorZoneCounts[zone] += 1;
 	}
@@ -3061,6 +3062,9 @@ ACTOR Future<StatusReply> clusterGetStatus(
 			state std::vector<JsonBuilderObject> workerStatuses = wait(getAll(futures2));
 			wait(success(primaryDCFO));
 
+			std::vector<NetworkAddress> coordinatorAddresses =
+			    wait(coordinators.ccr->getConnectionString().tryResolveHostnames());
+
 			int logFaultTolerance = 100;
 			if (db->get().recoveryState >= RecoveryState::ACCEPTING_COMMITS) {
 				statusObj["logs"] = tlogFetcher(&logFaultTolerance, db, address_workers);
@@ -3070,6 +3074,7 @@ ACTOR Future<StatusReply> clusterGetStatus(
 			statusObj["fault_tolerance"] =
 			    faultToleranceStatusFetcher(configuration.get(),
 			                                coordinators,
+			                                coordinatorAddresses,
 			                                workers,
 			                                extraTlogEligibleZones,
 			                                minStorageReplicasRemaining,
diff --git a/fdbserver/fdbserver.actor.cpp b/fdbserver/fdbserver.actor.cpp
index 3a2cc88f0a..1a2f244b0b 100644
--- a/fdbserver/fdbserver.actor.cpp
+++ b/fdbserver/fdbserver.actor.cpp
@@ -859,9 +859,9 @@ std::pair<NetworkAddressList, NetworkAddressList> buildNetworkAddresses(
 	NetworkAddressList publicNetworkAddresses;
 	NetworkAddressList listenNetworkAddresses;
 
-	connectionRecord.resolveHostnamesBlocking();
-	auto& coordinators = connectionRecord.getConnectionString().coordinators();
-	ASSERT(coordinators.size() > 0);
+	std::vector<Hostname>& hostnames = connectionRecord.getConnectionString().hostnames;
+	const std::vector<NetworkAddress>& coords = connectionRecord.getConnectionString().coordinators();
+	ASSERT(hostnames.size() + coords.size() > 0);
 
 	for (int ii = 0; ii < publicAddressStrs.size(); ++ii) {
 		const std::string& publicAddressStr = publicAddressStrs[ii];
@@ -930,13 +930,26 @@ std::pair<NetworkAddressList, NetworkAddressList> buildNetworkAddresses(
 			listenNetworkAddresses.secondaryAddress = currentListenAddress;
 		}
 
-		bool hasSameCoord = std::all_of(coordinators.begin(), coordinators.end(), [&](const NetworkAddress& address) {
+		bool matchCoordinatorsTls = std::all_of(coords.begin(), coords.end(), [&](const NetworkAddress& address) {
 			if (address.ip == currentPublicAddress.ip && address.port == currentPublicAddress.port) {
 				return address.isTLS() == currentPublicAddress.isTLS();
 			}
 			return true;
 		});
-		if (!hasSameCoord) {
+		// If true, further check hostnames.
+		if (matchCoordinatorsTls) {
+			matchCoordinatorsTls = std::all_of(hostnames.begin(), hostnames.end(), [&](Hostname& hostname) {
+				Optional<NetworkAddress> resolvedAddress = hostname.resolveBlocking();
+				if (resolvedAddress.present()) {
+					NetworkAddress address = resolvedAddress.get();
+					if (address.ip == currentPublicAddress.ip && address.port == currentPublicAddress.port) {
+						return address.isTLS() == currentPublicAddress.isTLS();
+					}
+				}
+				return true;
+			});
+		}
+		if (!matchCoordinatorsTls) {
 			fprintf(stderr,
 			        "ERROR: TLS state of public address %s does not match in coordinator list.\n",
 			        publicAddressStr.c_str());
diff --git a/fdbserver/worker.actor.cpp b/fdbserver/worker.actor.cpp
index a777588037..932a6d9a8a 100644
--- a/fdbserver/worker.actor.cpp
+++ b/fdbserver/worker.actor.cpp
@@ -2977,21 +2977,43 @@ ACTOR Future<MonitorLeaderInfo> monitorLeaderWithDelayedCandidacyImplOneGenerati
     Reference<IClusterConnectionRecord> connRecord,
     Reference<AsyncVar<Value>> result,
     MonitorLeaderInfo info) {
-	state ClusterConnectionString ccf = info.intermediateConnRecord->getConnectionString();
-	state std::vector<NetworkAddress> addrs = ccf.coordinators();
+	ClusterConnectionString cs = info.intermediateConnRecord->getConnectionString();
+	std::vector<Hostname> hostnames;
+	state int coordinatorsSize = cs.hostnames.size() + cs.coordinators().size();
 	state ElectionResultRequest request;
 	state int index = 0;
 	state int successIndex = 0;
-	request.key = ccf.clusterKey();
-	request.coordinators = ccf.coordinators();
+	state std::vector<LeaderElectionRegInterface> leaderElectionServers;
 
-	deterministicRandom()->randomShuffle(addrs);
+	hostnames.reserve(cs.hostnames.size());
+	leaderElectionServers.reserve(coordinatorsSize);
+	for (const auto& h : cs.hostnames) {
+		hostnames.push_back(h);
+		leaderElectionServers.push_back(LeaderElectionRegInterface(h));
+	}
+	for (const auto& c : cs.coordinators()) {
+		leaderElectionServers.push_back(LeaderElectionRegInterface(c));
+	}
+	deterministicRandom()->randomShuffle(leaderElectionServers);
+
+	request.key = cs.clusterKey();
+	request.hostnames = hostnames;
+	request.coordinators = cs.coordinators();
 
 	loop {
-		LeaderElectionRegInterface interf(addrs[index]);
+		LeaderElectionRegInterface interf = leaderElectionServers[index];
+		bool usingHostname = interf.hostname.present();
 		request.reply = ReplyPromise<Optional<LeaderInfo>>();
 
-		ErrorOr<Optional<LeaderInfo>> leader = wait(interf.electionResult.tryGetReply(request));
+		state ErrorOr<Optional<LeaderInfo>> leader;
+		if (usingHostname) {
+			wait(store(
+			    leader,
+			    tryGetReplyFromHostname(request, interf.hostname.get(), WLTOKEN_LEADERELECTIONREG_ELECTIONRESULT)));
+		} else {
+			wait(store(leader, interf.electionResult.tryGetReply(request)));
+		}
+
 		if (leader.present()) {
 			if (leader.get().present()) {
 				if (leader.get().get().forward) {
@@ -3027,14 +3049,9 @@ ACTOR Future<MonitorLeaderInfo> monitorLeaderWithDelayedCandidacyImplOneGenerati
 			}
 			successIndex = index;
 		} else {
-			if (leader.isError() && leader.getError().code() == error_code_coordinators_changed) {
-				info.intermediateConnRecord->getConnectionString().resetToUnresolved();
-				throw coordinators_changed();
-			}
-			index = (index + 1) % addrs.size();
+			index = (index + 1) % coordinatorsSize;
 			if (index == successIndex) {
 				wait(delay(CLIENT_KNOBS->COORDINATOR_RECONNECTION_DELAY));
-				throw coordinators_changed();
 			}
 		}
 	}
@@ -3042,22 +3059,11 @@ ACTOR Future<MonitorLeaderInfo> monitorLeaderWithDelayedCandidacyImplOneGenerati
 
 ACTOR Future<Void> monitorLeaderWithDelayedCandidacyImplInternal(Reference<IClusterConnectionRecord> connRecord,
                                                                  Reference<AsyncVar<Value>> outSerializedLeaderInfo) {
-	wait(connRecord->resolveHostnames());
 	state MonitorLeaderInfo info(connRecord);
 	loop {
-		try {
-			wait(info.intermediateConnRecord->resolveHostnames());
-			MonitorLeaderInfo _info =
-			    wait(monitorLeaderWithDelayedCandidacyImplOneGeneration(connRecord, outSerializedLeaderInfo, info));
-			info = _info;
-		} catch (Error& e) {
-			if (e.code() == error_code_coordinators_changed) {
-				TraceEvent("MonitorLeaderWithDelayedCandidacyCoordinatorsChanged").suppressFor(1.0);
-				info.intermediateConnRecord->getConnectionString().resetToUnresolved();
-			} else {
-				throw e;
-			}
-		}
+		MonitorLeaderInfo _info =
+		    wait(monitorLeaderWithDelayedCandidacyImplOneGeneration(connRecord, outSerializedLeaderInfo, info));
+		info = _info;
 	}
 }
 
@@ -3191,6 +3197,7 @@ ACTOR Future<Void> fdbd(Reference<IClusterConnectionRecord> connRecord,
 	actors.push_back(serveProcess());
 
 	try {
+		ServerCoordinators coordinators(connRecord);
 		if (g_network->isSimulated()) {
 			whitelistBinPaths = ",, random_path,  /bin/snap_create.sh,,";
 		}
diff --git a/fdbserver/workloads/ConsistencyCheck.actor.cpp b/fdbserver/workloads/ConsistencyCheck.actor.cpp
index 16d39a7f1e..fd352ab299 100644
--- a/fdbserver/workloads/ConsistencyCheck.actor.cpp
+++ b/fdbserver/workloads/ConsistencyCheck.actor.cpp
@@ -2096,7 +2096,8 @@ struct ConsistencyCheckWorkload : TestWorkload {
 					return false;
 				}
 
-				state ClusterConnectionString old(currentKey.get().toString());
+				ClusterConnectionString old(currentKey.get().toString());
+				state std::vector<NetworkAddress> oldCoordinators = wait(old.tryResolveHostnames());
 
 				std::vector<ProcessData> workers = wait(::getWorkers(&tr));
 
@@ -2106,7 +2107,7 @@ struct ConsistencyCheckWorkload : TestWorkload {
 				}
 
 				std::set<Optional<Standalone<StringRef>>> checkDuplicates;
-				for (const auto& addr : old.coordinators()) {
+				for (const auto& addr : oldCoordinators) {
 					auto findResult = addr_locality.find(addr);
 					if (findResult != addr_locality.end()) {
 						if (checkDuplicates.count(findResult->second.zoneId())) {
diff --git a/fdbserver/workloads/RemoveServersSafely.actor.cpp b/fdbserver/workloads/RemoveServersSafely.actor.cpp
index d2550394d1..6be4a58cee 100644
--- a/fdbserver/workloads/RemoveServersSafely.actor.cpp
+++ b/fdbserver/workloads/RemoveServersSafely.actor.cpp
@@ -541,7 +541,12 @@ struct RemoveServersSafelyWorkload : TestWorkload {
 		state AddressExclusion coordExcl;
 		// Exclude a coordinator under buggify, but only if fault tolerance is > 0 and kill set is non-empty already
 		if (BUGGIFY && toKill.size()) {
-			std::vector<NetworkAddress> coordinators = wait(getCoordinators(cx));
+			Optional<ClusterConnectionString> csOptional = wait(getConnectionString(cx));
+			state std::vector<NetworkAddress> coordinators;
+			if (csOptional.present()) {
+				ClusterConnectionString cs = csOptional.get();
+				wait(store(coordinators, cs.tryResolveHostnames()));
+			}
 			if (coordinators.size() > 2) {
 				auto randomCoordinator = deterministicRandom()->randomChoice(coordinators);
 				coordExcl = AddressExclusion(randomCoordinator.ip, randomCoordinator.port);
diff --git a/fdbserver/workloads/SpecialKeySpaceCorrectness.actor.cpp b/fdbserver/workloads/SpecialKeySpaceCorrectness.actor.cpp
index 47698572b3..cd5d2b7d80 100644
--- a/fdbserver/workloads/SpecialKeySpaceCorrectness.actor.cpp
+++ b/fdbserver/workloads/SpecialKeySpaceCorrectness.actor.cpp
@@ -957,9 +957,9 @@ struct SpecialKeySpaceCorrectnessWorkload : TestWorkload {
 				boost::split(
 				    process_addresses, coordinator_processes_key.get().toString(), [](char c) { return c == ','; });
 				ASSERT(process_addresses.size() == cs.coordinators().size() + cs.hostnames.size());
-				wait(cs.resolveHostnames());
 				// compare the coordinator process network addresses one by one
-				for (const auto& network_address : cs.coordinators()) {
+				std::vector<NetworkAddress> coordinators = wait(cs.tryResolveHostnames());
+				for (const auto& network_address : coordinators) {
 					ASSERT(std::find(process_addresses.begin(), process_addresses.end(), network_address.toString()) !=
 					       process_addresses.end());
 				}
@@ -1077,19 +1077,20 @@ struct SpecialKeySpaceCorrectnessWorkload : TestWorkload {
 					tx->setOption(FDBTransactionOptions::READ_SYSTEM_KEYS);
 					Optional<Value> res = wait(tx->get(coordinatorsKey));
 					ASSERT(res.present()); // Otherwise, database is in a bad state
-					state ClusterConnectionString csNew(res.get().toString());
-					wait(csNew.resolveHostnames());
-					ASSERT(csNew.coordinators().size() == old_coordinators_processes.size() + 1);
+					ClusterConnectionString csNew(res.get().toString());
+					// verify the cluster decription
+					ASSERT(new_cluster_description == csNew.clusterKeyName().toString());
+					ASSERT(csNew.hostnames.size() + csNew.coordinators().size() ==
+					       old_coordinators_processes.size() + 1);
+					std::vector<NetworkAddress> newCoordinators = wait(csNew.tryResolveHostnames());
 					// verify the coordinators' addresses
-					for (const auto& network_address : csNew.coordinators()) {
+					for (const auto& network_address : newCoordinators) {
 						std::string address_str = network_address.toString();
 						ASSERT(std::find(old_coordinators_processes.begin(),
 						                 old_coordinators_processes.end(),
 						                 address_str) != old_coordinators_processes.end() ||
 						       new_coordinator_process == address_str);
 					}
-					// verify the cluster decription
-					ASSERT(new_cluster_description == csNew.clusterKeyName().toString());
 					tx->reset();
 				} catch (Error& e) {
 					wait(tx->onError(e));

From f13a8df5d9eef6c3a21ee29cf416bc94e867f892 Mon Sep 17 00:00:00 2001
From: Lukas Joswiak <lukas.joswiak@snowflake.com>
Date: Wed, 20 Apr 2022 14:31:14 -0700
Subject: [PATCH 70/84] Add logging measuring commit compute duration

---
 fdbclient/ServerKnobs.cpp             |  1 +
 fdbclient/ServerKnobs.h               |  1 +
 fdbserver/CommitProxyServer.actor.cpp | 13 +++++++++++++
 fdbserver/ProxyCommitData.actor.h     |  6 ++++++
 4 files changed, 21 insertions(+)

diff --git a/fdbclient/ServerKnobs.cpp b/fdbclient/ServerKnobs.cpp
index 5b90e0b930..119e3e735e 100644
--- a/fdbclient/ServerKnobs.cpp
+++ b/fdbclient/ServerKnobs.cpp
@@ -450,6 +450,7 @@ void ServerKnobs::initialize(Randomize randomize, ClientKnobs* clientKnobs, IsSi
 	init( MAX_COMMIT_UPDATES,                                    2000 ); if( randomize && BUGGIFY ) MAX_COMMIT_UPDATES = 1;
 	init( MAX_PROXY_COMPUTE,                                      2.0 );
 	init( MAX_COMPUTE_PER_OPERATION,                              0.1 );
+	init( MAX_COMPUTE_DURATION_LOG_CUTOFF,                       0.15 );
 	init( PROXY_COMPUTE_BUCKETS,                                20000 );
 	init( PROXY_COMPUTE_GROWTH_RATE,                             0.01 );
 	init( TXN_STATE_SEND_AMOUNT,                                    4 );
diff --git a/fdbclient/ServerKnobs.h b/fdbclient/ServerKnobs.h
index 92674e55d0..dc770502e2 100644
--- a/fdbclient/ServerKnobs.h
+++ b/fdbclient/ServerKnobs.h
@@ -374,6 +374,7 @@ public:
 	int MAX_COMMIT_UPDATES;
 	double MAX_PROXY_COMPUTE;
 	double MAX_COMPUTE_PER_OPERATION;
+	double MAX_COMPUTE_DURATION_LOG_CUTOFF;
 	int PROXY_COMPUTE_BUCKETS;
 	double PROXY_COMPUTE_GROWTH_RATE;
 	int TXN_STATE_SEND_AMOUNT;
diff --git a/fdbserver/CommitProxyServer.actor.cpp b/fdbserver/CommitProxyServer.actor.cpp
index 097c6f632f..18e255f03c 100644
--- a/fdbserver/CommitProxyServer.actor.cpp
+++ b/fdbserver/CommitProxyServer.actor.cpp
@@ -708,6 +708,7 @@ ACTOR Future<Void> preresolutionProcessing(CommitBatchContext* self) {
 	// Pre-resolution the commits
 	TEST(pProxyCommitData->latestLocalCommitBatchResolving.get() < localBatchNumber - 1); // Wait for local batch
 	wait(pProxyCommitData->latestLocalCommitBatchResolving.whenAtLeast(localBatchNumber - 1));
+	pProxyCommitData->stats.computeLatency.addMeasurement(now() - timeStart);
 	double queuingDelay = g_network->now() - timeStart;
 	pProxyCommitData->stats.commitBatchQueuingDist->sampleSeconds(queuingDelay);
 	if ((queuingDelay > (double)SERVER_KNOBS->MAX_READ_TRANSACTION_LIFE_VERSIONS / SERVER_KNOBS->VERSIONS_PER_SECOND ||
@@ -1401,6 +1402,18 @@ ACTOR Future<Void> postResolution(CommitBatchContext* self) {
 		pProxyCommitData->stats.minComputeNS =
 		    std::min<int64_t>(pProxyCommitData->stats.minComputeNS,
 		                      1e9 * pProxyCommitData->commitComputePerOperation[self->latencyBucket]);
+
+		if (self->computeDuration >= SERVER_KNOBS->MAX_COMPUTE_DURATION_LOG_CUTOFF) {
+			TraceEvent(SevInfo, "LongComputeDuration")
+			    .suppressFor(5.0)
+			    .detail("ComputeDuration", self->computeDuration)
+			    .detail("ComputePerOperation", computePerOperation)
+			    .detail("LatencyBucket", self->latencyBucket)
+			    .detail("UpdatedComputePerOperationEstimate",
+			            pProxyCommitData->commitComputePerOperation[self->latencyBucket])
+			    .detail("BatchBytes", self->batchBytes)
+			    .detail("BatchOperations", self->batchOperations);
+		}
 	}
 
 	pProxyCommitData->stats.processingMutationDist->sampleSeconds(now() - postResolutionQueuing);
diff --git a/fdbserver/ProxyCommitData.actor.h b/fdbserver/ProxyCommitData.actor.h
index 620e58622e..5b9315da59 100644
--- a/fdbserver/ProxyCommitData.actor.h
+++ b/fdbserver/ProxyCommitData.actor.h
@@ -73,6 +73,8 @@ struct ProxyStats {
 
 	LatencySample commitBatchingWindowSize;
 
+	LatencySample computeLatency;
+
 	Future<Void> logger;
 
 	int64_t maxComputeNS;
@@ -126,6 +128,10 @@ struct ProxyStats {
 	                             id,
 	                             SERVER_KNOBS->LATENCY_METRICS_LOGGING_INTERVAL,
 	                             SERVER_KNOBS->LATENCY_SAMPLE_SIZE),
+	    computeLatency("ComputeLatency",
+	                   id,
+	                   SERVER_KNOBS->LATENCY_METRICS_LOGGING_INTERVAL,
+	                   SERVER_KNOBS->LATENCY_SAMPLE_SIZE),
 	    maxComputeNS(0), minComputeNS(1e12),
 	    commitBatchQueuingDist(Histogram::getHistogram(LiteralStringRef("CommitProxy"),
 	                                                   LiteralStringRef("CommitBatchQueuing"),

From 802c45f8431e5403222bd4d07dacfb427e903a3d Mon Sep 17 00:00:00 2001
From: Lukas Joswiak <lukas.joswiak@snowflake.com>
Date: Wed, 20 Apr 2022 15:02:08 -0700
Subject: [PATCH 71/84] Add estimated compute duration

---
 fdbserver/CommitProxyServer.actor.cpp | 38 ++++++++++++++++-----------
 1 file changed, 22 insertions(+), 16 deletions(-)

diff --git a/fdbserver/CommitProxyServer.actor.cpp b/fdbserver/CommitProxyServer.actor.cpp
index 18e255f03c..f1add616f1 100644
--- a/fdbserver/CommitProxyServer.actor.cpp
+++ b/fdbserver/CommitProxyServer.actor.cpp
@@ -685,6 +685,11 @@ bool canReject(const std::vector<CommitTransactionRequest>& trs) {
 	return true;
 }
 
+double computeReleaseDelay(CommitBatchContext* self, double latencyBucket) {
+	return std::min(SERVER_KNOBS->MAX_PROXY_COMPUTE,
+	                self->batchOperations * self->pProxyCommitData->commitComputePerOperation[latencyBucket]);
+}
+
 ACTOR Future<Void> preresolutionProcessing(CommitBatchContext* self) {
 
 	state ProxyCommitData* const pProxyCommitData = self->pProxyCommitData;
@@ -737,10 +742,7 @@ ACTOR Future<Void> preresolutionProcessing(CommitBatchContext* self) {
 		return Void();
 	}
 
-	self->releaseDelay =
-	    delay(std::min(SERVER_KNOBS->MAX_PROXY_COMPUTE,
-	                   self->batchOperations * pProxyCommitData->commitComputePerOperation[latencyBucket]),
-	          TaskPriority::ProxyMasterVersionReply);
+	self->releaseDelay = delay(computeReleaseDelay(self, latencyBucket), TaskPriority::ProxyMasterVersionReply);
 
 	if (debugID.present()) {
 		g_traceBatch.addEvent(
@@ -1388,6 +1390,22 @@ ACTOR Future<Void> postResolution(CommitBatchContext* self) {
 	if (self->batchOperations > 0) {
 		double computePerOperation =
 		    std::min(SERVER_KNOBS->MAX_COMPUTE_PER_OPERATION, self->computeDuration / self->batchOperations);
+
+		double estimatedDelay = computeReleaseDelay(self, self->latencyBucket);
+		if (estimatedDelay >= SERVER_KNOBS->MAX_COMPUTE_DURATION_LOG_CUTOFF ||
+		    self->computeDuration >= SERVER_KNOBS->MAX_COMPUTE_DURATION_LOG_CUTOFF) {
+			TraceEvent(SevInfo, "LongComputeDuration")
+			    .suppressFor(5.0)
+			    .detail("EstimatedComputeDuration", estimatedDelay)
+			    .detail("ComputeDuration", self->computeDuration)
+			    .detail("ComputePerOperation", computePerOperation)
+			    .detail("LatencyBucket", self->latencyBucket)
+			    .detail("UpdatedComputePerOperationEstimate",
+			            pProxyCommitData->commitComputePerOperation[self->latencyBucket])
+			    .detail("BatchBytes", self->batchBytes)
+			    .detail("BatchOperations", self->batchOperations);
+		}
+
 		if (computePerOperation <= pProxyCommitData->commitComputePerOperation[self->latencyBucket]) {
 			pProxyCommitData->commitComputePerOperation[self->latencyBucket] = computePerOperation;
 		} else {
@@ -1402,18 +1420,6 @@ ACTOR Future<Void> postResolution(CommitBatchContext* self) {
 		pProxyCommitData->stats.minComputeNS =
 		    std::min<int64_t>(pProxyCommitData->stats.minComputeNS,
 		                      1e9 * pProxyCommitData->commitComputePerOperation[self->latencyBucket]);
-
-		if (self->computeDuration >= SERVER_KNOBS->MAX_COMPUTE_DURATION_LOG_CUTOFF) {
-			TraceEvent(SevInfo, "LongComputeDuration")
-			    .suppressFor(5.0)
-			    .detail("ComputeDuration", self->computeDuration)
-			    .detail("ComputePerOperation", computePerOperation)
-			    .detail("LatencyBucket", self->latencyBucket)
-			    .detail("UpdatedComputePerOperationEstimate",
-			            pProxyCommitData->commitComputePerOperation[self->latencyBucket])
-			    .detail("BatchBytes", self->batchBytes)
-			    .detail("BatchOperations", self->batchOperations);
-		}
 	}
 
 	pProxyCommitData->stats.processingMutationDist->sampleSeconds(now() - postResolutionQueuing);

From 8b489ae0bffbddfc470ac631fa17b3dbe6051328 Mon Sep 17 00:00:00 2001
From: Lukas Joswiak <lukas.joswiak@snowflake.com>
Date: Wed, 20 Apr 2022 15:42:17 -0700
Subject: [PATCH 72/84] Lower max compute duration cutoff and increase
 suppression duration

---
 fdbclient/ServerKnobs.cpp             | 2 +-
 fdbserver/CommitProxyServer.actor.cpp | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/fdbclient/ServerKnobs.cpp b/fdbclient/ServerKnobs.cpp
index 119e3e735e..1556241ea0 100644
--- a/fdbclient/ServerKnobs.cpp
+++ b/fdbclient/ServerKnobs.cpp
@@ -450,7 +450,7 @@ void ServerKnobs::initialize(Randomize randomize, ClientKnobs* clientKnobs, IsSi
 	init( MAX_COMMIT_UPDATES,                                    2000 ); if( randomize && BUGGIFY ) MAX_COMMIT_UPDATES = 1;
 	init( MAX_PROXY_COMPUTE,                                      2.0 );
 	init( MAX_COMPUTE_PER_OPERATION,                              0.1 );
-	init( MAX_COMPUTE_DURATION_LOG_CUTOFF,                       0.15 );
+	init( MAX_COMPUTE_DURATION_LOG_CUTOFF,                       0.05 );
 	init( PROXY_COMPUTE_BUCKETS,                                20000 );
 	init( PROXY_COMPUTE_GROWTH_RATE,                             0.01 );
 	init( TXN_STATE_SEND_AMOUNT,                                    4 );
diff --git a/fdbserver/CommitProxyServer.actor.cpp b/fdbserver/CommitProxyServer.actor.cpp
index f1add616f1..30c0753acf 100644
--- a/fdbserver/CommitProxyServer.actor.cpp
+++ b/fdbserver/CommitProxyServer.actor.cpp
@@ -1395,7 +1395,7 @@ ACTOR Future<Void> postResolution(CommitBatchContext* self) {
 		if (estimatedDelay >= SERVER_KNOBS->MAX_COMPUTE_DURATION_LOG_CUTOFF ||
 		    self->computeDuration >= SERVER_KNOBS->MAX_COMPUTE_DURATION_LOG_CUTOFF) {
 			TraceEvent(SevInfo, "LongComputeDuration")
-			    .suppressFor(5.0)
+			    .suppressFor(10.0)
 			    .detail("EstimatedComputeDuration", estimatedDelay)
 			    .detail("ComputeDuration", self->computeDuration)
 			    .detail("ComputePerOperation", computePerOperation)

From 0dc662bfd205f0ec6dfad45b463c15f03e332b6f Mon Sep 17 00:00:00 2001
From: Lukas Joswiak <lukas.joswiak@snowflake.com>
Date: Wed, 20 Apr 2022 15:46:41 -0700
Subject: [PATCH 73/84] Move trace below where is updated

---
 fdbserver/CommitProxyServer.actor.cpp | 30 +++++++++++++--------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/fdbserver/CommitProxyServer.actor.cpp b/fdbserver/CommitProxyServer.actor.cpp
index 30c0753acf..cddd5c929e 100644
--- a/fdbserver/CommitProxyServer.actor.cpp
+++ b/fdbserver/CommitProxyServer.actor.cpp
@@ -1388,24 +1388,10 @@ ACTOR Future<Void> postResolution(CommitBatchContext* self) {
 
 	self->computeDuration += g_network->timer() - self->computeStart;
 	if (self->batchOperations > 0) {
+		double estimatedDelay = computeReleaseDelay(self, self->latencyBucket);
 		double computePerOperation =
 		    std::min(SERVER_KNOBS->MAX_COMPUTE_PER_OPERATION, self->computeDuration / self->batchOperations);
 
-		double estimatedDelay = computeReleaseDelay(self, self->latencyBucket);
-		if (estimatedDelay >= SERVER_KNOBS->MAX_COMPUTE_DURATION_LOG_CUTOFF ||
-		    self->computeDuration >= SERVER_KNOBS->MAX_COMPUTE_DURATION_LOG_CUTOFF) {
-			TraceEvent(SevInfo, "LongComputeDuration")
-			    .suppressFor(10.0)
-			    .detail("EstimatedComputeDuration", estimatedDelay)
-			    .detail("ComputeDuration", self->computeDuration)
-			    .detail("ComputePerOperation", computePerOperation)
-			    .detail("LatencyBucket", self->latencyBucket)
-			    .detail("UpdatedComputePerOperationEstimate",
-			            pProxyCommitData->commitComputePerOperation[self->latencyBucket])
-			    .detail("BatchBytes", self->batchBytes)
-			    .detail("BatchOperations", self->batchOperations);
-		}
-
 		if (computePerOperation <= pProxyCommitData->commitComputePerOperation[self->latencyBucket]) {
 			pProxyCommitData->commitComputePerOperation[self->latencyBucket] = computePerOperation;
 		} else {
@@ -1420,6 +1406,20 @@ ACTOR Future<Void> postResolution(CommitBatchContext* self) {
 		pProxyCommitData->stats.minComputeNS =
 		    std::min<int64_t>(pProxyCommitData->stats.minComputeNS,
 		                      1e9 * pProxyCommitData->commitComputePerOperation[self->latencyBucket]);
+
+		if (estimatedDelay >= SERVER_KNOBS->MAX_COMPUTE_DURATION_LOG_CUTOFF ||
+		    self->computeDuration >= SERVER_KNOBS->MAX_COMPUTE_DURATION_LOG_CUTOFF) {
+			TraceEvent(SevInfo, "LongComputeDuration")
+			    .suppressFor(10.0)
+			    .detail("EstimatedComputeDuration", estimatedDelay)
+			    .detail("ComputeDuration", self->computeDuration)
+			    .detail("ComputePerOperation", computePerOperation)
+			    .detail("LatencyBucket", self->latencyBucket)
+			    .detail("UpdatedComputePerOperationEstimate",
+			            pProxyCommitData->commitComputePerOperation[self->latencyBucket])
+			    .detail("BatchBytes", self->batchBytes)
+			    .detail("BatchOperations", self->batchOperations);
+		}
 	}
 
 	pProxyCommitData->stats.processingMutationDist->sampleSeconds(now() - postResolutionQueuing);

From 0ae0bf9e3196c306e89e9878f130b6f8f5d80700 Mon Sep 17 00:00:00 2001
From: Lukas Joswiak <lukas.joswiak@snowflake.com>
Date: Wed, 27 Apr 2022 10:31:04 -0400
Subject: [PATCH 74/84] Add proxy debug ID

---
 fdbserver/CommitProxyServer.actor.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/fdbserver/CommitProxyServer.actor.cpp b/fdbserver/CommitProxyServer.actor.cpp
index cddd5c929e..8272cb3c07 100644
--- a/fdbserver/CommitProxyServer.actor.cpp
+++ b/fdbserver/CommitProxyServer.actor.cpp
@@ -1409,7 +1409,7 @@ ACTOR Future<Void> postResolution(CommitBatchContext* self) {
 
 		if (estimatedDelay >= SERVER_KNOBS->MAX_COMPUTE_DURATION_LOG_CUTOFF ||
 		    self->computeDuration >= SERVER_KNOBS->MAX_COMPUTE_DURATION_LOG_CUTOFF) {
-			TraceEvent(SevInfo, "LongComputeDuration")
+			TraceEvent(SevInfo, "LongComputeDuration", pProxyCommitData->dbgid)
 			    .suppressFor(10.0)
 			    .detail("EstimatedComputeDuration", estimatedDelay)
 			    .detail("ComputeDuration", self->computeDuration)

From 195a196392297292e5c149eab072dd6ae4e71b6b Mon Sep 17 00:00:00 2001
From: pranavPandit1 <pranav.pandit1@ibm.com>
Date: Thu, 28 Apr 2022 12:26:36 +0000
Subject: [PATCH 75/84] crc32 support added for ppc64le

---
 flow/CMakeLists.txt  |   4 +
 flow/crc32.S         | 791 +++++++++++++++++++++++++++++++++++++++++++
 flow/crc32_wrapper.c |  81 +++++
 flow/crc32_wrapper.h |  33 ++
 flow/crc32c.cpp      |  26 +-
 flow/ppc-asm.h       | 366 ++++++++++++++++++++
 flow/ppc-opcode.h    |  35 ++
 7 files changed, 1331 insertions(+), 5 deletions(-)
 create mode 100644 flow/crc32.S
 create mode 100644 flow/crc32_wrapper.c
 create mode 100644 flow/crc32_wrapper.h
 create mode 100644 flow/ppc-asm.h
 create mode 100644 flow/ppc-opcode.h

diff --git a/flow/CMakeLists.txt b/flow/CMakeLists.txt
index a2246df1a1..42e4f135ae 100644
--- a/flow/CMakeLists.txt
+++ b/flow/CMakeLists.txt
@@ -84,6 +84,10 @@ set(FLOW_SRCS
   actorcompiler.h
   crc32c.h
   crc32c.cpp
+  ppc-asm.h
+  crc32.S
+  crc32_wrapper.h
+  crc32_wrapper.c
   error_definitions.h
   ${CMAKE_CURRENT_BINARY_DIR}/SourceVersion.h
   flat_buffers.cpp
diff --git a/flow/crc32.S b/flow/crc32.S
new file mode 100644
index 0000000000..3c7f2efa58
--- /dev/null
+++ b/flow/crc32.S
@@ -0,0 +1,791 @@
+#if defined(__powerpc64__)
+/*
+ * Calculate the checksum of data that is 16 byte aligned and a multiple of
+ * 16 bytes.
+ *
+ * The first step is to reduce it to 1024 bits. We do this in 8 parallel
+ * chunks in order to mask the latency of the vpmsum instructions. If we
+ * have more than 32 kB of data to checksum we repeat this step multiple
+ * times, passing in the previous 1024 bits.
+ *
+ * The next step is to reduce the 1024 bits to 64 bits. This step adds
+ * 32 bits of 0s to the end - this matches what a CRC does. We just
+ * calculate constants that land the data in this 32 bits.
+ *
+ * We then use fixed point Barrett reduction to compute a mod n over GF(2)
+ * for n = CRC using POWER8 instructions. We use x = 32.
+ *
+ * http://en.wikipedia.org/wiki/Barrett_reduction
+ *
+ * Copyright (C) 2015 Anton Blanchard <anton@au.ibm.com>, IBM
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of either:
+ *
+ *  a) the GNU General Public License as published by the Free Software
+ *     Foundation; either version 2 of the License, or (at your option)
+ *     any later version, or
+ *  b) the Apache License, Version 2.0
+ */
+
+#if defined (__clang__)
+#ifndef __ALTIVEC__
+#define __ALTIVEC__
+#endif
+#include "ppc-asm.h"
+#else
+#include <ppc-asm.h>
+#endif
+#include "ppc-opcode.h"
+
+#undef toc
+
+#ifndef r1
+#define r1 1
+#endif
+
+#ifndef r2
+#define r2 2
+#endif
+
+	.section	.rodata
+.balign 16
+
+.byteswap_constant:
+	/* byte reverse permute constant */
+	.octa 0x0F0E0D0C0B0A09080706050403020100
+
+#ifdef CRC32_CONSTANTS_HEADER
+#include CRC32_CONSTANTS_HEADER
+#else
+#include "crc32_constants.h"
+#endif
+
+	.text
+
+#if defined(__BIG_ENDIAN__) && defined(REFLECT)
+#define BYTESWAP_DATA
+#elif defined(__LITTLE_ENDIAN__) && !defined(REFLECT)
+#define BYTESWAP_DATA
+#else
+#undef BYTESWAP_DATA
+#endif
+
+#define off16		r25
+#define off32		r26
+#define off48		r27
+#define off64		r28
+#define off80		r29
+#define off96		r30
+#define off112		r31
+
+#define const1		v24
+#define const2		v25
+
+#define byteswap	v26
+#define	mask_32bit	v27
+#define	mask_64bit	v28
+#define zeroes		v29
+
+#ifdef BYTESWAP_DATA
+#define VPERM(A, B, C, D) vperm	A, B, C, D
+#else
+#define VPERM(A, B, C, D)
+#endif
+
+#ifndef CRC32_FUNCTION_ASM
+#define CRC32_FUNCTION_ASM __crc32_vpmsum
+#endif
+
+//clang-format off
+
+/* unsigned int __crc32_vpmsum(unsigned int crc, void *p, unsigned long len) */
+FUNC_START(CRC32_FUNCTION_ASM)
+	std	r31,-8(r1)
+	std	r30,-16(r1)
+	std	r29,-24(r1)
+	std	r28,-32(r1)
+	std	r27,-40(r1)
+	std	r26,-48(r1)
+	std	r25,-56(r1)
+
+	li	off16,16
+	li	off32,32
+	li	off48,48
+	li	off64,64
+	li	off80,80
+	li	off96,96
+	li	off112,112
+	li	r0,0
+
+	/* Enough room for saving 10 non volatile VMX registers */
+	subi	r6,r1,56+10*16
+	subi	r7,r1,56+2*16
+
+	stvx	v20,0,r6
+	stvx	v21,off16,r6
+	stvx	v22,off32,r6
+	stvx	v23,off48,r6
+	stvx	v24,off64,r6
+	stvx	v25,off80,r6
+	stvx	v26,off96,r6
+	stvx	v27,off112,r6
+	stvx	v28,0,r7
+	stvx	v29,off16,r7
+
+	mr	r10,r3
+
+	vxor	zeroes,zeroes,zeroes
+	vspltisw v0,-1
+
+	vsldoi	mask_32bit,zeroes,v0,4
+	vsldoi	mask_64bit,zeroes,v0,8
+
+	/* Get the initial value into v8 */
+	vxor	v8,v8,v8
+	MTVRD(v8, r3)
+#ifdef REFLECT
+	vsldoi	v8,zeroes,v8,8	/* shift into bottom 32 bits */
+#else
+	vsldoi	v8,v8,zeroes,4	/* shift into top 32 bits */
+#endif
+
+#ifdef BYTESWAP_DATA
+	addis	r3,r2,.byteswap_constant@toc@ha
+	addi	r3,r3,.byteswap_constant@toc@l
+
+	lvx	byteswap,0,r3
+	addi	r3,r3,16
+#endif
+
+	cmpdi	r5,256
+	blt	.Lshort
+
+	rldicr	r6,r5,0,56
+
+	/* Checksum in blocks of MAX_SIZE */
+1:	lis	r7,MAX_SIZE@h
+	ori	r7,r7,MAX_SIZE@l
+	mr	r9,r7
+	cmpd	r6,r7
+	bgt	2f
+	mr	r7,r6
+2:	subf	r6,r7,r6
+
+	/* our main loop does 128 bytes at a time */
+	srdi	r7,r7,7
+
+	/*
+	 * Work out the offset into the constants table to start at. Each
+	 * constant is 16 bytes, and it is used against 128 bytes of input
+	 * data - 128 / 16 = 8
+	 */
+	sldi	r8,r7,4
+	srdi	r9,r9,3
+	subf	r8,r8,r9
+
+	/* We reduce our final 128 bytes in a separate step */
+	addi	r7,r7,-1
+	mtctr	r7
+
+	addis	r3,r2,.constants@toc@ha
+	addi	r3,r3,.constants@toc@l
+
+	/* Find the start of our constants */
+	add	r3,r3,r8
+
+	/* zero v0-v7 which will contain our checksums */
+	vxor	v0,v0,v0
+	vxor	v1,v1,v1
+	vxor	v2,v2,v2
+	vxor	v3,v3,v3
+	vxor	v4,v4,v4
+	vxor	v5,v5,v5
+	vxor	v6,v6,v6
+	vxor	v7,v7,v7
+
+	lvx	const1,0,r3
+
+	/*
+	 * If we are looping back to consume more data we use the values
+	 * already in v16-v23.
+	 */
+	cmpdi	r0,1
+	beq	2f
+
+	/* First warm up pass */
+	lvx	v16,0,r4
+	lvx	v17,off16,r4
+	VPERM(v16,v16,v16,byteswap)
+	VPERM(v17,v17,v17,byteswap)
+	lvx	v18,off32,r4
+	lvx	v19,off48,r4
+	VPERM(v18,v18,v18,byteswap)
+	VPERM(v19,v19,v19,byteswap)
+	lvx	v20,off64,r4
+	lvx	v21,off80,r4
+	VPERM(v20,v20,v20,byteswap)
+	VPERM(v21,v21,v21,byteswap)
+	lvx	v22,off96,r4
+	lvx	v23,off112,r4
+	VPERM(v22,v22,v22,byteswap)
+	VPERM(v23,v23,v23,byteswap)
+	addi	r4,r4,8*16
+
+	/* xor in initial value */
+	vxor	v16,v16,v8
+
+2:	bdz	.Lfirst_warm_up_done
+
+	addi	r3,r3,16
+	lvx	const2,0,r3
+
+	/* Second warm up pass */
+	VPMSUMD(v8,v16,const1)
+	lvx	v16,0,r4
+	VPERM(v16,v16,v16,byteswap)
+	ori	r2,r2,0
+
+	VPMSUMD(v9,v17,const1)
+	lvx	v17,off16,r4
+	VPERM(v17,v17,v17,byteswap)
+	ori	r2,r2,0
+
+	VPMSUMD(v10,v18,const1)
+	lvx	v18,off32,r4
+	VPERM(v18,v18,v18,byteswap)
+	ori	r2,r2,0
+
+	VPMSUMD(v11,v19,const1)
+	lvx	v19,off48,r4
+	VPERM(v19,v19,v19,byteswap)
+	ori	r2,r2,0
+
+	VPMSUMD(v12,v20,const1)
+	lvx	v20,off64,r4
+	VPERM(v20,v20,v20,byteswap)
+	ori	r2,r2,0
+
+	VPMSUMD(v13,v21,const1)
+	lvx	v21,off80,r4
+	VPERM(v21,v21,v21,byteswap)
+	ori	r2,r2,0
+
+	VPMSUMD(v14,v22,const1)
+	lvx	v22,off96,r4
+	VPERM(v22,v22,v22,byteswap)
+	ori	r2,r2,0
+
+	VPMSUMD(v15,v23,const1)
+	lvx	v23,off112,r4
+	VPERM(v23,v23,v23,byteswap)
+
+	addi	r4,r4,8*16
+
+	bdz	.Lfirst_cool_down
+
+	/*
+	 * main loop. We modulo schedule it such that it takes three iterations
+	 * to complete - first iteration load, second iteration vpmsum, third
+	 * iteration xor.
+	 */
+	.balign	16
+4:	lvx	const1,0,r3
+	addi	r3,r3,16
+	ori	r2,r2,0
+
+	vxor	v0,v0,v8
+	VPMSUMD(v8,v16,const2)
+	lvx	v16,0,r4
+	VPERM(v16,v16,v16,byteswap)
+	ori	r2,r2,0
+
+	vxor	v1,v1,v9
+	VPMSUMD(v9,v17,const2)
+	lvx	v17,off16,r4
+	VPERM(v17,v17,v17,byteswap)
+	ori	r2,r2,0
+
+	vxor	v2,v2,v10
+	VPMSUMD(v10,v18,const2)
+	lvx	v18,off32,r4
+	VPERM(v18,v18,v18,byteswap)
+	ori	r2,r2,0
+
+	vxor	v3,v3,v11
+	VPMSUMD(v11,v19,const2)
+	lvx	v19,off48,r4
+	VPERM(v19,v19,v19,byteswap)
+	lvx	const2,0,r3
+	ori	r2,r2,0
+
+	vxor	v4,v4,v12
+	VPMSUMD(v12,v20,const1)
+	lvx	v20,off64,r4
+	VPERM(v20,v20,v20,byteswap)
+	ori	r2,r2,0
+
+	vxor	v5,v5,v13
+	VPMSUMD(v13,v21,const1)
+	lvx	v21,off80,r4
+	VPERM(v21,v21,v21,byteswap)
+	ori	r2,r2,0
+
+	vxor	v6,v6,v14
+	VPMSUMD(v14,v22,const1)
+	lvx	v22,off96,r4
+	VPERM(v22,v22,v22,byteswap)
+	ori	r2,r2,0
+
+	vxor	v7,v7,v15
+	VPMSUMD(v15,v23,const1)
+	lvx	v23,off112,r4
+	VPERM(v23,v23,v23,byteswap)
+
+	addi	r4,r4,8*16
+
+	bdnz	4b
+
+.Lfirst_cool_down:
+	/* First cool down pass */
+	lvx	const1,0,r3
+	addi	r3,r3,16
+
+	vxor	v0,v0,v8
+	VPMSUMD(v8,v16,const1)
+	ori	r2,r2,0
+
+	vxor	v1,v1,v9
+	VPMSUMD(v9,v17,const1)
+	ori	r2,r2,0
+
+	vxor	v2,v2,v10
+	VPMSUMD(v10,v18,const1)
+	ori	r2,r2,0
+
+	vxor	v3,v3,v11
+	VPMSUMD(v11,v19,const1)
+	ori	r2,r2,0
+
+	vxor	v4,v4,v12
+	VPMSUMD(v12,v20,const1)
+	ori	r2,r2,0
+
+	vxor	v5,v5,v13
+	VPMSUMD(v13,v21,const1)
+	ori	r2,r2,0
+
+	vxor	v6,v6,v14
+	VPMSUMD(v14,v22,const1)
+	ori	r2,r2,0
+
+	vxor	v7,v7,v15
+	VPMSUMD(v15,v23,const1)
+	ori	r2,r2,0
+
+.Lsecond_cool_down:
+	/* Second cool down pass */
+	vxor	v0,v0,v8
+	vxor	v1,v1,v9
+	vxor	v2,v2,v10
+	vxor	v3,v3,v11
+	vxor	v4,v4,v12
+	vxor	v5,v5,v13
+	vxor	v6,v6,v14
+	vxor	v7,v7,v15
+
+#ifdef REFLECT
+	/*
+	 * vpmsumd produces a 96 bit result in the least significant bits
+	 * of the register. Since we are bit reflected we have to shift it
+	 * left 32 bits so it occupies the least significant bits in the
+	 * bit reflected domain.
+	 */
+	vsldoi	v0,v0,zeroes,4
+	vsldoi	v1,v1,zeroes,4
+	vsldoi	v2,v2,zeroes,4
+	vsldoi	v3,v3,zeroes,4
+	vsldoi	v4,v4,zeroes,4
+	vsldoi	v5,v5,zeroes,4
+	vsldoi	v6,v6,zeroes,4
+	vsldoi	v7,v7,zeroes,4
+#endif
+
+	/* xor with last 1024 bits */
+	lvx	v8,0,r4
+	lvx	v9,off16,r4
+	VPERM(v8,v8,v8,byteswap)
+	VPERM(v9,v9,v9,byteswap)
+	lvx	v10,off32,r4
+	lvx	v11,off48,r4
+	VPERM(v10,v10,v10,byteswap)
+	VPERM(v11,v11,v11,byteswap)
+	lvx	v12,off64,r4
+	lvx	v13,off80,r4
+	VPERM(v12,v12,v12,byteswap)
+	VPERM(v13,v13,v13,byteswap)
+	lvx	v14,off96,r4
+	lvx	v15,off112,r4
+	VPERM(v14,v14,v14,byteswap)
+	VPERM(v15,v15,v15,byteswap)
+
+	addi	r4,r4,8*16
+
+	vxor	v16,v0,v8
+	vxor	v17,v1,v9
+	vxor	v18,v2,v10
+	vxor	v19,v3,v11
+	vxor	v20,v4,v12
+	vxor	v21,v5,v13
+	vxor	v22,v6,v14
+	vxor	v23,v7,v15
+
+	li	r0,1
+	cmpdi	r6,0
+	addi	r6,r6,128
+	bne	1b
+
+	/* Work out how many bytes we have left */
+	andi.	r5,r5,127
+
+	/* Calculate where in the constant table we need to start */
+	subfic	r6,r5,128
+	add	r3,r3,r6
+
+	/* How many 16 byte chunks are in the tail */
+	srdi	r7,r5,4
+	mtctr	r7
+
+	/*
+	 * Reduce the previously calculated 1024 bits to 64 bits, shifting
+	 * 32 bits to include the trailing 32 bits of zeros
+	 */
+	lvx	v0,0,r3
+	lvx	v1,off16,r3
+	lvx	v2,off32,r3
+	lvx	v3,off48,r3
+	lvx	v4,off64,r3
+	lvx	v5,off80,r3
+	lvx	v6,off96,r3
+	lvx	v7,off112,r3
+	addi	r3,r3,8*16
+
+	VPMSUMW(v0,v16,v0)
+	VPMSUMW(v1,v17,v1)
+	VPMSUMW(v2,v18,v2)
+	VPMSUMW(v3,v19,v3)
+	VPMSUMW(v4,v20,v4)
+	VPMSUMW(v5,v21,v5)
+	VPMSUMW(v6,v22,v6)
+	VPMSUMW(v7,v23,v7)
+
+	/* Now reduce the tail (0 - 112 bytes) */
+	cmpdi	r7,0
+	beq	1f
+
+	lvx	v16,0,r4
+	lvx	v17,0,r3
+	VPERM(v16,v16,v16,byteswap)
+	VPMSUMW(v16,v16,v17)
+	vxor	v0,v0,v16
+	bdz	1f
+
+	lvx	v16,off16,r4
+	lvx	v17,off16,r3
+	VPERM(v16,v16,v16,byteswap)
+	VPMSUMW(v16,v16,v17)
+	vxor	v0,v0,v16
+	bdz	1f
+
+	lvx	v16,off32,r4
+	lvx	v17,off32,r3
+	VPERM(v16,v16,v16,byteswap)
+	VPMSUMW(v16,v16,v17)
+	vxor	v0,v0,v16
+	bdz	1f
+
+	lvx	v16,off48,r4
+	lvx	v17,off48,r3
+	VPERM(v16,v16,v16,byteswap)
+	VPMSUMW(v16,v16,v17)
+	vxor	v0,v0,v16
+	bdz	1f
+
+	lvx	v16,off64,r4
+	lvx	v17,off64,r3
+	VPERM(v16,v16,v16,byteswap)
+	VPMSUMW(v16,v16,v17)
+	vxor	v0,v0,v16
+	bdz	1f
+
+	lvx	v16,off80,r4
+	lvx	v17,off80,r3
+	VPERM(v16,v16,v16,byteswap)
+	VPMSUMW(v16,v16,v17)
+	vxor	v0,v0,v16
+	bdz	1f
+
+	lvx	v16,off96,r4
+	lvx	v17,off96,r3
+	VPERM(v16,v16,v16,byteswap)
+	VPMSUMW(v16,v16,v17)
+	vxor	v0,v0,v16
+
+	/* Now xor all the parallel chunks together */
+1:	vxor	v0,v0,v1
+	vxor	v2,v2,v3
+	vxor	v4,v4,v5
+	vxor	v6,v6,v7
+
+	vxor	v0,v0,v2
+	vxor	v4,v4,v6
+
+	vxor	v0,v0,v4
+
+.Lbarrett_reduction:
+	/* Barrett constants */
+	addis	r3,r2,.barrett_constants@toc@ha
+	addi	r3,r3,.barrett_constants@toc@l
+
+	lvx	const1,0,r3
+	lvx	const2,off16,r3
+
+	vsldoi	v1,v0,v0,8
+	vxor	v0,v0,v1		/* xor two 64 bit results together */
+
+#ifdef REFLECT
+	/* shift left one bit */
+	vspltisb v1,1
+	vsl	v0,v0,v1
+#endif
+
+	vand	v0,v0,mask_64bit
+
+#ifndef REFLECT
+	/*
+	 * Now for the Barrett reduction algorithm. The idea is to calculate q,
+	 * the multiple of our polynomial that we need to subtract. By
+	 * doing the computation 2x bits higher (ie 64 bits) and shifting the
+	 * result back down 2x bits, we round down to the nearest multiple.
+	 */
+	VPMSUMD(v1,v0,const1)	/* ma */
+	vsldoi	v1,zeroes,v1,8	/* q = floor(ma/(2^64)) */
+	VPMSUMD(v1,v1,const2)	/* qn */
+	vxor	v0,v0,v1	/* a - qn, subtraction is xor in GF(2) */
+
+	/*
+	 * Get the result into r3. We need to shift it left 8 bytes:
+	 * V0 [ 0 1 2 X ]
+	 * V0 [ 0 X 2 3 ]
+	 */
+	vsldoi	v0,v0,zeroes,8	/* shift result into top 64 bits */
+#else
+	/*
+	 * The reflected version of Barrett reduction. Instead of bit
+	 * reflecting our data (which is expensive to do), we bit reflect our
+	 * constants and our algorithm, which means the intermediate data in
+	 * our vector registers goes from 0-63 instead of 63-0. We can reflect
+	 * the algorithm because we don't carry in mod 2 arithmetic.
+	 */
+	vand	v1,v0,mask_32bit	/* bottom 32 bits of a */
+	VPMSUMD(v1,v1,const1)		/* ma */
+	vand	v1,v1,mask_32bit	/* bottom 32bits of ma */
+	VPMSUMD(v1,v1,const2)		/* qn */
+	vxor	v0,v0,v1		/* a - qn, subtraction is xor in GF(2) */
+
+	/*
+	 * Since we are bit reflected, the result (ie the low 32 bits) is in
+	 * the high 32 bits. We just need to shift it left 4 bytes
+	 * V0 [ 0 1 X 3 ]
+	 * V0 [ 0 X 2 3 ]
+	 */
+	vsldoi	v0,v0,zeroes,4		/* shift result into top 64 bits of */
+#endif
+
+	/* Get it into r3 */
+	MFVRD(r3, v0)
+
+.Lout:
+	subi	r6,r1,56+10*16
+	subi	r7,r1,56+2*16
+
+	lvx	v20,0,r6
+	lvx	v21,off16,r6
+	lvx	v22,off32,r6
+	lvx	v23,off48,r6
+	lvx	v24,off64,r6
+	lvx	v25,off80,r6
+	lvx	v26,off96,r6
+	lvx	v27,off112,r6
+	lvx	v28,0,r7
+	lvx	v29,off16,r7
+
+	ld	r31,-8(r1)
+	ld	r30,-16(r1)
+	ld	r29,-24(r1)
+	ld	r28,-32(r1)
+	ld	r27,-40(r1)
+	ld	r26,-48(r1)
+	ld	r25,-56(r1)
+
+	blr
+
+.Lfirst_warm_up_done:
+	lvx	const1,0,r3
+	addi	r3,r3,16
+
+	VPMSUMD(v8,v16,const1)
+	VPMSUMD(v9,v17,const1)
+	VPMSUMD(v10,v18,const1)
+	VPMSUMD(v11,v19,const1)
+	VPMSUMD(v12,v20,const1)
+	VPMSUMD(v13,v21,const1)
+	VPMSUMD(v14,v22,const1)
+	VPMSUMD(v15,v23,const1)
+
+	b	.Lsecond_cool_down
+
+.Lshort:
+	cmpdi	r5,0
+	beq	.Lzero
+
+	addis	r3,r2,.short_constants@toc@ha
+	addi	r3,r3,.short_constants@toc@l
+
+	/* Calculate where in the constant table we need to start */
+	subfic	r6,r5,256
+	add	r3,r3,r6
+
+	/* How many 16 byte chunks? */
+	srdi	r7,r5,4
+	mtctr	r7
+
+	vxor	v19,v19,v19
+	vxor	v20,v20,v20
+
+	lvx	v0,0,r4
+	lvx	v16,0,r3
+	VPERM(v0,v0,v16,byteswap)
+	vxor	v0,v0,v8	/* xor in initial value */
+	VPMSUMW(v0,v0,v16)
+	bdz	.Lv0
+
+	lvx	v1,off16,r4
+	lvx	v17,off16,r3
+	VPERM(v1,v1,v17,byteswap)
+	VPMSUMW(v1,v1,v17)
+	bdz	.Lv1
+
+	lvx	v2,off32,r4
+	lvx	v16,off32,r3
+	VPERM(v2,v2,v16,byteswap)
+	VPMSUMW(v2,v2,v16)
+	bdz	.Lv2
+
+	lvx	v3,off48,r4
+	lvx	v17,off48,r3
+	VPERM(v3,v3,v17,byteswap)
+	VPMSUMW(v3,v3,v17)
+	bdz	.Lv3
+
+	lvx	v4,off64,r4
+	lvx	v16,off64,r3
+	VPERM(v4,v4,v16,byteswap)
+	VPMSUMW(v4,v4,v16)
+	bdz	.Lv4
+
+	lvx	v5,off80,r4
+	lvx	v17,off80,r3
+	VPERM(v5,v5,v17,byteswap)
+	VPMSUMW(v5,v5,v17)
+	bdz	.Lv5
+
+	lvx	v6,off96,r4
+	lvx	v16,off96,r3
+	VPERM(v6,v6,v16,byteswap)
+	VPMSUMW(v6,v6,v16)
+	bdz	.Lv6
+
+	lvx	v7,off112,r4
+	lvx	v17,off112,r3
+	VPERM(v7,v7,v17,byteswap)
+	VPMSUMW(v7,v7,v17)
+	bdz	.Lv7
+
+	addi	r3,r3,128
+	addi	r4,r4,128
+
+	lvx	v8,0,r4
+	lvx	v16,0,r3
+	VPERM(v8,v8,v16,byteswap)
+	VPMSUMW(v8,v8,v16)
+	bdz	.Lv8
+
+	lvx	v9,off16,r4
+	lvx	v17,off16,r3
+	VPERM(v9,v9,v17,byteswap)
+	VPMSUMW(v9,v9,v17)
+	bdz	.Lv9
+
+	lvx	v10,off32,r4
+	lvx	v16,off32,r3
+	VPERM(v10,v10,v16,byteswap)
+	VPMSUMW(v10,v10,v16)
+	bdz	.Lv10
+
+	lvx	v11,off48,r4
+	lvx	v17,off48,r3
+	VPERM(v11,v11,v17,byteswap)
+	VPMSUMW(v11,v11,v17)
+	bdz	.Lv11
+
+	lvx	v12,off64,r4
+	lvx	v16,off64,r3
+	VPERM(v12,v12,v16,byteswap)
+	VPMSUMW(v12,v12,v16)
+	bdz	.Lv12
+
+	lvx	v13,off80,r4
+	lvx	v17,off80,r3
+	VPERM(v13,v13,v17,byteswap)
+	VPMSUMW(v13,v13,v17)
+	bdz	.Lv13
+
+	lvx	v14,off96,r4
+	lvx	v16,off96,r3
+	VPERM(v14,v14,v16,byteswap)
+	VPMSUMW(v14,v14,v16)
+	bdz	.Lv14
+
+	lvx	v15,off112,r4
+	lvx	v17,off112,r3
+	VPERM(v15,v15,v17,byteswap)
+	VPMSUMW(v15,v15,v17)
+
+.Lv15:	vxor	v19,v19,v15
+.Lv14:	vxor	v20,v20,v14
+.Lv13:	vxor	v19,v19,v13
+.Lv12:	vxor	v20,v20,v12
+.Lv11:	vxor	v19,v19,v11
+.Lv10:	vxor	v20,v20,v10
+.Lv9:	vxor	v19,v19,v9
+.Lv8:	vxor	v20,v20,v8
+.Lv7:	vxor	v19,v19,v7
+.Lv6:	vxor	v20,v20,v6
+.Lv5:	vxor	v19,v19,v5
+.Lv4:	vxor	v20,v20,v4
+.Lv3:	vxor	v19,v19,v3
+.Lv2:	vxor	v20,v20,v2
+.Lv1:	vxor	v19,v19,v1
+.Lv0:	vxor	v20,v20,v0
+
+	vxor	v0,v19,v20
+
+	b	.Lbarrett_reduction
+
+.Lzero:
+	mr	r3,r10
+	b	.Lout
+
+FUNC_END(CRC32_FUNCTION_ASM)
+#endif
diff --git a/flow/crc32_wrapper.c b/flow/crc32_wrapper.c
new file mode 100644
index 0000000000..fb08c9d007
--- /dev/null
+++ b/flow/crc32_wrapper.c
@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2015 Anton Blanchard <anton@au.ibm.com>, IBM
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of either:
+ *
+ *  a) the GNU General Public License as published by the Free Software
+ *     Foundation; either version 2 of the License, or (at your option)
+ *     any later version, or
+ *  b) the Apache License, Version 2.0
+ */
+
+#define CRC_TABLE
+
+#ifdef CRC32_CONSTANTS_HEADER
+#include CRC32_CONSTANTS_HEADER
+#else
+#include "crc32_constants.h"
+#endif
+
+#define VMX_ALIGN 16
+#define VMX_ALIGN_MASK (VMX_ALIGN - 1)
+
+#ifdef REFLECT
+static unsigned int crc32_align(unsigned int crc, unsigned char* p, unsigned long len) {
+	while (len--)
+		crc = crc_table[(crc ^ *p++) & 0xff] ^ (crc >> 8);
+	return crc;
+}
+#else
+static unsigned int crc32_align(unsigned int crc, unsigned char* p, unsigned long len) {
+	while (len--)
+		crc = crc_table[((crc >> 24) ^ *p++) & 0xff] ^ (crc << 8);
+	return crc;
+}
+#endif
+
+#ifndef CRC32_FUNCTION
+#define CRC32_FUNCTION crc32_vpmsum
+#endif
+#ifndef CRC32_FUNCTION_ASM
+#define CRC32_FUNCTION_ASM __crc32_vpmsum
+#endif
+
+unsigned int CRC32_FUNCTION_ASM(unsigned int crc, unsigned char* p, unsigned long len);
+
+unsigned int CRC32_FUNCTION(unsigned int crc, unsigned char* p, unsigned long len) {
+	unsigned int prealign;
+	unsigned int tail;
+
+#ifdef CRC_XOR
+	crc ^= 0xffffffff;
+#endif
+
+	if (len < VMX_ALIGN + VMX_ALIGN_MASK) {
+		crc = crc32_align(crc, p, len);
+		goto out;
+	}
+
+	if ((unsigned long)p & VMX_ALIGN_MASK) {
+		prealign = VMX_ALIGN - ((unsigned long)p & VMX_ALIGN_MASK);
+		crc = crc32_align(crc, p, prealign);
+		len -= prealign;
+		p += prealign;
+	}
+
+	crc = CRC32_FUNCTION_ASM(crc, p, len & ~VMX_ALIGN_MASK);
+
+	tail = len & VMX_ALIGN_MASK;
+	if (tail) {
+		p += len & ~VMX_ALIGN_MASK;
+		crc = crc32_align(crc, p, tail);
+	}
+
+out:
+#ifdef CRC_XOR
+	crc ^= 0xffffffff;
+#endif
+
+	return crc;
+}
diff --git a/flow/crc32_wrapper.h b/flow/crc32_wrapper.h
new file mode 100644
index 0000000000..e2eddd0595
--- /dev/null
+++ b/flow/crc32_wrapper.h
@@ -0,0 +1,33 @@
+
+/*
+ * crc32_wrapper.h
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2013-2022 Apple Inc. and the FoundationDB project authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef FLOW_CRC32_WRAPPER_H
+#define FLOW_CRC32_WRAPPER_H
+#pragma once
+
+#ifdef __powerpc64__
+extern "C" {
+unsigned int crc32_vpmsum(unsigned int crc, unsigned char* p, unsigned long len);
+}
+
+#endif // powerpc64
+
+#endif
diff --git a/flow/crc32c.cpp b/flow/crc32c.cpp
index 07cfac5ede..2aabdee843 100644
--- a/flow/crc32c.cpp
+++ b/flow/crc32c.cpp
@@ -266,13 +266,29 @@ append_hw(uint32_t crc, const uint8_t* buf, size_t len) {
 }
 #endif
 
+#ifdef __powerpc64__
+#include "crc32_wrapper.h"
+
+#ifndef CRC32_FUNCTION
+#define CRC32_FUNCTION crc32_vpmsum
+#endif
+
+uint32_t ppc_hw(uint32_t crc, const uint8_t* input, size_t length) {
+        return CRC32_FUNCTION(0, (unsigned char*)input, (unsigned long)length);
+}
+#endif
+
 static bool hw_available = platform::isHwCrcSupported();
 
 extern "C" uint32_t crc32c_append(uint32_t crc, const uint8_t* input, size_t length) {
-#ifndef __powerpc64__
-	if (hw_available)
-		return append_hw(crc, input, length);
-	else
+        if (hw_available) {
+#ifdef __powerpc64__
+                return ppc_hw(crc, input, length);
 #endif
-		return append_table(crc, input, length);
+#ifndef __powerpc64__
+                return append_hw(crc, input, length);
+#endif
+        } else
+                return append_table(crc, input, length);
 }
+
diff --git a/flow/ppc-asm.h b/flow/ppc-asm.h
new file mode 100644
index 0000000000..73572d17eb
--- /dev/null
+++ b/flow/ppc-asm.h
@@ -0,0 +1,366 @@
+/* PowerPC asm definitions for GNU C.
+
+Copyright (C) 2002-2017 Free Software Foundation, Inc.
+
+This file is part of GCC.
+
+GCC is free software; you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free
+Software Foundation; either version 3, or (at your option) any later
+version.
+
+GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+WARRANTY; without even the implied warranty of MERCHANTABILITY or
+FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+for more details.
+
+Under Section 7 of GPL version 3, you are granted additional
+permissions described in the GCC Runtime Library Exception, version
+3.1, as published by the Free Software Foundation.
+
+You should have received a copy of the GNU General Public License and
+a copy of the GCC Runtime Library Exception along with this program;
+see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+<http://www.gnu.org/licenses/>.  */
+
+/* Under winnt, 1) gas supports the following as names and 2) in particular
+   defining "toc" breaks the FUNC_START macro as ".toc" becomes ".2" */
+
+#define r0 0
+#define sp 1
+#define toc 2
+#define r3 3
+#define r4 4
+#define r5 5
+#define r6 6
+#define r7 7
+#define r8 8
+#define r9 9
+#define r10 10
+#define r11 11
+#define r12 12
+#define r13 13
+#define r14 14
+#define r15 15
+#define r16 16
+#define r17 17
+#define r18 18
+#define r19 19
+#define r20 20
+#define r21 21
+#define r22 22
+#define r23 23
+#define r24 24
+#define r25 25
+#define r26 26
+#define r27 27
+#define r28 28
+#define r29 29
+#define r30 30
+#define r31 31
+
+#define cr0 0
+#define cr1 1
+#define cr2 2
+#define cr3 3
+#define cr4 4
+#define cr5 5
+#define cr6 6
+#define cr7 7
+
+#define f0 0
+#define f1 1
+#define f2 2
+#define f3 3
+#define f4 4
+#define f5 5
+#define f6 6
+#define f7 7
+#define f8 8
+#define f9 9
+#define f10 10
+#define f11 11
+#define f12 12
+#define f13 13
+#define f14 14
+#define f15 15
+#define f16 16
+#define f17 17
+#define f18 18
+#define f19 19
+#define f20 20
+#define f21 21
+#define f22 22
+#define f23 23
+#define f24 24
+#define f25 25
+#define f26 26
+#define f27 27
+#define f28 28
+#define f29 29
+#define f30 30
+#define f31 31
+
+#ifdef __VSX__
+#define f32 32
+#define f33 33
+#define f34 34
+#define f35 35
+#define f36 36
+#define f37 37
+#define f38 38
+#define f39 39
+#define f40 40
+#define f41 41
+#define f42 42
+#define f43 43
+#define f44 44
+#define f45 45
+#define f46 46
+#define f47 47
+#define f48 48
+#define f49 49
+#define f50 30
+#define f51 51
+#define f52 52
+#define f53 53
+#define f54 54
+#define f55 55
+#define f56 56
+#define f57 57
+#define f58 58
+#define f59 59
+#define f60 60
+#define f61 61
+#define f62 62
+#define f63 63
+#endif
+
+#ifdef __ALTIVEC__
+#define v0 0
+#define v1 1
+#define v2 2
+#define v3 3
+#define v4 4
+#define v5 5
+#define v6 6
+#define v7 7
+#define v8 8
+#define v9 9
+#define v10 10
+#define v11 11
+#define v12 12
+#define v13 13
+#define v14 14
+#define v15 15
+#define v16 16
+#define v17 17
+#define v18 18
+#define v19 19
+#define v20 20
+#define v21 21
+#define v22 22
+#define v23 23
+#define v24 24
+#define v25 25
+#define v26 26
+#define v27 27
+#define v28 28
+#define v29 29
+#define v30 30
+#define v31 31
+#endif
+
+#ifdef __VSX__
+#define vs0 0
+#define vs1 1
+#define vs2 2
+#define vs3 3
+#define vs4 4
+#define vs5 5
+#define vs6 6
+#define vs7 7
+#define vs8 8
+#define vs9 9
+#define vs10 10
+#define vs11 11
+#define vs12 12
+#define vs13 13
+#define vs14 14
+#define vs15 15
+#define vs16 16
+#define vs17 17
+#define vs18 18
+#define vs19 19
+#define vs20 20
+#define vs21 21
+#define vs22 22
+#define vs23 23
+#define vs24 24
+#define vs25 25
+#define vs26 26
+#define vs27 27
+#define vs28 28
+#define vs29 29
+#define vs30 30
+#define vs31 31
+#define vs32 32
+#define vs33 33
+#define vs34 34
+#define vs35 35
+#define vs36 36
+#define vs37 37
+#define vs38 38
+#define vs39 39
+#define vs40 40
+#define vs41 41
+#define vs42 42
+#define vs43 43
+#define vs44 44
+#define vs45 45
+#define vs46 46
+#define vs47 47
+#define vs48 48
+#define vs49 49
+#define vs50 30
+#define vs51 51
+#define vs52 52
+#define vs53 53
+#define vs54 54
+#define vs55 55
+#define vs56 56
+#define vs57 57
+#define vs58 58
+#define vs59 59
+#define vs60 60
+#define vs61 61
+#define vs62 62
+#define vs63 63
+#endif
+
+/*
+ * Macros to glue together two tokens.
+ */
+
+#ifdef __STDC__
+#define XGLUE(a, b) a##b
+#else
+#define XGLUE(a, b) a /**/ b
+#endif
+
+#define GLUE(a, b) XGLUE(a, b)
+
+/*
+ * Macros to begin and end a function written in assembler.  If -mcall-aixdesc
+ * or -mcall-nt, create a function descriptor with the given name, and create
+ * the real function with one or two leading periods respectively.
+ */
+
+#if defined(__powerpc64__) && _CALL_ELF == 2
+
+/* Defining "toc" above breaks @toc in assembler code.  */
+#undef toc
+
+#define FUNC_NAME(name) GLUE(__USER_LABEL_PREFIX__, name)
+#define JUMP_TARGET(name) FUNC_NAME(name)
+#define FUNC_START(name)                                                                                               \
+	.type FUNC_NAME(name), @function;                                                                                  \
+	.globl FUNC_NAME(name);                                                                                            \
+	FUNC_NAME(name) : 0 : addis 2, 12, (.TOC.- 0b) @ha;                                                                \
+	addi 2, 2, (.TOC.- 0b) @l;                                                                                         \
+	.localentry FUNC_NAME(name), .- FUNC_NAME(name)
+
+#define HIDDEN_FUNC(name) FUNC_START(name).hidden FUNC_NAME(name);
+
+#define FUNC_END(name) .size FUNC_NAME(name), .- FUNC_NAME(name)
+
+#elif defined(__powerpc64__)
+
+#define FUNC_NAME(name) GLUE(., name)
+#define JUMP_TARGET(name) FUNC_NAME(name)
+#define FUNC_START(name)                                                                                               \
+	.section ".opd", "aw";                                                                                             \
+	name:                                                                                                              \
+	.quad GLUE(., name);                                                                                               \
+	.quad.TOC.@tocbase;                                                                                                \
+	.quad 0;                                                                                                           \
+	.previous;                                                                                                         \
+	.type GLUE(., name), @function;                                                                                    \
+	.globl name;                                                                                                       \
+	.globl GLUE(., name);                                                                                              \
+	GLUE(., name) :
+
+#define HIDDEN_FUNC(name)                                                                                              \
+	FUNC_START(name).hidden name;                                                                                      \
+	.hidden GLUE(., name);
+
+#define FUNC_END(name) GLUE(.L, name) :.size GLUE(., name), GLUE(.L, name) - GLUE(., name)
+
+#elif defined(_CALL_AIXDESC)
+
+#ifdef _RELOCATABLE
+#define DESC_SECTION ".got2"
+#else
+#define DESC_SECTION ".got1"
+#endif
+
+#define FUNC_NAME(name) GLUE(., name)
+#define JUMP_TARGET(name) FUNC_NAME(name)
+#define FUNC_START(name)                                                                                               \
+	.section DESC_SECTION, "aw";                                                                                       \
+	name:                                                                                                              \
+	.long GLUE(., name);                                                                                               \
+	.long _GLOBAL_OFFSET_TABLE_;                                                                                       \
+	.long 0;                                                                                                           \
+	.previous;                                                                                                         \
+	.type GLUE(., name), @function;                                                                                    \
+	.globl name;                                                                                                       \
+	.globl GLUE(., name);                                                                                              \
+	GLUE(., name) :
+
+#define HIDDEN_FUNC(name)                                                                                              \
+	FUNC_START(name).hidden name;                                                                                      \
+	.hidden GLUE(., name);
+
+#define FUNC_END(name) GLUE(.L, name) :.size GLUE(., name), GLUE(.L, name) - GLUE(., name)
+
+#else
+
+#define FUNC_NAME(name) GLUE(__USER_LABEL_PREFIX__, name)
+#if defined __PIC__ || defined __pic__
+#define JUMP_TARGET(name) FUNC_NAME(name @plt)
+#else
+#define JUMP_TARGET(name) FUNC_NAME(name)
+#endif
+#define FUNC_START(name)                                                                                               \
+	.type FUNC_NAME(name), @function;                                                                                  \
+	.globl FUNC_NAME(name);                                                                                            \
+	FUNC_NAME(name) :
+
+#define HIDDEN_FUNC(name) FUNC_START(name).hidden FUNC_NAME(name);
+
+#define FUNC_END(name) GLUE(.L, name) :.size FUNC_NAME(name), GLUE(.L, name) - FUNC_NAME(name)
+#endif
+
+#ifdef IN_GCC
+/* For HAVE_GAS_CFI_DIRECTIVE.  */
+#include "auto-host.h"
+
+#ifdef HAVE_GAS_CFI_DIRECTIVE
+#define CFI_STARTPROC .cfi_startproc
+#define CFI_ENDPROC .cfi_endproc
+#define CFI_OFFSET(reg, off) .cfi_offset reg, off
+#define CFI_DEF_CFA_REGISTER(reg) .cfi_def_cfa_register reg
+#define CFI_RESTORE(reg) .cfi_restore reg
+#else
+#define CFI_STARTPROC
+#define CFI_ENDPROC
+#define CFI_OFFSET(reg, off)
+#define CFI_DEF_CFA_REGISTER(reg)
+#define CFI_RESTORE(reg)
+#endif
+#endif
+
+#if defined __linux__
+.section.note.GNU - stack.previous
+#endif
diff --git a/flow/ppc-opcode.h b/flow/ppc-opcode.h
new file mode 100644
index 0000000000..2fd18407c0
--- /dev/null
+++ b/flow/ppc-opcode.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2015 Anton Blanchard <anton@au.ibm.com>, IBM
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of either:
+ *
+ *  a) the GNU General Public License as published by the Free Software
+ *     Foundation; either version 2 of the License, or (at your option)
+ *     any later version, or
+ *  b) the Apache License, Version 2.0
+ */
+
+#ifndef __OPCODES_H
+#define __OPCODES_H
+
+#define __PPC_RA(a) (((a)&0x1f) << 16)
+#define __PPC_RB(b) (((b)&0x1f) << 11)
+#define __PPC_XA(a) ((((a)&0x1f) << 16) | (((a)&0x20) >> 3))
+#define __PPC_XB(b) ((((b)&0x1f) << 11) | (((b)&0x20) >> 4))
+#define __PPC_XS(s) ((((s)&0x1f) << 21) | (((s)&0x20) >> 5))
+#define __PPC_XT(s) __PPC_XS(s)
+#define VSX_XX3(t, a, b) (__PPC_XT(t) | __PPC_XA(a) | __PPC_XB(b))
+#define VSX_XX1(s, a, b) (__PPC_XS(s) | __PPC_RA(a) | __PPC_RB(b))
+
+#define PPC_INST_VPMSUMW 0x10000488
+#define PPC_INST_VPMSUMD 0x100004c8
+#define PPC_INST_MFVSRD 0x7c000066
+#define PPC_INST_MTVSRD 0x7c000166
+
+#define VPMSUMW(t, a, b) .long PPC_INST_VPMSUMW | VSX_XX3((t), a, b)
+#define VPMSUMD(t, a, b) .long PPC_INST_VPMSUMD | VSX_XX3((t), a, b)
+#define MFVRD(a, t) .long PPC_INST_MFVSRD | VSX_XX1((t) + 32, a, 0)
+#define MTVRD(t, a) .long PPC_INST_MTVSRD | VSX_XX1((t) + 32, a, 0)
+
+#endif

From 5794fd4e91b7e9f0e1007367acbcaf8e14de789a Mon Sep 17 00:00:00 2001
From: pranavPandit1 <pranav.pandit1@ibm.com>
Date: Thu, 28 Apr 2022 12:41:48 +0000
Subject: [PATCH 76/84] clang format corrected for file

---
 flow/crc32c.cpp | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/flow/crc32c.cpp b/flow/crc32c.cpp
index 2aabdee843..776e61b698 100644
--- a/flow/crc32c.cpp
+++ b/flow/crc32c.cpp
@@ -274,21 +274,20 @@ append_hw(uint32_t crc, const uint8_t* buf, size_t len) {
 #endif
 
 uint32_t ppc_hw(uint32_t crc, const uint8_t* input, size_t length) {
-        return CRC32_FUNCTION(0, (unsigned char*)input, (unsigned long)length);
+	return CRC32_FUNCTION(0, (unsigned char*)input, (unsigned long)length);
 }
 #endif
 
 static bool hw_available = platform::isHwCrcSupported();
 
 extern "C" uint32_t crc32c_append(uint32_t crc, const uint8_t* input, size_t length) {
-        if (hw_available) {
+	if (hw_available) {
 #ifdef __powerpc64__
-                return ppc_hw(crc, input, length);
+		return ppc_hw(crc, input, length);
 #endif
 #ifndef __powerpc64__
-                return append_hw(crc, input, length);
+		return append_hw(crc, input, length);
 #endif
-        } else
-                return append_table(crc, input, length);
+	} else
+		return append_table(crc, input, length);
 }
-

From a192264e7e52661c352858e11c94f151045c001d Mon Sep 17 00:00:00 2001
From: pranavPandit1 <pranav.pandit1@ibm.com>
Date: Thu, 28 Apr 2022 12:45:00 +0000
Subject: [PATCH 77/84] missing file added

---
 flow/crc32_constants.h | 1994 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1994 insertions(+)
 create mode 100644 flow/crc32_constants.h

diff --git a/flow/crc32_constants.h b/flow/crc32_constants.h
new file mode 100644
index 0000000000..66d575bb9f
--- /dev/null
+++ b/flow/crc32_constants.h
@@ -0,0 +1,1994 @@
+/*
+*
+* THIS FILE IS GENERATED WITH
+./crc32_constants -r -x 0x11EDC6F41
+
+* This is from https://github.com/antonblanchard/crc32-vpmsum/
+* DO NOT MODIFY IT MANUALLY!
+*
+*/
+
+#define CRC 0x1edc6f41
+#define CRC_XOR
+#define REFLECT
+#define MAX_SIZE 32768
+
+#ifndef __ASSEMBLER__
+#ifdef CRC_TABLE
+static const unsigned int crc_table[] = {
+	0x00000000, 0xf26b8303, 0xe13b70f7, 0x1350f3f4, 0xc79a971f, 0x35f1141c, 0x26a1e7e8, 0xd4ca64eb, 0x8ad958cf,
+	0x78b2dbcc, 0x6be22838, 0x9989ab3b, 0x4d43cfd0, 0xbf284cd3, 0xac78bf27, 0x5e133c24, 0x105ec76f, 0xe235446c,
+	0xf165b798, 0x030e349b, 0xd7c45070, 0x25afd373, 0x36ff2087, 0xc494a384, 0x9a879fa0, 0x68ec1ca3, 0x7bbcef57,
+	0x89d76c54, 0x5d1d08bf, 0xaf768bbc, 0xbc267848, 0x4e4dfb4b, 0x20bd8ede, 0xd2d60ddd, 0xc186fe29, 0x33ed7d2a,
+	0xe72719c1, 0x154c9ac2, 0x061c6936, 0xf477ea35, 0xaa64d611, 0x580f5512, 0x4b5fa6e6, 0xb93425e5, 0x6dfe410e,
+	0x9f95c20d, 0x8cc531f9, 0x7eaeb2fa, 0x30e349b1, 0xc288cab2, 0xd1d83946, 0x23b3ba45, 0xf779deae, 0x05125dad,
+	0x1642ae59, 0xe4292d5a, 0xba3a117e, 0x4851927d, 0x5b016189, 0xa96ae28a, 0x7da08661, 0x8fcb0562, 0x9c9bf696,
+	0x6ef07595, 0x417b1dbc, 0xb3109ebf, 0xa0406d4b, 0x522bee48, 0x86e18aa3, 0x748a09a0, 0x67dafa54, 0x95b17957,
+	0xcba24573, 0x39c9c670, 0x2a993584, 0xd8f2b687, 0x0c38d26c, 0xfe53516f, 0xed03a29b, 0x1f682198, 0x5125dad3,
+	0xa34e59d0, 0xb01eaa24, 0x42752927, 0x96bf4dcc, 0x64d4cecf, 0x77843d3b, 0x85efbe38, 0xdbfc821c, 0x2997011f,
+	0x3ac7f2eb, 0xc8ac71e8, 0x1c661503, 0xee0d9600, 0xfd5d65f4, 0x0f36e6f7, 0x61c69362, 0x93ad1061, 0x80fde395,
+	0x72966096, 0xa65c047d, 0x5437877e, 0x4767748a, 0xb50cf789, 0xeb1fcbad, 0x197448ae, 0x0a24bb5a, 0xf84f3859,
+	0x2c855cb2, 0xdeeedfb1, 0xcdbe2c45, 0x3fd5af46, 0x7198540d, 0x83f3d70e, 0x90a324fa, 0x62c8a7f9, 0xb602c312,
+	0x44694011, 0x5739b3e5, 0xa55230e6, 0xfb410cc2, 0x092a8fc1, 0x1a7a7c35, 0xe811ff36, 0x3cdb9bdd, 0xceb018de,
+	0xdde0eb2a, 0x2f8b6829, 0x82f63b78, 0x709db87b, 0x63cd4b8f, 0x91a6c88c, 0x456cac67, 0xb7072f64, 0xa457dc90,
+	0x563c5f93, 0x082f63b7, 0xfa44e0b4, 0xe9141340, 0x1b7f9043, 0xcfb5f4a8, 0x3dde77ab, 0x2e8e845f, 0xdce5075c,
+	0x92a8fc17, 0x60c37f14, 0x73938ce0, 0x81f80fe3, 0x55326b08, 0xa759e80b, 0xb4091bff, 0x466298fc, 0x1871a4d8,
+	0xea1a27db, 0xf94ad42f, 0x0b21572c, 0xdfeb33c7, 0x2d80b0c4, 0x3ed04330, 0xccbbc033, 0xa24bb5a6, 0x502036a5,
+	0x4370c551, 0xb11b4652, 0x65d122b9, 0x97baa1ba, 0x84ea524e, 0x7681d14d, 0x2892ed69, 0xdaf96e6a, 0xc9a99d9e,
+	0x3bc21e9d, 0xef087a76, 0x1d63f975, 0x0e330a81, 0xfc588982, 0xb21572c9, 0x407ef1ca, 0x532e023e, 0xa145813d,
+	0x758fe5d6, 0x87e466d5, 0x94b49521, 0x66df1622, 0x38cc2a06, 0xcaa7a905, 0xd9f75af1, 0x2b9cd9f2, 0xff56bd19,
+	0x0d3d3e1a, 0x1e6dcdee, 0xec064eed, 0xc38d26c4, 0x31e6a5c7, 0x22b65633, 0xd0ddd530, 0x0417b1db, 0xf67c32d8,
+	0xe52cc12c, 0x1747422f, 0x49547e0b, 0xbb3ffd08, 0xa86f0efc, 0x5a048dff, 0x8ecee914, 0x7ca56a17, 0x6ff599e3,
+	0x9d9e1ae0, 0xd3d3e1ab, 0x21b862a8, 0x32e8915c, 0xc083125f, 0x144976b4, 0xe622f5b7, 0xf5720643, 0x07198540,
+	0x590ab964, 0xab613a67, 0xb831c993, 0x4a5a4a90, 0x9e902e7b, 0x6cfbad78, 0x7fab5e8c, 0x8dc0dd8f, 0xe330a81a,
+	0x115b2b19, 0x020bd8ed, 0xf0605bee, 0x24aa3f05, 0xd6c1bc06, 0xc5914ff2, 0x37faccf1, 0x69e9f0d5, 0x9b8273d6,
+	0x88d28022, 0x7ab90321, 0xae7367ca, 0x5c18e4c9, 0x4f48173d, 0xbd23943e, 0xf36e6f75, 0x0105ec76, 0x12551f82,
+	0xe03e9c81, 0x34f4f86a, 0xc69f7b69, 0xd5cf889d, 0x27a40b9e, 0x79b737ba, 0x8bdcb4b9, 0x988c474d, 0x6ae7c44e,
+	0xbe2da0a5, 0x4c4623a6, 0x5f16d052, 0xad7d5351,
+};
+
+#endif /* CRC_TABLE */
+#ifdef POWER8_INTRINSICS
+
+/* Constants */
+
+/* Reduce 262144 kbits to 1024 bits */
+static const __vector unsigned long long vcrc_const[255] __attribute__((aligned(16))) = {
+#ifdef __LITTLE_ENDIAN__
+	/* x^261120 mod p(x)` << 1, x^261184 mod p(x)` << 1 */
+	{ 0x000000009c37c408, 0x00000000b6ca9e20 },
+	/* x^260096 mod p(x)` << 1, x^260160 mod p(x)` << 1 */
+	{ 0x00000001b51df26c, 0x00000000350249a8 },
+	/* x^259072 mod p(x)` << 1, x^259136 mod p(x)` << 1 */
+	{ 0x000000000724b9d0, 0x00000001862dac54 },
+	/* x^258048 mod p(x)` << 1, x^258112 mod p(x)` << 1 */
+	{ 0x00000001c00532fe, 0x00000001d87fb48c },
+	/* x^257024 mod p(x)` << 1, x^257088 mod p(x)` << 1 */
+	{ 0x00000000f05a9362, 0x00000001f39b699e },
+	/* x^256000 mod p(x)` << 1, x^256064 mod p(x)` << 1 */
+	{ 0x00000001e1007970, 0x0000000101da11b4 },
+	/* x^254976 mod p(x)` << 1, x^255040 mod p(x)` << 1 */
+	{ 0x00000000a57366ee, 0x00000001cab571e0 },
+	/* x^253952 mod p(x)` << 1, x^254016 mod p(x)` << 1 */
+	{ 0x0000000192011284, 0x00000000c7020cfe },
+	/* x^252928 mod p(x)` << 1, x^252992 mod p(x)` << 1 */
+	{ 0x0000000162716d9a, 0x00000000cdaed1ae },
+	/* x^251904 mod p(x)` << 1, x^251968 mod p(x)` << 1 */
+	{ 0x00000000cd97ecde, 0x00000001e804effc },
+	/* x^250880 mod p(x)` << 1, x^250944 mod p(x)` << 1 */
+	{ 0x0000000058812bc0, 0x0000000077c3ea3a },
+	/* x^249856 mod p(x)` << 1, x^249920 mod p(x)` << 1 */
+	{ 0x0000000088b8c12e, 0x0000000068df31b4 },
+	/* x^248832 mod p(x)` << 1, x^248896 mod p(x)` << 1 */
+	{ 0x00000001230b234c, 0x00000000b059b6c2 },
+	/* x^247808 mod p(x)` << 1, x^247872 mod p(x)` << 1 */
+	{ 0x00000001120b416e, 0x0000000145fb8ed8 },
+	/* x^246784 mod p(x)` << 1, x^246848 mod p(x)` << 1 */
+	{ 0x00000001974aecb0, 0x00000000cbc09168 },
+	/* x^245760 mod p(x)` << 1, x^245824 mod p(x)` << 1 */
+	{ 0x000000008ee3f226, 0x000000005ceeedc2 },
+	/* x^244736 mod p(x)` << 1, x^244800 mod p(x)` << 1 */
+	{ 0x00000001089aba9a, 0x0000000047d74e86 },
+	/* x^243712 mod p(x)` << 1, x^243776 mod p(x)` << 1 */
+	{ 0x0000000065113872, 0x00000001407e9e22 },
+	/* x^242688 mod p(x)` << 1, x^242752 mod p(x)` << 1 */
+	{ 0x000000005c07ec10, 0x00000001da967bda },
+	/* x^241664 mod p(x)` << 1, x^241728 mod p(x)` << 1 */
+	{ 0x0000000187590924, 0x000000006c898368 },
+	/* x^240640 mod p(x)` << 1, x^240704 mod p(x)` << 1 */
+	{ 0x00000000e35da7c6, 0x00000000f2d14c98 },
+	/* x^239616 mod p(x)` << 1, x^239680 mod p(x)` << 1 */
+	{ 0x000000000415855a, 0x00000001993c6ad4 },
+	/* x^238592 mod p(x)` << 1, x^238656 mod p(x)` << 1 */
+	{ 0x0000000073617758, 0x000000014683d1ac },
+	/* x^237568 mod p(x)` << 1, x^237632 mod p(x)` << 1 */
+	{ 0x0000000176021d28, 0x00000001a7c93e6c },
+	/* x^236544 mod p(x)` << 1, x^236608 mod p(x)` << 1 */
+	{ 0x00000001c358fd0a, 0x000000010211e90a },
+	/* x^235520 mod p(x)` << 1, x^235584 mod p(x)` << 1 */
+	{ 0x00000001ff7a2c18, 0x000000001119403e },
+	/* x^234496 mod p(x)` << 1, x^234560 mod p(x)` << 1 */
+	{ 0x00000000f2d9f7e4, 0x000000001c3261aa },
+	/* x^233472 mod p(x)` << 1, x^233536 mod p(x)` << 1 */
+	{ 0x000000016cf1f9c8, 0x000000014e37a634 },
+	/* x^232448 mod p(x)` << 1, x^232512 mod p(x)` << 1 */
+	{ 0x000000010af9279a, 0x0000000073786c0c },
+	/* x^231424 mod p(x)` << 1, x^231488 mod p(x)` << 1 */
+	{ 0x0000000004f101e8, 0x000000011dc037f8 },
+	/* x^230400 mod p(x)` << 1, x^230464 mod p(x)` << 1 */
+	{ 0x0000000070bcf184, 0x0000000031433dfc },
+	/* x^229376 mod p(x)` << 1, x^229440 mod p(x)` << 1 */
+	{ 0x000000000a8de642, 0x000000009cde8348 },
+	/* x^228352 mod p(x)` << 1, x^228416 mod p(x)` << 1 */
+	{ 0x0000000062ea130c, 0x0000000038d3c2a6 },
+	/* x^227328 mod p(x)` << 1, x^227392 mod p(x)` << 1 */
+	{ 0x00000001eb31cbb2, 0x000000011b25f260 },
+	/* x^226304 mod p(x)` << 1, x^226368 mod p(x)` << 1 */
+	{ 0x0000000170783448, 0x000000001629e6f0 },
+	/* x^225280 mod p(x)` << 1, x^225344 mod p(x)` << 1 */
+	{ 0x00000001a684b4c6, 0x0000000160838b4c },
+	/* x^224256 mod p(x)` << 1, x^224320 mod p(x)` << 1 */
+	{ 0x00000000253ca5b4, 0x000000007a44011c },
+	/* x^223232 mod p(x)` << 1, x^223296 mod p(x)` << 1 */
+	{ 0x0000000057b4b1e2, 0x00000000226f417a },
+	/* x^222208 mod p(x)` << 1, x^222272 mod p(x)` << 1 */
+	{ 0x00000000b6bd084c, 0x0000000045eb2eb4 },
+	/* x^221184 mod p(x)` << 1, x^221248 mod p(x)` << 1 */
+	{ 0x0000000123c2d592, 0x000000014459d70c },
+	/* x^220160 mod p(x)` << 1, x^220224 mod p(x)` << 1 */
+	{ 0x00000000159dafce, 0x00000001d406ed82 },
+	/* x^219136 mod p(x)` << 1, x^219200 mod p(x)` << 1 */
+	{ 0x0000000127e1a64e, 0x0000000160c8e1a8 },
+	/* x^218112 mod p(x)` << 1, x^218176 mod p(x)` << 1 */
+	{ 0x0000000056860754, 0x0000000027ba8098 },
+	/* x^217088 mod p(x)` << 1, x^217152 mod p(x)` << 1 */
+	{ 0x00000001e661aae8, 0x000000006d92d018 },
+	/* x^216064 mod p(x)` << 1, x^216128 mod p(x)` << 1 */
+	{ 0x00000000f82c6166, 0x000000012ed7e3f2 },
+	/* x^215040 mod p(x)` << 1, x^215104 mod p(x)` << 1 */
+	{ 0x00000000c4f9c7ae, 0x000000002dc87788 },
+	/* x^214016 mod p(x)` << 1, x^214080 mod p(x)` << 1 */
+	{ 0x0000000074203d20, 0x0000000018240bb8 },
+	/* x^212992 mod p(x)` << 1, x^213056 mod p(x)` << 1 */
+	{ 0x0000000198173052, 0x000000001ad38158 },
+	/* x^211968 mod p(x)` << 1, x^212032 mod p(x)` << 1 */
+	{ 0x00000001ce8aba54, 0x00000001396b78f2 },
+	/* x^210944 mod p(x)` << 1, x^211008 mod p(x)` << 1 */
+	{ 0x00000001850d5d94, 0x000000011a681334 },
+	/* x^209920 mod p(x)` << 1, x^209984 mod p(x)` << 1 */
+	{ 0x00000001d609239c, 0x000000012104732e },
+	/* x^208896 mod p(x)` << 1, x^208960 mod p(x)` << 1 */
+	{ 0x000000001595f048, 0x00000000a140d90c },
+	/* x^207872 mod p(x)` << 1, x^207936 mod p(x)` << 1 */
+	{ 0x0000000042ccee08, 0x00000001b7215eda },
+	/* x^206848 mod p(x)` << 1, x^206912 mod p(x)` << 1 */
+	{ 0x000000010a389d74, 0x00000001aaf1df3c },
+	/* x^205824 mod p(x)` << 1, x^205888 mod p(x)` << 1 */
+	{ 0x000000012a840da6, 0x0000000029d15b8a },
+	/* x^204800 mod p(x)` << 1, x^204864 mod p(x)` << 1 */
+	{ 0x000000001d181c0c, 0x00000000f1a96922 },
+	/* x^203776 mod p(x)` << 1, x^203840 mod p(x)` << 1 */
+	{ 0x0000000068b7d1f6, 0x00000001ac80d03c },
+	/* x^202752 mod p(x)` << 1, x^202816 mod p(x)` << 1 */
+	{ 0x000000005b0f14fc, 0x000000000f11d56a },
+	/* x^201728 mod p(x)` << 1, x^201792 mod p(x)` << 1 */
+	{ 0x0000000179e9e730, 0x00000001f1c022a2 },
+	/* x^200704 mod p(x)` << 1, x^200768 mod p(x)` << 1 */
+	{ 0x00000001ce1368d6, 0x0000000173d00ae2 },
+	/* x^199680 mod p(x)` << 1, x^199744 mod p(x)` << 1 */
+	{ 0x0000000112c3a84c, 0x00000001d4ffe4ac },
+	/* x^198656 mod p(x)` << 1, x^198720 mod p(x)` << 1 */
+	{ 0x00000000de940fee, 0x000000016edc5ae4 },
+	/* x^197632 mod p(x)` << 1, x^197696 mod p(x)` << 1 */
+	{ 0x00000000fe896b7e, 0x00000001f1a02140 },
+	/* x^196608 mod p(x)` << 1, x^196672 mod p(x)` << 1 */
+	{ 0x00000001f797431c, 0x00000000ca0b28a0 },
+	/* x^195584 mod p(x)` << 1, x^195648 mod p(x)` << 1 */
+	{ 0x0000000053e989ba, 0x00000001928e30a2 },
+	/* x^194560 mod p(x)` << 1, x^194624 mod p(x)` << 1 */
+	{ 0x000000003920cd16, 0x0000000097b1b002 },
+	/* x^193536 mod p(x)` << 1, x^193600 mod p(x)` << 1 */
+	{ 0x00000001e6f579b8, 0x00000000b15bf906 },
+	/* x^192512 mod p(x)` << 1, x^192576 mod p(x)` << 1 */
+	{ 0x000000007493cb0a, 0x00000000411c5d52 },
+	/* x^191488 mod p(x)` << 1, x^191552 mod p(x)` << 1 */
+	{ 0x00000001bdd376d8, 0x00000001c36f3300 },
+	/* x^190464 mod p(x)` << 1, x^190528 mod p(x)` << 1 */
+	{ 0x000000016badfee6, 0x00000001119227e0 },
+	/* x^189440 mod p(x)` << 1, x^189504 mod p(x)` << 1 */
+	{ 0x0000000071de5c58, 0x00000000114d4702 },
+	/* x^188416 mod p(x)` << 1, x^188480 mod p(x)` << 1 */
+	{ 0x00000000453f317c, 0x00000000458b5b98 },
+	/* x^187392 mod p(x)` << 1, x^187456 mod p(x)` << 1 */
+	{ 0x0000000121675cce, 0x000000012e31fb8e },
+	/* x^186368 mod p(x)` << 1, x^186432 mod p(x)` << 1 */
+	{ 0x00000001f409ee92, 0x000000005cf619d8 },
+	/* x^185344 mod p(x)` << 1, x^185408 mod p(x)` << 1 */
+	{ 0x00000000f36b9c88, 0x0000000063f4d8b2 },
+	/* x^184320 mod p(x)` << 1, x^184384 mod p(x)` << 1 */
+	{ 0x0000000036b398f4, 0x000000004138dc8a },
+	/* x^183296 mod p(x)` << 1, x^183360 mod p(x)` << 1 */
+	{ 0x00000001748f9adc, 0x00000001d29ee8e0 },
+	/* x^182272 mod p(x)` << 1, x^182336 mod p(x)` << 1 */
+	{ 0x00000001be94ec00, 0x000000006a08ace8 },
+	/* x^181248 mod p(x)` << 1, x^181312 mod p(x)` << 1 */
+	{ 0x00000000b74370d6, 0x0000000127d42010 },
+	/* x^180224 mod p(x)` << 1, x^180288 mod p(x)` << 1 */
+	{ 0x00000001174d0b98, 0x0000000019d76b62 },
+	/* x^179200 mod p(x)` << 1, x^179264 mod p(x)` << 1 */
+	{ 0x00000000befc06a4, 0x00000001b1471f6e },
+	/* x^178176 mod p(x)` << 1, x^178240 mod p(x)` << 1 */
+	{ 0x00000001ae125288, 0x00000001f64c19cc },
+	/* x^177152 mod p(x)` << 1, x^177216 mod p(x)` << 1 */
+	{ 0x0000000095c19b34, 0x00000000003c0ea0 },
+	/* x^176128 mod p(x)` << 1, x^176192 mod p(x)` << 1 */
+	{ 0x00000001a78496f2, 0x000000014d73abf6 },
+	/* x^175104 mod p(x)` << 1, x^175168 mod p(x)` << 1 */
+	{ 0x00000001ac5390a0, 0x00000001620eb844 },
+	/* x^174080 mod p(x)` << 1, x^174144 mod p(x)` << 1 */
+	{ 0x000000002a80ed6e, 0x0000000147655048 },
+	/* x^173056 mod p(x)` << 1, x^173120 mod p(x)` << 1 */
+	{ 0x00000001fa9b0128, 0x0000000067b5077e },
+	/* x^172032 mod p(x)` << 1, x^172096 mod p(x)` << 1 */
+	{ 0x00000001ea94929e, 0x0000000010ffe206 },
+	/* x^171008 mod p(x)` << 1, x^171072 mod p(x)` << 1 */
+	{ 0x0000000125f4305c, 0x000000000fee8f1e },
+	/* x^169984 mod p(x)` << 1, x^170048 mod p(x)` << 1 */
+	{ 0x00000001471e2002, 0x00000001da26fbae },
+	/* x^168960 mod p(x)` << 1, x^169024 mod p(x)` << 1 */
+	{ 0x0000000132d2253a, 0x00000001b3a8bd88 },
+	/* x^167936 mod p(x)` << 1, x^168000 mod p(x)` << 1 */
+	{ 0x00000000f26b3592, 0x00000000e8f3898e },
+	/* x^166912 mod p(x)` << 1, x^166976 mod p(x)` << 1 */
+	{ 0x00000000bc8b67b0, 0x00000000b0d0d28c },
+	/* x^165888 mod p(x)` << 1, x^165952 mod p(x)` << 1 */
+	{ 0x000000013a826ef2, 0x0000000030f2a798 },
+	/* x^164864 mod p(x)` << 1, x^164928 mod p(x)` << 1 */
+	{ 0x0000000081482c84, 0x000000000fba1002 },
+	/* x^163840 mod p(x)` << 1, x^163904 mod p(x)` << 1 */
+	{ 0x00000000e77307c2, 0x00000000bdb9bd72 },
+	/* x^162816 mod p(x)` << 1, x^162880 mod p(x)` << 1 */
+	{ 0x00000000d4a07ec8, 0x0000000075d3bf5a },
+	/* x^161792 mod p(x)` << 1, x^161856 mod p(x)` << 1 */
+	{ 0x0000000017102100, 0x00000000ef1f98a0 },
+	/* x^160768 mod p(x)` << 1, x^160832 mod p(x)` << 1 */
+	{ 0x00000000db406486, 0x00000000689c7602 },
+	/* x^159744 mod p(x)` << 1, x^159808 mod p(x)` << 1 */
+	{ 0x0000000192db7f88, 0x000000016d5fa5fe },
+	/* x^158720 mod p(x)` << 1, x^158784 mod p(x)` << 1 */
+	{ 0x000000018bf67b1e, 0x00000001d0d2b9ca },
+	/* x^157696 mod p(x)` << 1, x^157760 mod p(x)` << 1 */
+	{ 0x000000007c09163e, 0x0000000041e7b470 },
+	/* x^156672 mod p(x)` << 1, x^156736 mod p(x)` << 1 */
+	{ 0x000000000adac060, 0x00000001cbb6495e },
+	/* x^155648 mod p(x)` << 1, x^155712 mod p(x)` << 1 */
+	{ 0x00000000bd8316ae, 0x000000010052a0b0 },
+	/* x^154624 mod p(x)` << 1, x^154688 mod p(x)` << 1 */
+	{ 0x000000019f09ab54, 0x00000001d8effb5c },
+	/* x^153600 mod p(x)` << 1, x^153664 mod p(x)` << 1 */
+	{ 0x0000000125155542, 0x00000001d969853c },
+	/* x^152576 mod p(x)` << 1, x^152640 mod p(x)` << 1 */
+	{ 0x000000018fdb5882, 0x00000000523ccce2 },
+	/* x^151552 mod p(x)` << 1, x^151616 mod p(x)` << 1 */
+	{ 0x00000000e794b3f4, 0x000000001e2436bc },
+	/* x^150528 mod p(x)` << 1, x^150592 mod p(x)` << 1 */
+	{ 0x000000016f9bb022, 0x00000000ddd1c3a2 },
+	/* x^149504 mod p(x)` << 1, x^149568 mod p(x)` << 1 */
+	{ 0x00000000290c9978, 0x0000000019fcfe38 },
+	/* x^148480 mod p(x)` << 1, x^148544 mod p(x)` << 1 */
+	{ 0x0000000083c0f350, 0x00000001ce95db64 },
+	/* x^147456 mod p(x)` << 1, x^147520 mod p(x)` << 1 */
+	{ 0x0000000173ea6628, 0x00000000af582806 },
+	/* x^146432 mod p(x)` << 1, x^146496 mod p(x)` << 1 */
+	{ 0x00000001c8b4e00a, 0x00000001006388f6 },
+	/* x^145408 mod p(x)` << 1, x^145472 mod p(x)` << 1 */
+	{ 0x00000000de95d6aa, 0x0000000179eca00a },
+	/* x^144384 mod p(x)` << 1, x^144448 mod p(x)` << 1 */
+	{ 0x000000010b7f7248, 0x0000000122410a6a },
+	/* x^143360 mod p(x)` << 1, x^143424 mod p(x)` << 1 */
+	{ 0x00000001326e3a06, 0x000000004288e87c },
+	/* x^142336 mod p(x)` << 1, x^142400 mod p(x)` << 1 */
+	{ 0x00000000bb62c2e6, 0x000000016c5490da },
+	/* x^141312 mod p(x)` << 1, x^141376 mod p(x)` << 1 */
+	{ 0x0000000156a4b2c2, 0x00000000d1c71f6e },
+	/* x^140288 mod p(x)` << 1, x^140352 mod p(x)` << 1 */
+	{ 0x000000011dfe763a, 0x00000001b4ce08a6 },
+	/* x^139264 mod p(x)` << 1, x^139328 mod p(x)` << 1 */
+	{ 0x000000007bcca8e2, 0x00000001466ba60c },
+	/* x^138240 mod p(x)` << 1, x^138304 mod p(x)` << 1 */
+	{ 0x0000000186118faa, 0x00000001f6c488a4 },
+	/* x^137216 mod p(x)` << 1, x^137280 mod p(x)` << 1 */
+	{ 0x0000000111a65a88, 0x000000013bfb0682 },
+	/* x^136192 mod p(x)` << 1, x^136256 mod p(x)` << 1 */
+	{ 0x000000003565e1c4, 0x00000000690e9e54 },
+	/* x^135168 mod p(x)` << 1, x^135232 mod p(x)` << 1 */
+	{ 0x000000012ed02a82, 0x00000000281346b6 },
+	/* x^134144 mod p(x)` << 1, x^134208 mod p(x)` << 1 */
+	{ 0x00000000c486ecfc, 0x0000000156464024 },
+	/* x^133120 mod p(x)` << 1, x^133184 mod p(x)` << 1 */
+	{ 0x0000000001b951b2, 0x000000016063a8dc },
+	/* x^132096 mod p(x)` << 1, x^132160 mod p(x)` << 1 */
+	{ 0x0000000048143916, 0x0000000116a66362 },
+	/* x^131072 mod p(x)` << 1, x^131136 mod p(x)` << 1 */
+	{ 0x00000001dc2ae124, 0x000000017e8aa4d2 },
+	/* x^130048 mod p(x)` << 1, x^130112 mod p(x)` << 1 */
+	{ 0x00000001416c58d6, 0x00000001728eb10c },
+	/* x^129024 mod p(x)` << 1, x^129088 mod p(x)` << 1 */
+	{ 0x00000000a479744a, 0x00000001b08fd7fa },
+	/* x^128000 mod p(x)` << 1, x^128064 mod p(x)` << 1 */
+	{ 0x0000000096ca3a26, 0x00000001092a16e8 },
+	/* x^126976 mod p(x)` << 1, x^127040 mod p(x)` << 1 */
+	{ 0x00000000ff223d4e, 0x00000000a505637c },
+	/* x^125952 mod p(x)` << 1, x^126016 mod p(x)` << 1 */
+	{ 0x000000010e84da42, 0x00000000d94869b2 },
+	/* x^124928 mod p(x)` << 1, x^124992 mod p(x)` << 1 */
+	{ 0x00000001b61ba3d0, 0x00000001c8b203ae },
+	/* x^123904 mod p(x)` << 1, x^123968 mod p(x)` << 1 */
+	{ 0x00000000680f2de8, 0x000000005704aea0 },
+	/* x^122880 mod p(x)` << 1, x^122944 mod p(x)` << 1 */
+	{ 0x000000008772a9a8, 0x000000012e295fa2 },
+	/* x^121856 mod p(x)` << 1, x^121920 mod p(x)` << 1 */
+	{ 0x0000000155f295bc, 0x000000011d0908bc },
+	/* x^120832 mod p(x)` << 1, x^120896 mod p(x)` << 1 */
+	{ 0x00000000595f9282, 0x0000000193ed97ea },
+	/* x^119808 mod p(x)` << 1, x^119872 mod p(x)` << 1 */
+	{ 0x0000000164b1c25a, 0x000000013a0f1c52 },
+	/* x^118784 mod p(x)` << 1, x^118848 mod p(x)` << 1 */
+	{ 0x00000000fbd67c50, 0x000000010c2c40c0 },
+	/* x^117760 mod p(x)` << 1, x^117824 mod p(x)` << 1 */
+	{ 0x0000000096076268, 0x00000000ff6fac3e },
+	/* x^116736 mod p(x)` << 1, x^116800 mod p(x)` << 1 */
+	{ 0x00000001d288e4cc, 0x000000017b3609c0 },
+	/* x^115712 mod p(x)` << 1, x^115776 mod p(x)` << 1 */
+	{ 0x00000001eaac1bdc, 0x0000000088c8c922 },
+	/* x^114688 mod p(x)` << 1, x^114752 mod p(x)` << 1 */
+	{ 0x00000001f1ea39e2, 0x00000001751baae6 },
+	/* x^113664 mod p(x)` << 1, x^113728 mod p(x)` << 1 */
+	{ 0x00000001eb6506fc, 0x0000000107952972 },
+	/* x^112640 mod p(x)` << 1, x^112704 mod p(x)` << 1 */
+	{ 0x000000010f806ffe, 0x0000000162b00abe },
+	/* x^111616 mod p(x)` << 1, x^111680 mod p(x)` << 1 */
+	{ 0x000000010408481e, 0x000000000d7b404c },
+	/* x^110592 mod p(x)` << 1, x^110656 mod p(x)` << 1 */
+	{ 0x0000000188260534, 0x00000000763b13d4 },
+	/* x^109568 mod p(x)` << 1, x^109632 mod p(x)` << 1 */
+	{ 0x0000000058fc73e0, 0x00000000f6dc22d8 },
+	/* x^108544 mod p(x)` << 1, x^108608 mod p(x)` << 1 */
+	{ 0x00000000391c59b8, 0x000000007daae060 },
+	/* x^107520 mod p(x)` << 1, x^107584 mod p(x)` << 1 */
+	{ 0x000000018b638400, 0x000000013359ab7c },
+	/* x^106496 mod p(x)` << 1, x^106560 mod p(x)` << 1 */
+	{ 0x000000011738f5c4, 0x000000008add438a },
+	/* x^105472 mod p(x)` << 1, x^105536 mod p(x)` << 1 */
+	{ 0x000000008cf7c6da, 0x00000001edbefdea },
+	/* x^104448 mod p(x)` << 1, x^104512 mod p(x)` << 1 */
+	{ 0x00000001ef97fb16, 0x000000004104e0f8 },
+	/* x^103424 mod p(x)` << 1, x^103488 mod p(x)` << 1 */
+	{ 0x0000000102130e20, 0x00000000b48a8222 },
+	/* x^102400 mod p(x)` << 1, x^102464 mod p(x)` << 1 */
+	{ 0x00000000db968898, 0x00000001bcb46844 },
+	/* x^101376 mod p(x)` << 1, x^101440 mod p(x)` << 1 */
+	{ 0x00000000b5047b5e, 0x000000013293ce0a },
+	/* x^100352 mod p(x)` << 1, x^100416 mod p(x)` << 1 */
+	{ 0x000000010b90fdb2, 0x00000001710d0844 },
+	/* x^99328 mod p(x)` << 1, x^99392 mod p(x)` << 1 */
+	{ 0x000000004834a32e, 0x0000000117907f6e },
+	/* x^98304 mod p(x)` << 1, x^98368 mod p(x)` << 1 */
+	{ 0x0000000059c8f2b0, 0x0000000087ddf93e },
+	/* x^97280 mod p(x)` << 1, x^97344 mod p(x)` << 1 */
+	{ 0x0000000122cec508, 0x000000005970e9b0 },
+	/* x^96256 mod p(x)` << 1, x^96320 mod p(x)` << 1 */
+	{ 0x000000000a330cda, 0x0000000185b2b7d0 },
+	/* x^95232 mod p(x)` << 1, x^95296 mod p(x)` << 1 */
+	{ 0x000000014a47148c, 0x00000001dcee0efc },
+	/* x^94208 mod p(x)` << 1, x^94272 mod p(x)` << 1 */
+	{ 0x0000000042c61cb8, 0x0000000030da2722 },
+	/* x^93184 mod p(x)` << 1, x^93248 mod p(x)` << 1 */
+	{ 0x0000000012fe6960, 0x000000012f925a18 },
+	/* x^92160 mod p(x)` << 1, x^92224 mod p(x)` << 1 */
+	{ 0x00000000dbda2c20, 0x00000000dd2e357c },
+	/* x^91136 mod p(x)` << 1, x^91200 mod p(x)` << 1 */
+	{ 0x000000011122410c, 0x00000000071c80de },
+	/* x^90112 mod p(x)` << 1, x^90176 mod p(x)` << 1 */
+	{ 0x00000000977b2070, 0x000000011513140a },
+	/* x^89088 mod p(x)` << 1, x^89152 mod p(x)` << 1 */
+	{ 0x000000014050438e, 0x00000001df876e8e },
+	/* x^88064 mod p(x)` << 1, x^88128 mod p(x)` << 1 */
+	{ 0x0000000147c840e8, 0x000000015f81d6ce },
+	/* x^87040 mod p(x)` << 1, x^87104 mod p(x)` << 1 */
+	{ 0x00000001cc7c88ce, 0x000000019dd94dbe },
+	/* x^86016 mod p(x)` << 1, x^86080 mod p(x)` << 1 */
+	{ 0x00000001476b35a4, 0x00000001373d206e },
+	/* x^84992 mod p(x)` << 1, x^85056 mod p(x)` << 1 */
+	{ 0x000000013d52d508, 0x00000000668ccade },
+	/* x^83968 mod p(x)` << 1, x^84032 mod p(x)` << 1 */
+	{ 0x000000008e4be32e, 0x00000001b192d268 },
+	/* x^82944 mod p(x)` << 1, x^83008 mod p(x)` << 1 */
+	{ 0x00000000024120fe, 0x00000000e30f3a78 },
+	/* x^81920 mod p(x)` << 1, x^81984 mod p(x)` << 1 */
+	{ 0x00000000ddecddb4, 0x000000010ef1f7bc },
+	/* x^80896 mod p(x)` << 1, x^80960 mod p(x)` << 1 */
+	{ 0x00000000d4d403bc, 0x00000001f5ac7380 },
+	/* x^79872 mod p(x)` << 1, x^79936 mod p(x)` << 1 */
+	{ 0x00000001734b89aa, 0x000000011822ea70 },
+	/* x^78848 mod p(x)` << 1, x^78912 mod p(x)` << 1 */
+	{ 0x000000010e7a58d6, 0x00000000c3a33848 },
+	/* x^77824 mod p(x)` << 1, x^77888 mod p(x)` << 1 */
+	{ 0x00000001f9f04e9c, 0x00000001bd151c24 },
+	/* x^76800 mod p(x)` << 1, x^76864 mod p(x)` << 1 */
+	{ 0x00000000b692225e, 0x0000000056002d76 },
+	/* x^75776 mod p(x)` << 1, x^75840 mod p(x)` << 1 */
+	{ 0x000000019b8d3f3e, 0x000000014657c4f4 },
+	/* x^74752 mod p(x)` << 1, x^74816 mod p(x)` << 1 */
+	{ 0x00000001a874f11e, 0x0000000113742d7c },
+	/* x^73728 mod p(x)` << 1, x^73792 mod p(x)` << 1 */
+	{ 0x000000010d5a4254, 0x000000019c5920ba },
+	/* x^72704 mod p(x)` << 1, x^72768 mod p(x)` << 1 */
+	{ 0x00000000bbb2f5d6, 0x000000005216d2d6 },
+	/* x^71680 mod p(x)` << 1, x^71744 mod p(x)` << 1 */
+	{ 0x0000000179cc0e36, 0x0000000136f5ad8a },
+	/* x^70656 mod p(x)` << 1, x^70720 mod p(x)` << 1 */
+	{ 0x00000001dca1da4a, 0x000000018b07beb6 },
+	/* x^69632 mod p(x)` << 1, x^69696 mod p(x)` << 1 */
+	{ 0x00000000feb1a192, 0x00000000db1e93b0 },
+	/* x^68608 mod p(x)` << 1, x^68672 mod p(x)` << 1 */
+	{ 0x00000000d1eeedd6, 0x000000000b96fa3a },
+	/* x^67584 mod p(x)` << 1, x^67648 mod p(x)` << 1 */
+	{ 0x000000008fad9bb4, 0x00000001d9968af0 },
+	/* x^66560 mod p(x)` << 1, x^66624 mod p(x)` << 1 */
+	{ 0x00000001884938e4, 0x000000000e4a77a2 },
+	/* x^65536 mod p(x)` << 1, x^65600 mod p(x)` << 1 */
+	{ 0x00000001bc2e9bc0, 0x00000000508c2ac8 },
+	/* x^64512 mod p(x)` << 1, x^64576 mod p(x)` << 1 */
+	{ 0x00000001f9658a68, 0x0000000021572a80 },
+	/* x^63488 mod p(x)` << 1, x^63552 mod p(x)` << 1 */
+	{ 0x000000001b9224fc, 0x00000001b859daf2 },
+	/* x^62464 mod p(x)` << 1, x^62528 mod p(x)` << 1 */
+	{ 0x0000000055b2fb84, 0x000000016f788474 },
+	/* x^61440 mod p(x)` << 1, x^61504 mod p(x)` << 1 */
+	{ 0x000000018b090348, 0x00000001b438810e },
+	/* x^60416 mod p(x)` << 1, x^60480 mod p(x)` << 1 */
+	{ 0x000000011ccbd5ea, 0x0000000095ddc6f2 },
+	/* x^59392 mod p(x)` << 1, x^59456 mod p(x)` << 1 */
+	{ 0x0000000007ae47f8, 0x00000001d977c20c },
+	/* x^58368 mod p(x)` << 1, x^58432 mod p(x)` << 1 */
+	{ 0x0000000172acbec0, 0x00000000ebedb99a },
+	/* x^57344 mod p(x)` << 1, x^57408 mod p(x)` << 1 */
+	{ 0x00000001c6e3ff20, 0x00000001df9e9e92 },
+	/* x^56320 mod p(x)` << 1, x^56384 mod p(x)` << 1 */
+	{ 0x00000000e1b38744, 0x00000001a4a3f952 },
+	/* x^55296 mod p(x)` << 1, x^55360 mod p(x)` << 1 */
+	{ 0x00000000791585b2, 0x00000000e2f51220 },
+	/* x^54272 mod p(x)` << 1, x^54336 mod p(x)` << 1 */
+	{ 0x00000000ac53b894, 0x000000004aa01f3e },
+	/* x^53248 mod p(x)` << 1, x^53312 mod p(x)` << 1 */
+	{ 0x00000001ed5f2cf4, 0x00000000b3e90a58 },
+	/* x^52224 mod p(x)` << 1, x^52288 mod p(x)` << 1 */
+	{ 0x00000001df48b2e0, 0x000000000c9ca2aa },
+	/* x^51200 mod p(x)` << 1, x^51264 mod p(x)` << 1 */
+	{ 0x00000000049c1c62, 0x0000000151682316 },
+	/* x^50176 mod p(x)` << 1, x^50240 mod p(x)` << 1 */
+	{ 0x000000017c460c12, 0x0000000036fce78c },
+	/* x^49152 mod p(x)` << 1, x^49216 mod p(x)` << 1 */
+	{ 0x000000015be4da7e, 0x000000009037dc10 },
+	/* x^48128 mod p(x)` << 1, x^48192 mod p(x)` << 1 */
+	{ 0x000000010f38f668, 0x00000000d3298582 },
+	/* x^47104 mod p(x)` << 1, x^47168 mod p(x)` << 1 */
+	{ 0x0000000039f40a00, 0x00000001b42e8ad6 },
+	/* x^46080 mod p(x)` << 1, x^46144 mod p(x)` << 1 */
+	{ 0x00000000bd4c10c4, 0x00000000142a9838 },
+	/* x^45056 mod p(x)` << 1, x^45120 mod p(x)` << 1 */
+	{ 0x0000000042db1d98, 0x0000000109c7f190 },
+	/* x^44032 mod p(x)` << 1, x^44096 mod p(x)` << 1 */
+	{ 0x00000001c905bae6, 0x0000000056ff9310 },
+	/* x^43008 mod p(x)` << 1, x^43072 mod p(x)` << 1 */
+	{ 0x00000000069d40ea, 0x00000001594513aa },
+	/* x^41984 mod p(x)` << 1, x^42048 mod p(x)` << 1 */
+	{ 0x000000008e4fbad0, 0x00000001e3b5b1e8 },
+	/* x^40960 mod p(x)` << 1, x^41024 mod p(x)` << 1 */
+	{ 0x0000000047bedd46, 0x000000011dd5fc08 },
+	/* x^39936 mod p(x)` << 1, x^40000 mod p(x)` << 1 */
+	{ 0x0000000026396bf8, 0x00000001675f0cc2 },
+	/* x^38912 mod p(x)` << 1, x^38976 mod p(x)` << 1 */
+	{ 0x00000000379beb92, 0x00000000d1c8dd44 },
+	/* x^37888 mod p(x)` << 1, x^37952 mod p(x)` << 1 */
+	{ 0x000000000abae54a, 0x0000000115ebd3d8 },
+	/* x^36864 mod p(x)` << 1, x^36928 mod p(x)` << 1 */
+	{ 0x0000000007e6a128, 0x00000001ecbd0dac },
+	/* x^35840 mod p(x)` << 1, x^35904 mod p(x)` << 1 */
+	{ 0x000000000ade29d2, 0x00000000cdf67af2 },
+	/* x^34816 mod p(x)` << 1, x^34880 mod p(x)` << 1 */
+	{ 0x00000000f974c45c, 0x000000004c01ff4c },
+	/* x^33792 mod p(x)` << 1, x^33856 mod p(x)` << 1 */
+	{ 0x00000000e77ac60a, 0x00000000f2d8657e },
+	/* x^32768 mod p(x)` << 1, x^32832 mod p(x)` << 1 */
+	{ 0x0000000145895816, 0x000000006bae74c4 },
+	/* x^31744 mod p(x)` << 1, x^31808 mod p(x)` << 1 */
+	{ 0x0000000038e362be, 0x0000000152af8aa0 },
+	/* x^30720 mod p(x)` << 1, x^30784 mod p(x)` << 1 */
+	{ 0x000000007f991a64, 0x0000000004663802 },
+	/* x^29696 mod p(x)` << 1, x^29760 mod p(x)` << 1 */
+	{ 0x00000000fa366d3a, 0x00000001ab2f5afc },
+	/* x^28672 mod p(x)` << 1, x^28736 mod p(x)` << 1 */
+	{ 0x00000001a2bb34f0, 0x0000000074a4ebd4 },
+	/* x^27648 mod p(x)` << 1, x^27712 mod p(x)` << 1 */
+	{ 0x0000000028a9981e, 0x00000001d7ab3a4c },
+	/* x^26624 mod p(x)` << 1, x^26688 mod p(x)` << 1 */
+	{ 0x00000001dbc672be, 0x00000001a8da60c6 },
+	/* x^25600 mod p(x)` << 1, x^25664 mod p(x)` << 1 */
+	{ 0x00000000b04d77f6, 0x000000013cf63820 },
+	/* x^24576 mod p(x)` << 1, x^24640 mod p(x)` << 1 */
+	{ 0x0000000124400d96, 0x00000000bec12e1e },
+	/* x^23552 mod p(x)` << 1, x^23616 mod p(x)` << 1 */
+	{ 0x000000014ca4b414, 0x00000001c6368010 },
+	/* x^22528 mod p(x)` << 1, x^22592 mod p(x)` << 1 */
+	{ 0x000000012fe2c938, 0x00000001e6e78758 },
+	/* x^21504 mod p(x)` << 1, x^21568 mod p(x)` << 1 */
+	{ 0x00000001faed01e6, 0x000000008d7f2b3c },
+	/* x^20480 mod p(x)` << 1, x^20544 mod p(x)` << 1 */
+	{ 0x000000007e80ecfe, 0x000000016b4a156e },
+	/* x^19456 mod p(x)` << 1, x^19520 mod p(x)` << 1 */
+	{ 0x0000000098daee94, 0x00000001c63cfeb6 },
+	/* x^18432 mod p(x)` << 1, x^18496 mod p(x)` << 1 */
+	{ 0x000000010a04edea, 0x000000015f902670 },
+	/* x^17408 mod p(x)` << 1, x^17472 mod p(x)` << 1 */
+	{ 0x00000001c00b4524, 0x00000001cd5de11e },
+	/* x^16384 mod p(x)` << 1, x^16448 mod p(x)` << 1 */
+	{ 0x0000000170296550, 0x000000001acaec54 },
+	/* x^15360 mod p(x)` << 1, x^15424 mod p(x)` << 1 */
+	{ 0x0000000181afaa48, 0x000000002bd0ca78 },
+	/* x^14336 mod p(x)` << 1, x^14400 mod p(x)` << 1 */
+	{ 0x0000000185a31ffa, 0x0000000032d63d5c },
+	/* x^13312 mod p(x)` << 1, x^13376 mod p(x)` << 1 */
+	{ 0x000000002469f608, 0x000000001c6d4e4c },
+	/* x^12288 mod p(x)` << 1, x^12352 mod p(x)` << 1 */
+	{ 0x000000006980102a, 0x0000000106a60b92 },
+	/* x^11264 mod p(x)` << 1, x^11328 mod p(x)` << 1 */
+	{ 0x0000000111ea9ca8, 0x00000000d3855e12 },
+	/* x^10240 mod p(x)` << 1, x^10304 mod p(x)` << 1 */
+	{ 0x00000001bd1d29ce, 0x00000000e3125636 },
+	/* x^9216 mod p(x)` << 1, x^9280 mod p(x)` << 1 */
+	{ 0x00000001b34b9580, 0x000000009e8f7ea4 },
+	/* x^8192 mod p(x)` << 1, x^8256 mod p(x)` << 1 */
+	{ 0x000000003076054e, 0x00000001c82e562c },
+	/* x^7168 mod p(x)` << 1, x^7232 mod p(x)` << 1 */
+	{ 0x000000012a608ea4, 0x00000000ca9f09ce },
+	/* x^6144 mod p(x)` << 1, x^6208 mod p(x)` << 1 */
+	{ 0x00000000784d05fe, 0x00000000c63764e6 },
+	/* x^5120 mod p(x)` << 1, x^5184 mod p(x)` << 1 */
+	{ 0x000000016ef0d82a, 0x0000000168d2e49e },
+	/* x^4096 mod p(x)` << 1, x^4160 mod p(x)` << 1 */
+	{ 0x0000000075bda454, 0x00000000e986c148 },
+	/* x^3072 mod p(x)` << 1, x^3136 mod p(x)` << 1 */
+	{ 0x000000003dc0a1c4, 0x00000000cfb65894 },
+	/* x^2048 mod p(x)` << 1, x^2112 mod p(x)` << 1 */
+	{ 0x00000000e9a5d8be, 0x0000000111cadee4 },
+	/* x^1024 mod p(x)` << 1, x^1088 mod p(x)` << 1 */
+	{ 0x00000001609bc4b4, 0x0000000171fb63ce }
+#else /* __LITTLE_ENDIAN__ */
+	/* x^261120 mod p(x)` << 1, x^261184 mod p(x)` << 1 */
+	{ 0x00000000b6ca9e20, 0x000000009c37c408 },
+	/* x^260096 mod p(x)` << 1, x^260160 mod p(x)` << 1 */
+	{ 0x00000000350249a8, 0x00000001b51df26c },
+	/* x^259072 mod p(x)` << 1, x^259136 mod p(x)` << 1 */
+	{ 0x00000001862dac54, 0x000000000724b9d0 },
+	/* x^258048 mod p(x)` << 1, x^258112 mod p(x)` << 1 */
+	{ 0x00000001d87fb48c, 0x00000001c00532fe },
+	/* x^257024 mod p(x)` << 1, x^257088 mod p(x)` << 1 */
+	{ 0x00000001f39b699e, 0x00000000f05a9362 },
+	/* x^256000 mod p(x)` << 1, x^256064 mod p(x)` << 1 */
+	{ 0x0000000101da11b4, 0x00000001e1007970 },
+	/* x^254976 mod p(x)` << 1, x^255040 mod p(x)` << 1 */
+	{ 0x00000001cab571e0, 0x00000000a57366ee },
+	/* x^253952 mod p(x)` << 1, x^254016 mod p(x)` << 1 */
+	{ 0x00000000c7020cfe, 0x0000000192011284 },
+	/* x^252928 mod p(x)` << 1, x^252992 mod p(x)` << 1 */
+	{ 0x00000000cdaed1ae, 0x0000000162716d9a },
+	/* x^251904 mod p(x)` << 1, x^251968 mod p(x)` << 1 */
+	{ 0x00000001e804effc, 0x00000000cd97ecde },
+	/* x^250880 mod p(x)` << 1, x^250944 mod p(x)` << 1 */
+	{ 0x0000000077c3ea3a, 0x0000000058812bc0 },
+	/* x^249856 mod p(x)` << 1, x^249920 mod p(x)` << 1 */
+	{ 0x0000000068df31b4, 0x0000000088b8c12e },
+	/* x^248832 mod p(x)` << 1, x^248896 mod p(x)` << 1 */
+	{ 0x00000000b059b6c2, 0x00000001230b234c },
+	/* x^247808 mod p(x)` << 1, x^247872 mod p(x)` << 1 */
+	{ 0x0000000145fb8ed8, 0x00000001120b416e },
+	/* x^246784 mod p(x)` << 1, x^246848 mod p(x)` << 1 */
+	{ 0x00000000cbc09168, 0x00000001974aecb0 },
+	/* x^245760 mod p(x)` << 1, x^245824 mod p(x)` << 1 */
+	{ 0x000000005ceeedc2, 0x000000008ee3f226 },
+	/* x^244736 mod p(x)` << 1, x^244800 mod p(x)` << 1 */
+	{ 0x0000000047d74e86, 0x00000001089aba9a },
+	/* x^243712 mod p(x)` << 1, x^243776 mod p(x)` << 1 */
+	{ 0x00000001407e9e22, 0x0000000065113872 },
+	/* x^242688 mod p(x)` << 1, x^242752 mod p(x)` << 1 */
+	{ 0x00000001da967bda, 0x000000005c07ec10 },
+	/* x^241664 mod p(x)` << 1, x^241728 mod p(x)` << 1 */
+	{ 0x000000006c898368, 0x0000000187590924 },
+	/* x^240640 mod p(x)` << 1, x^240704 mod p(x)` << 1 */
+	{ 0x00000000f2d14c98, 0x00000000e35da7c6 },
+	/* x^239616 mod p(x)` << 1, x^239680 mod p(x)` << 1 */
+	{ 0x00000001993c6ad4, 0x000000000415855a },
+	/* x^238592 mod p(x)` << 1, x^238656 mod p(x)` << 1 */
+	{ 0x000000014683d1ac, 0x0000000073617758 },
+	/* x^237568 mod p(x)` << 1, x^237632 mod p(x)` << 1 */
+	{ 0x00000001a7c93e6c, 0x0000000176021d28 },
+	/* x^236544 mod p(x)` << 1, x^236608 mod p(x)` << 1 */
+	{ 0x000000010211e90a, 0x00000001c358fd0a },
+	/* x^235520 mod p(x)` << 1, x^235584 mod p(x)` << 1 */
+	{ 0x000000001119403e, 0x00000001ff7a2c18 },
+	/* x^234496 mod p(x)` << 1, x^234560 mod p(x)` << 1 */
+	{ 0x000000001c3261aa, 0x00000000f2d9f7e4 },
+	/* x^233472 mod p(x)` << 1, x^233536 mod p(x)` << 1 */
+	{ 0x000000014e37a634, 0x000000016cf1f9c8 },
+	/* x^232448 mod p(x)` << 1, x^232512 mod p(x)` << 1 */
+	{ 0x0000000073786c0c, 0x000000010af9279a },
+	/* x^231424 mod p(x)` << 1, x^231488 mod p(x)` << 1 */
+	{ 0x000000011dc037f8, 0x0000000004f101e8 },
+	/* x^230400 mod p(x)` << 1, x^230464 mod p(x)` << 1 */
+	{ 0x0000000031433dfc, 0x0000000070bcf184 },
+	/* x^229376 mod p(x)` << 1, x^229440 mod p(x)` << 1 */
+	{ 0x000000009cde8348, 0x000000000a8de642 },
+	/* x^228352 mod p(x)` << 1, x^228416 mod p(x)` << 1 */
+	{ 0x0000000038d3c2a6, 0x0000000062ea130c },
+	/* x^227328 mod p(x)` << 1, x^227392 mod p(x)` << 1 */
+	{ 0x000000011b25f260, 0x00000001eb31cbb2 },
+	/* x^226304 mod p(x)` << 1, x^226368 mod p(x)` << 1 */
+	{ 0x000000001629e6f0, 0x0000000170783448 },
+	/* x^225280 mod p(x)` << 1, x^225344 mod p(x)` << 1 */
+	{ 0x0000000160838b4c, 0x00000001a684b4c6 },
+	/* x^224256 mod p(x)` << 1, x^224320 mod p(x)` << 1 */
+	{ 0x000000007a44011c, 0x00000000253ca5b4 },
+	/* x^223232 mod p(x)` << 1, x^223296 mod p(x)` << 1 */
+	{ 0x00000000226f417a, 0x0000000057b4b1e2 },
+	/* x^222208 mod p(x)` << 1, x^222272 mod p(x)` << 1 */
+	{ 0x0000000045eb2eb4, 0x00000000b6bd084c },
+	/* x^221184 mod p(x)` << 1, x^221248 mod p(x)` << 1 */
+	{ 0x000000014459d70c, 0x0000000123c2d592 },
+	/* x^220160 mod p(x)` << 1, x^220224 mod p(x)` << 1 */
+	{ 0x00000001d406ed82, 0x00000000159dafce },
+	/* x^219136 mod p(x)` << 1, x^219200 mod p(x)` << 1 */
+	{ 0x0000000160c8e1a8, 0x0000000127e1a64e },
+	/* x^218112 mod p(x)` << 1, x^218176 mod p(x)` << 1 */
+	{ 0x0000000027ba8098, 0x0000000056860754 },
+	/* x^217088 mod p(x)` << 1, x^217152 mod p(x)` << 1 */
+	{ 0x000000006d92d018, 0x00000001e661aae8 },
+	/* x^216064 mod p(x)` << 1, x^216128 mod p(x)` << 1 */
+	{ 0x000000012ed7e3f2, 0x00000000f82c6166 },
+	/* x^215040 mod p(x)` << 1, x^215104 mod p(x)` << 1 */
+	{ 0x000000002dc87788, 0x00000000c4f9c7ae },
+	/* x^214016 mod p(x)` << 1, x^214080 mod p(x)` << 1 */
+	{ 0x0000000018240bb8, 0x0000000074203d20 },
+	/* x^212992 mod p(x)` << 1, x^213056 mod p(x)` << 1 */
+	{ 0x000000001ad38158, 0x0000000198173052 },
+	/* x^211968 mod p(x)` << 1, x^212032 mod p(x)` << 1 */
+	{ 0x00000001396b78f2, 0x00000001ce8aba54 },
+	/* x^210944 mod p(x)` << 1, x^211008 mod p(x)` << 1 */
+	{ 0x000000011a681334, 0x00000001850d5d94 },
+	/* x^209920 mod p(x)` << 1, x^209984 mod p(x)` << 1 */
+	{ 0x000000012104732e, 0x00000001d609239c },
+	/* x^208896 mod p(x)` << 1, x^208960 mod p(x)` << 1 */
+	{ 0x00000000a140d90c, 0x000000001595f048 },
+	/* x^207872 mod p(x)` << 1, x^207936 mod p(x)` << 1 */
+	{ 0x00000001b7215eda, 0x0000000042ccee08 },
+	/* x^206848 mod p(x)` << 1, x^206912 mod p(x)` << 1 */
+	{ 0x00000001aaf1df3c, 0x000000010a389d74 },
+	/* x^205824 mod p(x)` << 1, x^205888 mod p(x)` << 1 */
+	{ 0x0000000029d15b8a, 0x000000012a840da6 },
+	/* x^204800 mod p(x)` << 1, x^204864 mod p(x)` << 1 */
+	{ 0x00000000f1a96922, 0x000000001d181c0c },
+	/* x^203776 mod p(x)` << 1, x^203840 mod p(x)` << 1 */
+	{ 0x00000001ac80d03c, 0x0000000068b7d1f6 },
+	/* x^202752 mod p(x)` << 1, x^202816 mod p(x)` << 1 */
+	{ 0x000000000f11d56a, 0x000000005b0f14fc },
+	/* x^201728 mod p(x)` << 1, x^201792 mod p(x)` << 1 */
+	{ 0x00000001f1c022a2, 0x0000000179e9e730 },
+	/* x^200704 mod p(x)` << 1, x^200768 mod p(x)` << 1 */
+	{ 0x0000000173d00ae2, 0x00000001ce1368d6 },
+	/* x^199680 mod p(x)` << 1, x^199744 mod p(x)` << 1 */
+	{ 0x00000001d4ffe4ac, 0x0000000112c3a84c },
+	/* x^198656 mod p(x)` << 1, x^198720 mod p(x)` << 1 */
+	{ 0x000000016edc5ae4, 0x00000000de940fee },
+	/* x^197632 mod p(x)` << 1, x^197696 mod p(x)` << 1 */
+	{ 0x00000001f1a02140, 0x00000000fe896b7e },
+	/* x^196608 mod p(x)` << 1, x^196672 mod p(x)` << 1 */
+	{ 0x00000000ca0b28a0, 0x00000001f797431c },
+	/* x^195584 mod p(x)` << 1, x^195648 mod p(x)` << 1 */
+	{ 0x00000001928e30a2, 0x0000000053e989ba },
+	/* x^194560 mod p(x)` << 1, x^194624 mod p(x)` << 1 */
+	{ 0x0000000097b1b002, 0x000000003920cd16 },
+	/* x^193536 mod p(x)` << 1, x^193600 mod p(x)` << 1 */
+	{ 0x00000000b15bf906, 0x00000001e6f579b8 },
+	/* x^192512 mod p(x)` << 1, x^192576 mod p(x)` << 1 */
+	{ 0x00000000411c5d52, 0x000000007493cb0a },
+	/* x^191488 mod p(x)` << 1, x^191552 mod p(x)` << 1 */
+	{ 0x00000001c36f3300, 0x00000001bdd376d8 },
+	/* x^190464 mod p(x)` << 1, x^190528 mod p(x)` << 1 */
+	{ 0x00000001119227e0, 0x000000016badfee6 },
+	/* x^189440 mod p(x)` << 1, x^189504 mod p(x)` << 1 */
+	{ 0x00000000114d4702, 0x0000000071de5c58 },
+	/* x^188416 mod p(x)` << 1, x^188480 mod p(x)` << 1 */
+	{ 0x00000000458b5b98, 0x00000000453f317c },
+	/* x^187392 mod p(x)` << 1, x^187456 mod p(x)` << 1 */
+	{ 0x000000012e31fb8e, 0x0000000121675cce },
+	/* x^186368 mod p(x)` << 1, x^186432 mod p(x)` << 1 */
+	{ 0x000000005cf619d8, 0x00000001f409ee92 },
+	/* x^185344 mod p(x)` << 1, x^185408 mod p(x)` << 1 */
+	{ 0x0000000063f4d8b2, 0x00000000f36b9c88 },
+	/* x^184320 mod p(x)` << 1, x^184384 mod p(x)` << 1 */
+	{ 0x000000004138dc8a, 0x0000000036b398f4 },
+	/* x^183296 mod p(x)` << 1, x^183360 mod p(x)` << 1 */
+	{ 0x00000001d29ee8e0, 0x00000001748f9adc },
+	/* x^182272 mod p(x)` << 1, x^182336 mod p(x)` << 1 */
+	{ 0x000000006a08ace8, 0x00000001be94ec00 },
+	/* x^181248 mod p(x)` << 1, x^181312 mod p(x)` << 1 */
+	{ 0x0000000127d42010, 0x00000000b74370d6 },
+	/* x^180224 mod p(x)` << 1, x^180288 mod p(x)` << 1 */
+	{ 0x0000000019d76b62, 0x00000001174d0b98 },
+	/* x^179200 mod p(x)` << 1, x^179264 mod p(x)` << 1 */
+	{ 0x00000001b1471f6e, 0x00000000befc06a4 },
+	/* x^178176 mod p(x)` << 1, x^178240 mod p(x)` << 1 */
+	{ 0x00000001f64c19cc, 0x00000001ae125288 },
+	/* x^177152 mod p(x)` << 1, x^177216 mod p(x)` << 1 */
+	{ 0x00000000003c0ea0, 0x0000000095c19b34 },
+	/* x^176128 mod p(x)` << 1, x^176192 mod p(x)` << 1 */
+	{ 0x000000014d73abf6, 0x00000001a78496f2 },
+	/* x^175104 mod p(x)` << 1, x^175168 mod p(x)` << 1 */
+	{ 0x00000001620eb844, 0x00000001ac5390a0 },
+	/* x^174080 mod p(x)` << 1, x^174144 mod p(x)` << 1 */
+	{ 0x0000000147655048, 0x000000002a80ed6e },
+	/* x^173056 mod p(x)` << 1, x^173120 mod p(x)` << 1 */
+	{ 0x0000000067b5077e, 0x00000001fa9b0128 },
+	/* x^172032 mod p(x)` << 1, x^172096 mod p(x)` << 1 */
+	{ 0x0000000010ffe206, 0x00000001ea94929e },
+	/* x^171008 mod p(x)` << 1, x^171072 mod p(x)` << 1 */
+	{ 0x000000000fee8f1e, 0x0000000125f4305c },
+	/* x^169984 mod p(x)` << 1, x^170048 mod p(x)` << 1 */
+	{ 0x00000001da26fbae, 0x00000001471e2002 },
+	/* x^168960 mod p(x)` << 1, x^169024 mod p(x)` << 1 */
+	{ 0x00000001b3a8bd88, 0x0000000132d2253a },
+	/* x^167936 mod p(x)` << 1, x^168000 mod p(x)` << 1 */
+	{ 0x00000000e8f3898e, 0x00000000f26b3592 },
+	/* x^166912 mod p(x)` << 1, x^166976 mod p(x)` << 1 */
+	{ 0x00000000b0d0d28c, 0x00000000bc8b67b0 },
+	/* x^165888 mod p(x)` << 1, x^165952 mod p(x)` << 1 */
+	{ 0x0000000030f2a798, 0x000000013a826ef2 },
+	/* x^164864 mod p(x)` << 1, x^164928 mod p(x)` << 1 */
+	{ 0x000000000fba1002, 0x0000000081482c84 },
+	/* x^163840 mod p(x)` << 1, x^163904 mod p(x)` << 1 */
+	{ 0x00000000bdb9bd72, 0x00000000e77307c2 },
+	/* x^162816 mod p(x)` << 1, x^162880 mod p(x)` << 1 */
+	{ 0x0000000075d3bf5a, 0x00000000d4a07ec8 },
+	/* x^161792 mod p(x)` << 1, x^161856 mod p(x)` << 1 */
+	{ 0x00000000ef1f98a0, 0x0000000017102100 },
+	/* x^160768 mod p(x)` << 1, x^160832 mod p(x)` << 1 */
+	{ 0x00000000689c7602, 0x00000000db406486 },
+	/* x^159744 mod p(x)` << 1, x^159808 mod p(x)` << 1 */
+	{ 0x000000016d5fa5fe, 0x0000000192db7f88 },
+	/* x^158720 mod p(x)` << 1, x^158784 mod p(x)` << 1 */
+	{ 0x00000001d0d2b9ca, 0x000000018bf67b1e },
+	/* x^157696 mod p(x)` << 1, x^157760 mod p(x)` << 1 */
+	{ 0x0000000041e7b470, 0x000000007c09163e },
+	/* x^156672 mod p(x)` << 1, x^156736 mod p(x)` << 1 */
+	{ 0x00000001cbb6495e, 0x000000000adac060 },
+	/* x^155648 mod p(x)` << 1, x^155712 mod p(x)` << 1 */
+	{ 0x000000010052a0b0, 0x00000000bd8316ae },
+	/* x^154624 mod p(x)` << 1, x^154688 mod p(x)` << 1 */
+	{ 0x00000001d8effb5c, 0x000000019f09ab54 },
+	/* x^153600 mod p(x)` << 1, x^153664 mod p(x)` << 1 */
+	{ 0x00000001d969853c, 0x0000000125155542 },
+	/* x^152576 mod p(x)` << 1, x^152640 mod p(x)` << 1 */
+	{ 0x00000000523ccce2, 0x000000018fdb5882 },
+	/* x^151552 mod p(x)` << 1, x^151616 mod p(x)` << 1 */
+	{ 0x000000001e2436bc, 0x00000000e794b3f4 },
+	/* x^150528 mod p(x)` << 1, x^150592 mod p(x)` << 1 */
+	{ 0x00000000ddd1c3a2, 0x000000016f9bb022 },
+	/* x^149504 mod p(x)` << 1, x^149568 mod p(x)` << 1 */
+	{ 0x0000000019fcfe38, 0x00000000290c9978 },
+	/* x^148480 mod p(x)` << 1, x^148544 mod p(x)` << 1 */
+	{ 0x00000001ce95db64, 0x0000000083c0f350 },
+	/* x^147456 mod p(x)` << 1, x^147520 mod p(x)` << 1 */
+	{ 0x00000000af582806, 0x0000000173ea6628 },
+	/* x^146432 mod p(x)` << 1, x^146496 mod p(x)` << 1 */
+	{ 0x00000001006388f6, 0x00000001c8b4e00a },
+	/* x^145408 mod p(x)` << 1, x^145472 mod p(x)` << 1 */
+	{ 0x0000000179eca00a, 0x00000000de95d6aa },
+	/* x^144384 mod p(x)` << 1, x^144448 mod p(x)` << 1 */
+	{ 0x0000000122410a6a, 0x000000010b7f7248 },
+	/* x^143360 mod p(x)` << 1, x^143424 mod p(x)` << 1 */
+	{ 0x000000004288e87c, 0x00000001326e3a06 },
+	/* x^142336 mod p(x)` << 1, x^142400 mod p(x)` << 1 */
+	{ 0x000000016c5490da, 0x00000000bb62c2e6 },
+	/* x^141312 mod p(x)` << 1, x^141376 mod p(x)` << 1 */
+	{ 0x00000000d1c71f6e, 0x0000000156a4b2c2 },
+	/* x^140288 mod p(x)` << 1, x^140352 mod p(x)` << 1 */
+	{ 0x00000001b4ce08a6, 0x000000011dfe763a },
+	/* x^139264 mod p(x)` << 1, x^139328 mod p(x)` << 1 */
+	{ 0x00000001466ba60c, 0x000000007bcca8e2 },
+	/* x^138240 mod p(x)` << 1, x^138304 mod p(x)` << 1 */
+	{ 0x00000001f6c488a4, 0x0000000186118faa },
+	/* x^137216 mod p(x)` << 1, x^137280 mod p(x)` << 1 */
+	{ 0x000000013bfb0682, 0x0000000111a65a88 },
+	/* x^136192 mod p(x)` << 1, x^136256 mod p(x)` << 1 */
+	{ 0x00000000690e9e54, 0x000000003565e1c4 },
+	/* x^135168 mod p(x)` << 1, x^135232 mod p(x)` << 1 */
+	{ 0x00000000281346b6, 0x000000012ed02a82 },
+	/* x^134144 mod p(x)` << 1, x^134208 mod p(x)` << 1 */
+	{ 0x0000000156464024, 0x00000000c486ecfc },
+	/* x^133120 mod p(x)` << 1, x^133184 mod p(x)` << 1 */
+	{ 0x000000016063a8dc, 0x0000000001b951b2 },
+	/* x^132096 mod p(x)` << 1, x^132160 mod p(x)` << 1 */
+	{ 0x0000000116a66362, 0x0000000048143916 },
+	/* x^131072 mod p(x)` << 1, x^131136 mod p(x)` << 1 */
+	{ 0x000000017e8aa4d2, 0x00000001dc2ae124 },
+	/* x^130048 mod p(x)` << 1, x^130112 mod p(x)` << 1 */
+	{ 0x00000001728eb10c, 0x00000001416c58d6 },
+	/* x^129024 mod p(x)` << 1, x^129088 mod p(x)` << 1 */
+	{ 0x00000001b08fd7fa, 0x00000000a479744a },
+	/* x^128000 mod p(x)` << 1, x^128064 mod p(x)` << 1 */
+	{ 0x00000001092a16e8, 0x0000000096ca3a26 },
+	/* x^126976 mod p(x)` << 1, x^127040 mod p(x)` << 1 */
+	{ 0x00000000a505637c, 0x00000000ff223d4e },
+	/* x^125952 mod p(x)` << 1, x^126016 mod p(x)` << 1 */
+	{ 0x00000000d94869b2, 0x000000010e84da42 },
+	/* x^124928 mod p(x)` << 1, x^124992 mod p(x)` << 1 */
+	{ 0x00000001c8b203ae, 0x00000001b61ba3d0 },
+	/* x^123904 mod p(x)` << 1, x^123968 mod p(x)` << 1 */
+	{ 0x000000005704aea0, 0x00000000680f2de8 },
+	/* x^122880 mod p(x)` << 1, x^122944 mod p(x)` << 1 */
+	{ 0x000000012e295fa2, 0x000000008772a9a8 },
+	/* x^121856 mod p(x)` << 1, x^121920 mod p(x)` << 1 */
+	{ 0x000000011d0908bc, 0x0000000155f295bc },
+	/* x^120832 mod p(x)` << 1, x^120896 mod p(x)` << 1 */
+	{ 0x0000000193ed97ea, 0x00000000595f9282 },
+	/* x^119808 mod p(x)` << 1, x^119872 mod p(x)` << 1 */
+	{ 0x000000013a0f1c52, 0x0000000164b1c25a },
+	/* x^118784 mod p(x)` << 1, x^118848 mod p(x)` << 1 */
+	{ 0x000000010c2c40c0, 0x00000000fbd67c50 },
+	/* x^117760 mod p(x)` << 1, x^117824 mod p(x)` << 1 */
+	{ 0x00000000ff6fac3e, 0x0000000096076268 },
+	/* x^116736 mod p(x)` << 1, x^116800 mod p(x)` << 1 */
+	{ 0x000000017b3609c0, 0x00000001d288e4cc },
+	/* x^115712 mod p(x)` << 1, x^115776 mod p(x)` << 1 */
+	{ 0x0000000088c8c922, 0x00000001eaac1bdc },
+	/* x^114688 mod p(x)` << 1, x^114752 mod p(x)` << 1 */
+	{ 0x00000001751baae6, 0x00000001f1ea39e2 },
+	/* x^113664 mod p(x)` << 1, x^113728 mod p(x)` << 1 */
+	{ 0x0000000107952972, 0x00000001eb6506fc },
+	/* x^112640 mod p(x)` << 1, x^112704 mod p(x)` << 1 */
+	{ 0x0000000162b00abe, 0x000000010f806ffe },
+	/* x^111616 mod p(x)` << 1, x^111680 mod p(x)` << 1 */
+	{ 0x000000000d7b404c, 0x000000010408481e },
+	/* x^110592 mod p(x)` << 1, x^110656 mod p(x)` << 1 */
+	{ 0x00000000763b13d4, 0x0000000188260534 },
+	/* x^109568 mod p(x)` << 1, x^109632 mod p(x)` << 1 */
+	{ 0x00000000f6dc22d8, 0x0000000058fc73e0 },
+	/* x^108544 mod p(x)` << 1, x^108608 mod p(x)` << 1 */
+	{ 0x000000007daae060, 0x00000000391c59b8 },
+	/* x^107520 mod p(x)` << 1, x^107584 mod p(x)` << 1 */
+	{ 0x000000013359ab7c, 0x000000018b638400 },
+	/* x^106496 mod p(x)` << 1, x^106560 mod p(x)` << 1 */
+	{ 0x000000008add438a, 0x000000011738f5c4 },
+	/* x^105472 mod p(x)` << 1, x^105536 mod p(x)` << 1 */
+	{ 0x00000001edbefdea, 0x000000008cf7c6da },
+	/* x^104448 mod p(x)` << 1, x^104512 mod p(x)` << 1 */
+	{ 0x000000004104e0f8, 0x00000001ef97fb16 },
+	/* x^103424 mod p(x)` << 1, x^103488 mod p(x)` << 1 */
+	{ 0x00000000b48a8222, 0x0000000102130e20 },
+	/* x^102400 mod p(x)` << 1, x^102464 mod p(x)` << 1 */
+	{ 0x00000001bcb46844, 0x00000000db968898 },
+	/* x^101376 mod p(x)` << 1, x^101440 mod p(x)` << 1 */
+	{ 0x000000013293ce0a, 0x00000000b5047b5e },
+	/* x^100352 mod p(x)` << 1, x^100416 mod p(x)` << 1 */
+	{ 0x00000001710d0844, 0x000000010b90fdb2 },
+	/* x^99328 mod p(x)` << 1, x^99392 mod p(x)` << 1 */
+	{ 0x0000000117907f6e, 0x000000004834a32e },
+	/* x^98304 mod p(x)` << 1, x^98368 mod p(x)` << 1 */
+	{ 0x0000000087ddf93e, 0x0000000059c8f2b0 },
+	/* x^97280 mod p(x)` << 1, x^97344 mod p(x)` << 1 */
+	{ 0x000000005970e9b0, 0x0000000122cec508 },
+	/* x^96256 mod p(x)` << 1, x^96320 mod p(x)` << 1 */
+	{ 0x0000000185b2b7d0, 0x000000000a330cda },
+	/* x^95232 mod p(x)` << 1, x^95296 mod p(x)` << 1 */
+	{ 0x00000001dcee0efc, 0x000000014a47148c },
+	/* x^94208 mod p(x)` << 1, x^94272 mod p(x)` << 1 */
+	{ 0x0000000030da2722, 0x0000000042c61cb8 },
+	/* x^93184 mod p(x)` << 1, x^93248 mod p(x)` << 1 */
+	{ 0x000000012f925a18, 0x0000000012fe6960 },
+	/* x^92160 mod p(x)` << 1, x^92224 mod p(x)` << 1 */
+	{ 0x00000000dd2e357c, 0x00000000dbda2c20 },
+	/* x^91136 mod p(x)` << 1, x^91200 mod p(x)` << 1 */
+	{ 0x00000000071c80de, 0x000000011122410c },
+	/* x^90112 mod p(x)` << 1, x^90176 mod p(x)` << 1 */
+	{ 0x000000011513140a, 0x00000000977b2070 },
+	/* x^89088 mod p(x)` << 1, x^89152 mod p(x)` << 1 */
+	{ 0x00000001df876e8e, 0x000000014050438e },
+	/* x^88064 mod p(x)` << 1, x^88128 mod p(x)` << 1 */
+	{ 0x000000015f81d6ce, 0x0000000147c840e8 },
+	/* x^87040 mod p(x)` << 1, x^87104 mod p(x)` << 1 */
+	{ 0x000000019dd94dbe, 0x00000001cc7c88ce },
+	/* x^86016 mod p(x)` << 1, x^86080 mod p(x)` << 1 */
+	{ 0x00000001373d206e, 0x00000001476b35a4 },
+	/* x^84992 mod p(x)` << 1, x^85056 mod p(x)` << 1 */
+	{ 0x00000000668ccade, 0x000000013d52d508 },
+	/* x^83968 mod p(x)` << 1, x^84032 mod p(x)` << 1 */
+	{ 0x00000001b192d268, 0x000000008e4be32e },
+	/* x^82944 mod p(x)` << 1, x^83008 mod p(x)` << 1 */
+	{ 0x00000000e30f3a78, 0x00000000024120fe },
+	/* x^81920 mod p(x)` << 1, x^81984 mod p(x)` << 1 */
+	{ 0x000000010ef1f7bc, 0x00000000ddecddb4 },
+	/* x^80896 mod p(x)` << 1, x^80960 mod p(x)` << 1 */
+	{ 0x00000001f5ac7380, 0x00000000d4d403bc },
+	/* x^79872 mod p(x)` << 1, x^79936 mod p(x)` << 1 */
+	{ 0x000000011822ea70, 0x00000001734b89aa },
+	/* x^78848 mod p(x)` << 1, x^78912 mod p(x)` << 1 */
+	{ 0x00000000c3a33848, 0x000000010e7a58d6 },
+	/* x^77824 mod p(x)` << 1, x^77888 mod p(x)` << 1 */
+	{ 0x00000001bd151c24, 0x00000001f9f04e9c },
+	/* x^76800 mod p(x)` << 1, x^76864 mod p(x)` << 1 */
+	{ 0x0000000056002d76, 0x00000000b692225e },
+	/* x^75776 mod p(x)` << 1, x^75840 mod p(x)` << 1 */
+	{ 0x000000014657c4f4, 0x000000019b8d3f3e },
+	/* x^74752 mod p(x)` << 1, x^74816 mod p(x)` << 1 */
+	{ 0x0000000113742d7c, 0x00000001a874f11e },
+	/* x^73728 mod p(x)` << 1, x^73792 mod p(x)` << 1 */
+	{ 0x000000019c5920ba, 0x000000010d5a4254 },
+	/* x^72704 mod p(x)` << 1, x^72768 mod p(x)` << 1 */
+	{ 0x000000005216d2d6, 0x00000000bbb2f5d6 },
+	/* x^71680 mod p(x)` << 1, x^71744 mod p(x)` << 1 */
+	{ 0x0000000136f5ad8a, 0x0000000179cc0e36 },
+	/* x^70656 mod p(x)` << 1, x^70720 mod p(x)` << 1 */
+	{ 0x000000018b07beb6, 0x00000001dca1da4a },
+	/* x^69632 mod p(x)` << 1, x^69696 mod p(x)` << 1 */
+	{ 0x00000000db1e93b0, 0x00000000feb1a192 },
+	/* x^68608 mod p(x)` << 1, x^68672 mod p(x)` << 1 */
+	{ 0x000000000b96fa3a, 0x00000000d1eeedd6 },
+	/* x^67584 mod p(x)` << 1, x^67648 mod p(x)` << 1 */
+	{ 0x00000001d9968af0, 0x000000008fad9bb4 },
+	/* x^66560 mod p(x)` << 1, x^66624 mod p(x)` << 1 */
+	{ 0x000000000e4a77a2, 0x00000001884938e4 },
+	/* x^65536 mod p(x)` << 1, x^65600 mod p(x)` << 1 */
+	{ 0x00000000508c2ac8, 0x00000001bc2e9bc0 },
+	/* x^64512 mod p(x)` << 1, x^64576 mod p(x)` << 1 */
+	{ 0x0000000021572a80, 0x00000001f9658a68 },
+	/* x^63488 mod p(x)` << 1, x^63552 mod p(x)` << 1 */
+	{ 0x00000001b859daf2, 0x000000001b9224fc },
+	/* x^62464 mod p(x)` << 1, x^62528 mod p(x)` << 1 */
+	{ 0x000000016f788474, 0x0000000055b2fb84 },
+	/* x^61440 mod p(x)` << 1, x^61504 mod p(x)` << 1 */
+	{ 0x00000001b438810e, 0x000000018b090348 },
+	/* x^60416 mod p(x)` << 1, x^60480 mod p(x)` << 1 */
+	{ 0x0000000095ddc6f2, 0x000000011ccbd5ea },
+	/* x^59392 mod p(x)` << 1, x^59456 mod p(x)` << 1 */
+	{ 0x00000001d977c20c, 0x0000000007ae47f8 },
+	/* x^58368 mod p(x)` << 1, x^58432 mod p(x)` << 1 */
+	{ 0x00000000ebedb99a, 0x0000000172acbec0 },
+	/* x^57344 mod p(x)` << 1, x^57408 mod p(x)` << 1 */
+	{ 0x00000001df9e9e92, 0x00000001c6e3ff20 },
+	/* x^56320 mod p(x)` << 1, x^56384 mod p(x)` << 1 */
+	{ 0x00000001a4a3f952, 0x00000000e1b38744 },
+	/* x^55296 mod p(x)` << 1, x^55360 mod p(x)` << 1 */
+	{ 0x00000000e2f51220, 0x00000000791585b2 },
+	/* x^54272 mod p(x)` << 1, x^54336 mod p(x)` << 1 */
+	{ 0x000000004aa01f3e, 0x00000000ac53b894 },
+	/* x^53248 mod p(x)` << 1, x^53312 mod p(x)` << 1 */
+	{ 0x00000000b3e90a58, 0x00000001ed5f2cf4 },
+	/* x^52224 mod p(x)` << 1, x^52288 mod p(x)` << 1 */
+	{ 0x000000000c9ca2aa, 0x00000001df48b2e0 },
+	/* x^51200 mod p(x)` << 1, x^51264 mod p(x)` << 1 */
+	{ 0x0000000151682316, 0x00000000049c1c62 },
+	/* x^50176 mod p(x)` << 1, x^50240 mod p(x)` << 1 */
+	{ 0x0000000036fce78c, 0x000000017c460c12 },
+	/* x^49152 mod p(x)` << 1, x^49216 mod p(x)` << 1 */
+	{ 0x000000009037dc10, 0x000000015be4da7e },
+	/* x^48128 mod p(x)` << 1, x^48192 mod p(x)` << 1 */
+	{ 0x00000000d3298582, 0x000000010f38f668 },
+	/* x^47104 mod p(x)` << 1, x^47168 mod p(x)` << 1 */
+	{ 0x00000001b42e8ad6, 0x0000000039f40a00 },
+	/* x^46080 mod p(x)` << 1, x^46144 mod p(x)` << 1 */
+	{ 0x00000000142a9838, 0x00000000bd4c10c4 },
+	/* x^45056 mod p(x)` << 1, x^45120 mod p(x)` << 1 */
+	{ 0x0000000109c7f190, 0x0000000042db1d98 },
+	/* x^44032 mod p(x)` << 1, x^44096 mod p(x)` << 1 */
+	{ 0x0000000056ff9310, 0x00000001c905bae6 },
+	/* x^43008 mod p(x)` << 1, x^43072 mod p(x)` << 1 */
+	{ 0x00000001594513aa, 0x00000000069d40ea },
+	/* x^41984 mod p(x)` << 1, x^42048 mod p(x)` << 1 */
+	{ 0x00000001e3b5b1e8, 0x000000008e4fbad0 },
+	/* x^40960 mod p(x)` << 1, x^41024 mod p(x)` << 1 */
+	{ 0x000000011dd5fc08, 0x0000000047bedd46 },
+	/* x^39936 mod p(x)` << 1, x^40000 mod p(x)` << 1 */
+	{ 0x00000001675f0cc2, 0x0000000026396bf8 },
+	/* x^38912 mod p(x)` << 1, x^38976 mod p(x)` << 1 */
+	{ 0x00000000d1c8dd44, 0x00000000379beb92 },
+	/* x^37888 mod p(x)` << 1, x^37952 mod p(x)` << 1 */
+	{ 0x0000000115ebd3d8, 0x000000000abae54a },
+	/* x^36864 mod p(x)` << 1, x^36928 mod p(x)` << 1 */
+	{ 0x00000001ecbd0dac, 0x0000000007e6a128 },
+	/* x^35840 mod p(x)` << 1, x^35904 mod p(x)` << 1 */
+	{ 0x00000000cdf67af2, 0x000000000ade29d2 },
+	/* x^34816 mod p(x)` << 1, x^34880 mod p(x)` << 1 */
+	{ 0x000000004c01ff4c, 0x00000000f974c45c },
+	/* x^33792 mod p(x)` << 1, x^33856 mod p(x)` << 1 */
+	{ 0x00000000f2d8657e, 0x00000000e77ac60a },
+	/* x^32768 mod p(x)` << 1, x^32832 mod p(x)` << 1 */
+	{ 0x000000006bae74c4, 0x0000000145895816 },
+	/* x^31744 mod p(x)` << 1, x^31808 mod p(x)` << 1 */
+	{ 0x0000000152af8aa0, 0x0000000038e362be },
+	/* x^30720 mod p(x)` << 1, x^30784 mod p(x)` << 1 */
+	{ 0x0000000004663802, 0x000000007f991a64 },
+	/* x^29696 mod p(x)` << 1, x^29760 mod p(x)` << 1 */
+	{ 0x00000001ab2f5afc, 0x00000000fa366d3a },
+	/* x^28672 mod p(x)` << 1, x^28736 mod p(x)` << 1 */
+	{ 0x0000000074a4ebd4, 0x00000001a2bb34f0 },
+	/* x^27648 mod p(x)` << 1, x^27712 mod p(x)` << 1 */
+	{ 0x00000001d7ab3a4c, 0x0000000028a9981e },
+	/* x^26624 mod p(x)` << 1, x^26688 mod p(x)` << 1 */
+	{ 0x00000001a8da60c6, 0x00000001dbc672be },
+	/* x^25600 mod p(x)` << 1, x^25664 mod p(x)` << 1 */
+	{ 0x000000013cf63820, 0x00000000b04d77f6 },
+	/* x^24576 mod p(x)` << 1, x^24640 mod p(x)` << 1 */
+	{ 0x00000000bec12e1e, 0x0000000124400d96 },
+	/* x^23552 mod p(x)` << 1, x^23616 mod p(x)` << 1 */
+	{ 0x00000001c6368010, 0x000000014ca4b414 },
+	/* x^22528 mod p(x)` << 1, x^22592 mod p(x)` << 1 */
+	{ 0x00000001e6e78758, 0x000000012fe2c938 },
+	/* x^21504 mod p(x)` << 1, x^21568 mod p(x)` << 1 */
+	{ 0x000000008d7f2b3c, 0x00000001faed01e6 },
+	/* x^20480 mod p(x)` << 1, x^20544 mod p(x)` << 1 */
+	{ 0x000000016b4a156e, 0x000000007e80ecfe },
+	/* x^19456 mod p(x)` << 1, x^19520 mod p(x)` << 1 */
+	{ 0x00000001c63cfeb6, 0x0000000098daee94 },
+	/* x^18432 mod p(x)` << 1, x^18496 mod p(x)` << 1 */
+	{ 0x000000015f902670, 0x000000010a04edea },
+	/* x^17408 mod p(x)` << 1, x^17472 mod p(x)` << 1 */
+	{ 0x00000001cd5de11e, 0x00000001c00b4524 },
+	/* x^16384 mod p(x)` << 1, x^16448 mod p(x)` << 1 */
+	{ 0x000000001acaec54, 0x0000000170296550 },
+	/* x^15360 mod p(x)` << 1, x^15424 mod p(x)` << 1 */
+	{ 0x000000002bd0ca78, 0x0000000181afaa48 },
+	/* x^14336 mod p(x)` << 1, x^14400 mod p(x)` << 1 */
+	{ 0x0000000032d63d5c, 0x0000000185a31ffa },
+	/* x^13312 mod p(x)` << 1, x^13376 mod p(x)` << 1 */
+	{ 0x000000001c6d4e4c, 0x000000002469f608 },
+	/* x^12288 mod p(x)` << 1, x^12352 mod p(x)` << 1 */
+	{ 0x0000000106a60b92, 0x000000006980102a },
+	/* x^11264 mod p(x)` << 1, x^11328 mod p(x)` << 1 */
+	{ 0x00000000d3855e12, 0x0000000111ea9ca8 },
+	/* x^10240 mod p(x)` << 1, x^10304 mod p(x)` << 1 */
+	{ 0x00000000e3125636, 0x00000001bd1d29ce },
+	/* x^9216 mod p(x)` << 1, x^9280 mod p(x)` << 1 */
+	{ 0x000000009e8f7ea4, 0x00000001b34b9580 },
+	/* x^8192 mod p(x)` << 1, x^8256 mod p(x)` << 1 */
+	{ 0x00000001c82e562c, 0x000000003076054e },
+	/* x^7168 mod p(x)` << 1, x^7232 mod p(x)` << 1 */
+	{ 0x00000000ca9f09ce, 0x000000012a608ea4 },
+	/* x^6144 mod p(x)` << 1, x^6208 mod p(x)` << 1 */
+	{ 0x00000000c63764e6, 0x00000000784d05fe },
+	/* x^5120 mod p(x)` << 1, x^5184 mod p(x)` << 1 */
+	{ 0x0000000168d2e49e, 0x000000016ef0d82a },
+	/* x^4096 mod p(x)` << 1, x^4160 mod p(x)` << 1 */
+	{ 0x00000000e986c148, 0x0000000075bda454 },
+	/* x^3072 mod p(x)` << 1, x^3136 mod p(x)` << 1 */
+	{ 0x00000000cfb65894, 0x000000003dc0a1c4 },
+	/* x^2048 mod p(x)` << 1, x^2112 mod p(x)` << 1 */
+	{ 0x0000000111cadee4, 0x00000000e9a5d8be },
+	/* x^1024 mod p(x)` << 1, x^1088 mod p(x)` << 1 */
+	{ 0x0000000171fb63ce, 0x00000001609bc4b4 }
+#endif /* __LITTLE_ENDIAN__ */
+};
+
+/* Reduce final 1024-2048 bits to 64 bits, shifting 32 bits to include the trailing 32 bits of zeros */
+
+static const __vector unsigned long long vcrc_short_const[16] __attribute__((aligned(16))) = {
+#ifdef __LITTLE_ENDIAN__
+	/* x^1952 mod p(x) , x^1984 mod p(x) , x^2016 mod p(x) , x^2048 mod p(x)  */
+	{ 0x5cf015c388e56f72, 0x7fec2963e5bf8048 },
+	/* x^1824 mod p(x) , x^1856 mod p(x) , x^1888 mod p(x) , x^1920 mod p(x)  */
+	{ 0x963a18920246e2e6, 0x38e888d4844752a9 },
+	/* x^1696 mod p(x) , x^1728 mod p(x) , x^1760 mod p(x) , x^1792 mod p(x)  */
+	{ 0x419a441956993a31, 0x42316c00730206ad },
+	/* x^1568 mod p(x) , x^1600 mod p(x) , x^1632 mod p(x) , x^1664 mod p(x)  */
+	{ 0x924752ba2b830011, 0x543d5c543e65ddf9 },
+	/* x^1440 mod p(x) , x^1472 mod p(x) , x^1504 mod p(x) , x^1536 mod p(x)  */
+	{ 0x55bd7f9518e4a304, 0x78e87aaf56767c92 },
+	/* x^1312 mod p(x) , x^1344 mod p(x) , x^1376 mod p(x) , x^1408 mod p(x)  */
+	{ 0x6d76739fe0553f1e, 0x8f68fcec1903da7f },
+	/* x^1184 mod p(x) , x^1216 mod p(x) , x^1248 mod p(x) , x^1280 mod p(x)  */
+	{ 0xc133722b1fe0b5c3, 0x3f4840246791d588 },
+	/* x^1056 mod p(x) , x^1088 mod p(x) , x^1120 mod p(x) , x^1152 mod p(x)  */
+	{ 0x64b67ee0e55ef1f3, 0x34c96751b04de25a },
+	/* x^928 mod p(x) , x^960 mod p(x) , x^992 mod p(x) , x^1024 mod p(x)  */
+	{ 0x069db049b8fdb1e7, 0x156c8e180b4a395b },
+	/* x^800 mod p(x) , x^832 mod p(x) , x^864 mod p(x) , x^896 mod p(x)  */
+	{ 0xa11bfaf3c9e90b9e, 0xe0b99ccbe661f7be },
+	/* x^672 mod p(x) , x^704 mod p(x) , x^736 mod p(x) , x^768 mod p(x)  */
+	{ 0x817cdc5119b29a35, 0x041d37768cd75659 },
+	/* x^544 mod p(x) , x^576 mod p(x) , x^608 mod p(x) , x^640 mod p(x)  */
+	{ 0x1ce9d94b36c41f1c, 0x3a0777818cfaa965 },
+	/* x^416 mod p(x) , x^448 mod p(x) , x^480 mod p(x) , x^512 mod p(x)  */
+	{ 0x4f256efcb82be955, 0x0e148e8252377a55 },
+	/* x^288 mod p(x) , x^320 mod p(x) , x^352 mod p(x) , x^384 mod p(x)  */
+	{ 0xec1631edb2dea967, 0x9c25531d19e65dde },
+	/* x^160 mod p(x) , x^192 mod p(x) , x^224 mod p(x) , x^256 mod p(x)  */
+	{ 0x5d27e147510ac59a, 0x790606ff9957c0a6 },
+	/* x^32 mod p(x) , x^64 mod p(x) , x^96 mod p(x) , x^128 mod p(x)  */
+	{ 0xa66805eb18b8ea18, 0x82f63b786ea2d55c }
+#else /* __LITTLE_ENDIAN__ */
+	/* x^1952 mod p(x) , x^1984 mod p(x) , x^2016 mod p(x) , x^2048 mod p(x)  */
+	{ 0x7fec2963e5bf8048, 0x5cf015c388e56f72 },
+	/* x^1824 mod p(x) , x^1856 mod p(x) , x^1888 mod p(x) , x^1920 mod p(x)  */
+	{ 0x38e888d4844752a9, 0x963a18920246e2e6 },
+	/* x^1696 mod p(x) , x^1728 mod p(x) , x^1760 mod p(x) , x^1792 mod p(x)  */
+	{ 0x42316c00730206ad, 0x419a441956993a31 },
+	/* x^1568 mod p(x) , x^1600 mod p(x) , x^1632 mod p(x) , x^1664 mod p(x)  */
+	{ 0x543d5c543e65ddf9, 0x924752ba2b830011 },
+	/* x^1440 mod p(x) , x^1472 mod p(x) , x^1504 mod p(x) , x^1536 mod p(x)  */
+	{ 0x78e87aaf56767c92, 0x55bd7f9518e4a304 },
+	/* x^1312 mod p(x) , x^1344 mod p(x) , x^1376 mod p(x) , x^1408 mod p(x)  */
+	{ 0x8f68fcec1903da7f, 0x6d76739fe0553f1e },
+	/* x^1184 mod p(x) , x^1216 mod p(x) , x^1248 mod p(x) , x^1280 mod p(x)  */
+	{ 0x3f4840246791d588, 0xc133722b1fe0b5c3 },
+	/* x^1056 mod p(x) , x^1088 mod p(x) , x^1120 mod p(x) , x^1152 mod p(x)  */
+	{ 0x34c96751b04de25a, 0x64b67ee0e55ef1f3 },
+	/* x^928 mod p(x) , x^960 mod p(x) , x^992 mod p(x) , x^1024 mod p(x)  */
+	{ 0x156c8e180b4a395b, 0x069db049b8fdb1e7 },
+	/* x^800 mod p(x) , x^832 mod p(x) , x^864 mod p(x) , x^896 mod p(x)  */
+	{ 0xe0b99ccbe661f7be, 0xa11bfaf3c9e90b9e },
+	/* x^672 mod p(x) , x^704 mod p(x) , x^736 mod p(x) , x^768 mod p(x)  */
+	{ 0x041d37768cd75659, 0x817cdc5119b29a35 },
+	/* x^544 mod p(x) , x^576 mod p(x) , x^608 mod p(x) , x^640 mod p(x)  */
+	{ 0x3a0777818cfaa965, 0x1ce9d94b36c41f1c },
+	/* x^416 mod p(x) , x^448 mod p(x) , x^480 mod p(x) , x^512 mod p(x)  */
+	{ 0x0e148e8252377a55, 0x4f256efcb82be955 },
+	/* x^288 mod p(x) , x^320 mod p(x) , x^352 mod p(x) , x^384 mod p(x)  */
+	{ 0x9c25531d19e65dde, 0xec1631edb2dea967 },
+	/* x^160 mod p(x) , x^192 mod p(x) , x^224 mod p(x) , x^256 mod p(x)  */
+	{ 0x790606ff9957c0a6, 0x5d27e147510ac59a },
+	/* x^32 mod p(x) , x^64 mod p(x) , x^96 mod p(x) , x^128 mod p(x)  */
+	{ 0x82f63b786ea2d55c, 0xa66805eb18b8ea18 }
+#endif /* __LITTLE_ENDIAN__ */
+};
+
+/* Barrett constants */
+/* 33 bit reflected Barrett constant m - (4^32)/n */
+
+static const __vector unsigned long long v_Barrett_const[2] __attribute__((aligned(16))) = {
+/* x^64 div p(x)  */
+#ifdef __LITTLE_ENDIAN__
+	{ 0x00000000dea713f1, 0x0000000000000000 },
+	{ 0x0000000105ec76f1, 0x0000000000000000 }
+#else /* __LITTLE_ENDIAN__ */
+	{ 0x0000000000000000, 0x00000000dea713f1 },
+	{ 0x0000000000000000, 0x0000000105ec76f1 }
+#endif /* __LITTLE_ENDIAN__ */
+};
+#endif /* POWER8_INTRINSICS */
+
+#else /* __ASSEMBLER__ */
+.constants :
+
+      /* Reduce 262144 kbits to 1024 bits */
+      /* x^261120 mod p(x)` << 1, x^261184 mod p(x)` << 1 */
+      .octa 0x00000000b6ca9e20000000009c37c408
+
+      /* x^260096 mod p(x)` << 1, x^260160 mod p(x)` << 1 */
+      .octa 0x00000000350249a800000001b51df26c
+
+      /* x^259072 mod p(x)` << 1, x^259136 mod p(x)` << 1 */
+      .octa 0x00000001862dac54000000000724b9d0
+
+      /* x^258048 mod p(x)` << 1, x^258112 mod p(x)` << 1 */
+      .octa 0x00000001d87fb48c00000001c00532fe
+
+      /* x^257024 mod p(x)` << 1, x^257088 mod p(x)` << 1 */
+      .octa 0x00000001f39b699e00000000f05a9362
+
+      /* x^256000 mod p(x)` << 1, x^256064 mod p(x)` << 1 */
+      .octa 0x0000000101da11b400000001e1007970
+
+      /* x^254976 mod p(x)` << 1, x^255040 mod p(x)` << 1 */
+      .octa 0x00000001cab571e000000000a57366ee
+
+      /* x^253952 mod p(x)` << 1, x^254016 mod p(x)` << 1 */
+      .octa 0x00000000c7020cfe0000000192011284
+
+      /* x^252928 mod p(x)` << 1, x^252992 mod p(x)` << 1 */
+      .octa 0x00000000cdaed1ae0000000162716d9a
+
+      /* x^251904 mod p(x)` << 1, x^251968 mod p(x)` << 1 */
+      .octa 0x00000001e804effc00000000cd97ecde
+
+      /* x^250880 mod p(x)` << 1, x^250944 mod p(x)` << 1 */
+      .octa 0x0000000077c3ea3a0000000058812bc0
+
+      /* x^249856 mod p(x)` << 1, x^249920 mod p(x)` << 1 */
+      .octa 0x0000000068df31b40000000088b8c12e
+
+      /* x^248832 mod p(x)` << 1, x^248896 mod p(x)` << 1 */
+      .octa 0x00000000b059b6c200000001230b234c
+
+      /* x^247808 mod p(x)` << 1, x^247872 mod p(x)` << 1 */
+      .octa 0x0000000145fb8ed800000001120b416e
+
+      /* x^246784 mod p(x)` << 1, x^246848 mod p(x)` << 1 */
+      .octa 0x00000000cbc0916800000001974aecb0
+
+      /* x^245760 mod p(x)` << 1, x^245824 mod p(x)` << 1 */
+      .octa 0x000000005ceeedc2000000008ee3f226
+
+      /* x^244736 mod p(x)` << 1, x^244800 mod p(x)` << 1 */
+      .octa 0x0000000047d74e8600000001089aba9a
+
+      /* x^243712 mod p(x)` << 1, x^243776 mod p(x)` << 1 */
+      .octa 0x00000001407e9e220000000065113872
+
+      /* x^242688 mod p(x)` << 1, x^242752 mod p(x)` << 1 */
+      .octa 0x00000001da967bda000000005c07ec10
+
+      /* x^241664 mod p(x)` << 1, x^241728 mod p(x)` << 1 */
+      .octa 0x000000006c8983680000000187590924
+
+      /* x^240640 mod p(x)` << 1, x^240704 mod p(x)` << 1 */
+      .octa 0x00000000f2d14c9800000000e35da7c6
+
+      /* x^239616 mod p(x)` << 1, x^239680 mod p(x)` << 1 */
+      .octa 0x00000001993c6ad4000000000415855a
+
+      /* x^238592 mod p(x)` << 1, x^238656 mod p(x)` << 1 */
+      .octa 0x000000014683d1ac0000000073617758
+
+      /* x^237568 mod p(x)` << 1, x^237632 mod p(x)` << 1 */
+      .octa 0x00000001a7c93e6c0000000176021d28
+
+      /* x^236544 mod p(x)` << 1, x^236608 mod p(x)` << 1 */
+      .octa 0x000000010211e90a00000001c358fd0a
+
+      /* x^235520 mod p(x)` << 1, x^235584 mod p(x)` << 1 */
+      .octa 0x000000001119403e00000001ff7a2c18
+
+      /* x^234496 mod p(x)` << 1, x^234560 mod p(x)` << 1 */
+      .octa 0x000000001c3261aa00000000f2d9f7e4
+
+      /* x^233472 mod p(x)` << 1, x^233536 mod p(x)` << 1 */
+      .octa 0x000000014e37a634000000016cf1f9c8
+
+      /* x^232448 mod p(x)` << 1, x^232512 mod p(x)` << 1 */
+      .octa 0x0000000073786c0c000000010af9279a
+
+      /* x^231424 mod p(x)` << 1, x^231488 mod p(x)` << 1 */
+      .octa 0x000000011dc037f80000000004f101e8
+
+      /* x^230400 mod p(x)` << 1, x^230464 mod p(x)` << 1 */
+      .octa 0x0000000031433dfc0000000070bcf184
+
+      /* x^229376 mod p(x)` << 1, x^229440 mod p(x)` << 1 */
+      .octa 0x000000009cde8348000000000a8de642
+
+      /* x^228352 mod p(x)` << 1, x^228416 mod p(x)` << 1 */
+      .octa 0x0000000038d3c2a60000000062ea130c
+
+      /* x^227328 mod p(x)` << 1, x^227392 mod p(x)` << 1 */
+      .octa 0x000000011b25f26000000001eb31cbb2
+
+      /* x^226304 mod p(x)` << 1, x^226368 mod p(x)` << 1 */
+      .octa 0x000000001629e6f00000000170783448
+
+      /* x^225280 mod p(x)` << 1, x^225344 mod p(x)` << 1 */
+      .octa 0x0000000160838b4c00000001a684b4c6
+
+      /* x^224256 mod p(x)` << 1, x^224320 mod p(x)` << 1 */
+      .octa 0x000000007a44011c00000000253ca5b4
+
+      /* x^223232 mod p(x)` << 1, x^223296 mod p(x)` << 1 */
+      .octa 0x00000000226f417a0000000057b4b1e2
+
+      /* x^222208 mod p(x)` << 1, x^222272 mod p(x)` << 1 */
+      .octa 0x0000000045eb2eb400000000b6bd084c
+
+      /* x^221184 mod p(x)` << 1, x^221248 mod p(x)` << 1 */
+      .octa 0x000000014459d70c0000000123c2d592
+
+      /* x^220160 mod p(x)` << 1, x^220224 mod p(x)` << 1 */
+      .octa 0x00000001d406ed8200000000159dafce
+
+      /* x^219136 mod p(x)` << 1, x^219200 mod p(x)` << 1 */
+      .octa 0x0000000160c8e1a80000000127e1a64e
+
+      /* x^218112 mod p(x)` << 1, x^218176 mod p(x)` << 1 */
+      .octa 0x0000000027ba80980000000056860754
+
+      /* x^217088 mod p(x)` << 1, x^217152 mod p(x)` << 1 */
+      .octa 0x000000006d92d01800000001e661aae8
+
+      /* x^216064 mod p(x)` << 1, x^216128 mod p(x)` << 1 */
+      .octa 0x000000012ed7e3f200000000f82c6166
+
+      /* x^215040 mod p(x)` << 1, x^215104 mod p(x)` << 1 */
+      .octa 0x000000002dc8778800000000c4f9c7ae
+
+      /* x^214016 mod p(x)` << 1, x^214080 mod p(x)` << 1 */
+      .octa 0x0000000018240bb80000000074203d20
+
+      /* x^212992 mod p(x)` << 1, x^213056 mod p(x)` << 1 */
+      .octa 0x000000001ad381580000000198173052
+
+      /* x^211968 mod p(x)` << 1, x^212032 mod p(x)` << 1 */
+      .octa 0x00000001396b78f200000001ce8aba54
+
+      /* x^210944 mod p(x)` << 1, x^211008 mod p(x)` << 1 */
+      .octa 0x000000011a68133400000001850d5d94
+
+      /* x^209920 mod p(x)` << 1, x^209984 mod p(x)` << 1 */
+      .octa 0x000000012104732e00000001d609239c
+
+      /* x^208896 mod p(x)` << 1, x^208960 mod p(x)` << 1 */
+      .octa 0x00000000a140d90c000000001595f048
+
+      /* x^207872 mod p(x)` << 1, x^207936 mod p(x)` << 1 */
+      .octa 0x00000001b7215eda0000000042ccee08
+
+      /* x^206848 mod p(x)` << 1, x^206912 mod p(x)` << 1 */
+      .octa 0x00000001aaf1df3c000000010a389d74
+
+      /* x^205824 mod p(x)` << 1, x^205888 mod p(x)` << 1 */
+      .octa 0x0000000029d15b8a000000012a840da6
+
+      /* x^204800 mod p(x)` << 1, x^204864 mod p(x)` << 1 */
+      .octa 0x00000000f1a96922000000001d181c0c
+
+      /* x^203776 mod p(x)` << 1, x^203840 mod p(x)` << 1 */
+      .octa 0x00000001ac80d03c0000000068b7d1f6
+
+      /* x^202752 mod p(x)` << 1, x^202816 mod p(x)` << 1 */
+      .octa 0x000000000f11d56a000000005b0f14fc
+
+      /* x^201728 mod p(x)` << 1, x^201792 mod p(x)` << 1 */
+      .octa 0x00000001f1c022a20000000179e9e730
+
+      /* x^200704 mod p(x)` << 1, x^200768 mod p(x)` << 1 */
+      .octa 0x0000000173d00ae200000001ce1368d6
+
+      /* x^199680 mod p(x)` << 1, x^199744 mod p(x)` << 1 */
+      .octa 0x00000001d4ffe4ac0000000112c3a84c
+
+      /* x^198656 mod p(x)` << 1, x^198720 mod p(x)` << 1 */
+      .octa 0x000000016edc5ae400000000de940fee
+
+      /* x^197632 mod p(x)` << 1, x^197696 mod p(x)` << 1 */
+      .octa 0x00000001f1a0214000000000fe896b7e
+
+      /* x^196608 mod p(x)` << 1, x^196672 mod p(x)` << 1 */
+      .octa 0x00000000ca0b28a000000001f797431c
+
+      /* x^195584 mod p(x)` << 1, x^195648 mod p(x)` << 1 */
+      .octa 0x00000001928e30a20000000053e989ba
+
+      /* x^194560 mod p(x)` << 1, x^194624 mod p(x)` << 1 */
+      .octa 0x0000000097b1b002000000003920cd16
+
+      /* x^193536 mod p(x)` << 1, x^193600 mod p(x)` << 1 */
+      .octa 0x00000000b15bf90600000001e6f579b8
+
+      /* x^192512 mod p(x)` << 1, x^192576 mod p(x)` << 1 */
+      .octa 0x00000000411c5d52000000007493cb0a
+
+      /* x^191488 mod p(x)` << 1, x^191552 mod p(x)` << 1 */
+      .octa 0x00000001c36f330000000001bdd376d8
+
+      /* x^190464 mod p(x)` << 1, x^190528 mod p(x)` << 1 */
+      .octa 0x00000001119227e0000000016badfee6
+
+      /* x^189440 mod p(x)` << 1, x^189504 mod p(x)` << 1 */
+      .octa 0x00000000114d47020000000071de5c58
+
+      /* x^188416 mod p(x)` << 1, x^188480 mod p(x)` << 1 */
+      .octa 0x00000000458b5b9800000000453f317c
+
+      /* x^187392 mod p(x)` << 1, x^187456 mod p(x)` << 1 */
+      .octa 0x000000012e31fb8e0000000121675cce
+
+      /* x^186368 mod p(x)` << 1, x^186432 mod p(x)` << 1 */
+      .octa 0x000000005cf619d800000001f409ee92
+
+      /* x^185344 mod p(x)` << 1, x^185408 mod p(x)` << 1 */
+      .octa 0x0000000063f4d8b200000000f36b9c88
+
+      /* x^184320 mod p(x)` << 1, x^184384 mod p(x)` << 1 */
+      .octa 0x000000004138dc8a0000000036b398f4
+
+      /* x^183296 mod p(x)` << 1, x^183360 mod p(x)` << 1 */
+      .octa 0x00000001d29ee8e000000001748f9adc
+
+      /* x^182272 mod p(x)` << 1, x^182336 mod p(x)` << 1 */
+      .octa 0x000000006a08ace800000001be94ec00
+
+      /* x^181248 mod p(x)` << 1, x^181312 mod p(x)` << 1 */
+      .octa 0x0000000127d4201000000000b74370d6
+
+      /* x^180224 mod p(x)` << 1, x^180288 mod p(x)` << 1 */
+      .octa 0x0000000019d76b6200000001174d0b98
+
+      /* x^179200 mod p(x)` << 1, x^179264 mod p(x)` << 1 */
+      .octa 0x00000001b1471f6e00000000befc06a4
+
+      /* x^178176 mod p(x)` << 1, x^178240 mod p(x)` << 1 */
+      .octa 0x00000001f64c19cc00000001ae125288
+
+      /* x^177152 mod p(x)` << 1, x^177216 mod p(x)` << 1 */
+      .octa 0x00000000003c0ea00000000095c19b34
+
+      /* x^176128 mod p(x)` << 1, x^176192 mod p(x)` << 1 */
+      .octa 0x000000014d73abf600000001a78496f2
+
+      /* x^175104 mod p(x)` << 1, x^175168 mod p(x)` << 1 */
+      .octa 0x00000001620eb84400000001ac5390a0
+
+      /* x^174080 mod p(x)` << 1, x^174144 mod p(x)` << 1 */
+      .octa 0x0000000147655048000000002a80ed6e
+
+      /* x^173056 mod p(x)` << 1, x^173120 mod p(x)` << 1 */
+      .octa 0x0000000067b5077e00000001fa9b0128
+
+      /* x^172032 mod p(x)` << 1, x^172096 mod p(x)` << 1 */
+      .octa 0x0000000010ffe20600000001ea94929e
+
+      /* x^171008 mod p(x)` << 1, x^171072 mod p(x)` << 1 */
+      .octa 0x000000000fee8f1e0000000125f4305c
+
+      /* x^169984 mod p(x)` << 1, x^170048 mod p(x)` << 1 */
+      .octa 0x00000001da26fbae00000001471e2002
+
+      /* x^168960 mod p(x)` << 1, x^169024 mod p(x)` << 1 */
+      .octa 0x00000001b3a8bd880000000132d2253a
+
+      /* x^167936 mod p(x)` << 1, x^168000 mod p(x)` << 1 */
+      .octa 0x00000000e8f3898e00000000f26b3592
+
+      /* x^166912 mod p(x)` << 1, x^166976 mod p(x)` << 1 */
+      .octa 0x00000000b0d0d28c00000000bc8b67b0
+
+      /* x^165888 mod p(x)` << 1, x^165952 mod p(x)` << 1 */
+      .octa 0x0000000030f2a798000000013a826ef2
+
+      /* x^164864 mod p(x)` << 1, x^164928 mod p(x)` << 1 */
+      .octa 0x000000000fba10020000000081482c84
+
+      /* x^163840 mod p(x)` << 1, x^163904 mod p(x)` << 1 */
+      .octa 0x00000000bdb9bd7200000000e77307c2
+
+      /* x^162816 mod p(x)` << 1, x^162880 mod p(x)` << 1 */
+      .octa 0x0000000075d3bf5a00000000d4a07ec8
+
+      /* x^161792 mod p(x)` << 1, x^161856 mod p(x)` << 1 */
+      .octa 0x00000000ef1f98a00000000017102100
+
+      /* x^160768 mod p(x)` << 1, x^160832 mod p(x)` << 1 */
+      .octa 0x00000000689c760200000000db406486
+
+      /* x^159744 mod p(x)` << 1, x^159808 mod p(x)` << 1 */
+      .octa 0x000000016d5fa5fe0000000192db7f88
+
+      /* x^158720 mod p(x)` << 1, x^158784 mod p(x)` << 1 */
+      .octa 0x00000001d0d2b9ca000000018bf67b1e
+
+      /* x^157696 mod p(x)` << 1, x^157760 mod p(x)` << 1 */
+      .octa 0x0000000041e7b470000000007c09163e
+
+      /* x^156672 mod p(x)` << 1, x^156736 mod p(x)` << 1 */
+      .octa 0x00000001cbb6495e000000000adac060
+
+      /* x^155648 mod p(x)` << 1, x^155712 mod p(x)` << 1 */
+      .octa 0x000000010052a0b000000000bd8316ae
+
+      /* x^154624 mod p(x)` << 1, x^154688 mod p(x)` << 1 */
+      .octa 0x00000001d8effb5c000000019f09ab54
+
+      /* x^153600 mod p(x)` << 1, x^153664 mod p(x)` << 1 */
+      .octa 0x00000001d969853c0000000125155542
+
+      /* x^152576 mod p(x)` << 1, x^152640 mod p(x)` << 1 */
+      .octa 0x00000000523ccce2000000018fdb5882
+
+      /* x^151552 mod p(x)` << 1, x^151616 mod p(x)` << 1 */
+      .octa 0x000000001e2436bc00000000e794b3f4
+
+      /* x^150528 mod p(x)` << 1, x^150592 mod p(x)` << 1 */
+      .octa 0x00000000ddd1c3a2000000016f9bb022
+
+      /* x^149504 mod p(x)` << 1, x^149568 mod p(x)` << 1 */
+      .octa 0x0000000019fcfe3800000000290c9978
+
+      /* x^148480 mod p(x)` << 1, x^148544 mod p(x)` << 1 */
+      .octa 0x00000001ce95db640000000083c0f350
+
+      /* x^147456 mod p(x)` << 1, x^147520 mod p(x)` << 1 */
+      .octa 0x00000000af5828060000000173ea6628
+
+      /* x^146432 mod p(x)` << 1, x^146496 mod p(x)` << 1 */
+      .octa 0x00000001006388f600000001c8b4e00a
+
+      /* x^145408 mod p(x)` << 1, x^145472 mod p(x)` << 1 */
+      .octa 0x0000000179eca00a00000000de95d6aa
+
+      /* x^144384 mod p(x)` << 1, x^144448 mod p(x)` << 1 */
+      .octa 0x0000000122410a6a000000010b7f7248
+
+      /* x^143360 mod p(x)` << 1, x^143424 mod p(x)` << 1 */
+      .octa 0x000000004288e87c00000001326e3a06
+
+      /* x^142336 mod p(x)` << 1, x^142400 mod p(x)` << 1 */
+      .octa 0x000000016c5490da00000000bb62c2e6
+
+      /* x^141312 mod p(x)` << 1, x^141376 mod p(x)` << 1 */
+      .octa 0x00000000d1c71f6e0000000156a4b2c2
+
+      /* x^140288 mod p(x)` << 1, x^140352 mod p(x)` << 1 */
+      .octa 0x00000001b4ce08a6000000011dfe763a
+
+      /* x^139264 mod p(x)` << 1, x^139328 mod p(x)` << 1 */
+      .octa 0x00000001466ba60c000000007bcca8e2
+
+      /* x^138240 mod p(x)` << 1, x^138304 mod p(x)` << 1 */
+      .octa 0x00000001f6c488a40000000186118faa
+
+      /* x^137216 mod p(x)` << 1, x^137280 mod p(x)` << 1 */
+      .octa 0x000000013bfb06820000000111a65a88
+
+      /* x^136192 mod p(x)` << 1, x^136256 mod p(x)` << 1 */
+      .octa 0x00000000690e9e54000000003565e1c4
+
+      /* x^135168 mod p(x)` << 1, x^135232 mod p(x)` << 1 */
+      .octa 0x00000000281346b6000000012ed02a82
+
+      /* x^134144 mod p(x)` << 1, x^134208 mod p(x)` << 1 */
+      .octa 0x000000015646402400000000c486ecfc
+
+      /* x^133120 mod p(x)` << 1, x^133184 mod p(x)` << 1 */
+      .octa 0x000000016063a8dc0000000001b951b2
+
+      /* x^132096 mod p(x)` << 1, x^132160 mod p(x)` << 1 */
+      .octa 0x0000000116a663620000000048143916
+
+      /* x^131072 mod p(x)` << 1, x^131136 mod p(x)` << 1 */
+      .octa 0x000000017e8aa4d200000001dc2ae124
+
+      /* x^130048 mod p(x)` << 1, x^130112 mod p(x)` << 1 */
+      .octa 0x00000001728eb10c00000001416c58d6
+
+      /* x^129024 mod p(x)` << 1, x^129088 mod p(x)` << 1 */
+      .octa 0x00000001b08fd7fa00000000a479744a
+
+      /* x^128000 mod p(x)` << 1, x^128064 mod p(x)` << 1 */
+      .octa 0x00000001092a16e80000000096ca3a26
+
+      /* x^126976 mod p(x)` << 1, x^127040 mod p(x)` << 1 */
+      .octa 0x00000000a505637c00000000ff223d4e
+
+      /* x^125952 mod p(x)` << 1, x^126016 mod p(x)` << 1 */
+      .octa 0x00000000d94869b2000000010e84da42
+
+      /* x^124928 mod p(x)` << 1, x^124992 mod p(x)` << 1 */
+      .octa 0x00000001c8b203ae00000001b61ba3d0
+
+      /* x^123904 mod p(x)` << 1, x^123968 mod p(x)` << 1 */
+      .octa 0x000000005704aea000000000680f2de8
+
+      /* x^122880 mod p(x)` << 1, x^122944 mod p(x)` << 1 */
+      .octa 0x000000012e295fa2000000008772a9a8
+
+      /* x^121856 mod p(x)` << 1, x^121920 mod p(x)` << 1 */
+      .octa 0x000000011d0908bc0000000155f295bc
+
+      /* x^120832 mod p(x)` << 1, x^120896 mod p(x)` << 1 */
+      .octa 0x0000000193ed97ea00000000595f9282
+
+      /* x^119808 mod p(x)` << 1, x^119872 mod p(x)` << 1 */
+      .octa 0x000000013a0f1c520000000164b1c25a
+
+      /* x^118784 mod p(x)` << 1, x^118848 mod p(x)` << 1 */
+      .octa 0x000000010c2c40c000000000fbd67c50
+
+      /* x^117760 mod p(x)` << 1, x^117824 mod p(x)` << 1 */
+      .octa 0x00000000ff6fac3e0000000096076268
+
+      /* x^116736 mod p(x)` << 1, x^116800 mod p(x)` << 1 */
+      .octa 0x000000017b3609c000000001d288e4cc
+
+      /* x^115712 mod p(x)` << 1, x^115776 mod p(x)` << 1 */
+      .octa 0x0000000088c8c92200000001eaac1bdc
+
+      /* x^114688 mod p(x)` << 1, x^114752 mod p(x)` << 1 */
+      .octa 0x00000001751baae600000001f1ea39e2
+
+      /* x^113664 mod p(x)` << 1, x^113728 mod p(x)` << 1 */
+      .octa 0x000000010795297200000001eb6506fc
+
+      /* x^112640 mod p(x)` << 1, x^112704 mod p(x)` << 1 */
+      .octa 0x0000000162b00abe000000010f806ffe
+
+      /* x^111616 mod p(x)` << 1, x^111680 mod p(x)` << 1 */
+      .octa 0x000000000d7b404c000000010408481e
+
+      /* x^110592 mod p(x)` << 1, x^110656 mod p(x)` << 1 */
+      .octa 0x00000000763b13d40000000188260534
+
+      /* x^109568 mod p(x)` << 1, x^109632 mod p(x)` << 1 */
+      .octa 0x00000000f6dc22d80000000058fc73e0
+
+      /* x^108544 mod p(x)` << 1, x^108608 mod p(x)` << 1 */
+      .octa 0x000000007daae06000000000391c59b8
+
+      /* x^107520 mod p(x)` << 1, x^107584 mod p(x)` << 1 */
+      .octa 0x000000013359ab7c000000018b638400
+
+      /* x^106496 mod p(x)` << 1, x^106560 mod p(x)` << 1 */
+      .octa 0x000000008add438a000000011738f5c4
+
+      /* x^105472 mod p(x)` << 1, x^105536 mod p(x)` << 1 */
+      .octa 0x00000001edbefdea000000008cf7c6da
+
+      /* x^104448 mod p(x)` << 1, x^104512 mod p(x)` << 1 */
+      .octa 0x000000004104e0f800000001ef97fb16
+
+      /* x^103424 mod p(x)` << 1, x^103488 mod p(x)` << 1 */
+      .octa 0x00000000b48a82220000000102130e20
+
+      /* x^102400 mod p(x)` << 1, x^102464 mod p(x)` << 1 */
+      .octa 0x00000001bcb4684400000000db968898
+
+      /* x^101376 mod p(x)` << 1, x^101440 mod p(x)` << 1 */
+      .octa 0x000000013293ce0a00000000b5047b5e
+
+      /* x^100352 mod p(x)` << 1, x^100416 mod p(x)` << 1 */
+      .octa 0x00000001710d0844000000010b90fdb2
+
+      /* x^99328 mod p(x)` << 1, x^99392 mod p(x)` << 1 */
+      .octa 0x0000000117907f6e000000004834a32e
+
+      /* x^98304 mod p(x)` << 1, x^98368 mod p(x)` << 1 */
+      .octa 0x0000000087ddf93e0000000059c8f2b0
+
+      /* x^97280 mod p(x)` << 1, x^97344 mod p(x)` << 1 */
+      .octa 0x000000005970e9b00000000122cec508
+
+      /* x^96256 mod p(x)` << 1, x^96320 mod p(x)` << 1 */
+      .octa 0x0000000185b2b7d0000000000a330cda
+
+      /* x^95232 mod p(x)` << 1, x^95296 mod p(x)` << 1 */
+      .octa 0x00000001dcee0efc000000014a47148c
+
+      /* x^94208 mod p(x)` << 1, x^94272 mod p(x)` << 1 */
+      .octa 0x0000000030da27220000000042c61cb8
+
+      /* x^93184 mod p(x)` << 1, x^93248 mod p(x)` << 1 */
+      .octa 0x000000012f925a180000000012fe6960
+
+      /* x^92160 mod p(x)` << 1, x^92224 mod p(x)` << 1 */
+      .octa 0x00000000dd2e357c00000000dbda2c20
+
+      /* x^91136 mod p(x)` << 1, x^91200 mod p(x)` << 1 */
+      .octa 0x00000000071c80de000000011122410c
+
+      /* x^90112 mod p(x)` << 1, x^90176 mod p(x)` << 1 */
+      .octa 0x000000011513140a00000000977b2070
+
+      /* x^89088 mod p(x)` << 1, x^89152 mod p(x)` << 1 */
+      .octa 0x00000001df876e8e000000014050438e
+
+      /* x^88064 mod p(x)` << 1, x^88128 mod p(x)` << 1 */
+      .octa 0x000000015f81d6ce0000000147c840e8
+
+      /* x^87040 mod p(x)` << 1, x^87104 mod p(x)` << 1 */
+      .octa 0x000000019dd94dbe00000001cc7c88ce
+
+      /* x^86016 mod p(x)` << 1, x^86080 mod p(x)` << 1 */
+      .octa 0x00000001373d206e00000001476b35a4
+
+      /* x^84992 mod p(x)` << 1, x^85056 mod p(x)` << 1 */
+      .octa 0x00000000668ccade000000013d52d508
+
+      /* x^83968 mod p(x)` << 1, x^84032 mod p(x)` << 1 */
+      .octa 0x00000001b192d268000000008e4be32e
+
+      /* x^82944 mod p(x)` << 1, x^83008 mod p(x)` << 1 */
+      .octa 0x00000000e30f3a7800000000024120fe
+
+      /* x^81920 mod p(x)` << 1, x^81984 mod p(x)` << 1 */
+      .octa 0x000000010ef1f7bc00000000ddecddb4
+
+      /* x^80896 mod p(x)` << 1, x^80960 mod p(x)` << 1 */
+      .octa 0x00000001f5ac738000000000d4d403bc
+
+      /* x^79872 mod p(x)` << 1, x^79936 mod p(x)` << 1 */
+      .octa 0x000000011822ea7000000001734b89aa
+
+      /* x^78848 mod p(x)` << 1, x^78912 mod p(x)` << 1 */
+      .octa 0x00000000c3a33848000000010e7a58d6
+
+      /* x^77824 mod p(x)` << 1, x^77888 mod p(x)` << 1 */
+      .octa 0x00000001bd151c2400000001f9f04e9c
+
+      /* x^76800 mod p(x)` << 1, x^76864 mod p(x)` << 1 */
+      .octa 0x0000000056002d7600000000b692225e
+
+      /* x^75776 mod p(x)` << 1, x^75840 mod p(x)` << 1 */
+      .octa 0x000000014657c4f4000000019b8d3f3e
+
+      /* x^74752 mod p(x)` << 1, x^74816 mod p(x)` << 1 */
+      .octa 0x0000000113742d7c00000001a874f11e
+
+      /* x^73728 mod p(x)` << 1, x^73792 mod p(x)` << 1 */
+      .octa 0x000000019c5920ba000000010d5a4254
+
+      /* x^72704 mod p(x)` << 1, x^72768 mod p(x)` << 1 */
+      .octa 0x000000005216d2d600000000bbb2f5d6
+
+      /* x^71680 mod p(x)` << 1, x^71744 mod p(x)` << 1 */
+      .octa 0x0000000136f5ad8a0000000179cc0e36
+
+      /* x^70656 mod p(x)` << 1, x^70720 mod p(x)` << 1 */
+      .octa 0x000000018b07beb600000001dca1da4a
+
+      /* x^69632 mod p(x)` << 1, x^69696 mod p(x)` << 1 */
+      .octa 0x00000000db1e93b000000000feb1a192
+
+      /* x^68608 mod p(x)` << 1, x^68672 mod p(x)` << 1 */
+      .octa 0x000000000b96fa3a00000000d1eeedd6
+
+      /* x^67584 mod p(x)` << 1, x^67648 mod p(x)` << 1 */
+      .octa 0x00000001d9968af0000000008fad9bb4
+
+      /* x^66560 mod p(x)` << 1, x^66624 mod p(x)` << 1 */
+      .octa 0x000000000e4a77a200000001884938e4
+
+      /* x^65536 mod p(x)` << 1, x^65600 mod p(x)` << 1 */
+      .octa 0x00000000508c2ac800000001bc2e9bc0
+
+      /* x^64512 mod p(x)` << 1, x^64576 mod p(x)` << 1 */
+      .octa 0x0000000021572a8000000001f9658a68
+
+      /* x^63488 mod p(x)` << 1, x^63552 mod p(x)` << 1 */
+      .octa 0x00000001b859daf2000000001b9224fc
+
+      /* x^62464 mod p(x)` << 1, x^62528 mod p(x)` << 1 */
+      .octa 0x000000016f7884740000000055b2fb84
+
+      /* x^61440 mod p(x)` << 1, x^61504 mod p(x)` << 1 */
+      .octa 0x00000001b438810e000000018b090348
+
+      /* x^60416 mod p(x)` << 1, x^60480 mod p(x)` << 1 */
+      .octa 0x0000000095ddc6f2000000011ccbd5ea
+
+      /* x^59392 mod p(x)` << 1, x^59456 mod p(x)` << 1 */
+      .octa 0x00000001d977c20c0000000007ae47f8
+
+      /* x^58368 mod p(x)` << 1, x^58432 mod p(x)` << 1 */
+      .octa 0x00000000ebedb99a0000000172acbec0
+
+      /* x^57344 mod p(x)` << 1, x^57408 mod p(x)` << 1 */
+      .octa 0x00000001df9e9e9200000001c6e3ff20
+
+      /* x^56320 mod p(x)` << 1, x^56384 mod p(x)` << 1 */
+      .octa 0x00000001a4a3f95200000000e1b38744
+
+      /* x^55296 mod p(x)` << 1, x^55360 mod p(x)` << 1 */
+      .octa 0x00000000e2f5122000000000791585b2
+
+      /* x^54272 mod p(x)` << 1, x^54336 mod p(x)` << 1 */
+      .octa 0x000000004aa01f3e00000000ac53b894
+
+      /* x^53248 mod p(x)` << 1, x^53312 mod p(x)` << 1 */
+      .octa 0x00000000b3e90a5800000001ed5f2cf4
+
+      /* x^52224 mod p(x)` << 1, x^52288 mod p(x)` << 1 */
+      .octa 0x000000000c9ca2aa00000001df48b2e0
+
+      /* x^51200 mod p(x)` << 1, x^51264 mod p(x)` << 1 */
+      .octa 0x000000015168231600000000049c1c62
+
+      /* x^50176 mod p(x)` << 1, x^50240 mod p(x)` << 1 */
+      .octa 0x0000000036fce78c000000017c460c12
+
+      /* x^49152 mod p(x)` << 1, x^49216 mod p(x)` << 1 */
+      .octa 0x000000009037dc10000000015be4da7e
+
+      /* x^48128 mod p(x)` << 1, x^48192 mod p(x)` << 1 */
+      .octa 0x00000000d3298582000000010f38f668
+
+      /* x^47104 mod p(x)` << 1, x^47168 mod p(x)` << 1 */
+      .octa 0x00000001b42e8ad60000000039f40a00
+
+      /* x^46080 mod p(x)` << 1, x^46144 mod p(x)` << 1 */
+      .octa 0x00000000142a983800000000bd4c10c4
+
+      /* x^45056 mod p(x)` << 1, x^45120 mod p(x)` << 1 */
+      .octa 0x0000000109c7f1900000000042db1d98
+
+      /* x^44032 mod p(x)` << 1, x^44096 mod p(x)` << 1 */
+      .octa 0x0000000056ff931000000001c905bae6
+
+      /* x^43008 mod p(x)` << 1, x^43072 mod p(x)` << 1 */
+      .octa 0x00000001594513aa00000000069d40ea
+
+      /* x^41984 mod p(x)` << 1, x^42048 mod p(x)` << 1 */
+      .octa 0x00000001e3b5b1e8000000008e4fbad0
+
+      /* x^40960 mod p(x)` << 1, x^41024 mod p(x)` << 1 */
+      .octa 0x000000011dd5fc080000000047bedd46
+
+      /* x^39936 mod p(x)` << 1, x^40000 mod p(x)` << 1 */
+      .octa 0x00000001675f0cc20000000026396bf8
+
+      /* x^38912 mod p(x)` << 1, x^38976 mod p(x)` << 1 */
+      .octa 0x00000000d1c8dd4400000000379beb92
+
+      /* x^37888 mod p(x)` << 1, x^37952 mod p(x)` << 1 */
+      .octa 0x0000000115ebd3d8000000000abae54a
+
+      /* x^36864 mod p(x)` << 1, x^36928 mod p(x)` << 1 */
+      .octa 0x00000001ecbd0dac0000000007e6a128
+
+      /* x^35840 mod p(x)` << 1, x^35904 mod p(x)` << 1 */
+      .octa 0x00000000cdf67af2000000000ade29d2
+
+      /* x^34816 mod p(x)` << 1, x^34880 mod p(x)` << 1 */
+      .octa 0x000000004c01ff4c00000000f974c45c
+
+      /* x^33792 mod p(x)` << 1, x^33856 mod p(x)` << 1 */
+      .octa 0x00000000f2d8657e00000000e77ac60a
+
+      /* x^32768 mod p(x)` << 1, x^32832 mod p(x)` << 1 */
+      .octa 0x000000006bae74c40000000145895816
+
+      /* x^31744 mod p(x)` << 1, x^31808 mod p(x)` << 1 */
+      .octa 0x0000000152af8aa00000000038e362be
+
+      /* x^30720 mod p(x)` << 1, x^30784 mod p(x)` << 1 */
+      .octa 0x0000000004663802000000007f991a64
+
+      /* x^29696 mod p(x)` << 1, x^29760 mod p(x)` << 1 */
+      .octa 0x00000001ab2f5afc00000000fa366d3a
+
+      /* x^28672 mod p(x)` << 1, x^28736 mod p(x)` << 1 */
+      .octa 0x0000000074a4ebd400000001a2bb34f0
+
+      /* x^27648 mod p(x)` << 1, x^27712 mod p(x)` << 1 */
+      .octa 0x00000001d7ab3a4c0000000028a9981e
+
+      /* x^26624 mod p(x)` << 1, x^26688 mod p(x)` << 1 */
+      .octa 0x00000001a8da60c600000001dbc672be
+
+      /* x^25600 mod p(x)` << 1, x^25664 mod p(x)` << 1 */
+      .octa 0x000000013cf6382000000000b04d77f6
+
+      /* x^24576 mod p(x)` << 1, x^24640 mod p(x)` << 1 */
+      .octa 0x00000000bec12e1e0000000124400d96
+
+      /* x^23552 mod p(x)` << 1, x^23616 mod p(x)` << 1 */
+      .octa 0x00000001c6368010000000014ca4b414
+
+      /* x^22528 mod p(x)` << 1, x^22592 mod p(x)` << 1 */
+      .octa 0x00000001e6e78758000000012fe2c938
+
+      /* x^21504 mod p(x)` << 1, x^21568 mod p(x)` << 1 */
+      .octa 0x000000008d7f2b3c00000001faed01e6
+
+      /* x^20480 mod p(x)` << 1, x^20544 mod p(x)` << 1 */
+      .octa 0x000000016b4a156e000000007e80ecfe
+
+      /* x^19456 mod p(x)` << 1, x^19520 mod p(x)` << 1 */
+      .octa 0x00000001c63cfeb60000000098daee94
+
+      /* x^18432 mod p(x)` << 1, x^18496 mod p(x)` << 1 */
+      .octa 0x000000015f902670000000010a04edea
+
+      /* x^17408 mod p(x)` << 1, x^17472 mod p(x)` << 1 */
+      .octa 0x00000001cd5de11e00000001c00b4524
+
+      /* x^16384 mod p(x)` << 1, x^16448 mod p(x)` << 1 */
+      .octa 0x000000001acaec540000000170296550
+
+      /* x^15360 mod p(x)` << 1, x^15424 mod p(x)` << 1 */
+      .octa 0x000000002bd0ca780000000181afaa48
+
+      /* x^14336 mod p(x)` << 1, x^14400 mod p(x)` << 1 */
+      .octa 0x0000000032d63d5c0000000185a31ffa
+
+      /* x^13312 mod p(x)` << 1, x^13376 mod p(x)` << 1 */
+      .octa 0x000000001c6d4e4c000000002469f608
+
+      /* x^12288 mod p(x)` << 1, x^12352 mod p(x)` << 1 */
+      .octa 0x0000000106a60b92000000006980102a
+
+      /* x^11264 mod p(x)` << 1, x^11328 mod p(x)` << 1 */
+      .octa 0x00000000d3855e120000000111ea9ca8
+
+      /* x^10240 mod p(x)` << 1, x^10304 mod p(x)` << 1 */
+      .octa 0x00000000e312563600000001bd1d29ce
+
+      /* x^9216 mod p(x)` << 1, x^9280 mod p(x)` << 1 */
+      .octa 0x000000009e8f7ea400000001b34b9580
+
+      /* x^8192 mod p(x)` << 1, x^8256 mod p(x)` << 1 */
+      .octa 0x00000001c82e562c000000003076054e
+
+      /* x^7168 mod p(x)` << 1, x^7232 mod p(x)` << 1 */
+      .octa 0x00000000ca9f09ce000000012a608ea4
+
+      /* x^6144 mod p(x)` << 1, x^6208 mod p(x)` << 1 */
+      .octa 0x00000000c63764e600000000784d05fe
+
+      /* x^5120 mod p(x)` << 1, x^5184 mod p(x)` << 1 */
+      .octa 0x0000000168d2e49e000000016ef0d82a
+
+      /* x^4096 mod p(x)` << 1, x^4160 mod p(x)` << 1 */
+      .octa 0x00000000e986c1480000000075bda454
+
+      /* x^3072 mod p(x)` << 1, x^3136 mod p(x)` << 1 */
+      .octa 0x00000000cfb65894000000003dc0a1c4
+
+      /* x^2048 mod p(x)` << 1, x^2112 mod p(x)` << 1 */
+      .octa 0x0000000111cadee400000000e9a5d8be
+
+      /* x^1024 mod p(x)` << 1, x^1088 mod p(x)` << 1 */
+      .octa 0x0000000171fb63ce00000001609bc4b4
+
+      .short_constants :
+
+      /* Reduce final 1024-2048 bits to 64 bits, shifting 32 bits to include the trailing 32 bits of zeros */
+      /* x^1952 mod p(x)`, x^1984 mod p(x)`, x^2016 mod p(x)`, x^2048 mod p(x)` */
+      .octa 0x7fec2963e5bf80485cf015c388e56f72
+
+      /* x^1824 mod p(x)`, x^1856 mod p(x)`, x^1888 mod p(x)`, x^1920 mod p(x)` */
+      .octa 0x38e888d4844752a9963a18920246e2e6
+
+      /* x^1696 mod p(x)`, x^1728 mod p(x)`, x^1760 mod p(x)`, x^1792 mod p(x)` */
+      .octa 0x42316c00730206ad419a441956993a31
+
+      /* x^1568 mod p(x)`, x^1600 mod p(x)`, x^1632 mod p(x)`, x^1664 mod p(x)` */
+      .octa 0x543d5c543e65ddf9924752ba2b830011
+
+      /* x^1440 mod p(x)`, x^1472 mod p(x)`, x^1504 mod p(x)`, x^1536 mod p(x)` */
+      .octa 0x78e87aaf56767c9255bd7f9518e4a304
+
+      /* x^1312 mod p(x)`, x^1344 mod p(x)`, x^1376 mod p(x)`, x^1408 mod p(x)` */
+      .octa 0x8f68fcec1903da7f6d76739fe0553f1e
+
+      /* x^1184 mod p(x)`, x^1216 mod p(x)`, x^1248 mod p(x)`, x^1280 mod p(x)` */
+      .octa 0x3f4840246791d588c133722b1fe0b5c3
+
+      /* x^1056 mod p(x)`, x^1088 mod p(x)`, x^1120 mod p(x)`, x^1152 mod p(x)` */
+      .octa 0x34c96751b04de25a64b67ee0e55ef1f3
+
+      /* x^928 mod p(x)`, x^960 mod p(x)`, x^992 mod p(x)`, x^1024 mod p(x)` */
+      .octa 0x156c8e180b4a395b069db049b8fdb1e7
+
+      /* x^800 mod p(x)`, x^832 mod p(x)`, x^864 mod p(x)`, x^896 mod p(x)` */
+      .octa 0xe0b99ccbe661f7bea11bfaf3c9e90b9e
+
+      /* x^672 mod p(x)`, x^704 mod p(x)`, x^736 mod p(x)`, x^768 mod p(x)` */
+      .octa 0x041d37768cd75659817cdc5119b29a35
+
+      /* x^544 mod p(x)`, x^576 mod p(x)`, x^608 mod p(x)`, x^640 mod p(x)` */
+      .octa 0x3a0777818cfaa9651ce9d94b36c41f1c
+
+      /* x^416 mod p(x)`, x^448 mod p(x)`, x^480 mod p(x)`, x^512 mod p(x)` */
+      .octa 0x0e148e8252377a554f256efcb82be955
+
+      /* x^288 mod p(x)`, x^320 mod p(x)`, x^352 mod p(x)`, x^384 mod p(x)` */
+      .octa 0x9c25531d19e65ddeec1631edb2dea967
+
+      /* x^160 mod p(x)`, x^192 mod p(x)`, x^224 mod p(x)`, x^256 mod p(x)` */
+      .octa 0x790606ff9957c0a65d27e147510ac59a
+
+      /* x^32 mod p(x)`, x^64 mod p(x)`, x^96 mod p(x)`, x^128 mod p(x)` */
+      .octa 0x82f63b786ea2d55ca66805eb18b8ea18
+
+      .barrett_constants :
+      /* 33 bit reflected Barrett constant m - (4^32)/n */
+      .octa 0x000000000000000000000000dea713f1 /* x^64 div p(x)` */
+      /* 33 bit reflected Barrett constant n */
+      .octa 0x00000000000000000000000105ec76f1
+#endif /* __ASSEMBLER__ */

From 74ec6962b027643b856a187fad8bdffd0fad5eb7 Mon Sep 17 00:00:00 2001
From: Aaron Molitor <amolitor@apple.com>
Date: Wed, 27 Apr 2022 16:32:37 -0500
Subject: [PATCH 78/84] update build-images.sh to play nice with AWS IMDSv2

---
 packaging/docker/build-images.sh | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/packaging/docker/build-images.sh b/packaging/docker/build-images.sh
index c9e9a586f7..4d4774b213 100755
--- a/packaging/docker/build-images.sh
+++ b/packaging/docker/build-images.sh
@@ -254,7 +254,8 @@ push_docker_images="false"
 if [ -n "${OKTETO_NAMESPACE+x}" ]; then
     logg "RUNNING IN OKTETO/AWS"
     # these are defaults for the Apple development environment
-    aws_region=$(curl -s "http://169.254.169.254/latest/meta-data/placement/region")
+    imdsv2_token=$(curl -X PUT "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600")
+    aws_region=$(curl -H "X-aws-ec2-metadata-token: ${imdsv2_token}" "http://169.254.169.254/latest/meta-data/placement/region")
     aws_account_id=$(aws --output text sts get-caller-identity --query 'Account')
     build_output_directory="${HOME}/build_output"
     fdb_library_versions=( "${fdb_version}" )

From 13a388ff147d4eb424093d5c8bd148f48e296486 Mon Sep 17 00:00:00 2001
From: Andrew Noyes <andrew.noyes@snowflake.com>
Date: Thu, 28 Apr 2022 12:55:34 -0700
Subject: [PATCH 79/84] Disable leak checks for some tests that intentionally
 leak (#6997)

---
 fdbclient/MultiVersionTransaction.actor.cpp | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/fdbclient/MultiVersionTransaction.actor.cpp b/fdbclient/MultiVersionTransaction.actor.cpp
index a55695253d..9966cf678d 100644
--- a/fdbclient/MultiVersionTransaction.actor.cpp
+++ b/fdbclient/MultiVersionTransaction.actor.cpp
@@ -18,6 +18,10 @@
  * limitations under the License.
  */
 
+#ifdef ADDRESS_SANITIZER
+#include <sanitizer/lsan_interface.h>
+#endif
+
 #include "fdbclient/FDBOptions.g.h"
 #include "fdbclient/FDBTypes.h"
 #include "fdbclient/GenericManagementAPI.actor.h"
@@ -2763,6 +2767,11 @@ template <class T>
 THREAD_FUNC runSingleAssignmentVarTest(void* arg) {
 	noUnseed = true;
 
+// This test intentionally leaks memory
+#ifdef ADDRESS_SANITIZER
+	__lsan::ScopedDisabler disableLeakChecks;
+#endif
+
 	volatile bool* done = (volatile bool*)arg;
 	try {
 		for (int i = 0; i < 25; ++i) {

From db6d7396ca3664388b76d1e985b0bf6349fa0db4 Mon Sep 17 00:00:00 2001
From: Josh Slocum <josh.slocum@snowflake.com>
Date: Thu, 28 Apr 2022 17:45:09 -0500
Subject: [PATCH 80/84] Add delay between quickly re-recruiting the same
 singleton process, to avoid recruit thrashing when there are temporarily
 multiple cluster controllers (#7000)

---
 fdbclient/ServerKnobs.cpp             |  1 +
 fdbclient/ServerKnobs.h               |  2 +
 fdbserver/ClusterController.actor.cpp | 92 +++++++++++++++++----------
 3 files changed, 62 insertions(+), 33 deletions(-)

diff --git a/fdbclient/ServerKnobs.cpp b/fdbclient/ServerKnobs.cpp
index 1556241ea0..3d091424f5 100644
--- a/fdbclient/ServerKnobs.cpp
+++ b/fdbclient/ServerKnobs.cpp
@@ -542,6 +542,7 @@ void ServerKnobs::initialize(Randomize randomize, ClientKnobs* clientKnobs, IsSi
 	init( CC_ENABLE_ENTIRE_SATELLITE_MONITORING,               false );
 	init( CC_SATELLITE_DEGRADATION_MIN_COMPLAINER,                 3 );
 	init( CC_SATELLITE_DEGRADATION_MIN_BAD_SERVER,                 3 );
+	init( CC_THROTTLE_SINGLETON_RERECRUIT_INTERVAL,              0.5 );
 
 	init( INCOMPATIBLE_PEERS_LOGGING_INTERVAL,                   600 ); if( randomize && BUGGIFY ) INCOMPATIBLE_PEERS_LOGGING_INTERVAL = 60.0;
 	init( EXPECTED_MASTER_FITNESS,            ProcessClass::UnsetFit );
diff --git a/fdbclient/ServerKnobs.h b/fdbclient/ServerKnobs.h
index dc770502e2..9ef13d43fd 100644
--- a/fdbclient/ServerKnobs.h
+++ b/fdbclient/ServerKnobs.h
@@ -481,6 +481,8 @@ public:
 	                                             // be determined as degraded worker.
 	int CC_SATELLITE_DEGRADATION_MIN_BAD_SERVER; // The minimum amount of degraded server in satellite DC to be
 	                                             // determined as degraded satellite.
+	double CC_THROTTLE_SINGLETON_RERECRUIT_INTERVAL; // The interval to prevent re-recruiting the same singleton if a
+	                                                 // recruiting fight between two cluster controllers occurs.
 
 	// Knobs used to select the best policy (via monte carlo)
 	int POLICY_RATING_TESTS; // number of tests per policy (in order to compare)
diff --git a/fdbserver/ClusterController.actor.cpp b/fdbserver/ClusterController.actor.cpp
index 4be2faca3f..83b7250dc5 100644
--- a/fdbserver/ClusterController.actor.cpp
+++ b/fdbserver/ClusterController.actor.cpp
@@ -1933,8 +1933,24 @@ ACTOR Future<Void> handleForcedRecoveries(ClusterControllerData* self, ClusterCo
 	}
 }
 
-ACTOR Future<Void> startDataDistributor(ClusterControllerData* self) {
-	wait(delay(0.0)); // If master fails at the same time, give it a chance to clear master PID.
+struct SingletonRecruitThrottler {
+	double lastRecruitStart;
+
+	SingletonRecruitThrottler() : lastRecruitStart(-1) {}
+
+	double newRecruitment() {
+		double n = now();
+		double waitTime =
+		    std::max(0.0, (lastRecruitStart + SERVER_KNOBS->CC_THROTTLE_SINGLETON_RERECRUIT_INTERVAL - n));
+		lastRecruitStart = n;
+		return waitTime;
+	}
+};
+
+ACTOR Future<Void> startDataDistributor(ClusterControllerData* self, double waitTime) {
+	// If master fails at the same time, give it a chance to clear master PID.
+	// Also wait to avoid too many consecutive recruits in a small time window.
+	wait(delay(waitTime));
 
 	TraceEvent("CCStartDataDistributor", self->id).log();
 	loop {
@@ -2003,6 +2019,7 @@ ACTOR Future<Void> startDataDistributor(ClusterControllerData* self) {
 }
 
 ACTOR Future<Void> monitorDataDistributor(ClusterControllerData* self) {
+	state SingletonRecruitThrottler recruitThrottler;
 	while (self->db.serverInfo->get().recoveryState < RecoveryState::ACCEPTING_COMMITS) {
 		wait(self->db.serverInfo->onChange());
 	}
@@ -2019,13 +2036,15 @@ ACTOR Future<Void> monitorDataDistributor(ClusterControllerData* self) {
 				when(wait(self->recruitDistributor.onChange())) {}
 			}
 		} else {
-			wait(startDataDistributor(self));
+			wait(startDataDistributor(self, recruitThrottler.newRecruitment()));
 		}
 	}
 }
 
-ACTOR Future<Void> startRatekeeper(ClusterControllerData* self) {
-	wait(delay(0.0)); // If master fails at the same time, give it a chance to clear master PID.
+ACTOR Future<Void> startRatekeeper(ClusterControllerData* self, double waitTime) {
+	// If master fails at the same time, give it a chance to clear master PID.
+	// Also wait to avoid too many consecutive recruits in a small time window.
+	wait(delay(waitTime));
 
 	TraceEvent("CCStartRatekeeper", self->id).log();
 	loop {
@@ -2091,6 +2110,7 @@ ACTOR Future<Void> startRatekeeper(ClusterControllerData* self) {
 }
 
 ACTOR Future<Void> monitorRatekeeper(ClusterControllerData* self) {
+	state SingletonRecruitThrottler recruitThrottler;
 	while (self->db.serverInfo->get().recoveryState < RecoveryState::ACCEPTING_COMMITS) {
 		wait(self->db.serverInfo->onChange());
 	}
@@ -2107,34 +2127,15 @@ ACTOR Future<Void> monitorRatekeeper(ClusterControllerData* self) {
 				when(wait(self->recruitRatekeeper.onChange())) {}
 			}
 		} else {
-			wait(startRatekeeper(self));
+			wait(startRatekeeper(self, recruitThrottler.newRecruitment()));
 		}
 	}
 }
 
-// Acquires the BM lock by getting the next epoch no.
-ACTOR Future<int64_t> getNextBMEpoch(ClusterControllerData* self) {
-	state Reference<ReadYourWritesTransaction> tr = makeReference<ReadYourWritesTransaction>(self->cx);
-
-	loop {
-		tr->setOption(FDBTransactionOptions::ACCESS_SYSTEM_KEYS);
-		tr->setOption(FDBTransactionOptions::PRIORITY_SYSTEM_IMMEDIATE);
-		try {
-			Optional<Value> oldEpoch = wait(tr->get(blobManagerEpochKey));
-			state int64_t newEpoch = oldEpoch.present() ? decodeBlobManagerEpochValue(oldEpoch.get()) + 1 : 1;
-			tr->set(blobManagerEpochKey, blobManagerEpochValueFor(newEpoch));
-
-			wait(tr->commit());
-			TraceEvent(SevDebug, "CCNextBlobManagerEpoch", self->id).detail("Epoch", newEpoch);
-			return newEpoch;
-		} catch (Error& e) {
-			wait(tr->onError(e));
-		}
-	}
-}
-
-ACTOR Future<Void> startEncryptKeyProxy(ClusterControllerData* self) {
-	wait(delay(0.0)); // If master fails at the same time, give it a chance to clear master PID.
+ACTOR Future<Void> startEncryptKeyProxy(ClusterControllerData* self, double waitTime) {
+	// If master fails at the same time, give it a chance to clear master PID.
+	// Also wait to avoid too many consecutive recruits in a small time window.
+	wait(delay(waitTime));
 
 	TraceEvent("CCEKP_Start", self->id).log();
 	loop {
@@ -2208,6 +2209,7 @@ ACTOR Future<Void> startEncryptKeyProxy(ClusterControllerData* self) {
 }
 
 ACTOR Future<Void> monitorEncryptKeyProxy(ClusterControllerData* self) {
+	state SingletonRecruitThrottler recruitThrottler;
 	loop {
 		if (self->db.serverInfo->get().encryptKeyProxy.present() && !self->recruitEncryptKeyProxy.get()) {
 			choose {
@@ -2219,13 +2221,36 @@ ACTOR Future<Void> monitorEncryptKeyProxy(ClusterControllerData* self) {
 				when(wait(self->recruitEncryptKeyProxy.onChange())) {}
 			}
 		} else {
-			wait(startEncryptKeyProxy(self));
+			wait(startEncryptKeyProxy(self, recruitThrottler.newRecruitment()));
 		}
 	}
 }
 
-ACTOR Future<Void> startBlobManager(ClusterControllerData* self) {
-	wait(delay(0.0)); // If master fails at the same time, give it a chance to clear master PID.
+// Acquires the BM lock by getting the next epoch no.
+ACTOR Future<int64_t> getNextBMEpoch(ClusterControllerData* self) {
+	state Reference<ReadYourWritesTransaction> tr = makeReference<ReadYourWritesTransaction>(self->cx);
+
+	loop {
+		tr->setOption(FDBTransactionOptions::ACCESS_SYSTEM_KEYS);
+		tr->setOption(FDBTransactionOptions::PRIORITY_SYSTEM_IMMEDIATE);
+		try {
+			Optional<Value> oldEpoch = wait(tr->get(blobManagerEpochKey));
+			state int64_t newEpoch = oldEpoch.present() ? decodeBlobManagerEpochValue(oldEpoch.get()) + 1 : 1;
+			tr->set(blobManagerEpochKey, blobManagerEpochValueFor(newEpoch));
+
+			wait(tr->commit());
+			TraceEvent(SevDebug, "CCNextBlobManagerEpoch", self->id).detail("Epoch", newEpoch);
+			return newEpoch;
+		} catch (Error& e) {
+			wait(tr->onError(e));
+		}
+	}
+}
+
+ACTOR Future<Void> startBlobManager(ClusterControllerData* self, double waitTime) {
+	// If master fails at the same time, give it a chance to clear master PID.
+	// Also wait to avoid too many consecutive recruits in a small time window.
+	wait(delay(waitTime));
 
 	TraceEvent("CCStartBlobManager", self->id).log();
 	loop {
@@ -2322,6 +2347,7 @@ ACTOR Future<Void> watchBlobGranulesConfigKey(ClusterControllerData* self) {
 }
 
 ACTOR Future<Void> monitorBlobManager(ClusterControllerData* self) {
+	state SingletonRecruitThrottler recruitThrottler;
 	while (self->db.serverInfo->get().recoveryState < RecoveryState::ACCEPTING_COMMITS) {
 		wait(self->db.serverInfo->onChange());
 	}
@@ -2352,7 +2378,7 @@ ACTOR Future<Void> monitorBlobManager(ClusterControllerData* self) {
 			}
 		} else if (self->db.blobGranulesEnabled.get()) {
 			// if there is no blob manager present but blob granules are now enabled, recruit a BM
-			wait(startBlobManager(self));
+			wait(startBlobManager(self, recruitThrottler.newRecruitment()));
 		} else {
 			// if there is no blob manager present and blob granules are disabled, wait for a config change
 			wait(self->db.blobGranulesEnabled.onChange());

From 5403a29ecb1338c20329df5c75c824e4055dcd29 Mon Sep 17 00:00:00 2001
From: Sam Gwydir <sam.gwydir@snowflake.com>
Date: Thu, 28 Apr 2022 16:53:38 -0700
Subject: [PATCH 81/84] add WolfSSL support (#6682)

remove extraneous include
---
 FDBLibTLS/CMakeLists.txt        |  1 +
 FDBLibTLS/FDBLibTLSPolicy.cpp   |  3 ++
 FDBLibTLS/FDBLibTLSSession.cpp  |  3 ++
 FDBLibTLS/FDBLibTLSVerify.cpp   |  3 ++
 FDBLibTLS/verify-test.cpp       |  3 ++
 cmake/FDBComponents.cmake       | 43 +++++++++++++++-------
 cmake/FindWolfSSL.cmake         | 63 +++++++++++++++++++++++++++++++++
 fdbclient/S3BlobStore.actor.cpp |  6 ++++
 fdbclient/md5/md5.h             |  3 ++
 flow/BlobCipher.h               |  3 ++
 flow/CMakeLists.txt             |  4 +++
 flow/Net2.actor.cpp             |  6 ++++
 flow/StreamCipher.h             |  3 ++
 flow/TLSConfig.actor.cpp        |  3 ++
 flow/TLSConfig.actor.h          |  5 ++-
 flow/network.h                  |  3 --
 16 files changed, 138 insertions(+), 17 deletions(-)
 create mode 100644 cmake/FindWolfSSL.cmake

diff --git a/FDBLibTLS/CMakeLists.txt b/FDBLibTLS/CMakeLists.txt
index 62ea4d5cad..2bf3016bc9 100644
--- a/FDBLibTLS/CMakeLists.txt
+++ b/FDBLibTLS/CMakeLists.txt
@@ -10,3 +10,4 @@ set(SRCS
 
 add_library(FDBLibTLS STATIC ${SRCS})
 target_link_libraries(FDBLibTLS PUBLIC OpenSSL::SSL boost_target PRIVATE flow)
+target_include_directories(FDBLibTLS INTERFACE OpenSSL::SSL boost_target PRIVATE flow)
diff --git a/FDBLibTLS/FDBLibTLSPolicy.cpp b/FDBLibTLS/FDBLibTLSPolicy.cpp
index 9eeb9df833..6f81f91335 100644
--- a/FDBLibTLS/FDBLibTLSPolicy.cpp
+++ b/FDBLibTLS/FDBLibTLSPolicy.cpp
@@ -22,6 +22,9 @@
 #include "FDBLibTLS/FDBLibTLSSession.h"
 #include "flow/Trace.h"
 
+#if defined(HAVE_WOLFSSL)
+#include <wolfssl/options.h>
+#endif
 #include <openssl/bio.h>
 #include <openssl/err.h>
 #include <openssl/evp.h>
diff --git a/FDBLibTLS/FDBLibTLSSession.cpp b/FDBLibTLS/FDBLibTLSSession.cpp
index a7193a61a4..754f3809e0 100644
--- a/FDBLibTLS/FDBLibTLSSession.cpp
+++ b/FDBLibTLS/FDBLibTLSSession.cpp
@@ -23,6 +23,9 @@
 #include "flow/flow.h"
 #include "flow/Trace.h"
 
+#if defined(HAVE_WOLFSSL)
+#include <wolfssl/options.h>
+#endif
 #include <openssl/bio.h>
 #include <openssl/err.h>
 #include <openssl/pem.h>
diff --git a/FDBLibTLS/FDBLibTLSVerify.cpp b/FDBLibTLS/FDBLibTLSVerify.cpp
index a885584a7b..216966f4c0 100644
--- a/FDBLibTLS/FDBLibTLSVerify.cpp
+++ b/FDBLibTLS/FDBLibTLSVerify.cpp
@@ -20,6 +20,9 @@
 
 #include "FDBLibTLS/FDBLibTLSVerify.h"
 
+#if defined(HAVE_WOLFSSL)
+#include <wolfssl/options.h>
+#endif
 #include <openssl/objects.h>
 
 #include <algorithm>
diff --git a/FDBLibTLS/verify-test.cpp b/FDBLibTLS/verify-test.cpp
index 9932e88329..a894aafcb0 100644
--- a/FDBLibTLS/verify-test.cpp
+++ b/FDBLibTLS/verify-test.cpp
@@ -25,6 +25,9 @@
 #include <string.h>
 #include <boost/lexical_cast.hpp>
 
+#if defined(HAVE_WOLFSSL)
+#include <wolfssl/options.h>
+#endif
 #include <openssl/objects.h>
 
 #include "fdbrpc/ITLSPlugin.h"
diff --git a/cmake/FDBComponents.cmake b/cmake/FDBComponents.cmake
index 60fbe44a0d..998dfaf616 100644
--- a/cmake/FDBComponents.cmake
+++ b/cmake/FDBComponents.cmake
@@ -21,22 +21,39 @@ endif()
 include(CheckSymbolExists)
 
 set(DISABLE_TLS OFF CACHE BOOL "Don't try to find OpenSSL and always build without TLS support")
+set(USE_WOLFSSL OFF CACHE BOOL "Build against WolfSSL instead of OpenSSL")
+set(USE_OPENSSL ON CACHE BOOL "Build against OpenSSL")
 if(DISABLE_TLS)
   set(WITH_TLS OFF)
 else()
-  set(OPENSSL_USE_STATIC_LIBS TRUE)
-  if(WIN32)
-    set(OPENSSL_MSVC_STATIC_RT ON)
-  endif()
-  find_package(OpenSSL)
-  if(OPENSSL_FOUND)
-    set(CMAKE_REQUIRED_INCLUDES ${OPENSSL_INCLUDE_DIR})
-    set(WITH_TLS ON)
-    add_compile_options(-DHAVE_OPENSSL)
-  else()
-    message(STATUS "OpenSSL was not found - Will compile without TLS Support")
-    message(STATUS "You can set OPENSSL_ROOT_DIR to help cmake find it")
-    set(WITH_TLS OFF)
+  if(USE_WOLFSSL)
+    set(WOLFSSL_USE_STATIC_LIBS TRUE)
+    find_package(WolfSSL)
+    if(WOLFSSL_FOUND)
+      set(CMAKE_REQUIRED_INCLUDES ${WOLFSSL_INCLUDE_DIR})
+      set(WITH_TLS ON)
+      add_compile_options(-DHAVE_OPENSSL)
+      add_compile_options(-DHAVE_WOLFSSL)
+    else()
+      message(STATUS "WolfSSL was not found - Will compile without TLS Support")
+      message(STATUS "You can set WOLFSSL_ROOT_DIR to help cmake find it")
+      set(WITH_TLS OFF)
+    endif()
+  elseif(USE_OPENSSL)
+    set(OPENSSL_USE_STATIC_LIBS TRUE)
+    if(WIN32)
+      set(OPENSSL_MSVC_STATIC_RT ON)
+    endif()
+    find_package(OpenSSL)
+    if(OPENSSL_FOUND)
+      set(CMAKE_REQUIRED_INCLUDES ${OPENSSL_INCLUDE_DIR})
+      set(WITH_TLS ON)
+      add_compile_options(-DHAVE_OPENSSL)
+    else()
+      message(STATUS "OpenSSL was not found - Will compile without TLS Support")
+      message(STATUS "You can set OPENSSL_ROOT_DIR to help cmake find it")
+      set(WITH_TLS OFF)
+    endif()
   endif()
 endif()
 
diff --git a/cmake/FindWolfSSL.cmake b/cmake/FindWolfSSL.cmake
new file mode 100644
index 0000000000..79e2b98035
--- /dev/null
+++ b/cmake/FindWolfSSL.cmake
@@ -0,0 +1,63 @@
+# FindWolfSSL
+
+# Support preference of static libs by adjusting CMAKE_FIND_LIBRARY_SUFFIXES
+if(WOLFSSL_USE_STATIC_LIBS)
+  if(WIN32)
+    set(CMAKE_FIND_LIBRARY_SUFFIXES .lib .a ${CMAKE_FIND_LIBRARY_SUFFIXES})
+  else()
+    set(CMAKE_FIND_LIBRARY_SUFFIXES .a)
+  endif()
+endif()
+
+find_path(WOLFSSL_ROOT_DIR
+  NAMES
+    include/wolfssl/options.h
+)
+
+find_path(WOLFSSL_INCLUDE_DIR
+  NAMES
+    wolfssl/ssl.h
+  PATHS
+   ${WOLFSSL_ROOT_DIR}/include
+)
+
+find_library(WOLFSSL_LIBRARY
+  NAMES 
+    wolfssl
+  PATHS
+   ${WOLFSSL_ROOT_DIR}/lib
+)
+
+include(FindPackageHandleStandardArgs)
+find_package_handle_standard_args(WolfSSL
+  REQUIRED_VARS
+    WOLFSSL_LIBRARY
+    WOLFSSL_INCLUDE_DIR
+  FAIL_MESSAGE
+    "Could NOT find WolfSSL"
+)
+
+mark_as_advanced(
+  WOLFSSL_ROOT_DIR
+  WOLFSSL_LIBRARY
+  WOLFSSL_INCLUDE_DIR
+)
+
+if(WOLFSSL_FOUND)
+  message(STATUS "Found wolfssl library: ${WOLFSSL_LIBRARY}")
+  message(STATUS "Found wolfssl includes: ${WOLFSSL_INCLUDE_DIR}")
+
+  set(WOLFSSL_INCLUDE_DIRS ${WOLFSSL_INCLUDE_DIR})
+  set(WOLFSSL_LIBRARIES ${WOLFSSL_LIBRARY})
+
+  add_library(WolfSSL UNKNOWN IMPORTED GLOBAL)
+  add_library(OpenSSL::SSL ALIAS WolfSSL)
+  add_library(OpenSSL::CRYPTO ALIAS WolfSSL)
+
+  target_include_directories(WolfSSL INTERFACE "${WOLFSSL_INCLUDE_DIR}")
+  target_link_libraries(WolfSSL INTERFACE "${WOLFSSL_TLS_LIBRARY}" "${WOLFSSL_SSL_LIBRARY}" "${WOLFSSL_CRYPTO_LIBRARY}")
+  set_target_properties(WolfSSL PROPERTIES
+    INTERFACE_INCLUDE_DIRECTORIES "${WOLFSSL_INCLUDE_DIR}"
+    IMPORTED_LINK_INTERFACE_LANGUAGES "C"
+    IMPORTED_LOCATION "${WOLFSSL_LIBRARY}")
+endif()
diff --git a/fdbclient/S3BlobStore.actor.cpp b/fdbclient/S3BlobStore.actor.cpp
index 25e4a26ff5..ad859b47a4 100644
--- a/fdbclient/S3BlobStore.actor.cpp
+++ b/fdbclient/S3BlobStore.actor.cpp
@@ -25,9 +25,15 @@
 #include "fdbclient/sha1/SHA1.h"
 #include <time.h>
 #include <iomanip>
+#if defined(HAVE_WOLFSSL)
+#include <wolfssl/options.h>
+#endif
 #include <openssl/sha.h>
 #include <openssl/evp.h>
 #include <openssl/hmac.h>
+#if defined(HAVE_WOLFSSL)
+#undef SHA1 // wolfSSL will will shadow FDB SHA1.h
+#endif
 #include <boost/algorithm/string/split.hpp>
 #include <boost/algorithm/string/classification.hpp>
 #include <boost/algorithm/string.hpp>
diff --git a/fdbclient/md5/md5.h b/fdbclient/md5/md5.h
index 6c290d1c28..71b1b0456b 100644
--- a/fdbclient/md5/md5.h
+++ b/fdbclient/md5/md5.h
@@ -24,6 +24,9 @@
  */
 
 #if defined(HAVE_OPENSSL) && !defined(TLS_DISABLED)
+#if defined(HAVE_WOLFSSL)
+#include <wolfssl/options.h>
+#endif
 #include <openssl/md5.h>
 #elif !defined(_MD5_H)
 #define _MD5_H
diff --git a/flow/BlobCipher.h b/flow/BlobCipher.h
index 7db574d60b..624762caaa 100644
--- a/flow/BlobCipher.h
+++ b/flow/BlobCipher.h
@@ -39,6 +39,9 @@
 #include "flow/flow.h"
 #include "flow/genericactors.actor.h"
 
+#if defined(HAVE_WOLFSSL)
+#include <wolfssl/options.h>
+#endif
 #include <openssl/aes.h>
 #include <openssl/engine.h>
 #include <openssl/evp.h>
diff --git a/flow/CMakeLists.txt b/flow/CMakeLists.txt
index 42e4f135ae..bf390d4b88 100644
--- a/flow/CMakeLists.txt
+++ b/flow/CMakeLists.txt
@@ -176,6 +176,10 @@ if(NOT WITH_TLS)
 else()
   target_link_libraries(flow PUBLIC OpenSSL::SSL)
   target_link_libraries(flow_sampling PUBLIC OpenSSL::SSL)
+  if(USE_WOLFSSL)
+    target_include_directories(flow SYSTEM BEFORE PUBLIC ${WOLFSSL_INCLUDE_DIR}/wolfssl)
+    target_include_directories(flow_sampling SYSTEM BEFORE PUBLIC ${WOLFSSL_INCLUDE_DIR}/wolfssl)
+  endif()
 endif()
 target_link_libraries(flow PUBLIC Threads::Threads ${CMAKE_DL_LIBS})
 target_link_libraries(flow_sampling PUBLIC Threads::Threads ${CMAKE_DL_LIBS})
diff --git a/flow/Net2.actor.cpp b/flow/Net2.actor.cpp
index 8c67f1b056..29785e1f39 100644
--- a/flow/Net2.actor.cpp
+++ b/flow/Net2.actor.cpp
@@ -29,6 +29,12 @@
 #define BOOST_DATE_TIME_NO_LIB
 #define BOOST_REGEX_NO_LIB
 #include <boost/asio.hpp>
+#ifndef TLS_DISABLED
+#if defined(HAVE_WOLFSSL)
+#include <wolfssl/options.h>
+#endif
+#include "boost/asio/ssl.hpp"
+#endif
 #include <boost/date_time/posix_time/posix_time_types.hpp>
 #include <boost/range.hpp>
 #include <boost/algorithm/string/join.hpp>
diff --git a/flow/StreamCipher.h b/flow/StreamCipher.h
index 98db51fe8d..3e1fe10fe0 100644
--- a/flow/StreamCipher.h
+++ b/flow/StreamCipher.h
@@ -32,6 +32,9 @@
 #include "flow/FastRef.h"
 #include "flow/flow.h"
 
+#if defined(HAVE_WOLFSSL)
+#include <wolfssl/options.h>
+#endif
 #include <openssl/aes.h>
 #include <openssl/evp.h>
 #include <openssl/hmac.h>
diff --git a/flow/TLSConfig.actor.cpp b/flow/TLSConfig.actor.cpp
index 4f1d385b9a..c7cad7945d 100644
--- a/flow/TLSConfig.actor.cpp
+++ b/flow/TLSConfig.actor.cpp
@@ -38,6 +38,9 @@ void LoadedTLSConfig::print(FILE* fp) {
 #include <exception>
 #include <map>
 #include <set>
+#if defined(HAVE_WOLFSSL)
+#include <wolfssl/options.h>
+#endif
 #include <openssl/objects.h>
 #include <openssl/bio.h>
 #include <openssl/err.h>
diff --git a/flow/TLSConfig.actor.h b/flow/TLSConfig.actor.h
index 723424da00..ff3e670f49 100644
--- a/flow/TLSConfig.actor.h
+++ b/flow/TLSConfig.actor.h
@@ -39,6 +39,9 @@
 
 #ifndef TLS_DISABLED
 
+#if defined(HAVE_WOLFSSL)
+#include <wolfssl/options.h>
+#endif
 #include <openssl/x509.h>
 typedef int NID;
 
@@ -280,4 +283,4 @@ public:
 	"                 and format of CONSTRAINTS are plugin-specific.\n"
 
 #include "flow/unactorcompiler.h"
-#endif
\ No newline at end of file
+#endif
diff --git a/flow/network.h b/flow/network.h
index 2fdd7ab32d..5a64d93e17 100644
--- a/flow/network.h
+++ b/flow/network.h
@@ -30,9 +30,6 @@
 #include <variant>
 #include <atomic>
 #include "boost/asio.hpp"
-#ifndef TLS_DISABLED
-#include "boost/asio/ssl.hpp"
-#endif
 #include "flow/Arena.h"
 #include "flow/BooleanParam.h"
 #include "flow/IRandom.h"

From 0362beb3f3c05adddb1e8886ebedbb36130ffaaf Mon Sep 17 00:00:00 2001
From: Hao Fu <77984096+hfu94@users.noreply.github.com>
Date: Thu, 28 Apr 2022 17:44:19 -0700
Subject: [PATCH 82/84] Fix limit bug in indexPrefetch (#7004)

limit for getRange was incorrectly set to 1, while
a single logical record is consists of at least 2
keyValue, causing record layer fail to unsplit the
logical record.
---
 fdbserver/storageserver.actor.cpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/fdbserver/storageserver.actor.cpp b/fdbserver/storageserver.actor.cpp
index 50936b5950..d7f3444582 100644
--- a/fdbserver/storageserver.actor.cpp
+++ b/fdbserver/storageserver.actor.cpp
@@ -3455,7 +3455,8 @@ ACTOR Future<GetRangeReqAndResultRef> quickGetKeyValues(
 		tr.setVersion(version);
 		// TODO: is DefaultPromiseEndpoint the best priority for this?
 		tr.trState->taskID = TaskPriority::DefaultPromiseEndpoint;
-		Future<RangeResult> rangeResultFuture = tr.getRange(prefixRange(prefix), Snapshot::True);
+		Future<RangeResult> rangeResultFuture =
+		    tr.getRange(prefixRange(prefix), GetRangeLimits::ROW_LIMIT_UNLIMITED, Snapshot::True);
 		// TODO: async in case it needs to read from other servers.
 		RangeResult rangeResult = wait(rangeResultFuture);
 		a->dependsOn(rangeResult.arena());

From 154de018ffdc82a79b48648bccb112c64292bece Mon Sep 17 00:00:00 2001
From: Renxuan Wang <renxuan@apple.com>
Date: Thu, 28 Apr 2022 18:32:55 -0700
Subject: [PATCH 83/84] One place in PaxosConfigConsumer was missed out in
 #6926. (#7006)

* One place in PaxosConfigConsumer was missed out.

* Minor improvements.
---
 fdbclient/MonitorLeader.actor.cpp       |  7 +++----
 fdbserver/PaxosConfigConsumer.actor.cpp | 18 +++++++++++++++---
 fdbserver/worker.actor.cpp              |  5 +----
 3 files changed, 19 insertions(+), 11 deletions(-)

diff --git a/fdbclient/MonitorLeader.actor.cpp b/fdbclient/MonitorLeader.actor.cpp
index ad08c8ba3d..7f76fcfdb2 100644
--- a/fdbclient/MonitorLeader.actor.cpp
+++ b/fdbclient/MonitorLeader.actor.cpp
@@ -866,8 +866,7 @@ ACTOR Future<MonitorLeaderInfo> monitorProxiesOneGeneration(
     Reference<ReferencedObject<Standalone<VectorRef<ClientVersionRef>>>> supportedVersions,
     Key traceLogGroup) {
 	state ClusterConnectionString cs = info.intermediateConnRecord->getConnectionString();
-	state std::vector<Hostname> hostnames = cs.hostnames;
-	state int coordinatorsSize = hostnames.size() + cs.coordinators().size();
+	state int coordinatorsSize = cs.hostnames.size() + cs.coordinators().size();
 	state int index = 0;
 	state int successIndex = 0;
 	state Optional<double> incorrectTime;
@@ -878,7 +877,7 @@ ACTOR Future<MonitorLeaderInfo> monitorProxiesOneGeneration(
 	state std::vector<ClientLeaderRegInterface> clientLeaderServers;
 
 	clientLeaderServers.reserve(coordinatorsSize);
-	for (const auto& h : hostnames) {
+	for (const auto& h : cs.hostnames) {
 		clientLeaderServers.push_back(ClientLeaderRegInterface(h));
 	}
 	for (const auto& c : cs.coordinators()) {
@@ -894,7 +893,7 @@ ACTOR Future<MonitorLeaderInfo> monitorProxiesOneGeneration(
 		coordinator->set(clientLeaderServer);
 
 		req.clusterKey = cs.clusterKey();
-		req.hostnames = hostnames;
+		req.hostnames = cs.hostnames;
 		req.coordinators = cs.coordinators();
 		req.knownClientInfoID = clientInfo->get().id;
 		req.supportedVersions = supportedVersions->get();
diff --git a/fdbserver/PaxosConfigConsumer.actor.cpp b/fdbserver/PaxosConfigConsumer.actor.cpp
index eb8e4f70f3..aee3b83bbe 100644
--- a/fdbserver/PaxosConfigConsumer.actor.cpp
+++ b/fdbserver/PaxosConfigConsumer.actor.cpp
@@ -117,9 +117,21 @@ class GetCommittedVersionQuorum {
 				                                       &ConfigFollowerInterface::getChanges,
 				                                       ConfigFollowerGetChangesRequest{ lastSeenVersion, target }),
 				                      SERVER_KNOBS->GET_COMMITTED_VERSION_TIMEOUT));
-				wait(timeoutError(cfi.rollforward.getReply(ConfigFollowerRollforwardRequest{
-				                      rollback, nodeVersion.lastCommitted, target, reply.changes, reply.annotations }),
-				                  SERVER_KNOBS->GET_COMMITTED_VERSION_TIMEOUT));
+
+				if (cfi.hostname.present()) {
+					wait(timeoutError(
+					    retryGetReplyFromHostname(
+					        ConfigFollowerRollforwardRequest{
+					            rollback, nodeVersion.lastCommitted, target, reply.changes, reply.annotations },
+					        cfi.hostname.get(),
+					        WLTOKEN_CONFIGFOLLOWER_ROLLFORWARD),
+					    SERVER_KNOBS->GET_COMMITTED_VERSION_TIMEOUT));
+				} else {
+					wait(timeoutError(
+					    cfi.rollforward.getReply(ConfigFollowerRollforwardRequest{
+					        rollback, nodeVersion.lastCommitted, target, reply.changes, reply.annotations }),
+					    SERVER_KNOBS->GET_COMMITTED_VERSION_TIMEOUT));
+				}
 			} catch (Error& e) {
 				if (e.code() == error_code_transaction_too_old) {
 					// Seeing this trace is not necessarily a problem. There
diff --git a/fdbserver/worker.actor.cpp b/fdbserver/worker.actor.cpp
index 932a6d9a8a..bde9f68511 100644
--- a/fdbserver/worker.actor.cpp
+++ b/fdbserver/worker.actor.cpp
@@ -2978,17 +2978,14 @@ ACTOR Future<MonitorLeaderInfo> monitorLeaderWithDelayedCandidacyImplOneGenerati
     Reference<AsyncVar<Value>> result,
     MonitorLeaderInfo info) {
 	ClusterConnectionString cs = info.intermediateConnRecord->getConnectionString();
-	std::vector<Hostname> hostnames;
 	state int coordinatorsSize = cs.hostnames.size() + cs.coordinators().size();
 	state ElectionResultRequest request;
 	state int index = 0;
 	state int successIndex = 0;
 	state std::vector<LeaderElectionRegInterface> leaderElectionServers;
 
-	hostnames.reserve(cs.hostnames.size());
 	leaderElectionServers.reserve(coordinatorsSize);
 	for (const auto& h : cs.hostnames) {
-		hostnames.push_back(h);
 		leaderElectionServers.push_back(LeaderElectionRegInterface(h));
 	}
 	for (const auto& c : cs.coordinators()) {
@@ -2997,7 +2994,7 @@ ACTOR Future<MonitorLeaderInfo> monitorLeaderWithDelayedCandidacyImplOneGenerati
 	deterministicRandom()->randomShuffle(leaderElectionServers);
 
 	request.key = cs.clusterKey();
-	request.hostnames = hostnames;
+	request.hostnames = cs.hostnames;
 	request.coordinators = cs.coordinators();
 
 	loop {

From e52662c7742f497d94f04f25edb5c8faf4119ce7 Mon Sep 17 00:00:00 2001
From: Vaidas Gasiunas <vaidas.gasiunas@snowflake.com>
Date: Fri, 29 Apr 2022 12:47:05 +0200
Subject: [PATCH 84/84] Upgrade Tests: Fix resetting of already initialized
 variables

---
 tests/TestRunner/upgrade_test.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/tests/TestRunner/upgrade_test.py b/tests/TestRunner/upgrade_test.py
index 8ebfcf038d..ec614a1585 100755
--- a/tests/TestRunner/upgrade_test.py
+++ b/tests/TestRunner/upgrade_test.py
@@ -173,8 +173,6 @@ class UpgradeTest:
         os.mkfifo(self.input_pipe_path)
         os.mkfifo(self.output_pipe_path)
         self.progress_event = Event()
-        self.external_lib_dir = None
-        self.cluster_version = None
         self.api_version = None
         self.tester_retcode = None
         self.tester_proc = None