rebase

CMakeLists.txt

@@ -97,7 +97,7 @@ list(GET FDB_VERSION_LIST 0 FDB_MAJOR)
 list(GET FDB_VERSION_LIST 1 FDB_MINOR)
 list(GET FDB_VERSION_LIST 2 FDB_PATCH)
 set(FDB_PACKAGE_NAME "${FDB_MAJOR}.${FDB_MINOR}")
-configure_file(${CMAKE_SOURCE_DIR}/versions.target.cmake ${CMAKE_SOURCE_DIR}/versions.target)
+configure_file(${CMAKE_SOURCE_DIR}/versions.target.cmake ${CMAKE_CURRENT_BINARY_DIR}/versions.target)
 file(WRITE ${CMAKE_BINARY_DIR}/version.txt ${FDB_VERSION})
 
 message(STATUS "FDB version is ${FDB_VERSION}")
@@ -207,7 +207,6 @@ configure_file(${CMAKE_CURRENT_SOURCE_DIR}/fdbclient/BuildFlags.h.in ${CMAKE_CUR
 ################################################################################
 # process compile commands for IDE
 ################################################################################
-
 if (CMAKE_EXPORT_COMPILE_COMMANDS AND WITH_PYTHON)
   add_custom_command(
 	  OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/compile_commands.json

bindings/bindingtester/spec/bindingApiTester.md

@@ -117,8 +117,8 @@ should simulate it using an anonymous transaction. Remember that set and clear
 operations must immediately commit (with appropriate retry behavior!).
 
 Any error that bubbles out of these operations must be caught. In the event of
-an error, you must push the packed tuple of the string `"ERROR"` and the error
-code (as a string, not an integer).
+an error, you must push the packed tuple of the byte string `"ERROR"` and the
+error code (as a byte string, not an integer).
 
 Some operations may allow you to push future values onto the stack. When popping
 objects from the stack, the future MUST BE waited on and errors caught before

bindings/c/CMakeLists.txt

@@ -7,18 +7,26 @@ file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/foundationdb)
 
 set(asm_file ${CMAKE_CURRENT_BINARY_DIR}/fdb_c.g.S)
 
-set(platform "linux")
+set(os "linux")
+set(cpu "intel")
 if(APPLE)
-  set(platform "osx")
+  set(os "osx")
 elseif(WIN32)
-  set(platform "windows")
+  set(os "windows")
   set(asm_file ${CMAKE_CURRENT_BINARY_DIR}/fdb_c.g.asm)
-elseif(CMAKE_SYSTEM_NAME MATCHES "Linux" AND CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
-  set(platform "linux-aarch64")
+endif()
+
+if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64" OR CMAKE_SYSTEM_PROCESSOR MATCHES "arm64")
+  set(cpu "aarch64")
+endif()
+
+set(IS_ARM_MAC NO)
+if(APPLE AND CMAKE_SYSTEM_PROCESSOR STREQUAL "arm64")
+  set(IS_ARM_MAC YES)
 endif()
 
 add_custom_command(OUTPUT ${asm_file} ${CMAKE_CURRENT_BINARY_DIR}/fdb_c_function_pointers.g.h
-  COMMAND $<TARGET_FILE:Python::Interpreter> ${CMAKE_CURRENT_SOURCE_DIR}/generate_asm.py ${platform}
+  COMMAND $<TARGET_FILE:Python::Interpreter> ${CMAKE_CURRENT_SOURCE_DIR}/generate_asm.py ${os} ${cpu}
       ${CMAKE_CURRENT_SOURCE_DIR}/fdb_c.cpp
       ${asm_file}
       ${CMAKE_CURRENT_BINARY_DIR}/fdb_c_function_pointers.g.h
@@ -55,7 +63,7 @@ if(APPLE)
   target_link_options(fdb_c PRIVATE "LINKER:-no_weak_exports,-exported_symbols_list,${symbols}")
 elseif(WIN32)
 else()
-  target_link_options(fdb_c PRIVATE "LINKER:--version-script=${CMAKE_CURRENT_SOURCE_DIR}/fdb_c.map,-z,nodelete")
+  target_link_options(fdb_c PRIVATE "LINKER:--version-script=${CMAKE_CURRENT_SOURCE_DIR}/fdb_c.map,-z,nodelete,-z,noexecstack")
 endif()
 target_include_directories(fdb_c PUBLIC
   $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>
@@ -66,8 +74,10 @@ if(WIN32)
   set_property(SOURCE ${asm_file} PROPERTY LANGUAGE ASM_MASM)
 endif()
 
-# The tests don't build on windows
-if(NOT WIN32)
+# The tests don't build on windows and ARM macs
+# doctest doesn't seem to compile on ARM macs, we should
+# check later whether this works
+if(NOT WIN32 AND NOT IS_ARM_MAC)
   set(MAKO_SRCS
     test/mako/mako.c
     test/mako/mako.h
@@ -147,11 +157,11 @@ if(NOT WIN32)
     set(FDB_C_TARGET $<TARGET_FILE:fdb_c>)
   endif()
   add_custom_command(
-    OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/libfdb_c.so
-    COMMAND ${CMAKE_COMMAND} -E copy ${FDB_C_TARGET} ${CMAKE_CURRENT_BINARY_DIR}/libfdb_c.so
+    OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/libfdb_c_external.so
+    COMMAND ${CMAKE_COMMAND} -E copy ${FDB_C_TARGET} ${CMAKE_CURRENT_BINARY_DIR}/libfdb_c_external.so
     DEPENDS fdb_c
     COMMENT "Copy libfdb_c to use as external client for test")
-  add_custom_target(external_client DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/libfdb_c.so)
+  add_custom_target(external_client DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/libfdb_c_external.so)
   add_dependencies(fdb_c_unit_tests external_client)
   add_dependencies(disconnected_timeout_unit_tests external_client)
 
@@ -178,7 +188,7 @@ if(NOT WIN32)
     COMMAND $<TARGET_FILE:fdb_c_unit_tests>
             @CLUSTER_FILE@
             fdb
-            ${CMAKE_CURRENT_BINARY_DIR}/libfdb_c.so
+            ${CMAKE_CURRENT_BINARY_DIR}/libfdb_c_external.so
             )
   add_unavailable_fdbclient_test(
     NAME disconnected_timeout_unit_tests
@@ -189,7 +199,7 @@ if(NOT WIN32)
     NAME disconnected_timeout_external_client_unit_tests
     COMMAND $<TARGET_FILE:disconnected_timeout_unit_tests>
             @CLUSTER_FILE@
-            ${CMAKE_CURRENT_BINARY_DIR}/libfdb_c.so
+            ${CMAKE_CURRENT_BINARY_DIR}/libfdb_c_external.so
             )
 endif()
 

bindings/c/fdb_c.cpp

@@ -18,6 +18,7 @@
  * limitations under the License.
  */
 
+#include "fdbclient/FDBTypes.h"
 #include <cstdint>
 #define FDB_API_VERSION 710
 #define FDB_INCLUDE_LEGACY_TYPES
@@ -34,6 +35,7 @@ int g_api_version = 0;
  *
  * type mapping:
  *   FDBFuture -> ThreadSingleAssignmentVarBase
+ *   FDBResult -> ThreadSingleAssignmentVarBase
  *   FDBDatabase -> IDatabase
  *   FDBTransaction -> ITransaction
  */
@@ -79,6 +81,30 @@ extern "C" DLLEXPORT fdb_bool_t fdb_error_predicate(int predicate_test, fdb_erro
 	return false;
 }
 
+#define RETURN_FUTURE_ON_ERROR(return_type, code_to_run)                                                               \
+	try {                                                                                                              \
+		code_to_run                                                                                                    \
+	} catch (Error & e) {                                                                                              \
+		if (e.code() <= 0)                                                                                             \
+			return ((FDBFuture*)(ThreadFuture<return_type>(internal_error())).extractPtr());                           \
+		else                                                                                                           \
+			return ((FDBFuture*)(ThreadFuture<return_type>(e)).extractPtr());                                          \
+	} catch (...) {                                                                                                    \
+		return ((FDBFuture*)(ThreadFuture<return_type>(unknown_error())).extractPtr());                                \
+	}
+
+#define RETURN_RESULT_ON_ERROR(return_type, code_to_run)                                                               \
+	try {                                                                                                              \
+		code_to_run                                                                                                    \
+	} catch (Error & e) {                                                                                              \
+		if (e.code() <= 0)                                                                                             \
+			return ((FDBResult*)(ThreadResult<return_type>(internal_error())).extractPtr());                           \
+		else                                                                                                           \
+			return ((FDBResult*)(ThreadResult<return_type>(e)).extractPtr());                                          \
+	} catch (...) {                                                                                                    \
+		return ((FDBResult*)(ThreadResult<return_type>(unknown_error())).extractPtr());                                \
+	}
+
 #define RETURN_ON_ERROR(code_to_run)                                                                                   \
 	try {                                                                                                              \
 		code_to_run                                                                                                    \
@@ -260,12 +286,33 @@ extern "C" DLLEXPORT fdb_error_t fdb_future_get_string_array(FDBFuture* f, const
 	                 *out_count = na.size(););
 }
 
+extern "C" DLLEXPORT fdb_error_t fdb_future_get_keyrange_array(FDBFuture* f,
+                                                               FDBKeyRange const** out_ranges,
+                                                               int* out_count) {
+	CATCH_AND_RETURN(Standalone<VectorRef<KeyRangeRef>> na = TSAV(Standalone<VectorRef<KeyRangeRef>>, f)->get();
+	                 *out_ranges = (FDBKeyRange*)na.begin();
+	                 *out_count = na.size(););
+}
+
 extern "C" DLLEXPORT fdb_error_t fdb_future_get_key_array(FDBFuture* f, FDBKey const** out_key_array, int* out_count) {
 	CATCH_AND_RETURN(Standalone<VectorRef<KeyRef>> na = TSAV(Standalone<VectorRef<KeyRef>>, f)->get();
 	                 *out_key_array = (FDBKey*)na.begin();
 	                 *out_count = na.size(););
 }
 
+extern "C" DLLEXPORT void fdb_result_destroy(FDBResult* r) {
+	CATCH_AND_DIE(TSAVB(r)->cancel(););
+}
+
+fdb_error_t fdb_result_get_keyvalue_array(FDBResult* r,
+                                          FDBKeyValue const** out_kv,
+                                          int* out_count,
+                                          fdb_bool_t* out_more) {
+	CATCH_AND_RETURN(RangeResult rr = TSAV(RangeResult, r)->get(); *out_kv = (FDBKeyValue*)rr.begin();
+	                 *out_count = rr.size();
+	                 *out_more = rr.more;);
+}
+
 FDBFuture* fdb_create_cluster_v609(const char* cluster_file_path) {
 	char* path;
 	if (cluster_file_path) {
@@ -436,21 +483,12 @@ extern "C" DLLEXPORT FDBFuture* fdb_transaction_get_addresses_for_key(FDBTransac
 	return (FDBFuture*)(TXN(tr)->getAddressesForKey(KeyRef(key_name, key_name_length)).extractPtr());
 }
 
-FDBFuture* fdb_transaction_get_range_impl(FDBTransaction* tr,
-                                          uint8_t const* begin_key_name,
-                                          int begin_key_name_length,
-                                          fdb_bool_t begin_or_equal,
-                                          int begin_offset,
-                                          uint8_t const* end_key_name,
-                                          int end_key_name_length,
-                                          fdb_bool_t end_or_equal,
-                                          int end_offset,
-                                          int limit,
-                                          int target_bytes,
+// Set to the actual limit, target_bytes, and reverse.
+FDBFuture* validate_and_update_parameters(int& limit,
+                                          int& target_bytes,
                                           FDBStreamingMode mode,
                                           int iteration,
-                                          fdb_bool_t snapshot,
-                                          fdb_bool_t reverse) {
+                                          fdb_bool_t& reverse) {
 	/* This method may be called with a runtime API version of 13, in
 	   which negative row limits are a reverse range read */
 	if (g_api_version <= 13 && limit < 0) {
@@ -500,6 +538,27 @@ FDBFuture* fdb_transaction_get_range_impl(FDBTransaction* tr,
 	else if (mode_bytes != GetRangeLimits::BYTE_LIMIT_UNLIMITED)
 		target_bytes = std::min(target_bytes, mode_bytes);
 
+	return nullptr;
+}
+
+FDBFuture* fdb_transaction_get_range_impl(FDBTransaction* tr,
+                                          uint8_t const* begin_key_name,
+                                          int begin_key_name_length,
+                                          fdb_bool_t begin_or_equal,
+                                          int begin_offset,
+                                          uint8_t const* end_key_name,
+                                          int end_key_name_length,
+                                          fdb_bool_t end_or_equal,
+                                          int end_offset,
+                                          int limit,
+                                          int target_bytes,
+                                          FDBStreamingMode mode,
+                                          int iteration,
+                                          fdb_bool_t snapshot,
+                                          fdb_bool_t reverse) {
+	FDBFuture* r = validate_and_update_parameters(limit, target_bytes, mode, iteration, reverse);
+	if (r != nullptr)
+		return r;
 	return (
 	    FDBFuture*)(TXN(tr)
 	                    ->getRange(
@@ -511,6 +570,60 @@ FDBFuture* fdb_transaction_get_range_impl(FDBTransaction* tr,
 	                    .extractPtr());
 }
 
+FDBFuture* fdb_transaction_get_range_and_flat_map_impl(FDBTransaction* tr,
+                                                       uint8_t const* begin_key_name,
+                                                       int begin_key_name_length,
+                                                       fdb_bool_t begin_or_equal,
+                                                       int begin_offset,
+                                                       uint8_t const* end_key_name,
+                                                       int end_key_name_length,
+                                                       fdb_bool_t end_or_equal,
+                                                       int end_offset,
+                                                       uint8_t const* mapper_name,
+                                                       int mapper_name_length,
+                                                       int limit,
+                                                       int target_bytes,
+                                                       FDBStreamingMode mode,
+                                                       int iteration,
+                                                       fdb_bool_t snapshot,
+                                                       fdb_bool_t reverse) {
+	FDBFuture* r = validate_and_update_parameters(limit, target_bytes, mode, iteration, reverse);
+	if (r != nullptr)
+		return r;
+	return (
+	    FDBFuture*)(TXN(tr)
+	                    ->getRangeAndFlatMap(
+	                        KeySelectorRef(KeyRef(begin_key_name, begin_key_name_length), begin_or_equal, begin_offset),
+	                        KeySelectorRef(KeyRef(end_key_name, end_key_name_length), end_or_equal, end_offset),
+	                        StringRef(mapper_name, mapper_name_length),
+	                        GetRangeLimits(limit, target_bytes),
+	                        snapshot,
+	                        reverse)
+	                    .extractPtr());
+}
+
+// TODO: Support FDB_API_ADDED in generate_asm.py and then this can be replaced with fdb_api_ptr_unimpl.
+FDBFuture* fdb_transaction_get_range_and_flat_map_v699(FDBTransaction* tr,
+                                                       uint8_t const* begin_key_name,
+                                                       int begin_key_name_length,
+                                                       fdb_bool_t begin_or_equal,
+                                                       int begin_offset,
+                                                       uint8_t const* end_key_name,
+                                                       int end_key_name_length,
+                                                       fdb_bool_t end_or_equal,
+                                                       int end_offset,
+                                                       uint8_t const* mapper_name,
+                                                       int mapper_name_length,
+                                                       int limit,
+                                                       int target_bytes,
+                                                       FDBStreamingMode mode,
+                                                       int iteration,
+                                                       fdb_bool_t snapshot,
+                                                       fdb_bool_t reverse) {
+	fprintf(stderr, "UNIMPLEMENTED FDB API FUNCTION\n");
+	abort();
+}
+
 FDBFuture* fdb_transaction_get_range_selector_v13(FDBTransaction* tr,
                                                   uint8_t const* begin_key_name,
                                                   int begin_key_name_length,
@@ -642,8 +755,10 @@ extern "C" DLLEXPORT FDBFuture* fdb_transaction_get_estimated_range_size_bytes(F
                                                                                int begin_key_name_length,
                                                                                uint8_t const* end_key_name,
                                                                                int end_key_name_length) {
-	KeyRangeRef range(KeyRef(begin_key_name, begin_key_name_length), KeyRef(end_key_name, end_key_name_length));
-	return (FDBFuture*)(TXN(tr)->getEstimatedRangeSizeBytes(range).extractPtr());
+	RETURN_FUTURE_ON_ERROR(
+	    int64_t,
+	    KeyRangeRef range(KeyRef(begin_key_name, begin_key_name_length), KeyRef(end_key_name, end_key_name_length));
+	    return (FDBFuture*)(TXN(tr)->getEstimatedRangeSizeBytes(range).extractPtr()););
 }
 
 extern "C" DLLEXPORT FDBFuture* fdb_transaction_get_range_split_points(FDBTransaction* tr,
@@ -652,8 +767,47 @@ extern "C" DLLEXPORT FDBFuture* fdb_transaction_get_range_split_points(FDBTransa
                                                                        uint8_t const* end_key_name,
                                                                        int end_key_name_length,
                                                                        int64_t chunk_size) {
-	KeyRangeRef range(KeyRef(begin_key_name, begin_key_name_length), KeyRef(end_key_name, end_key_name_length));
-	return (FDBFuture*)(TXN(tr)->getRangeSplitPoints(range, chunk_size).extractPtr());
+	RETURN_FUTURE_ON_ERROR(
+	    Standalone<VectorRef<KeyRef>>,
+	    KeyRangeRef range(KeyRef(begin_key_name, begin_key_name_length), KeyRef(end_key_name, end_key_name_length));
+	    return (FDBFuture*)(TXN(tr)->getRangeSplitPoints(range, chunk_size).extractPtr()););
+}
+
+extern "C" DLLEXPORT FDBFuture* fdb_transaction_get_blob_granule_ranges(FDBTransaction* tr,
+                                                                        uint8_t const* begin_key_name,
+                                                                        int begin_key_name_length,
+                                                                        uint8_t const* end_key_name,
+                                                                        int end_key_name_length) {
+	RETURN_FUTURE_ON_ERROR(
+	    Standalone<VectorRef<KeyRangeRef>>,
+	    KeyRangeRef range(KeyRef(begin_key_name, begin_key_name_length), KeyRef(end_key_name, end_key_name_length));
+	    return (FDBFuture*)(TXN(tr)->getBlobGranuleRanges(range).extractPtr()););
+}
+
+extern "C" DLLEXPORT FDBResult* fdb_transaction_read_blob_granules(FDBTransaction* tr,
+                                                                   uint8_t const* begin_key_name,
+                                                                   int begin_key_name_length,
+                                                                   uint8_t const* end_key_name,
+                                                                   int end_key_name_length,
+                                                                   int64_t beginVersion,
+                                                                   int64_t readVersion,
+                                                                   FDBReadBlobGranuleContext granule_context) {
+	RETURN_RESULT_ON_ERROR(
+	    RangeResult,
+	    KeyRangeRef range(KeyRef(begin_key_name, begin_key_name_length), KeyRef(end_key_name, end_key_name_length));
+
+	    // FIXME: better way to convert?
+	    ReadBlobGranuleContext context;
+	    context.userContext = granule_context.userContext;
+	    context.start_load_f = granule_context.start_load_f;
+	    context.get_load_f = granule_context.get_load_f;
+	    context.free_load_f = granule_context.free_load_f;
+	    context.debugNoMaterialize = granule_context.debugNoMaterialize;
+
+	    Optional<Version> rv;
+	    if (readVersion != invalidVersion) { rv = readVersion; }
+
+	    return (FDBResult*)(TXN(tr)->readBlobGranules(range, beginVersion, rv, context).extractPtr()););
 }
 
 #include "fdb_c_function_pointers.g.h"
@@ -702,6 +856,7 @@ extern "C" DLLEXPORT fdb_error_t fdb_select_api_version_impl(int runtime_version
 	// WARNING: use caution when implementing removed functions by calling public API functions. This can lead to
 	// undesired behavior when using the multi-version API. Instead, it is better to have both the removed and public
 	// functions call an internal implementation function. See fdb_create_database_impl for an example.
+	FDB_API_CHANGED(fdb_transaction_get_range_and_flat_map, 700);
 	FDB_API_REMOVED(fdb_future_get_version, 620);
 	FDB_API_REMOVED(fdb_create_cluster, 610);
 	FDB_API_REMOVED(fdb_cluster_create_database, 610);

bindings/c/foundationdb/ClientWorkload.h

@@ -37,6 +37,7 @@
 #endif
 
 typedef struct FDB_future FDBFuture;
+typedef struct FDB_result FDBResult;
 typedef struct FDB_database FDBDatabase;
 typedef struct FDB_transaction FDBTransaction;
 

bindings/c/foundationdb/fdb_c.h

@@ -65,6 +65,7 @@ extern "C" {
 
 /* Pointers to these opaque types represent objects in the FDB API */
 typedef struct FDB_future FDBFuture;
+typedef struct FDB_result FDBResult;
 typedef struct FDB_database FDBDatabase;
 typedef struct FDB_transaction FDBTransaction;
 
@@ -112,8 +113,32 @@ typedef struct keyvalue {
 	int value_length;
 } FDBKeyValue;
 #endif
+typedef struct keyrange {
+	const uint8_t* begin_key;
+	int begin_key_length;
+	const uint8_t* end_key;
+	int end_key_length;
+} FDBKeyRange;
 #pragma pack(pop)
 
+typedef struct readgranulecontext {
+	/* User context to pass along to functions */
+	void* userContext;
+
+	/* Returns a unique id for the load. Asynchronous to support queueing multiple in parallel. */
+	int64_t (*start_load_f)(const char* filename, int filenameLength, int64_t offset, int64_t length, void* context);
+
+	/* Returns data for the load. Pass the loadId returned by start_load_f */
+	uint8_t* (*get_load_f)(int64_t loadId, void* context);
+
+	/* Frees data from load. Pass the loadId returned by start_load_f */
+	void (*free_load_f)(int64_t loadId, void* context);
+
+	/* Set this to true for testing if you don't want to read the granule files,
+	   just do the request to the blob workers */
+	fdb_bool_t debugNoMaterialize;
+} FDBReadBlobGranuleContext;
+
 DLLEXPORT void fdb_future_cancel(FDBFuture* f);
 
 DLLEXPORT void fdb_future_release_memory(FDBFuture* f);
@@ -159,6 +184,20 @@ DLLEXPORT WARN_UNUSED_RESULT fdb_error_t fdb_future_get_string_array(FDBFuture*
                                                                      const char*** out_strings,
                                                                      int* out_count);
 
+DLLEXPORT WARN_UNUSED_RESULT fdb_error_t fdb_future_get_keyrange_array(FDBFuture* f,
+                                                                       FDBKeyRange const** out_ranges,
+                                                                       int* out_count);
+
+/* FDBResult is a synchronous computation result, as opposed to a future that is asynchronous. */
+DLLEXPORT void fdb_result_destroy(FDBResult* r);
+
+DLLEXPORT WARN_UNUSED_RESULT fdb_error_t fdb_result_get_keyvalue_array(FDBResult* r,
+                                                                       FDBKeyValue const** out_kv,
+                                                                       int* out_count,
+                                                                       fdb_bool_t* out_more);
+
+/* TODO: add other return types as we need them */
+
 DLLEXPORT WARN_UNUSED_RESULT fdb_error_t fdb_create_database(const char* cluster_file_path, FDBDatabase** out_database);
 
 DLLEXPORT void fdb_database_destroy(FDBDatabase* d);
@@ -244,6 +283,24 @@ DLLEXPORT WARN_UNUSED_RESULT FDBFuture* fdb_transaction_get_range(FDBTransaction
                                                                   fdb_bool_t reverse);
 #endif
 
+DLLEXPORT WARN_UNUSED_RESULT FDBFuture* fdb_transaction_get_range_and_flat_map(FDBTransaction* tr,
+                                                                               uint8_t const* begin_key_name,
+                                                                               int begin_key_name_length,
+                                                                               fdb_bool_t begin_or_equal,
+                                                                               int begin_offset,
+                                                                               uint8_t const* end_key_name,
+                                                                               int end_key_name_length,
+                                                                               fdb_bool_t end_or_equal,
+                                                                               int end_offset,
+                                                                               uint8_t const* mapper_name,
+                                                                               int mapper_name_length,
+                                                                               int limit,
+                                                                               int target_bytes,
+                                                                               FDBStreamingMode mode,
+                                                                               int iteration,
+                                                                               fdb_bool_t snapshot,
+                                                                               fdb_bool_t reverse);
+
 DLLEXPORT void fdb_transaction_set(FDBTransaction* tr,
                                    uint8_t const* key_name,
                                    int key_name_length,
@@ -309,6 +366,23 @@ DLLEXPORT WARN_UNUSED_RESULT FDBFuture* fdb_transaction_get_range_split_points(F
                                                                                int end_key_name_length,
                                                                                int64_t chunk_size);
 
+DLLEXPORT WARN_UNUSED_RESULT FDBFuture* fdb_transaction_get_blob_granule_ranges(FDBTransaction* db,
+                                                                                uint8_t const* begin_key_name,
+                                                                                int begin_key_name_length,
+                                                                                uint8_t const* end_key_name,
+                                                                                int end_key_name_length);
+
+/* InvalidVersion (-1) for readVersion means get read version from transaction
+   Separated out as optional because BG reads can support longer-lived reads than normal FDB transactions */
+DLLEXPORT WARN_UNUSED_RESULT FDBResult* fdb_transaction_read_blob_granules(FDBTransaction* db,
+                                                                           uint8_t const* begin_key_name,
+                                                                           int begin_key_name_length,
+                                                                           uint8_t const* end_key_name,
+                                                                           int end_key_name_length,
+                                                                           int64_t beginVersion,
+                                                                           int64_t readVersion,
+                                                                           FDBReadBlobGranuleContext granuleContext);
+
 #define FDB_KEYSEL_LAST_LESS_THAN(k, l) k, l, 0, 0
 #define FDB_KEYSEL_LAST_LESS_OR_EQUAL(k, l) k, l, 1, 0
 #define FDB_KEYSEL_FIRST_GREATER_THAN(k, l) k, l, 1, 1

bindings/c/generate_asm.py

@@ -23,7 +23,7 @@
 import re
 import sys
 
-(platform, source, asm, h) = sys.argv[1:]
+(os, cpu, source, asm, h) = sys.argv[1:]
 
 functions = {}
 
@@ -59,20 +59,23 @@ def write_windows_asm(asmfile, functions):
 
 
 def write_unix_asm(asmfile, functions, prefix):
-    if platform != "linux-aarch64":
+    if cpu != "aarch64":
         asmfile.write(".intel_syntax noprefix\n")
 
-    if platform.startswith('linux') or platform == "freebsd":
+    if os == 'linux' or os == 'freebsd':
         asmfile.write("\n.data\n")
         for f in functions:
             asmfile.write("\t.extern fdb_api_ptr_%s\n" % f)
 
-        asmfile.write("\n.text\n")
-        for f in functions:
-            asmfile.write("\t.global %s\n\t.type %s, @function\n" % (f, f))
+        if os == 'linux' or os == 'freebsd':
+            asmfile.write("\n.text\n")
+            for f in functions:
+                asmfile.write("\t.global %s\n\t.type %s, @function\n" % (f, f))
 
     for f in functions:
         asmfile.write("\n.globl %s%s\n" % (prefix, f))
+        if cpu == 'aarch64' and os == 'osx':
+            asmfile.write(".p2align\t2\n")
         asmfile.write("%s%s:\n" % (prefix, f))
 
         # These assembly implementations of versioned fdb c api functions must have the following properties.
@@ -104,9 +107,15 @@ def write_unix_asm(asmfile, functions, prefix):
         # 	.size	g, .-g
         # 	.ident	"GCC: (GNU) 8.3.1 20190311 (Red Hat 8.3.1-3)"
 
-        if platform == "linux-aarch64":
-            asmfile.write("\tadrp x8, :got:fdb_api_ptr_%s\n" % (f))
-            asmfile.write("\tldr x8, [x8, #:got_lo12:fdb_api_ptr_%s]\n" % (f))
+        if cpu == "aarch64":
+            if os == 'osx':
+                asmfile.write("\tadrp x8, _fdb_api_ptr_%s@GOTPAGE\n" % (f))
+                asmfile.write("\tldr x8, [x8, _fdb_api_ptr_%s@GOTPAGEOFF]\n" % (f))
+            elif os == 'linux':
+                asmfile.write("\tadrp x8, :got:fdb_api_ptr_%s\n" % (f))
+                asmfile.write("\tldr x8, [x8, #:got_lo12:fdb_api_ptr_%s]\n" % (f))
+            else:
+                assert False, '{} not supported for Arm yet'.format(os)
             asmfile.write("\tldr x8, [x8]\n")
             asmfile.write("\tbr x8\n")
         else:
@@ -123,15 +132,15 @@ with open(asm, 'w') as asmfile:
         hfile.write(
             "void fdb_api_ptr_removed() { fprintf(stderr, \"REMOVED FDB API FUNCTION\\n\"); abort(); }\n\n")
 
-        if platform.startswith('linux'):
+        if os == 'linux':
             write_unix_asm(asmfile, functions, '')
-        elif platform == "osx":
+        elif os == "osx":
             write_unix_asm(asmfile, functions, '_')
-        elif platform == "windows":
+        elif os == "windows":
             write_windows_asm(asmfile, functions)
 
         for f in functions:
-            if platform == "windows":
+            if os == "windows":
                 hfile.write("extern \"C\" ")
             hfile.write("void* fdb_api_ptr_%s = (void*)&fdb_api_ptr_unimpl;\n" % f)
             for v in functions[f]:

bindings/c/test/mako/mako.c

@@ -70,7 +70,38 @@ FILE* debugme; /* descriptor used for debug messages */
 				/* 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 adda retry limit in the future,                                                         \
+				/* 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;                                                                                \
@@ -541,6 +572,143 @@ int run_op_clearrange(FDBTransaction* transaction, char* keystr, char* 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,
+                           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 %ld 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 %ld 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: %ld\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: %ld\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;
+
+	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);
+
+	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,
@@ -785,6 +953,10 @@ retryTxn:
 					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;
@@ -943,7 +1115,7 @@ int run_workload(FDBTransaction* transaction,
 					if (tracetimer == dotrace) {
 						fdb_error_t err;
 						tracetimer = 0;
-						snprintf(traceid, 32, "makotrace%019lld", total_xacts);
+						snprintf(traceid, 32, "makotrace%019ld", total_xacts);
 						fprintf(debugme, "DEBUG: txn tracing %s\n", traceid);
 						err = fdb_transaction_set_option(transaction,
 						                                 FDB_TR_OPTION_DEBUG_TRANSACTION_IDENTIFIER,
@@ -1058,6 +1230,9 @@ void get_stats_file_name(char filename[], int worker_id, int thread_id, int op)
 	case OP_TRANSACTION:
 		strcat(filename, "TRANSACTION");
 		break;
+	case OP_READ_BG:
+		strcat(filename, "READBLOBGRANULES");
+		break;
 	}
 }
 
@@ -1101,7 +1276,7 @@ void* worker_thread(void* thread_args) {
 	}
 
 	fprintf(debugme,
-	        "DEBUG: worker_id:%d (%d) thread_id:%d (%d) database_index:%d (tid:%lld)\n",
+	        "DEBUG: worker_id:%d (%d) thread_id:%d (%d) database_index:%lu (tid:%lu)\n",
 	        worker_id,
 	        args->num_processes,
 	        thread_id,
@@ -1297,12 +1472,15 @@ int worker_process_main(mako_args_t* args, int worker_id, mako_shmhdr_t* shm, pi
 
 	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(uint32_t));
+		    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",
-			        (uint8_t*)&args->client_threads_per_version,
+			        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;
 		}
 	}
 
@@ -1476,6 +1654,8 @@ int init_args(mako_args_t* args) {
 	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;
 }
 
@@ -1538,6 +1718,10 @@ int parse_transaction(mako_args_t* args, char* optarg) {
 		} 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;
@@ -1643,6 +1827,9 @@ void usage() {
 	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 */
@@ -1692,6 +1879,7 @@ int parse_args(int argc, char* argv[], mako_args_t* args) {
 			{ "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;
@@ -1872,6 +2060,9 @@ int parse_args(int argc, char* argv[], mako_args_t* args) {
 				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);
 		}
 	}
 
@@ -1928,6 +2119,8 @@ char* get_ops_name(int ops_code) {
 		return "COMMIT";
 	case OP_TRANSACTION:
 		return "TRANSACTION";
+	case OP_READ_BG:
+		return "READBLOBGRANULE";
 	default:
 		return "";
 	}
@@ -2035,9 +2228,9 @@ void print_stats(mako_args_t* args, mako_stats_t* stats, struct timespec* now, s
 	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) "lld ", ops_total_diff);
+			printf("%" STR(STATS_FIELD_WIDTH) "lu ", ops_total_diff);
 			if (fp) {
-				fprintf(fp, "\"%s\": %lld,", get_ops_name(op), ops_total_diff);
+				fprintf(fp, "\"%s\": %lu,", get_ops_name(op), ops_total_diff);
 			}
 			errors_diff[op] = errors_total[op] - errors_total_prev[op];
 			print_err = (errors_diff[op] > 0);
@@ -2057,7 +2250,7 @@ void print_stats(mako_args_t* args, mako_stats_t* stats, struct timespec* now, s
 	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);
+		fprintf(fp, "\"conflictsPerSec\": %.2f", conflicts_diff);
 	}
 	conflicts_prev = conflicts;
 
@@ -2065,14 +2258,17 @@ void print_stats(mako_args_t* args, mako_stats_t* stats, struct timespec* now, s
 		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) "lld ", errors_diff[op]);
+				printf("%" STR(STATS_FIELD_WIDTH) "lu ", errors_diff[op]);
 				if (fp) {
-					fprintf(fp, "\"errors\": %.2f", conflicts_diff);
+					fprintf(fp, ",\"errors\": %.2f", conflicts_diff);
 				}
 			}
 		}
 		printf("\n");
 	}
+	if (fp) {
+		fprintf(fp, "}");
+	}
 
 	return;
 }
@@ -2143,6 +2339,7 @@ void print_report(mako_args_t* args,
                   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;
@@ -2210,10 +2407,10 @@ void print_report(mako_args_t* args,
 			break;
 		}
 	}
-	printf("Total Xacts:      %8lld\n", totalxacts);
-	printf("Total Conflicts:  %8lld\n", conflicts);
-	printf("Total Errors:     %8lld\n", totalerrors);
-	printf("Overall TPS:      %8lld\n\n", totalxacts * 1000000000 / duration_nsec);
+	printf("Total Xacts:      %8lu\n", totalxacts);
+	printf("Total Conflicts:  %8lu\n", conflicts);
+	printf("Total Errors:     %8lu\n", totalerrors);
+	printf("Overall TPS:      %8lu\n\n", totalxacts * 1000000000 / duration_nsec);
 
 	if (fp) {
 		fprintf(fp, "\"results\": {");
@@ -2221,10 +2418,10 @@ void print_report(mako_args_t* args,
 		fprintf(fp, "\"totalProcesses\": %d,", args->num_processes);
 		fprintf(fp, "\"totalThreads\": %d,", args->num_threads);
 		fprintf(fp, "\"targetTPS\": %d,", args->tpsmax);
-		fprintf(fp, "\"totalXacts\": %lld,", totalxacts);
-		fprintf(fp, "\"totalConflicts\": %lld,", conflicts);
-		fprintf(fp, "\"totalErrors\": %lld,", totalerrors);
-		fprintf(fp, "\"overallTPS\": %lld,", totalxacts * 1000000000 / duration_nsec);
+		fprintf(fp, "\"totalXacts\": %lu,", totalxacts);
+		fprintf(fp, "\"totalConflicts\": %lu,", conflicts);
+		fprintf(fp, "\"totalErrors\": %lu,", totalerrors);
+		fprintf(fp, "\"overallTPS\": %lu,", totalxacts * 1000000000 / duration_nsec);
 	}
 
 	/* per-op stats */
@@ -2237,9 +2434,14 @@ void print_report(mako_args_t* args,
 	}
 	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) "lld ", ops_total[op]);
+			printf("%" STR(STATS_FIELD_WIDTH) "lu ", ops_total[op]);
 			if (fp) {
-				fprintf(fp, "\"%s\": %lld,", get_ops_name(op), ops_total[op]);
+				if (first_op) {
+					first_op = 0;
+				} else {
+					fprintf(fp, ",");
+				}
+				fprintf(fp, "\"%s\": %lu", get_ops_name(op), ops_total[op]);
 			}
 		}
 	}
@@ -2258,11 +2460,17 @@ void print_report(mako_args_t* args,
 
 	/* 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) "lld ", errors_total[op]);
+			printf("%" STR(STATS_FIELD_WIDTH) "lu ", errors_total[op]);
 			if (fp) {
-				fprintf(fp, "\"%s\": %lld,", get_ops_name(op), errors_total[op]);
+				if (first_op) {
+					first_op = 0;
+				} else {
+					fprintf(fp, ",");
+				}
+				fprintf(fp, "\"%s\": %lu", get_ops_name(op), errors_total[op]);
 			}
 		}
 	}
@@ -2276,15 +2484,21 @@ void print_report(mako_args_t* args,
 
 	/* 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) "lld ", lat_samples[op]);
+				printf("%" STR(STATS_FIELD_WIDTH) "lu ", lat_samples[op]);
 			} else {
 				printf("%" STR(STATS_FIELD_WIDTH) "s ", "N/A");
 			}
 			if (fp) {
-				fprintf(fp, "\"%s\": %lld,", get_ops_name(op), lat_samples[op]);
+				if (first_op) {
+					first_op = 0;
+				} else {
+					fprintf(fp, ",");
+				}
+				fprintf(fp, "\"%s\": %lu", get_ops_name(op), lat_samples[op]);
 			}
 		}
 	}
@@ -2295,14 +2509,20 @@ void print_report(mako_args_t* args,
 		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) "lld ", lat_min[op]);
+				printf("%" STR(STATS_FIELD_WIDTH) "lu ", lat_min[op]);
 				if (fp) {
-					fprintf(fp, "\"%s\": %lld,", get_ops_name(op), lat_min[op]);
+					if (first_op) {
+						first_op = 0;
+					} else {
+						fprintf(fp, ",");
+					}
+					fprintf(fp, "\"%s\": %lu", get_ops_name(op), lat_min[op]);
 				}
 			}
 		}
@@ -2314,12 +2534,18 @@ void print_report(mako_args_t* args,
 		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) "lld ", lat_total[op] / lat_samples[op]);
+				printf("%" STR(STATS_FIELD_WIDTH) "lu ", lat_total[op] / lat_samples[op]);
 				if (fp) {
-					fprintf(fp, "\"%s\": %lld,", get_ops_name(op), lat_total[op] / lat_samples[op]);
+					if (first_op) {
+						first_op = 0;
+					} else {
+						fprintf(fp, ",");
+					}
+					fprintf(fp, "\"%s\": %lu", get_ops_name(op), lat_total[op] / lat_samples[op]);
 				}
 			} else {
 				printf("%" STR(STATS_FIELD_WIDTH) "s ", "N/A");
@@ -2333,14 +2559,20 @@ void print_report(mako_args_t* args,
 		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) "lld ", lat_max[op]);
+				printf("%" STR(STATS_FIELD_WIDTH) "lu ", lat_max[op]);
 				if (fp) {
-					fprintf(fp, "\"%s\": %lld,", get_ops_name(op), lat_max[op]);
+					if (first_op) {
+						first_op = 0;
+					} else {
+						fprintf(fp, ",");
+					}
+					fprintf(fp, "\"%s\": %lu", get_ops_name(op), lat_max[op]);
 				}
 			}
 		}
@@ -2357,6 +2589,7 @@ void print_report(mako_args_t* args,
 	}
 	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]) {
@@ -2390,9 +2623,14 @@ void print_report(mako_args_t* args,
 				} else {
 					median = (dataPoints[op][num_points[op] / 2] + dataPoints[op][num_points[op] / 2 - 1]) >> 1;
 				}
-				printf("%" STR(STATS_FIELD_WIDTH) "lld ", median);
+				printf("%" STR(STATS_FIELD_WIDTH) "lu ", median);
 				if (fp) {
-					fprintf(fp, "\"%s\": %lld,", get_ops_name(op), median);
+					if (first_op) {
+						first_op = 0;
+					} else {
+						fprintf(fp, ",");
+					}
+					fprintf(fp, "\"%s\": %lu", get_ops_name(op), median);
 				}
 			} else {
 				printf("%" STR(STATS_FIELD_WIDTH) "s ", "N/A");
@@ -2406,6 +2644,7 @@ void print_report(mako_args_t* args,
 		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) {
@@ -2414,9 +2653,14 @@ void print_report(mako_args_t* args,
 			}
 			if (lat_total[op]) {
 				point_95pct = ((float)(num_points[op]) * 0.95) - 1;
-				printf("%" STR(STATS_FIELD_WIDTH) "lld ", dataPoints[op][point_95pct]);
+				printf("%" STR(STATS_FIELD_WIDTH) "lu ", dataPoints[op][point_95pct]);
 				if (fp) {
-					fprintf(fp, "\"%s\": %lld,", get_ops_name(op), dataPoints[op][point_95pct]);
+					if (first_op) {
+						first_op = 0;
+					} else {
+						fprintf(fp, ",");
+					}
+					fprintf(fp, "\"%s\": %lu", get_ops_name(op), dataPoints[op][point_95pct]);
 				}
 			} else {
 				printf("%" STR(STATS_FIELD_WIDTH) "s ", "N/A");
@@ -2430,6 +2674,7 @@ void print_report(mako_args_t* args,
 		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) {
@@ -2438,9 +2683,14 @@ void print_report(mako_args_t* args,
 			}
 			if (lat_total[op]) {
 				point_99pct = ((float)(num_points[op]) * 0.99) - 1;
-				printf("%" STR(STATS_FIELD_WIDTH) "lld ", dataPoints[op][point_99pct]);
+				printf("%" STR(STATS_FIELD_WIDTH) "lu ", dataPoints[op][point_99pct]);
 				if (fp) {
-					fprintf(fp, "\"%s\": %lld,", get_ops_name(op), dataPoints[op][point_99pct]);
+					if (first_op) {
+						first_op = 0;
+					} else {
+						fprintf(fp, ",");
+					}
+					fprintf(fp, "\"%s\": %lu", get_ops_name(op), dataPoints[op][point_99pct]);
 				}
 			} else {
 				printf("%" STR(STATS_FIELD_WIDTH) "s ", "N/A");
@@ -2454,6 +2704,7 @@ void print_report(mako_args_t* args,
 		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) {
@@ -2462,9 +2713,14 @@ void print_report(mako_args_t* args,
 			}
 			if (lat_total[op]) {
 				point_99_9pct = ((float)(num_points[op]) * 0.999) - 1;
-				printf("%" STR(STATS_FIELD_WIDTH) "lld ", dataPoints[op][point_99_9pct]);
+				printf("%" STR(STATS_FIELD_WIDTH) "lu ", dataPoints[op][point_99_9pct]);
 				if (fp) {
-					fprintf(fp, "\"%s\": %lld,", get_ops_name(op), dataPoints[op][point_99_9pct]);
+					if (first_op) {
+						first_op = 0;
+					} else {
+						fprintf(fp, ",");
+					}
+					fprintf(fp, "\"%s\": %lu", get_ops_name(op), dataPoints[op][point_99_9pct]);
 				}
 			} else {
 				printf("%" STR(STATS_FIELD_WIDTH) "s ", "N/A");
@@ -2496,6 +2752,7 @@ int stats_process_main(mako_args_t* args,
                        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) {
@@ -2526,7 +2783,7 @@ int stats_process_main(mako_args_t* args,
 		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);
+		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);
@@ -2539,7 +2796,7 @@ int stats_process_main(mako_args_t* args,
 		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, "\"json_output_path\": \"%s\"", args->json_output_path);
 		fprintf(fp, "},\"samples\": [");
 	}
 
@@ -2583,8 +2840,15 @@ int stats_process_main(mako_args_t* args,
 				}
 			}
 
-			if (args->verbose >= VERBOSE_DEFAULT)
+			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;
 		}
@@ -2815,6 +3079,7 @@ failExit:
 	if (shmfd) {
 		close(shmfd);
 		shm_unlink(shmpath);
+		unlink(shmpath);
 	}
 
 	return 0;

bindings/c/test/mako/mako.h

@@ -51,6 +51,7 @@ enum Operations {
 	OP_SETCLEARRANGE,
 	OP_COMMIT,
 	OP_TRANSACTION, /* pseudo-operation - cumulative time for the operation + commit */
+	OP_READ_BG,
 	MAX_OP /* must be the last item */
 };
 
@@ -83,7 +84,8 @@ enum Arguments {
 	ARG_STREAMING_MODE,
 	ARG_DISABLE_RYW,
 	ARG_CLIENT_THREADS_PER_VERSION,
-	ARG_JSON_REPORT
+	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 };
@@ -107,6 +109,7 @@ typedef struct {
 #define TAGPREFIXLENGTH_MAX 8
 #define NUM_CLUSTERS_MAX 3
 #define NUM_DATABASES_MAX 10
+#define MAX_BG_IDS 1000
 
 /* benchmark parameters */
 typedef struct {
@@ -143,9 +146,11 @@ typedef struct {
 	int txntagging;
 	char txntagging_prefix[TAGPREFIXLENGTH_MAX];
 	FDBStreamingMode streaming_mode;
-	uint32_t client_threads_per_version;
+	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 */

bindings/c/test/txn_size_test.c

@@ -67,25 +67,25 @@ void runTests(struct ResultSet* rs) {
 	fdb_transaction_set(tr, keys[i], KEY_SIZE, valueStr, VALUE_SIZE);
 	e = getSize(rs, tr, sizes + i);
 	checkError(e, "transaction get size", rs);
-	printf("size %d: %u\n", i, sizes[i]);
+	printf("size %d: %ld\n", i, sizes[i]);
 	i++;
 
 	fdb_transaction_set(tr, keys[i], KEY_SIZE, valueStr, VALUE_SIZE);
 	e = getSize(rs, tr, sizes + i);
 	checkError(e, "transaction get size", rs);
-	printf("size %d: %u\n", i, sizes[i]);
+	printf("size %d: %ld\n", i, sizes[i]);
 	i++;
 
 	fdb_transaction_clear(tr, keys[i], KEY_SIZE);
 	e = getSize(rs, tr, sizes + i);
 	checkError(e, "transaction get size", rs);
-	printf("size %d: %u\n", i, sizes[i]);
+	printf("size %d: %ld\n", i, sizes[i]);
 	i++;
 
 	fdb_transaction_clear_range(tr, keys[i], KEY_SIZE, keys[i + 1], KEY_SIZE);
 	e = getSize(rs, tr, sizes + i);
 	checkError(e, "transaction get size", rs);
-	printf("size %d: %u\n", i, sizes[i]);
+	printf("size %d: %ld\n", i, sizes[i]);
 	i++;
 
 	for (j = 0; j + 1 < i; j++) {

bindings/c/test/unit/disconnected_timeout_tests.cpp

@@ -58,7 +58,7 @@ fdb_error_t wait_future(fdb::Future& f) {
 void validateTimeoutDuration(double expectedSeconds, std::chrono::time_point<std::chrono::steady_clock> start) {
 	std::chrono::duration<double> duration = std::chrono::steady_clock::now() - start;
 	double actualSeconds = duration.count();
-	CHECK(actualSeconds >= expectedSeconds - 1e-6);
+	CHECK(actualSeconds >= expectedSeconds - 1e-3);
 	CHECK(actualSeconds < expectedSeconds * 2);
 }
 

bindings/c/test/unit/fdb_api.cpp

@@ -78,12 +78,29 @@ void Future::cancel() {
 	return fdb_future_get_string_array(future_, out_strings, out_count);
 }
 
+// KeyRangeArrayFuture
+
+[[nodiscard]] fdb_error_t KeyRangeArrayFuture::get(const FDBKeyRange** out_keyranges, int* out_count) {
+	return fdb_future_get_keyrange_array(future_, out_keyranges, out_count);
+}
+
 // KeyValueArrayFuture
 
 [[nodiscard]] fdb_error_t KeyValueArrayFuture::get(const FDBKeyValue** out_kv, int* out_count, fdb_bool_t* out_more) {
 	return fdb_future_get_keyvalue_array(future_, out_kv, out_count, out_more);
 }
 
+// Result
+
+Result::~Result() {
+	fdb_result_destroy(result_);
+}
+
+// KeyValueArrayResult
+[[nodiscard]] fdb_error_t KeyValueArrayResult::get(const FDBKeyValue** out_kv, int* out_count, fdb_bool_t* out_more) {
+	return fdb_result_get_keyvalue_array(result_, out_kv, out_count, out_more);
+}
+
 // Database
 Int64Future Database::reboot_worker(FDBDatabase* db,
                                     const uint8_t* address,
@@ -193,6 +210,41 @@ KeyValueArrayFuture Transaction::get_range(const uint8_t* begin_key_name,
 	                                                     reverse));
 }
 
+KeyValueArrayFuture Transaction::get_range_and_flat_map(const uint8_t* begin_key_name,
+                                                        int begin_key_name_length,
+                                                        fdb_bool_t begin_or_equal,
+                                                        int begin_offset,
+                                                        const uint8_t* end_key_name,
+                                                        int end_key_name_length,
+                                                        fdb_bool_t end_or_equal,
+                                                        int end_offset,
+                                                        const uint8_t* mapper_name,
+                                                        int mapper_name_length,
+                                                        int limit,
+                                                        int target_bytes,
+                                                        FDBStreamingMode mode,
+                                                        int iteration,
+                                                        fdb_bool_t snapshot,
+                                                        fdb_bool_t reverse) {
+	return KeyValueArrayFuture(fdb_transaction_get_range_and_flat_map(tr_,
+	                                                                  begin_key_name,
+	                                                                  begin_key_name_length,
+	                                                                  begin_or_equal,
+	                                                                  begin_offset,
+	                                                                  end_key_name,
+	                                                                  end_key_name_length,
+	                                                                  end_or_equal,
+	                                                                  end_offset,
+	                                                                  mapper_name,
+	                                                                  mapper_name_length,
+	                                                                  limit,
+	                                                                  target_bytes,
+	                                                                  mode,
+	                                                                  iteration,
+	                                                                  snapshot,
+	                                                                  reverse));
+}
+
 EmptyFuture Transaction::watch(std::string_view key) {
 	return EmptyFuture(fdb_transaction_watch(tr_, (const uint8_t*)key.data(), key.size()));
 }
@@ -236,4 +288,23 @@ fdb_error_t Transaction::add_conflict_range(std::string_view begin_key,
 	    tr_, (const uint8_t*)begin_key.data(), begin_key.size(), (const uint8_t*)end_key.data(), end_key.size(), type);
 }
 
+KeyRangeArrayFuture Transaction::get_blob_granule_ranges(std::string_view begin_key, std::string_view end_key) {
+	return KeyRangeArrayFuture(fdb_transaction_get_blob_granule_ranges(
+	    tr_, (const uint8_t*)begin_key.data(), begin_key.size(), (const uint8_t*)end_key.data(), end_key.size()));
+}
+KeyValueArrayResult Transaction::read_blob_granules(std::string_view begin_key,
+                                                    std::string_view end_key,
+                                                    int64_t beginVersion,
+                                                    int64_t readVersion,
+                                                    FDBReadBlobGranuleContext granuleContext) {
+	return KeyValueArrayResult(fdb_transaction_read_blob_granules(tr_,
+	                                                              (const uint8_t*)begin_key.data(),
+	                                                              begin_key.size(),
+	                                                              (const uint8_t*)end_key.data(),
+	                                                              end_key.size(),
+	                                                              beginVersion,
+	                                                              readVersion,
+	                                                              granuleContext));
+}
+
 } // namespace fdb

bindings/c/test/unit/fdb_api.hpp

@@ -135,6 +135,18 @@ private:
 	KeyValueArrayFuture(FDBFuture* f) : Future(f) {}
 };
 
+class KeyRangeArrayFuture : public Future {
+public:
+	// Call this function instead of fdb_future_get_keyrange_array when using
+	// the KeyRangeArrayFuture type. It's behavior is identical to
+	// fdb_future_get_keyrange_array.
+	fdb_error_t get(const FDBKeyRange** out_keyranges, int* out_count);
+
+private:
+	friend class Transaction;
+	KeyRangeArrayFuture(FDBFuture* f) : Future(f) {}
+};
+
 class EmptyFuture : public Future {
 private:
 	friend class Transaction;
@@ -142,6 +154,27 @@ private:
 	EmptyFuture(FDBFuture* f) : Future(f) {}
 };
 
+class Result {
+public:
+	virtual ~Result() = 0;
+
+protected:
+	Result(FDBResult* r) : result_(r) {}
+	FDBResult* result_;
+};
+
+class KeyValueArrayResult : public Result {
+public:
+	// Call this function instead of fdb_result_get_keyvalue_array when using
+	// the KeyValueArrayREsult type. It's behavior is identical to
+	// fdb_result_get_keyvalue_array.
+	fdb_error_t get(const FDBKeyValue** out_kv, int* out_count, fdb_bool_t* out_more);
+
+private:
+	friend class Transaction;
+	KeyValueArrayResult(FDBResult* r) : Result(r) {}
+};
+
 // Wrapper around FDBDatabase, providing database-level API
 class Database final {
 public:
@@ -219,6 +252,25 @@ public:
 	                              fdb_bool_t snapshot,
 	                              fdb_bool_t reverse);
 
+	// WARNING: This feature is considered experimental at this time. It is only allowed when using snapshot isolation
+	// AND disabling read-your-writes. Returns a future which will be set to an FDBKeyValue array.
+	KeyValueArrayFuture get_range_and_flat_map(const uint8_t* begin_key_name,
+	                                           int begin_key_name_length,
+	                                           fdb_bool_t begin_or_equal,
+	                                           int begin_offset,
+	                                           const uint8_t* end_key_name,
+	                                           int end_key_name_length,
+	                                           fdb_bool_t end_or_equal,
+	                                           int end_offset,
+	                                           const uint8_t* mapper_name,
+	                                           int mapper_name_length,
+	                                           int limit,
+	                                           int target_bytes,
+	                                           FDBStreamingMode mode,
+	                                           int iteration,
+	                                           fdb_bool_t snapshot,
+	                                           fdb_bool_t reverse);
+
 	// Wrapper around fdb_transaction_watch. Returns a future representing an
 	// empty value.
 	EmptyFuture watch(std::string_view key);
@@ -249,6 +301,13 @@ public:
 	// Wrapper around fdb_transaction_add_conflict_range.
 	fdb_error_t add_conflict_range(std::string_view begin_key, std::string_view end_key, FDBConflictRangeType type);
 
+	KeyRangeArrayFuture get_blob_granule_ranges(std::string_view begin_key, std::string_view end_key);
+	KeyValueArrayResult read_blob_granules(std::string_view begin_key,
+	                                       std::string_view end_key,
+	                                       int64_t beginVersion,
+	                                       int64_t endVersion,
+	                                       FDBReadBlobGranuleContext granule_context);
+
 private:
 	FDBTransaction* tr_;
 };

bindings/c/test/unit/unit_tests.cpp

@@ -40,6 +40,7 @@
 #define DOCTEST_CONFIG_IMPLEMENT
 #include "doctest.h"
 #include "fdbclient/rapidjson/document.h"
+#include "fdbclient/Tuple.h"
 
 #include "flow/config.h"
 
@@ -76,7 +77,7 @@ fdb_error_t wait_future(fdb::Future& f) {
 // Given a string s, returns the "lowest" string greater than any string that
 // starts with s. Taken from
 // https://github.com/apple/foundationdb/blob/e7d72f458c6a985fdfa677ae021f357d6f49945b/flow/flow.cpp#L223.
-std::string strinc(const std::string& s) {
+std::string strinc_str(const std::string& s) {
 	int index = -1;
 	for (index = s.size() - 1; index >= 0; --index) {
 		if ((uint8_t)s[index] != 255) {
@@ -92,16 +93,16 @@ std::string strinc(const std::string& s) {
 	return r;
 }
 
-TEST_CASE("strinc") {
-	CHECK(strinc("a").compare("b") == 0);
-	CHECK(strinc("y").compare("z") == 0);
-	CHECK(strinc("!").compare("\"") == 0);
-	CHECK(strinc("*").compare("+") == 0);
-	CHECK(strinc("fdb").compare("fdc") == 0);
-	CHECK(strinc("foundation database 6").compare("foundation database 7") == 0);
+TEST_CASE("strinc_str") {
+	CHECK(strinc_str("a").compare("b") == 0);
+	CHECK(strinc_str("y").compare("z") == 0);
+	CHECK(strinc_str("!").compare("\"") == 0);
+	CHECK(strinc_str("*").compare("+") == 0);
+	CHECK(strinc_str("fdb").compare("fdc") == 0);
+	CHECK(strinc_str("foundation database 6").compare("foundation database 7") == 0);
 
 	char terminated[] = { 'a', 'b', '\xff' };
-	CHECK(strinc(std::string(terminated, 3)).compare("ac") == 0);
+	CHECK(strinc_str(std::string(terminated, 3)).compare("ac") == 0);
 }
 
 // Helper function to add `prefix` to all keys in the given map. Returns a new
@@ -117,7 +118,7 @@ std::map<std::string, std::string> create_data(std::map<std::string, std::string
 // Clears all data in the database, then inserts the given key value pairs.
 void insert_data(FDBDatabase* db, const std::map<std::string, std::string>& data) {
 	fdb::Transaction tr(db);
-	auto end_key = strinc(prefix);
+	auto end_key = strinc_str(prefix);
 	while (1) {
 		tr.clear_range(prefix, end_key);
 		for (const auto& [key, val] : data) {
@@ -224,6 +225,59 @@ GetRangeResult get_range(fdb::Transaction& tr,
 	return GetRangeResult{ results, out_more != 0, 0 };
 }
 
+GetRangeResult get_range_and_flat_map(fdb::Transaction& tr,
+                                      const uint8_t* begin_key_name,
+                                      int begin_key_name_length,
+                                      fdb_bool_t begin_or_equal,
+                                      int begin_offset,
+                                      const uint8_t* end_key_name,
+                                      int end_key_name_length,
+                                      fdb_bool_t end_or_equal,
+                                      int end_offset,
+                                      const uint8_t* mapper_name,
+                                      int mapper_name_length,
+                                      int limit,
+                                      int target_bytes,
+                                      FDBStreamingMode mode,
+                                      int iteration,
+                                      fdb_bool_t snapshot,
+                                      fdb_bool_t reverse) {
+	fdb::KeyValueArrayFuture f1 = tr.get_range_and_flat_map(begin_key_name,
+	                                                        begin_key_name_length,
+	                                                        begin_or_equal,
+	                                                        begin_offset,
+	                                                        end_key_name,
+	                                                        end_key_name_length,
+	                                                        end_or_equal,
+	                                                        end_offset,
+	                                                        mapper_name,
+	                                                        mapper_name_length,
+	                                                        limit,
+	                                                        target_bytes,
+	                                                        mode,
+	                                                        iteration,
+	                                                        snapshot,
+	                                                        reverse);
+
+	fdb_error_t err = wait_future(f1);
+	if (err) {
+		return GetRangeResult{ {}, false, err };
+	}
+
+	const FDBKeyValue* out_kv;
+	int out_count;
+	fdb_bool_t out_more;
+	fdb_check(f1.get(&out_kv, &out_count, &out_more));
+
+	std::vector<std::pair<std::string, std::string>> results;
+	for (int i = 0; i < out_count; ++i) {
+		std::string key((const char*)out_kv[i].key, out_kv[i].key_length);
+		std::string value((const char*)out_kv[i].value, out_kv[i].value_length);
+		results.emplace_back(key, value);
+	}
+	return GetRangeResult{ results, out_more != 0, 0 };
+}
+
 // Clears all data in the database.
 void clear_data(FDBDatabase* db) {
 	insert_data(db, {});
@@ -819,6 +873,137 @@ TEST_CASE("fdb_transaction_set_read_version future_version") {
 	CHECK(err == 1009); // future_version
 }
 
+const std::string EMPTY = Tuple().pack().toString();
+const KeyRef RECORD = "RECORD"_sr;
+const KeyRef INDEX = "INDEX"_sr;
+static Key primaryKey(const int i) {
+	return Key(format("primary-key-of-record-%08d", i));
+}
+static Key indexKey(const int i) {
+	return Key(format("index-key-of-record-%08d", i));
+}
+static Value dataOfRecord(const int i) {
+	return Value(format("data-of-record-%08d", i));
+}
+static std::string indexEntryKey(const int i) {
+	return Tuple().append(StringRef(prefix)).append(INDEX).append(indexKey(i)).append(primaryKey(i)).pack().toString();
+}
+static std::string recordKey(const int i) {
+	return Tuple().append(prefix).append(RECORD).append(primaryKey(i)).pack().toString();
+}
+static std::string recordValue(const int i) {
+	return Tuple().append(dataOfRecord(i)).pack().toString();
+}
+
+std::map<std::string, std::string> fillInRecords(int n) {
+	// Note: The user requested `prefix` should be added as the first element of the tuple that forms the key, rather
+	// than the prefix of the key. So we don't use key() or create_data() in this test.
+	std::map<std::string, std::string> data;
+	for (int i = 0; i < n; i++) {
+		data[indexEntryKey(i)] = EMPTY;
+		data[recordKey(i)] = recordValue(i);
+	}
+	insert_data(db, data);
+	return data;
+}
+
+GetRangeResult getIndexEntriesAndMap(int beginId, int endId, fdb::Transaction& tr) {
+	std::string indexEntryKeyBegin = indexEntryKey(beginId);
+	std::string indexEntryKeyEnd = indexEntryKey(endId);
+
+	std::string mapper = Tuple().append(prefix).append(RECORD).append("{K[3]}"_sr).pack().toString();
+
+	return get_range_and_flat_map(
+	    tr,
+	    FDB_KEYSEL_FIRST_GREATER_OR_EQUAL((const uint8_t*)indexEntryKeyBegin.c_str(), indexEntryKeyBegin.size()),
+	    FDB_KEYSEL_FIRST_GREATER_OR_EQUAL((const uint8_t*)indexEntryKeyEnd.c_str(), indexEntryKeyEnd.size()),
+	    (const uint8_t*)mapper.c_str(),
+	    mapper.size(),
+	    /* limit */ 0,
+	    /* target_bytes */ 0,
+	    /* FDBStreamingMode */ FDB_STREAMING_MODE_WANT_ALL,
+	    /* iteration */ 0,
+	    /* snapshot */ true,
+	    /* reverse */ 0);
+}
+
+TEST_CASE("fdb_transaction_get_range_and_flat_map") {
+	fillInRecords(20);
+
+	fdb::Transaction tr(db);
+	// get_range_and_flat_map is only support without RYW. This is a must!!!
+	fdb_check(tr.set_option(FDB_TR_OPTION_READ_YOUR_WRITES_DISABLE, nullptr, 0));
+	while (1) {
+		int beginId = 1;
+		int endId = 19;
+		auto result = getIndexEntriesAndMap(beginId, endId, tr);
+
+		if (result.err) {
+			fdb::EmptyFuture f1 = tr.on_error(result.err);
+			fdb_check(wait_future(f1));
+			continue;
+		}
+
+		int expectSize = endId - beginId;
+		CHECK(result.kvs.size() == expectSize);
+		CHECK(!result.more);
+
+		int id = beginId;
+		for (int i = 0; i < result.kvs.size(); i++, id++) {
+			const auto& [key, value] = result.kvs[i];
+			CHECK(recordKey(id).compare(key) == 0);
+			CHECK(recordValue(id).compare(value) == 0);
+		}
+		break;
+	}
+}
+
+TEST_CASE("fdb_transaction_get_range_and_flat_map get_key_values_and_map_has_more") {
+	fillInRecords(2000);
+	fdb::Transaction tr(db);
+	fdb_check(tr.set_option(FDB_TR_OPTION_READ_YOUR_WRITES_DISABLE, nullptr, 0));
+	auto result = getIndexEntriesAndMap(100, 1900, tr);
+	CHECK(result.err == error_code_get_key_values_and_map_has_more);
+}
+
+TEST_CASE("fdb_transaction_get_range_and_flat_map_restricted_to_snapshot") {
+	std::string mapper = Tuple().append(prefix).append(RECORD).append("{K[3]}"_sr).pack().toString();
+	fdb::Transaction tr(db);
+	fdb_check(tr.set_option(FDB_TR_OPTION_READ_YOUR_WRITES_DISABLE, nullptr, 0));
+	auto result = get_range_and_flat_map(
+	    tr,
+	    FDB_KEYSEL_FIRST_GREATER_OR_EQUAL((const uint8_t*)indexEntryKey(0).c_str(), indexEntryKey(0).size()),
+	    FDB_KEYSEL_FIRST_GREATER_THAN((const uint8_t*)indexEntryKey(1).c_str(), indexEntryKey(1).size()),
+	    (const uint8_t*)mapper.c_str(),
+	    mapper.size(),
+	    /* limit */ 0,
+	    /* target_bytes */ 0,
+	    /* FDBStreamingMode */ FDB_STREAMING_MODE_WANT_ALL,
+	    /* iteration */ 0,
+	    /* snapshot */ false, // Set snapshot to false
+	    /* reverse */ 0);
+	ASSERT(result.err == error_code_client_invalid_operation);
+}
+
+TEST_CASE("fdb_transaction_get_range_and_flat_map_restricted_to_ryw_disable") {
+	std::string mapper = Tuple().append(prefix).append(RECORD).append("{K[3]}"_sr).pack().toString();
+	fdb::Transaction tr(db);
+	// Not set FDB_TR_OPTION_READ_YOUR_WRITES_DISABLE.
+	auto result = get_range_and_flat_map(
+	    tr,
+	    FDB_KEYSEL_FIRST_GREATER_OR_EQUAL((const uint8_t*)indexEntryKey(0).c_str(), indexEntryKey(0).size()),
+	    FDB_KEYSEL_FIRST_GREATER_THAN((const uint8_t*)indexEntryKey(1).c_str(), indexEntryKey(1).size()),
+	    (const uint8_t*)mapper.c_str(),
+	    mapper.size(),
+	    /* limit */ 0,
+	    /* target_bytes */ 0,
+	    /* FDBStreamingMode */ FDB_STREAMING_MODE_WANT_ALL,
+	    /* iteration */ 0,
+	    /* snapshot */ true,
+	    /* reverse */ 0);
+	ASSERT(result.err == error_code_client_invalid_operation);
+}
+
 TEST_CASE("fdb_transaction_get_range reverse") {
 	std::map<std::string, std::string> data = create_data({ { "a", "1" }, { "b", "2" }, { "c", "3" }, { "d", "4" } });
 	insert_data(db, data);
@@ -1726,7 +1911,7 @@ TEST_CASE("fdb_transaction_add_conflict_range") {
 
 		fdb::Transaction tr2(db);
 		while (1) {
-			fdb_check(tr2.add_conflict_range(key("a"), strinc(key("a")), FDB_CONFLICT_RANGE_TYPE_WRITE));
+			fdb_check(tr2.add_conflict_range(key("a"), strinc_str(key("a")), FDB_CONFLICT_RANGE_TYPE_WRITE));
 			fdb::EmptyFuture f1 = tr2.commit();
 
 			fdb_error_t err = wait_future(f1);
@@ -1739,8 +1924,8 @@ TEST_CASE("fdb_transaction_add_conflict_range") {
 		}
 
 		while (1) {
-			fdb_check(tr.add_conflict_range(key("a"), strinc(key("a")), FDB_CONFLICT_RANGE_TYPE_READ));
-			fdb_check(tr.add_conflict_range(key("a"), strinc(key("a")), FDB_CONFLICT_RANGE_TYPE_WRITE));
+			fdb_check(tr.add_conflict_range(key("a"), strinc_str(key("a")), FDB_CONFLICT_RANGE_TYPE_READ));
+			fdb_check(tr.add_conflict_range(key("a"), strinc_str(key("a")), FDB_CONFLICT_RANGE_TYPE_WRITE));
 			fdb::EmptyFuture f1 = tr.commit();
 
 			fdb_error_t err = wait_future(f1);
@@ -1828,41 +2013,6 @@ TEST_CASE("special-key-space set transaction ID after write") {
 	}
 }
 
-TEST_CASE("special-key-space set token after write") {
-	fdb::Transaction tr(db);
-	fdb_check(tr.set_option(FDB_TR_OPTION_SPECIAL_KEY_SPACE_ENABLE_WRITES, nullptr, 0));
-	while (1) {
-		tr.set(key("foo"), "bar");
-		tr.set("\xff\xff/tracing/token", "false");
-		fdb::ValueFuture f1 = tr.get("\xff\xff/tracing/token",
-		                             /* snapshot */ false);
-
-		fdb_error_t err = wait_future(f1);
-		if (err) {
-			fdb::EmptyFuture f2 = tr.on_error(err);
-			fdb_check(wait_future(f2));
-			continue;
-		}
-
-		int out_present;
-		char* val;
-		int vallen;
-		fdb_check(f1.get(&out_present, (const uint8_t**)&val, &vallen));
-
-		REQUIRE(out_present);
-		uint64_t token = std::stoul(std::string(val, vallen));
-		CHECK(token != 0);
-		break;
-	}
-}
-
-TEST_CASE("special-key-space valid token") {
-	auto value = get_value("\xff\xff/tracing/token", /* snapshot */ false, {});
-	REQUIRE(value.has_value());
-	uint64_t token = std::stoul(value.value());
-	CHECK(token > 0);
-}
-
 TEST_CASE("special-key-space disable tracing") {
 	fdb::Transaction tr(db);
 	fdb_check(tr.set_option(FDB_TR_OPTION_SPECIAL_KEY_SPACE_ENABLE_WRITES, nullptr, 0));
@@ -1890,48 +2040,6 @@ TEST_CASE("special-key-space disable tracing") {
 	}
 }
 
-TEST_CASE("FDB_DB_OPTION_DISTRIBUTED_TRANSACTION_TRACE_DISABLE") {
-	fdb_check(fdb_database_set_option(db, FDB_DB_OPTION_DISTRIBUTED_TRANSACTION_TRACE_DISABLE, nullptr, 0));
-
-	auto value = get_value("\xff\xff/tracing/token", /* snapshot */ false, {});
-	REQUIRE(value.has_value());
-	uint64_t token = std::stoul(value.value());
-	CHECK(token == 0);
-
-	fdb_check(fdb_database_set_option(db, FDB_DB_OPTION_DISTRIBUTED_TRANSACTION_TRACE_ENABLE, nullptr, 0));
-}
-
-TEST_CASE("FDB_DB_OPTION_DISTRIBUTED_TRANSACTION_TRACE_DISABLE enable tracing for transaction") {
-	fdb_check(fdb_database_set_option(db, FDB_DB_OPTION_DISTRIBUTED_TRANSACTION_TRACE_DISABLE, nullptr, 0));
-
-	fdb::Transaction tr(db);
-	fdb_check(tr.set_option(FDB_TR_OPTION_SPECIAL_KEY_SPACE_ENABLE_WRITES, nullptr, 0));
-	while (1) {
-		tr.set("\xff\xff/tracing/token", "true");
-		fdb::ValueFuture f1 = tr.get("\xff\xff/tracing/token",
-		                             /* snapshot */ false);
-
-		fdb_error_t err = wait_future(f1);
-		if (err) {
-			fdb::EmptyFuture f2 = tr.on_error(err);
-			fdb_check(wait_future(f2));
-			continue;
-		}
-
-		int out_present;
-		char* val;
-		int vallen;
-		fdb_check(f1.get(&out_present, (const uint8_t**)&val, &vallen));
-
-		REQUIRE(out_present);
-		uint64_t token = std::stoul(std::string(val, vallen));
-		CHECK(token > 0);
-		break;
-	}
-
-	fdb_check(fdb_database_set_option(db, FDB_DB_OPTION_DISTRIBUTED_TRANSACTION_TRACE_ENABLE, nullptr, 0));
-}
-
 TEST_CASE("special-key-space tracing get range") {
 	std::string tracingBegin = "\xff\xff/tracing/";
 	std::string tracingEnd = "\xff\xff/tracing0";
@@ -1964,8 +2072,6 @@ TEST_CASE("special-key-space tracing get range") {
 		CHECK(!out_more);
 		CHECK(out_count == 2);
 
-		CHECK(std::string((char*)out_kv[0].key, out_kv[0].key_length) == tracingBegin + "token");
-		CHECK(std::stoul(std::string((char*)out_kv[0].value, out_kv[0].value_length)) > 0);
 		CHECK(std::string((char*)out_kv[1].key, out_kv[1].key_length) == tracingBegin + "transaction_id");
 		CHECK(std::stoul(std::string((char*)out_kv[1].value, out_kv[1].value_length)) > 0);
 		break;
@@ -2217,7 +2323,7 @@ TEST_CASE("commit_does_not_reset") {
 			continue;
 		}
 
-		fdb_check(tr2.add_conflict_range(key("foo"), strinc(key("foo")), FDB_CONFLICT_RANGE_TYPE_READ));
+		fdb_check(tr2.add_conflict_range(key("foo"), strinc_str(key("foo")), FDB_CONFLICT_RANGE_TYPE_READ));
 		tr2.set(key("foo"), "bar");
 		fdb::EmptyFuture tr2CommitFuture = tr2.commit();
 		err = wait_future(tr2CommitFuture);

bindings/c/test/workloads/SimpleWorkload.cpp

@@ -30,7 +30,7 @@
 
 namespace {
 
-struct SimpleWorkload : FDBWorkload {
+struct SimpleWorkload final : FDBWorkload {
 	static const std::string name;
 	static const std::string KEY_PREFIX;
 	std::mt19937 random;

bindings/flow/fdb_flow.actor.cpp

@@ -24,6 +24,7 @@
 #include <stdio.h>
 #include <cinttypes>
 
+#include "contrib/fmt-8.0.1/include/fmt/format.h"
 #include "flow/DeterministicRandom.h"
 #include "flow/SystemMonitor.h"
 #include "flow/TLSConfig.actor.h"
@@ -44,7 +45,7 @@ ACTOR Future<Void> _test() {
 	// tr->setVersion(1);
 
 	Version ver = wait(tr->getReadVersion());
-	printf("%" PRId64 "\n", ver);
+	fmt::print("{}\n", ver);
 
 	state std::vector<Future<Version>> versions;
 

bindings/go/CMakeLists.txt

@@ -122,3 +122,11 @@ add_dependencies(directory_go tuple_go)
 
 build_go_package(EXECUTABLE NAME fdb_go_tester PATH _stacktester)
 add_dependencies(fdb_go_tester directory_go)
+
+# If this fails, then you need to update bindings/go/src/fdb/generated.go
+# Ideally this wouldn't be necessary, but it looks like we distribute the go
+# bindings directly from the source on github.
+add_test(
+  NAME update_bindings_go_src_fdb_generated_go
+  COMMAND ${CMAKE_COMMAND} -E compare_files ${go_options_file} ${CMAKE_CURRENT_SOURCE_DIR}/src/fdb/generated.go
+)

bindings/go/src/fdb/cluster.go

@@ -22,10 +22,6 @@
 
 package fdb
 
-// #define FDB_API_VERSION 710
-// #include <foundationdb/fdb_c.h>
-import "C"
-
 // Deprecated: Use OpenDatabase or OpenDefault to obtain a database handle directly.
 // Cluster is a handle to a FoundationDB cluster. Cluster is a lightweight
 // object that may be efficiently copied, and is safe for concurrent use by

bindings/go/src/fdb/generated.go

@@ -102,6 +102,13 @@ func (o NetworkOptions) SetTraceFileIdentifier(param string) error {
 	return o.setOpt(36, []byte(param))
 }
 
+// Set file suffix for partially written log files.
+//
+// Parameter: Append this suffix to partially written log files. When a log file is complete, it is renamed to remove the suffix. No separator is added between the file and the suffix. If you want to add a file extension, you should include the separator - e.g. '.tmp' instead of 'tmp' to add the 'tmp' extension.
+func (o NetworkOptions) SetTracePartialFileSuffix(param string) error {
+	return o.setOpt(39, []byte(param))
+}
+
 // Set internal tuning or debugging knobs
 //
 // Parameter: knob_name=knob_value
@@ -271,6 +278,13 @@ func (o NetworkOptions) SetClientBuggifySectionFiredProbability(param int64) err
 	return o.setOpt(83, int64ToBytes(param))
 }
 
+// Set a tracer to run on the client. Should be set to the same value as the tracer set on the server.
+//
+// Parameter: Distributed tracer type. Choose from none, log_file, or network_lossy
+func (o NetworkOptions) SetDistributedClientTracer(param string) error {
+	return o.setOpt(90, []byte(param))
+}
+
 // Set the size of the client location cache. Raising this value can boost performance in very large databases where clients access data in a near-random pattern. Defaults to 100000.
 //
 // Parameter: Max location cache entries
@@ -354,6 +368,21 @@ func (o DatabaseOptions) SetTransactionIncludePortInAddress() error {
 	return o.setOpt(505, nil)
 }
 
+// Allows ``get`` operations to read from sections of keyspace that have become unreadable because of versionstamp operations. This sets the ``bypass_unreadable`` option of each transaction created by this database. See the transaction option description for more information.
+func (o DatabaseOptions) SetTransactionBypassUnreadable() error {
+	return o.setOpt(700, nil)
+}
+
+// Use configuration database.
+func (o DatabaseOptions) SetUseConfigDatabase() error {
+	return o.setOpt(800, nil)
+}
+
+// An integer between 0 and 100 (default is 0) expressing the probability that a client will verify it can't read stale data whenever it detects a recovery.
+func (o DatabaseOptions) SetTestCausalReadRisky() error {
+	return o.setOpt(900, nil)
+}
+
 // The transaction, if not self-conflicting, may be committed a second time after commit succeeds, in the event of a fault
 func (o TransactionOptions) SetCausalWriteRisky() error {
 	return o.setOpt(10, nil)
@@ -379,7 +408,7 @@ func (o TransactionOptions) SetNextWriteNoWriteConflictRange() error {
 	return o.setOpt(30, nil)
 }
 
-// Reads performed by a transaction will not see any prior mutations that occured in that transaction, instead seeing the value which was in the database at the transaction's read version. This option may provide a small performance benefit for the client, but also disables a number of client-side optimizations which are beneficial for transactions which tend to read and write the same keys within a single transaction.
+// Reads performed by a transaction will not see any prior mutations that occured in that transaction, instead seeing the value which was in the database at the transaction's read version. This option may provide a small performance benefit for the client, but also disables a number of client-side optimizations which are beneficial for transactions which tend to read and write the same keys within a single transaction. It is an error to set this option after performing any reads or writes on the transaction.
 func (o TransactionOptions) SetReadYourWritesDisable() error {
 	return o.setOpt(51, nil)
 }
@@ -533,6 +562,11 @@ func (o TransactionOptions) SetSpecialKeySpaceRelaxed() error {
 	return o.setOpt(713, nil)
 }
 
+// By default, users are not allowed to write to special keys. Enable this option will implicitly enable all options required to achieve the configuration change.
+func (o TransactionOptions) SetSpecialKeySpaceEnableWrites() error {
+	return o.setOpt(714, nil)
+}
+
 // Adds a tag to the transaction that can be used to apply manual targeted throttling. At most 5 tags can be set on a transaction.
 //
 // Parameter: String identifier used to associated this transaction with a throttling group. Must not exceed 16 characters.
@@ -547,6 +581,23 @@ func (o TransactionOptions) SetAutoThrottleTag(param string) error {
 	return o.setOpt(801, []byte(param))
 }
 
+// Adds a parent to the Span of this transaction. Used for transaction tracing. A span can be identified with any 16 bytes
+//
+// Parameter: A byte string of length 16 used to associate the span of this transaction with a parent
+func (o TransactionOptions) SetSpanParent(param []byte) error {
+	return o.setOpt(900, param)
+}
+
+// Asks storage servers for how many bytes a clear key range contains. Otherwise uses the location cache to roughly estimate this.
+func (o TransactionOptions) SetExpensiveClearCostEstimationEnable() error {
+	return o.setOpt(1000, nil)
+}
+
+// Allows ``get`` operations to read from sections of keyspace that have become unreadable because of versionstamp operations. These reads will view versionstamp operations as if they were set operations that did not fill in the versionstamp.
+func (o TransactionOptions) SetBypassUnreadable() error {
+	return o.setOpt(1100, nil)
+}
+
 type StreamingMode int
 
 const (
@@ -561,13 +612,13 @@ const (
 	// minimize costs if the client doesn't read the entire range), and as the
 	// caller iterates over more items in the range larger batches will be
 	// transferred in order to minimize latency. After enough iterations, the
-	// iterator mode will eventually reach the same byte limit as ``WANT_ALL``
+	// iterator mode will eventually reach the same byte limit as “WANT_ALL“
 	StreamingModeIterator StreamingMode = 0
 
 	// Infrequently used. The client has passed a specific row limit and wants
 	// that many rows delivered in a single batch. Because of iterator operation
 	// in client drivers make request batches transparent to the user, consider
-	// ``WANT_ALL`` StreamingMode instead. A row limit must be specified if this
+	// “WANT_ALL“ StreamingMode instead. A row limit must be specified if this
 	// mode is used.
 	StreamingModeExact StreamingMode = 1
 
@@ -684,15 +735,15 @@ type ErrorPredicate int
 
 const (
 
-	// Returns ``true`` if the error indicates the operations in the transactions
+	// Returns “true“ if the error indicates the operations in the transactions
 	// should be retried because of transient error.
 	ErrorPredicateRetryable ErrorPredicate = 50000
 
-	// Returns ``true`` if the error indicates the transaction may have succeeded,
+	// Returns “true“ if the error indicates the transaction may have succeeded,
 	// though not in a way the system can verify.
 	ErrorPredicateMaybeCommitted ErrorPredicate = 50001
 
-	// Returns ``true`` if the error indicates the transaction has not committed,
+	// Returns “true“ if the error indicates the transaction has not committed,
 	// though in a way that can be retried.
 	ErrorPredicateRetryableNotCommitted ErrorPredicate = 50002
 )

bindings/java/CMakeLists.txt

@@ -137,6 +137,7 @@ if(OPEN_FOR_IDE)
 else()
   add_library(fdb_java SHARED fdbJNI.cpp)
   add_library(java_workloads SHARED JavaWorkload.cpp)
+  target_link_libraries(java_workloads PRIVATE fdb_java_native)
 endif()
 
 if (NOT WIN32 AND NOT APPLE AND NOT OPEN_FOR_IDE)
@@ -146,6 +147,7 @@ endif()
 target_include_directories(fdb_java PRIVATE ${JNI_INCLUDE_DIRS})
 # libfdb_java.so is loaded by fdb-java.jar and doesn't need to depened on jvm shared libraries.
 target_link_libraries(fdb_java PRIVATE fdb_c)
+target_link_libraries(fdb_java PRIVATE fdb_java_native)
 if(APPLE)
   set_target_properties(fdb_java PROPERTIES SUFFIX ".jnilib")
 endif()
@@ -182,8 +184,8 @@ set(MANIFEST_FILE ${CMAKE_CURRENT_BINARY_DIR}/resources/META-INF/MANIFEST.MF)
 file(WRITE ${MANIFEST_FILE} ${MANIFEST_TEXT})
 
 add_jar(fdb-java ${JAVA_BINDING_SRCS} ${GENERATED_JAVA_FILES} ${CMAKE_SOURCE_DIR}/LICENSE
-  OUTPUT_DIR ${PROJECT_BINARY_DIR}/lib VERSION ${FDB_VERSION} MANIFEST ${MANIFEST_FILE})
-add_dependencies(fdb-java fdb_java_options fdb_java)
+  OUTPUT_DIR ${PROJECT_BINARY_DIR}/lib VERSION ${FDB_VERSION} MANIFEST ${MANIFEST_FILE} GENERATE_NATIVE_HEADERS fdb_java_native)
+add_dependencies(fdb-java fdb_java_options)
 
 if(NOT OPEN_FOR_IDE)
   set(FAT_JAR_BINARIES "NOTFOUND" CACHE STRING
@@ -218,7 +220,11 @@ if(NOT OPEN_FOR_IDE)
   if(WIN32)
     set(lib_destination "windows/amd64")
   elseif(APPLE)
-    set(lib_destination "osx/x86_64")
+    if(CMAKE_SYSTEM_PROCESSOR MATCHES "arm64")
+      set(lib_destination "osx/aarch64")
+    else()
+      set(lib_destination "osx/x86_64")
+    endif()
   else()
    if(CMAKE_SYSTEM_PROCESSOR MATCHES "aarch64")
      set(lib_destination "linux/aarch64")
@@ -234,6 +240,7 @@ if(NOT OPEN_FOR_IDE)
     COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:fdb_java> ${lib_destination} &&
     ${CMAKE_COMMAND} -E copy $<TARGET_FILE:fdb_java> ${jni_package} &&
     ${CMAKE_COMMAND} -E touch ${CMAKE_CURRENT_BINARY_DIR}/lib_copied
+    DEPENDS fdb_java
     COMMENT "Copy jni library for fat jar")
   add_custom_target(copy_lib DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/lib_copied)
   add_dependencies(copy_lib unpack_jar)
@@ -260,6 +267,7 @@ if(NOT OPEN_FOR_IDE)
   add_dependencies(fdb-java-tests foundationdb-tests)
   add_custom_target(fat-jar ALL DEPENDS ${target_jar})
   add_dependencies(fat-jar fdb-java)
+  add_dependencies(fat-jar fdb_java)
   add_dependencies(fat-jar copy_lib)
   add_dependencies(packages fat-jar)
 

bindings/java/JavaWorkload.cpp

@@ -22,6 +22,10 @@
 #define FDB_API_VERSION 710
 #include <foundationdb/fdb_c.h>
 
+#include "com_apple_foundationdb_testing_AbstractWorkload.h"
+#include "com_apple_foundationdb_testing_Promise.h"
+#include "com_apple_foundationdb_testing_WorkloadContext.h"
+
 #include <jni.h>
 #include <set>
 #include <iostream>
@@ -176,9 +180,9 @@ void promiseSend(JNIEnv, jclass, jlong self, jboolean value) {
 
 struct JNIError {
 	JNIEnv* env;
-	jthrowable throwable = nullptr;
-	const char* file;
-	int line;
+	jthrowable throwable{ nullptr };
+	const char* file{ nullptr };
+	int line{ 0 };
 
 	std::string location() const {
 		if (file == nullptr) {

bindings/java/fdbJNI.cpp

@@ -21,6 +21,17 @@
 #include <jni.h>
 #include <string.h>
 
+#include "com_apple_foundationdb_FDB.h"
+#include "com_apple_foundationdb_FDBDatabase.h"
+#include "com_apple_foundationdb_FDBTransaction.h"
+#include "com_apple_foundationdb_FutureInt64.h"
+#include "com_apple_foundationdb_FutureKey.h"
+#include "com_apple_foundationdb_FutureKeyArray.h"
+#include "com_apple_foundationdb_FutureResult.h"
+#include "com_apple_foundationdb_FutureResults.h"
+#include "com_apple_foundationdb_FutureStrings.h"
+#include "com_apple_foundationdb_NativeFuture.h"
+
 #define FDB_API_VERSION 710
 
 #include <foundationdb/fdb_c.h>
@@ -279,9 +290,9 @@ JNIEXPORT jlong JNICALL Java_com_apple_foundationdb_FutureInt64_FutureInt64_1get
 	return (jlong)value;
 }
 
-JNIEXPORT jobject JNICALL Java_com_apple_foundationdb_FutureStrings_FutureStrings_1get(JNIEnv* jenv,
-                                                                                       jobject,
-                                                                                       jlong future) {
+JNIEXPORT jobjectArray JNICALL Java_com_apple_foundationdb_FutureStrings_FutureStrings_1get(JNIEnv* jenv,
+                                                                                            jobject,
+                                                                                            jlong future) {
 	if (!future) {
 		throwParamNotNull(jenv);
 		return JNI_NULL;
@@ -500,7 +511,7 @@ JNIEXPORT jbyteArray JNICALL Java_com_apple_foundationdb_FutureResult_FutureResu
 	return result;
 }
 
-JNIEXPORT jbyteArray JNICALL Java_com_apple_foundationdb_FutureKey_FutureKey_1get(JNIEnv* jenv, jclass, jlong future) {
+JNIEXPORT jbyteArray JNICALL Java_com_apple_foundationdb_FutureKey_FutureKey_1get(JNIEnv* jenv, jobject, jlong future) {
 	if (!future) {
 		throwParamNotNull(jenv);
 		return JNI_NULL;
@@ -756,6 +767,76 @@ JNIEXPORT jlong JNICALL Java_com_apple_foundationdb_FDBTransaction_Transaction_1
 	return (jlong)f;
 }
 
+JNIEXPORT jlong JNICALL
+Java_com_apple_foundationdb_FDBTransaction_Transaction_1getRangeAndFlatMap(JNIEnv* jenv,
+                                                                           jobject,
+                                                                           jlong tPtr,
+                                                                           jbyteArray keyBeginBytes,
+                                                                           jboolean orEqualBegin,
+                                                                           jint offsetBegin,
+                                                                           jbyteArray keyEndBytes,
+                                                                           jboolean orEqualEnd,
+                                                                           jint offsetEnd,
+                                                                           jbyteArray mapperBytes,
+                                                                           jint rowLimit,
+                                                                           jint targetBytes,
+                                                                           jint streamingMode,
+                                                                           jint iteration,
+                                                                           jboolean snapshot,
+                                                                           jboolean reverse) {
+	if (!tPtr || !keyBeginBytes || !keyEndBytes || !mapperBytes) {
+		throwParamNotNull(jenv);
+		return 0;
+	}
+	FDBTransaction* tr = (FDBTransaction*)tPtr;
+
+	uint8_t* barrBegin = (uint8_t*)jenv->GetByteArrayElements(keyBeginBytes, JNI_NULL);
+	if (!barrBegin) {
+		if (!jenv->ExceptionOccurred())
+			throwRuntimeEx(jenv, "Error getting handle to native resources");
+		return 0;
+	}
+
+	uint8_t* barrEnd = (uint8_t*)jenv->GetByteArrayElements(keyEndBytes, JNI_NULL);
+	if (!barrEnd) {
+		jenv->ReleaseByteArrayElements(keyBeginBytes, (jbyte*)barrBegin, JNI_ABORT);
+		if (!jenv->ExceptionOccurred())
+			throwRuntimeEx(jenv, "Error getting handle to native resources");
+		return 0;
+	}
+
+	uint8_t* barrMapper = (uint8_t*)jenv->GetByteArrayElements(mapperBytes, JNI_NULL);
+	if (!barrMapper) {
+		jenv->ReleaseByteArrayElements(keyBeginBytes, (jbyte*)barrBegin, JNI_ABORT);
+		jenv->ReleaseByteArrayElements(keyEndBytes, (jbyte*)barrEnd, JNI_ABORT);
+		if (!jenv->ExceptionOccurred())
+			throwRuntimeEx(jenv, "Error getting handle to native resources");
+		return 0;
+	}
+
+	FDBFuture* f = fdb_transaction_get_range_and_flat_map(tr,
+	                                                      barrBegin,
+	                                                      jenv->GetArrayLength(keyBeginBytes),
+	                                                      orEqualBegin,
+	                                                      offsetBegin,
+	                                                      barrEnd,
+	                                                      jenv->GetArrayLength(keyEndBytes),
+	                                                      orEqualEnd,
+	                                                      offsetEnd,
+	                                                      barrMapper,
+	                                                      jenv->GetArrayLength(mapperBytes),
+	                                                      rowLimit,
+	                                                      targetBytes,
+	                                                      (FDBStreamingMode)streamingMode,
+	                                                      iteration,
+	                                                      snapshot,
+	                                                      reverse);
+	jenv->ReleaseByteArrayElements(keyBeginBytes, (jbyte*)barrBegin, JNI_ABORT);
+	jenv->ReleaseByteArrayElements(keyEndBytes, (jbyte*)barrEnd, JNI_ABORT);
+	jenv->ReleaseByteArrayElements(mapperBytes, (jbyte*)barrMapper, JNI_ABORT);
+	return (jlong)f;
+}
+
 JNIEXPORT void JNICALL Java_com_apple_foundationdb_FutureResults_FutureResults_1getDirect(JNIEnv* jenv,
                                                                                           jobject,
                                                                                           jlong future,

bindings/java/src/integration/com/apple/foundationdb/RangeAndFlatMapQueryIntegrationTest.java

@@ -0,0 +1,256 @@
+/*
+ * RangeAndFlatMapQueryIntegrationTest.java
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2013-2018 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.
+ */
+package com.apple.foundationdb;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.concurrent.atomic.AtomicReference;
+
+import com.apple.foundationdb.async.AsyncIterable;
+import com.apple.foundationdb.async.AsyncUtil;
+import com.apple.foundationdb.tuple.ByteArrayUtil;
+import com.apple.foundationdb.tuple.Tuple;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+@ExtendWith(RequiresDatabase.class)
+class RangeAndFlatMapQueryIntegrationTest {
+	private static final FDB fdb = FDB.selectAPIVersion(710);
+	public String databaseArg = null;
+	private Database openFDB() { return fdb.open(databaseArg); }
+
+	@BeforeEach
+	@AfterEach
+	void clearDatabase() throws Exception {
+		/*
+		 * Empty the database before and after each run, just in case
+		 */
+		try (Database db = openFDB()) {
+			db.run(tr -> {
+				tr.clear(Range.startsWith(new byte[] { (byte)0x00 }));
+				return null;
+			});
+		}
+	}
+
+	static private final byte[] EMPTY = Tuple.from().pack();
+	static private final String PREFIX = "prefix";
+	static private final String RECORD = "RECORD";
+	static private final String INDEX = "INDEX";
+	static private String primaryKey(int i) { return String.format("primary-key-of-record-%08d", i); }
+	static private String indexKey(int i) { return String.format("index-key-of-record-%08d", i); }
+	static private String dataOfRecord(int i) { return String.format("data-of-record-%08d", i); }
+
+	static byte[] MAPPER = Tuple.from(PREFIX, RECORD, "{K[3]}").pack();
+	static private byte[] indexEntryKey(final int i) {
+		return Tuple.from(PREFIX, INDEX, indexKey(i), primaryKey(i)).pack();
+	}
+	static private byte[] recordKey(final int i) { return Tuple.from(PREFIX, RECORD, primaryKey(i)).pack(); }
+	static private byte[] recordValue(final int i) { return Tuple.from(dataOfRecord(i)).pack(); }
+
+	static private void insertRecordWithIndex(final Transaction tr, final int i) {
+		tr.set(indexEntryKey(i), EMPTY);
+		tr.set(recordKey(i), recordValue(i));
+	}
+
+	private static String getArgFromEnv() {
+		String[] clusterFiles = MultiClientHelper.readClusterFromEnv();
+		String cluster = clusterFiles[0];
+		System.out.printf("Using Cluster: %s\n", cluster);
+		return cluster;
+	}
+	public static void main(String[] args) throws Exception {
+		final RangeAndFlatMapQueryIntegrationTest test = new RangeAndFlatMapQueryIntegrationTest();
+		test.databaseArg = getArgFromEnv();
+		test.clearDatabase();
+		test.comparePerformance();
+		test.clearDatabase();
+	}
+
+	int numRecords = 10000;
+	int numQueries = 10000;
+	int numRecordsPerQuery = 100;
+	boolean validate = false;
+	@Test
+	void comparePerformance() {
+		FDB fdb = FDB.selectAPIVersion(710);
+		try (Database db = openFDB()) {
+			insertRecordsWithIndexes(numRecords, db);
+			instrument(rangeQueryAndGet, "rangeQueryAndGet", db);
+			instrument(rangeQueryAndFlatMap, "rangeQueryAndFlatMap", db);
+		}
+	}
+
+	private void instrument(final RangeQueryWithIndex query, final String name, final Database db) {
+		System.out.printf("Starting %s (numQueries:%d, numRecordsPerQuery:%d)\n", name, numQueries, numRecordsPerQuery);
+		long startTime = System.currentTimeMillis();
+		for (int queryId = 0; queryId < numQueries; queryId++) {
+			int begin = ThreadLocalRandom.current().nextInt(numRecords - numRecordsPerQuery);
+			query.run(begin, begin + numRecordsPerQuery, db);
+		}
+		long time = System.currentTimeMillis() - startTime;
+		System.out.printf("Finished %s, it takes %d ms for %d queries (%d qps)\n", name, time, numQueries,
+		                  numQueries * 1000L / time);
+	}
+
+	static private final int RECORDS_PER_TXN = 100;
+	static private void insertRecordsWithIndexes(int n, Database db) {
+		int i = 0;
+		while (i < n) {
+			int begin = i;
+			int end = Math.min(n, i + RECORDS_PER_TXN);
+			// insert [begin, end) in one transaction
+			db.run(tr -> {
+				for (int t = begin; t < end; t++) {
+					insertRecordWithIndex(tr, t);
+				}
+				return null;
+			});
+			i = end;
+		}
+	}
+
+	public interface RangeQueryWithIndex {
+		void run(int begin, int end, Database db);
+	}
+
+	RangeQueryWithIndex rangeQueryAndGet = (int begin, int end, Database db) -> db.run(tr -> {
+		try {
+			List<KeyValue> kvs = tr.getRange(KeySelector.firstGreaterOrEqual(indexEntryKey(begin)),
+			                                 KeySelector.firstGreaterOrEqual(indexEntryKey(end)),
+			                                 ReadTransaction.ROW_LIMIT_UNLIMITED, false, StreamingMode.WANT_ALL)
+			                         .asList()
+			                         .get();
+			Assertions.assertEquals(end - begin, kvs.size());
+
+			// Get the records of each index entry IN PARALLEL.
+			List<CompletableFuture<byte[]>> resultFutures = new ArrayList<>();
+			// In reality, we need to get the record key by parsing the index entry key. But considering this is a
+			// performance test, we just ignore the returned key and simply generate it from recordKey.
+			for (int id = begin; id < end; id++) {
+				resultFutures.add(tr.get(recordKey(id)));
+			}
+			AsyncUtil.whenAll(resultFutures).get();
+
+			if (validate) {
+				final Iterator<KeyValue> indexes = kvs.iterator();
+				final Iterator<CompletableFuture<byte[]>> records = resultFutures.iterator();
+				for (int id = begin; id < end; id++) {
+					Assertions.assertTrue(indexes.hasNext());
+					assertByteArrayEquals(indexEntryKey(id), indexes.next().getKey());
+					Assertions.assertTrue(records.hasNext());
+					assertByteArrayEquals(recordValue(id), records.next().get());
+				}
+				Assertions.assertFalse(indexes.hasNext());
+				Assertions.assertFalse(records.hasNext());
+			}
+		} catch (Exception e) {
+			Assertions.fail("Unexpected exception", e);
+		}
+		return null;
+	});
+
+	RangeQueryWithIndex rangeQueryAndFlatMap = (int begin, int end, Database db) -> db.run(tr -> {
+		try {
+			tr.options().setReadYourWritesDisable();
+			List<KeyValue> kvs =
+			    tr.snapshot()
+			        .getRangeAndFlatMap(KeySelector.firstGreaterOrEqual(indexEntryKey(begin)),
+			                            KeySelector.firstGreaterOrEqual(indexEntryKey(end)), MAPPER,
+			                            ReadTransaction.ROW_LIMIT_UNLIMITED, false, StreamingMode.WANT_ALL)
+			        .asList()
+			        .get();
+			Assertions.assertEquals(end - begin, kvs.size());
+
+			if (validate) {
+				final Iterator<KeyValue> results = kvs.iterator();
+				for (int id = begin; id < end; id++) {
+					Assertions.assertTrue(results.hasNext());
+					assertByteArrayEquals(recordValue(id), results.next().getValue());
+				}
+				Assertions.assertFalse(results.hasNext());
+			}
+		} catch (Exception e) {
+			Assertions.fail("Unexpected exception", e);
+		}
+		return null;
+	});
+
+	void assertByteArrayEquals(byte[] expected, byte[] actual) {
+		Assertions.assertEquals(ByteArrayUtil.printable(expected), ByteArrayUtil.printable(actual));
+	}
+
+	@Test
+	void rangeAndFlatMapQueryOverMultipleRows() throws Exception {
+		try (Database db = openFDB()) {
+			insertRecordsWithIndexes(3, db);
+
+			List<byte[]> expected_data_of_records = new ArrayList<>();
+			for (int i = 0; i <= 1; i++) {
+				expected_data_of_records.add(recordValue(i));
+			}
+
+			db.run(tr -> {
+				// getRangeAndFlatMap is only support without RYW. This is a must!!!
+				tr.options().setReadYourWritesDisable();
+
+				// getRangeAndFlatMap is only supported with snapshot.
+				Iterator<KeyValue> kvs =
+				    tr.snapshot()
+				        .getRangeAndFlatMap(KeySelector.firstGreaterOrEqual(indexEntryKey(0)),
+				                            KeySelector.firstGreaterThan(indexEntryKey(1)), MAPPER,
+				                            ReadTransaction.ROW_LIMIT_UNLIMITED, false, StreamingMode.WANT_ALL)
+				        .iterator();
+				Iterator<byte[]> expected_data_of_records_iter = expected_data_of_records.iterator();
+				while (expected_data_of_records_iter.hasNext()) {
+					Assertions.assertTrue(kvs.hasNext(), "iterator ended too early");
+					KeyValue kv = kvs.next();
+					byte[] actual_data_of_record = kv.getValue();
+					byte[] expected_data_of_record = expected_data_of_records_iter.next();
+
+					// System.out.println("result key:" + ByteArrayUtil.printable(kv.getKey()) + " value:" +
+					// ByteArrayUtil.printable(kv.getValue())); Output:
+					// result
+					// key:\x02prefix\x00\x02INDEX\x00\x02index-key-of-record-0\x00\x02primary-key-of-record-0\x00
+					// value:\x02data-of-record-0\x00
+					// result
+					// key:\x02prefix\x00\x02INDEX\x00\x02index-key-of-record-1\x00\x02primary-key-of-record-1\x00
+					// value:\x02data-of-record-1\x00
+
+					// For now, we don't guarantee what that the returned keys mean.
+					Assertions.assertArrayEquals(expected_data_of_record, actual_data_of_record,
+					                             "Incorrect data of record!");
+				}
+				Assertions.assertFalse(kvs.hasNext(), "Iterator returned too much data");
+
+				return null;
+			});
+		}
+	}
+}

bindings/java/src/junit/com/apple/foundationdb/FakeFDBTransaction.java

@@ -88,8 +88,11 @@ public class FakeFDBTransaction extends FDBTransaction {
 	public int getNumRangeCalls() { return numRangeCalls; }
 
 	@Override
-	protected FutureResults getRange_internal(KeySelector begin, KeySelector end, int rowLimit, int targetBytes,
-	                                          int streamingMode, int iteration, boolean isSnapshot, boolean reverse) {
+	protected FutureResults getRange_internal(KeySelector begin, KeySelector end,
+	                                          // TODO: map is not supported in FakeFDBTransaction yet.
+	                                          byte[] mapper, // Nullable
+	                                          int rowLimit, int targetBytes, int streamingMode, int iteration,
+	                                          boolean isSnapshot, boolean reverse) {
 		numRangeCalls++;
 		// TODO this is probably not correct for all KeySelector instances--we'll want to match with real behavior
 		NavigableMap<byte[], byte[]> range =

bindings/java/src/main/com/apple/foundationdb/FDBTransaction.java

@@ -91,6 +91,15 @@ class FDBTransaction extends NativeObjectWrapper implements Transaction, OptionC
 			return FDBTransaction.this.getRangeSplitPoints(range, chunkSize);
 		}
 
+		@Override
+		public AsyncIterable<KeyValue> getRangeAndFlatMap(KeySelector begin, KeySelector end, byte[] mapper, int limit,
+		                                                  boolean reverse, StreamingMode mode) {
+			if (mapper == null) {
+				throw new IllegalArgumentException("Mapper must be non-null");
+			}
+			return new RangeQuery(FDBTransaction.this, true, begin, end, mapper, limit, reverse, mode, eventKeeper);
+		}
+
 		///////////////////
 		//  getRange -> KeySelectors
 		///////////////////
@@ -338,6 +347,12 @@ class FDBTransaction extends NativeObjectWrapper implements Transaction, OptionC
 		return this.getRangeSplitPoints(range.begin, range.end, chunkSize);
 	}
 
+	@Override
+	public AsyncIterable<KeyValue> getRangeAndFlatMap(KeySelector begin, KeySelector end, byte[] mapper, int limit,
+	                                                  boolean reverse, StreamingMode mode) {
+		throw new UnsupportedOperationException("getRangeAndFlatMap is only supported in snapshot");
+	}
+
 	///////////////////
 	//  getRange -> KeySelectors
 	///////////////////
@@ -415,10 +430,10 @@ class FDBTransaction extends NativeObjectWrapper implements Transaction, OptionC
 	}
 
 	// Users of this function must close the returned FutureResults when finished
-	protected FutureResults getRange_internal(
-					KeySelector begin, KeySelector end, 
-					int rowLimit, int targetBytes, int streamingMode, 
-					int iteration, boolean isSnapshot, boolean reverse) {
+	protected FutureResults getRange_internal(KeySelector begin, KeySelector end,
+	                                          byte[] mapper, // Nullable
+	                                          int rowLimit, int targetBytes, int streamingMode, int iteration,
+	                                          boolean isSnapshot, boolean reverse) {
 		if (eventKeeper != null) {
 			eventKeeper.increment(Events.JNI_CALL);
 		}
@@ -429,10 +444,14 @@ class FDBTransaction extends NativeObjectWrapper implements Transaction, OptionC
 				begin.toString(), end.toString(), rowLimit, targetBytes, streamingMode,
 				iteration, Boolean.toString(isSnapshot), Boolean.toString(reverse)));*/
 			return new FutureResults(
-				Transaction_getRange(getPtr(), begin.getKey(), begin.orEqual(), begin.getOffset(),
-									 end.getKey(), end.orEqual(), end.getOffset(), rowLimit, targetBytes,
-									 streamingMode, iteration, isSnapshot, reverse),
-				FDB.instance().isDirectBufferQueriesEnabled(), executor, eventKeeper);
+			    mapper == null
+			        ? Transaction_getRange(getPtr(), begin.getKey(), begin.orEqual(), begin.getOffset(), end.getKey(),
+			                               end.orEqual(), end.getOffset(), rowLimit, targetBytes, streamingMode,
+			                               iteration, isSnapshot, reverse)
+			        : Transaction_getRangeAndFlatMap(getPtr(), begin.getKey(), begin.orEqual(), begin.getOffset(),
+			                                         end.getKey(), end.orEqual(), end.getOffset(), mapper, rowLimit,
+			                                         targetBytes, streamingMode, iteration, isSnapshot, reverse),
+			    FDB.instance().isDirectBufferQueriesEnabled(), executor, eventKeeper);
 		} finally {
 			pointerReadLock.unlock();
 		}
@@ -771,6 +790,12 @@ class FDBTransaction extends NativeObjectWrapper implements Transaction, OptionC
 			byte[] keyEnd, boolean orEqualEnd, int offsetEnd,
 			int rowLimit, int targetBytes, int streamingMode, int iteration,
 			boolean isSnapshot, boolean reverse);
+	private native long Transaction_getRangeAndFlatMap(long cPtr, byte[] keyBegin, boolean orEqualBegin,
+	                                                   int offsetBegin, byte[] keyEnd, boolean orEqualEnd,
+	                                                   int offsetEnd,
+	                                                   byte[] mapper, // Nonnull
+	                                                   int rowLimit, int targetBytes, int streamingMode, int iteration,
+	                                                   boolean isSnapshot, boolean reverse);
 	private native void Transaction_addConflictRange(long cPtr,
 			byte[] keyBegin, byte[] keyEnd, int conflictRangeType);
 	private native void Transaction_set(long cPtr, byte[] key, byte[] value);

bindings/java/src/main/com/apple/foundationdb/FutureResults.java

@@ -81,6 +81,6 @@ class FutureResults extends NativeFuture<RangeResultInfo> {
 	private boolean enableDirectBufferQueries = false;
 
 	private native RangeResult FutureResults_get(long cPtr) throws FDBException;
-	private native boolean FutureResults_getDirect(long cPtr, ByteBuffer buffer, int capacity)
+	private native void FutureResults_getDirect(long cPtr, ByteBuffer buffer, int capacity)
 		throws FDBException;
 }

bindings/java/src/main/com/apple/foundationdb/RangeQuery.java

@@ -49,17 +49,19 @@ class RangeQuery implements AsyncIterable<KeyValue> {
 	private final FDBTransaction tr;
 	private final KeySelector begin;
 	private final KeySelector end;
+	private final byte[] mapper; // Nullable
 	private final boolean snapshot;
 	private final int rowLimit;
 	private final boolean reverse;
 	private final StreamingMode streamingMode;
 	private final EventKeeper eventKeeper;
 
-	RangeQuery(FDBTransaction transaction, boolean isSnapshot, KeySelector begin, KeySelector end, int rowLimit,
-			boolean reverse, StreamingMode streamingMode, EventKeeper eventKeeper) {
+	RangeQuery(FDBTransaction transaction, boolean isSnapshot, KeySelector begin, KeySelector end, byte[] mapper,
+	           int rowLimit, boolean reverse, StreamingMode streamingMode, EventKeeper eventKeeper) {
 		this.tr = transaction;
 		this.begin = begin;
 		this.end = end;
+		this.mapper = mapper;
 		this.snapshot = isSnapshot;
 		this.rowLimit = rowLimit;
 		this.reverse = reverse;
@@ -67,6 +69,12 @@ class RangeQuery implements AsyncIterable<KeyValue> {
 		this.eventKeeper = eventKeeper;
 	}
 
+	// RangeQueryAndFlatMap
+	RangeQuery(FDBTransaction transaction, boolean isSnapshot, KeySelector begin, KeySelector end, int rowLimit,
+	           boolean reverse, StreamingMode streamingMode, EventKeeper eventKeeper) {
+		this(transaction, isSnapshot, begin, end, null, rowLimit, reverse, streamingMode, eventKeeper);
+	}
+
 	/**
 	 * Returns all the results from the range requested as a {@code List}. If there were no
 	 *  limits on the original query and there is a large amount of data in the database
@@ -83,16 +91,16 @@ class RangeQuery implements AsyncIterable<KeyValue> {
 
 		// if the streaming mode is EXACT, try and grab things as one chunk
 		if(mode == StreamingMode.EXACT) {
-			FutureResults range = tr.getRange_internal(
-					this.begin, this.end, this.rowLimit, 0, StreamingMode.EXACT.code(),
-					1, this.snapshot, this.reverse);
+
+			FutureResults range = tr.getRange_internal(this.begin, this.end, this.mapper, this.rowLimit, 0,
+			                                           StreamingMode.EXACT.code(), 1, this.snapshot, this.reverse);
 			return range.thenApply(result -> result.get().values)
 					.whenComplete((result, e) -> range.close());
 		}
 
 		// If the streaming mode is not EXACT, simply collect the results of an
 		// iteration into a list
-		return AsyncUtil.collect(new RangeQuery(tr, snapshot, begin, end, rowLimit, reverse, mode, eventKeeper),
+		return AsyncUtil.collect(new RangeQuery(tr, snapshot, begin, end, mapper, rowLimit, reverse, mode, eventKeeper),
 		                         tr.getExecutor());
 	}
 
@@ -221,8 +229,8 @@ class RangeQuery implements AsyncIterable<KeyValue> {
 
 			nextFuture = new CompletableFuture<>();
 			final long sTime = System.nanoTime();
-			fetchingChunk = tr.getRange_internal(begin, end, rowsLimited ? rowsRemaining : 0, 0, streamingMode.code(),
-					++iteration, snapshot, reverse);
+			fetchingChunk = tr.getRange_internal(begin, end, mapper, rowsLimited ? rowsRemaining : 0, 0,
+			                                     streamingMode.code(), ++iteration, snapshot, reverse);
 
 			BiConsumer<RangeResultInfo,Throwable> cons = new FetchComplete(fetchingChunk,nextFuture);
 			if(eventKeeper!=null){

bindings/java/src/main/com/apple/foundationdb/ReadTransaction.java

@@ -424,6 +424,41 @@ public interface ReadTransaction extends ReadTransactionContext {
 	AsyncIterable<KeyValue> getRange(Range range,
 			int limit, boolean reverse, StreamingMode mode);
 
+	/**
+	 * WARNING: This feature is considered experimental at this time. It is only allowed when using snapshot isolation
+	 * AND disabling read-your-writes.
+	 *
+	 * @see KeySelector
+	 * @see AsyncIterator
+	 *
+	 * @param begin the beginning of the range (inclusive)
+	 * @param end the end of the range (exclusive)
+	 * @param mapper TODO
+	 * @param limit the maximum number of results to return. Limits results to the
+	 *  <i>first</i> keys in the range. Pass {@link #ROW_LIMIT_UNLIMITED} if this query
+	 *  should not limit the number of results. If {@code reverse} is {@code true} rows
+	 *  will be limited starting at the end of the range.
+	 * @param reverse return results starting at the end of the range in reverse order.
+	 *  Reading ranges in reverse is supported natively by the database and should
+	 *  have minimal extra cost.
+	 * @param mode provide a hint about how the results are to be used. This
+	 *  can provide speed improvements or efficiency gains based on the caller's
+	 *  knowledge of the upcoming access pattern.
+	 *
+	 * <p>
+	 *     When converting the result of this query to a list using {@link AsyncIterable#asList()} with the {@code
+	 * ITERATOR} streaming mode, the query is automatically modified to fetch results in larger batches. This is done
+	 * because it is known in advance that the {@link AsyncIterable#asList()} function will fetch all results in the
+	 * range. If a limit is specified, the {@code EXACT} streaming mode will be used, and otherwise it will use {@code
+	 * WANT_ALL}.
+	 *
+	 *     To achieve comparable performance when iterating over an entire range without using {@link
+	 * AsyncIterable#asList()}, the same streaming mode would need to be used.
+	 * </p>
+	 * @return a handle to access the results of the asynchronous call
+	 */
+	AsyncIterable<KeyValue> getRangeAndFlatMap(KeySelector begin, KeySelector end, byte[] mapper, int limit,
+	                                           boolean reverse, StreamingMode mode);
 
 	/**
 	 * Gets an estimate for the number of bytes stored in the given range.

bindings/java/src/tests.cmake

@@ -52,6 +52,7 @@ set(JAVA_INTEGRATION_TESTS
   src/integration/com/apple/foundationdb/CycleMultiClientIntegrationTest.java
   src/integration/com/apple/foundationdb/SidebandMultiThreadClientTest.java
   src/integration/com/apple/foundationdb/RepeatableReadMultiThreadClientTest.java
+  src/integration/com/apple/foundationdb/RangeAndFlatMapQueryIntegrationTest.java
 )
 
 # Resources that are used in integration testing, but are not explicitly test files (JUnit rules,

bindings/python/CMakeLists.txt

@@ -85,29 +85,27 @@ if (NOT WIN32 AND NOT OPEN_FOR_IDE)
   add_fdbclient_test(
     NAME multi_process_fdbcli_tests
     PROCESS_NUMBER 5
-    TEST_TIMEOUT 120 # The test can take near to 1 minutes sometime, set timeout to 2 minutes to be safe
     COMMAND ${CMAKE_SOURCE_DIR}/bindings/python/tests/fdbcli_tests.py
             ${CMAKE_BINARY_DIR}
             @CLUSTER_FILE@
             5
             )
-  if (TARGET external_client) # external_client copies fdb_c to bindings/c/libfdb_c.so
+  if (TARGET external_client) # external_client copies fdb_c to bindings/c/libfdb_c_external.so
     add_fdbclient_test(
     NAME single_process_external_client_fdbcli_tests
     COMMAND ${CMAKE_SOURCE_DIR}/bindings/python/tests/fdbcli_tests.py
             ${CMAKE_BINARY_DIR}
             @CLUSTER_FILE@
-            --external-client-library ${CMAKE_BINARY_DIR}/bindings/c/libfdb_c.so
+            --external-client-library ${CMAKE_BINARY_DIR}/bindings/c/libfdb_c_external.so
             )
     add_fdbclient_test(
     NAME multi_process_external_client_fdbcli_tests
     PROCESS_NUMBER 5
-    TEST_TIMEOUT 120 # The test can take near to 1 minutes sometime, set timeout to 2 minutes to be safe
     COMMAND ${CMAKE_SOURCE_DIR}/bindings/python/tests/fdbcli_tests.py
             ${CMAKE_BINARY_DIR}
             @CLUSTER_FILE@
             5
-            --external-client-library ${CMAKE_BINARY_DIR}/bindings/c/libfdb_c.so
+            --external-client-library ${CMAKE_BINARY_DIR}/bindings/c/libfdb_c_external.so
             )
   endif()
 endif()

bindings/python/tests/fdbcli_tests.py

@@ -188,7 +188,7 @@ def kill(logger):
     # and then specify the certain process to kill
     process = subprocess.Popen(command_template[:-1], stdin=subprocess.PIPE, stdout=subprocess.PIPE, env=fdbcli_env)
     #
-    output2, err = process.communicate(input='kill; kill {}\n'.format(address).encode())
+    output2, err = process.communicate(input='kill; kill {}; sleep 1\n'.format(address).encode())
     logger.debug(output2)
     # wait for a second for the cluster recovery
     time.sleep(1)
@@ -218,7 +218,7 @@ def suspend(logger):
     logger.debug("Pid: {}".format(pid))
     process = subprocess.Popen(command_template[:-1], stdin=subprocess.PIPE, stdout=subprocess.PIPE, env=fdbcli_env)
     # suspend the process for enough long time
-    output2, err = process.communicate(input='suspend; suspend 3600 {}\n'.format(address).encode())
+    output2, err = process.communicate(input='suspend; suspend 3600 {}; sleep 1\n'.format(address).encode())
     # the cluster should be unavailable after the only process being suspended
     assert not get_value_from_status_json(False, 'client', 'database_status', 'available')
     # check the process pid still exists
@@ -503,6 +503,18 @@ def profile(logger):
     assert run_fdbcli_command('profile', 'client', 'get') == default_profile_client_get_output
 
 
+@enable_logging()
+def test_available(logger):
+    duration = 0  # seconds we already wait
+    while not get_value_from_status_json(False, 'client', 'database_status', 'available') and duration < 10:
+        logger.debug("Sleep for 1 second to wait cluster recovery")
+        time.sleep(1)
+        duration += 1
+    if duration >= 10:
+        logger.debug(run_fdbcli_command('status', 'json'))
+        assert False
+
+
 @enable_logging()
 def triggerddteaminfolog(logger):
     # this command is straightforward and only has one code path
@@ -538,6 +550,7 @@ if __name__ == '__main__':
     command_template = [args.build_dir + '/bin/fdbcli', '-C', args.cluster_file, '--exec']
     # tests for fdbcli commands
     # assertions will fail if fdbcli does not work as expected
+    test_available()
     if args.process_number == 1:
         # TODO: disable for now, the change can cause the database unavailable
         # advanceversion()

cmake/AddFdbTest.cmake

@@ -438,7 +438,7 @@ function(add_fdbclient_test)
     set_tests_properties("${T_NAME}" PROPERTIES TIMEOUT ${T_TEST_TIMEOUT})
   else()
     # default timeout
-    set_tests_properties("${T_NAME}" PROPERTIES TIMEOUT 60)
+    set_tests_properties("${T_NAME}" PROPERTIES TIMEOUT 300)
   endif()
   set_tests_properties("${T_NAME}" PROPERTIES ENVIRONMENT UBSAN_OPTIONS=print_stacktrace=1:halt_on_error=1)
 endfunction()

cmake/CompileBoost.cmake

@@ -49,8 +49,8 @@ function(compile_boost)
   include(ExternalProject)
   set(BOOST_INSTALL_DIR "${CMAKE_BINARY_DIR}/boost_install")
   ExternalProject_add("${COMPILE_BOOST_TARGET}Project"
-    URL "https://boostorg.jfrog.io/artifactory/main/release/1.72.0/source/boost_1_72_0.tar.bz2"
-    URL_HASH SHA256=59c9b274bc451cf91a9ba1dd2c7fdcaf5d60b1b3aa83f2c9fa143417cc660722
+    URL "https://boostorg.jfrog.io/artifactory/main/release/1.77.0/source/boost_1_77_0.tar.bz2"
+    URL_HASH SHA256=fc9f85fc030e233142908241af7a846e60630aa7388de9a5fafb1f3a26840854
     CONFIGURE_COMMAND ${BOOTSTRAP_COMMAND} ${BOOTSTRAP_ARGS} --with-libraries=${BOOTSTRAP_LIBRARIES} --with-toolset=${BOOST_TOOLSET}
     BUILD_COMMAND ${B2_COMMAND} link=static ${COMPILE_BOOST_BUILD_ARGS} --prefix=${BOOST_INSTALL_DIR} ${USER_CONFIG_FLAG} install
     BUILD_IN_SOURCE ON
@@ -113,7 +113,7 @@ if(WIN32)
   return()
 endif()
 
-find_package(Boost 1.72.0 EXACT QUIET COMPONENTS context CONFIG PATHS ${BOOST_HINT_PATHS})
+find_package(Boost 1.77.0 EXACT QUIET COMPONENTS context CONFIG PATHS ${BOOST_HINT_PATHS})
 set(FORCE_BOOST_BUILD OFF CACHE BOOL "Forces cmake to build boost and ignores any installed boost")
 
 if(Boost_FOUND AND NOT FORCE_BOOST_BUILD)

cmake/ConfigureCompiler.cmake

@@ -283,19 +283,11 @@ else()
       -Woverloaded-virtual
       -Wshift-sign-overflow
       # Here's the current set of warnings we need to explicitly disable to compile warning-free with clang 11
-      -Wno-comment
-      -Wno-delete-non-virtual-dtor
-      -Wno-format
-      -Wno-mismatched-tags
-      -Wno-missing-field-initializers
       -Wno-sign-compare
-      -Wno-tautological-pointer-compare
       -Wno-undefined-var-template
-      -Wno-unknown-pragmas
       -Wno-unknown-warning-option
-      -Wno-unused-function
-      -Wno-unused-local-typedef
       -Wno-unused-parameter
+      -Wno-constant-logical-operand
       )
     if (USE_CCACHE)
       add_compile_options(
@@ -321,7 +313,7 @@ else()
     -fvisibility=hidden
     -Wreturn-type
     -fPIC)
-  if (CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "^x86")
+  if (CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "^x86" AND NOT CLANG)
     add_compile_options($<$<COMPILE_LANGUAGE:CXX>:-Wclass-memaccess>)
   endif()
   if (GPERFTOOLS_FOUND AND GCC)
@@ -347,9 +339,19 @@ else()
     set(DTRACE_PROBES 1)
   endif()
 
-  if(CMAKE_COMPILER_IS_GNUCXX)
-    set(USE_LTO OFF CACHE BOOL "Do link time optimization")
-    if (USE_LTO)
+  set(USE_LTO OFF CACHE BOOL "Do link time optimization")
+  if (USE_LTO)
+    if (CLANG)
+      set(CLANG_LTO_STRATEGY "Thin" CACHE STRING "LLVM LTO strategy (Thin, or Full)")
+      if (CLANG_LTO_STRATEGY STREQUAL "Full")
+        add_compile_options($<$<CONFIG:Release>:-flto=full>)
+      else()
+        add_compile_options($<$<CONFIG:Release>:-flto=thin>)
+      endif()
+      set(CMAKE_RANLIB "llvm-ranlib")
+      set(CMAKE_AR "llvm-ar")
+    endif()
+    if(CMAKE_COMPILER_IS_GNUCXX)
       add_compile_options($<$<CONFIG:Release>:-flto>)
       set(CMAKE_AR  "gcc-ar")
       set(CMAKE_C_ARCHIVE_CREATE "<CMAKE_AR> qcs <TARGET> <LINK_FLAGS> <OBJECTS>")

cmake/FDBComponents.cmake

@@ -29,13 +29,6 @@ else()
   if(OPENSSL_FOUND)
     set(CMAKE_REQUIRED_INCLUDES ${OPENSSL_INCLUDE_DIR})
     set(WITH_TLS ON)
-    add_compile_options(-DHAVE_OPENSSL)
-    check_symbol_exists("OPENSSL_INIT_NO_ATEXIT" "openssl/crypto.h" OPENSSL_HAS_NO_ATEXIT)
-    if(OPENSSL_HAS_NO_ATEXIT)
-      add_compile_options(-DHAVE_OPENSSL_INIT_NO_AT_EXIT)
-    else()
-      message(STATUS "Found OpenSSL without OPENSSL_INIT_NO_ATEXIT: assuming BoringSSL")
-    endif()
   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")
@@ -202,6 +195,21 @@ else()
   target_include_directories(toml11_target SYSTEM INTERFACE ${CMAKE_CURRENT_BINARY_DIR}/toml11/include)
 endif()
 
+################################################################################
+# Coroutine implementation
+################################################################################
+
+set(DEFAULT_COROUTINE_IMPL boost)
+if(WIN32)
+  # boost coroutine not available in windows build environment for now.
+  set(DEFAULT_COROUTINE_IMPL libcoro)
+elseif(NOT APPLE AND NOT USE_SANITIZER AND CMAKE_HOST_SYSTEM_PROCESSOR MATCHES "^x86")
+  # revert to libcoro for x86 linux while we investigate a performance regression
+  set(DEFAULT_COROUTINE_IMPL libcoro)
+endif()
+
+set(COROUTINE_IMPL ${DEFAULT_COROUTINE_IMPL} CACHE STRING "Which coroutine implementation to use. Options are boost and libcoro")
+
 ################################################################################
 
 file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/packages)

cmake/Sandbox.conf.cmake

@@ -7,32 +7,32 @@
 [fdbmonitor]
 
 [general]
-restart_delay = 10
-## by default, restart_backoff = restart_delay_reset_interval = restart_delay
-# initial_restart_delay = 0
-# restart_backoff = 60
-# restart_delay_reset_interval = 60
-cluster_file = ${CMAKE_BINARY_DIR}/fdb.cluster
-# delete_envvars =
-# kill_on_configuration_change = true
+restart-delay = 10
+## by default, restart-backoff = restart-delay-reset-interval = restart-delay
+# initial-restart-delay = 0
+# restart-backoff = 60
+# restart-delay-reset-interval = 60
+cluster-file = ${CMAKE_BINARY_DIR}/fdb.cluster
+# delete-envvars =
+# kill-on-configuration-change = true
 
 ## Default parameters for individual fdbserver processes
 [fdbserver]
 command = ${CMAKE_BINARY_DIR}/bin/fdbserver
-public_address = auto:$ID
-listen_address = public
+public-address = auto:$ID
+listen-address = public
 datadir = ${CMAKE_BINARY_DIR}/sandbox/data/$ID
 logdir = ${CMAKE_BINARY_DIR}/sandbox/logs
 # logsize = 10MiB
 # maxlogssize = 100MiB
-# machine_id =
-# datacenter_id =
+# machine-id =
+# datacenter-id =
 # class =
 # memory = 8GiB
-# storage_memory = 1GiB
-# cache_memory = 2GiB
-# metrics_cluster =
-# metrics_prefix =
+# storage-memory = 1GiB
+# cache-memory = 2GiB
+# metrics-cluster =
+# metrics-prefix =
 
 ## An individual fdbserver process with id 4000
 ## Parameters set here override defaults from the [fdbserver] section

contrib/CMakeLists.txt

@@ -1,3 +1,4 @@
+add_subdirectory(fmt-8.0.1)
 if(NOT WIN32)
   add_subdirectory(monitoring)
   add_subdirectory(TraceLogHelper)

contrib/Joshua/scripts/localClusterStart.sh

@@ -242,7 +242,7 @@ function startFdbServer
     let status="${status} + 1"
 
   else
-    "${BINDIR}/fdbserver" --knob_disable_posix_kernel_aio=1 -C "${FDBCONF}" -p "${FDBCLUSTERTEXT}" -L "${LOGDIR}" -d "${WORKDIR}/fdb/${$}" &> "${LOGDIR}/fdbserver.log" &
+    "${BINDIR}/fdbserver" --knob-disable-posix-kernel-aio=1 -C "${FDBCONF}" -p "${FDBCLUSTERTEXT}" -L "${LOGDIR}" -d "${WORKDIR}/fdb/${$}" &> "${LOGDIR}/fdbserver.log" &
     if [ "${?}" -ne 0 ]
     then
         log "Failed to start FDB Server"

contrib/TestHarness/Program.cs.cmake

@@ -440,6 +440,7 @@ namespace SummarizeTest
                     string tlsPluginArg = "";
                     if (tlsPluginFile.Length > 0) {
                         process.StartInfo.EnvironmentVariables["FDB_TLS_PLUGIN"] = tlsPluginFile;
+                        // Use the old-style option with underscores because old binaries do not support hyphens
                         tlsPluginArg = "--tls_plugin=" + tlsPluginFile;
                     }
                     process.StartInfo.RedirectStandardOutput = true;

contrib/fmt-8.0.1/.clang-format

@@ -0,0 +1 @@
+DisableFormat: true

contrib/fmt-8.0.1/CMakeLists.txt

@@ -0,0 +1,410 @@
+cmake_minimum_required(VERSION 3.1...3.18)
+
+# Fallback for using newer policies on CMake <3.12.
+if(${CMAKE_VERSION} VERSION_LESS 3.12)
+  cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
+endif()
+
+# Determine if fmt is built as a subproject (using add_subdirectory)
+# or if it is the master project.
+if (NOT DEFINED FMT_MASTER_PROJECT)
+  set(FMT_MASTER_PROJECT OFF)
+  if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+    set(FMT_MASTER_PROJECT ON)
+    message(STATUS "CMake version: ${CMAKE_VERSION}")
+  endif ()
+endif ()
+
+# Joins arguments and places the results in ${result_var}.
+function(join result_var)
+  set(result "")
+  foreach (arg ${ARGN})
+    set(result "${result}${arg}")
+  endforeach ()
+  set(${result_var} "${result}" PARENT_SCOPE)
+endfunction()
+
+function(enable_module target)
+  if (MSVC)
+    set(BMI ${CMAKE_CURRENT_BINARY_DIR}/${target}.ifc)
+    target_compile_options(${target}
+      PRIVATE /interface /ifcOutput ${BMI}
+      INTERFACE /reference fmt=${BMI})
+  endif ()
+  set_target_properties(${target} PROPERTIES ADDITIONAL_CLEAN_FILES ${BMI})
+  set_source_files_properties(${BMI} PROPERTIES GENERATED ON)
+endfunction()
+
+include(CMakeParseArguments)
+
+# Sets a cache variable with a docstring joined from multiple arguments:
+#   set(<variable> <value>... CACHE <type> <docstring>...)
+# This allows splitting a long docstring for readability.
+function(set_verbose)
+  # cmake_parse_arguments is broken in CMake 3.4 (cannot parse CACHE) so use
+  # list instead.
+  list(GET ARGN 0 var)
+  list(REMOVE_AT ARGN 0)
+  list(GET ARGN 0 val)
+  list(REMOVE_AT ARGN 0)
+  list(REMOVE_AT ARGN 0)
+  list(GET ARGN 0 type)
+  list(REMOVE_AT ARGN 0)
+  join(doc ${ARGN})
+  set(${var} ${val} CACHE ${type} ${doc})
+endfunction()
+
+# Set the default CMAKE_BUILD_TYPE to Release.
+# This should be done before the project command since the latter can set
+# CMAKE_BUILD_TYPE itself (it does so for nmake).
+if (FMT_MASTER_PROJECT AND NOT CMAKE_BUILD_TYPE)
+  set_verbose(CMAKE_BUILD_TYPE Release CACHE STRING
+              "Choose the type of build, options are: None(CMAKE_CXX_FLAGS or "
+              "CMAKE_C_FLAGS used) Debug Release RelWithDebInfo MinSizeRel.")
+endif ()
+
+project(FMT CXX)
+include(GNUInstallDirs)
+set_verbose(FMT_INC_DIR ${CMAKE_INSTALL_INCLUDEDIR} CACHE STRING
+            "Installation directory for include files, a relative path that "
+            "will be joined with ${CMAKE_INSTALL_PREFIX} or an absolute path.")
+
+option(FMT_PEDANTIC "Enable extra warnings and expensive tests." OFF)
+option(FMT_WERROR "Halt the compilation with an error on compiler warnings."
+       OFF)
+
+# Options that control generation of various targets.
+option(FMT_DOC "Generate the doc target." ${FMT_MASTER_PROJECT})
+option(FMT_INSTALL "Generate the install target." ${FMT_MASTER_PROJECT})
+option(FMT_TEST "Generate the test target." ${FMT_MASTER_PROJECT})
+option(FMT_FUZZ "Generate the fuzz target." OFF)
+option(FMT_CUDA_TEST "Generate the cuda-test target." OFF)
+option(FMT_OS "Include core requiring OS (Windows/Posix) " ON)
+option(FMT_MODULE "Build a module instead of a traditional library." OFF)
+
+set(FMT_CAN_MODULE OFF)
+if (CMAKE_CXX_STANDARD GREATER 17 AND
+    # msvc 16.10-pre4
+    MSVC AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 19.29.30035)
+  set(FMT_CAN_MODULE ON)
+endif ()
+if (NOT FMT_CAN_MODULE)
+  set(FMT_MODULE OFF)
+  message(STATUS "Module support is disabled.")
+endif ()
+if (FMT_TEST AND FMT_MODULE)
+  # The tests require {fmt} to be compiled as traditional library
+  message(STATUS "Testing is incompatible with build mode 'module'.")
+endif ()
+
+# Get version from core.h
+file(READ include/fmt/core.h core_h)
+if (NOT core_h MATCHES "FMT_VERSION ([0-9]+)([0-9][0-9])([0-9][0-9])")
+  message(FATAL_ERROR "Cannot get FMT_VERSION from core.h.")
+endif ()
+# Use math to skip leading zeros if any.
+math(EXPR CPACK_PACKAGE_VERSION_MAJOR ${CMAKE_MATCH_1})
+math(EXPR CPACK_PACKAGE_VERSION_MINOR ${CMAKE_MATCH_2})
+math(EXPR CPACK_PACKAGE_VERSION_PATCH ${CMAKE_MATCH_3})
+join(FMT_VERSION ${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.
+                 ${CPACK_PACKAGE_VERSION_PATCH})
+message(STATUS "Version: ${FMT_VERSION}")
+
+message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
+
+if (NOT CMAKE_RUNTIME_OUTPUT_DIRECTORY)
+  set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin)
+endif ()
+
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH}
+  "${CMAKE_CURRENT_SOURCE_DIR}/support/cmake")
+
+include(cxx14)
+include(CheckCXXCompilerFlag)
+include(JoinPaths)
+
+list(FIND CMAKE_CXX_COMPILE_FEATURES "cxx_variadic_templates" index)
+if (${index} GREATER -1)
+  # Use cxx_variadic_templates instead of more appropriate cxx_std_11 for
+  # compatibility with older CMake versions.
+  set(FMT_REQUIRED_FEATURES cxx_variadic_templates)
+endif ()
+message(STATUS "Required features: ${FMT_REQUIRED_FEATURES}")
+
+if (FMT_MASTER_PROJECT AND NOT DEFINED CMAKE_CXX_VISIBILITY_PRESET)
+  set_verbose(CMAKE_CXX_VISIBILITY_PRESET hidden CACHE STRING
+              "Preset for the export of private symbols")
+  set_property(CACHE CMAKE_CXX_VISIBILITY_PRESET PROPERTY STRINGS
+               hidden default)
+endif ()
+
+if (FMT_MASTER_PROJECT AND NOT DEFINED CMAKE_VISIBILITY_INLINES_HIDDEN)
+  set_verbose(CMAKE_VISIBILITY_INLINES_HIDDEN ON CACHE BOOL
+              "Whether to add a compile flag to hide symbols of inline functions")
+endif ()
+
+if (CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+  set(PEDANTIC_COMPILE_FLAGS -pedantic-errors -Wall -Wextra -pedantic
+      -Wold-style-cast -Wundef
+      -Wredundant-decls -Wwrite-strings -Wpointer-arith
+      -Wcast-qual -Wformat=2 -Wmissing-include-dirs
+      -Wcast-align
+      -Wctor-dtor-privacy -Wdisabled-optimization
+      -Winvalid-pch -Woverloaded-virtual
+      -Wconversion -Wswitch-enum -Wundef
+      -Wno-ctor-dtor-privacy -Wno-format-nonliteral)
+  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.6)
+      set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS}
+         -Wno-dangling-else -Wno-unused-local-typedefs)
+  endif ()
+  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0)
+      set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wdouble-promotion
+          -Wtrampolines -Wzero-as-null-pointer-constant -Wuseless-cast
+          -Wvector-operation-performance -Wsized-deallocation -Wshadow)
+  endif ()
+  if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 6.0)
+      set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wshift-overflow=2
+          -Wnull-dereference -Wduplicated-cond)
+  endif ()
+  set(WERROR_FLAG -Werror)
+endif ()
+
+if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+  set(PEDANTIC_COMPILE_FLAGS -Wall -Wextra -pedantic -Wconversion -Wundef
+      -Wdeprecated -Wweak-vtables -Wshadow
+      -Wno-gnu-zero-variadic-macro-arguments)
+  check_cxx_compiler_flag(-Wzero-as-null-pointer-constant HAS_NULLPTR_WARNING)
+  if (HAS_NULLPTR_WARNING)
+    set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS}
+        -Wzero-as-null-pointer-constant)
+  endif ()
+  set(WERROR_FLAG -Werror)
+endif ()
+
+if (MSVC)
+  set(PEDANTIC_COMPILE_FLAGS /W3)
+  set(WERROR_FLAG /WX)
+endif ()
+
+if (FMT_MASTER_PROJECT AND CMAKE_GENERATOR MATCHES "Visual Studio")
+  # If Microsoft SDK is installed create script run-msbuild.bat that
+  # calls SetEnv.cmd to set up build environment and runs msbuild.
+  # It is useful when building Visual Studio projects with the SDK
+  # toolchain rather than Visual Studio.
+  include(FindSetEnv)
+  if (WINSDK_SETENV)
+    set(MSBUILD_SETUP "call \"${WINSDK_SETENV}\"")
+  endif ()
+  # Set FrameworkPathOverride to get rid of MSB3644 warnings.
+  join(netfxpath
+       "C:\\Program Files\\Reference Assemblies\\Microsoft\\Framework\\"
+       ".NETFramework\\v4.0")
+  file(WRITE run-msbuild.bat "
+    ${MSBUILD_SETUP}
+    ${CMAKE_MAKE_PROGRAM} -p:FrameworkPathOverride=\"${netfxpath}\" %*")
+endif ()
+
+set(strtod_l_headers stdlib.h)
+if (APPLE)
+  set(strtod_l_headers ${strtod_l_headers} xlocale.h)
+endif ()
+
+include(CheckSymbolExists)
+if (WIN32)
+  check_symbol_exists(_strtod_l "${strtod_l_headers}" HAVE_STRTOD_L)
+else ()
+  check_symbol_exists(strtod_l "${strtod_l_headers}" HAVE_STRTOD_L)
+endif ()
+
+function(add_headers VAR)
+  set(headers ${${VAR}})
+  foreach (header ${ARGN})
+    set(headers ${headers} include/fmt/${header})
+  endforeach()
+  set(${VAR} ${headers} PARENT_SCOPE)
+endfunction()
+
+# Define the fmt library, its includes and the needed defines.
+add_headers(FMT_HEADERS args.h chrono.h color.h compile.h core.h format.h
+                        format-inl.h locale.h os.h ostream.h printf.h ranges.h
+                        xchar.h)
+if (FMT_MODULE)
+  set(FMT_SOURCES src/fmt.cc)
+elseif (FMT_OS)
+  set(FMT_SOURCES src/format.cc src/os.cc)
+else()
+  set(FMT_SOURCES src/format.cc)
+endif ()
+
+add_library(fmt ${FMT_SOURCES} ${FMT_HEADERS})
+add_library(fmt::fmt ALIAS fmt)
+
+if (HAVE_STRTOD_L)
+  target_compile_definitions(fmt PUBLIC FMT_LOCALE)
+endif ()
+
+if (MINGW)
+  check_cxx_compiler_flag("Wa,-mbig-obj" FMT_HAS_MBIG_OBJ)
+  if (${FMT_HAS_MBIG_OBJ})
+    target_compile_options(fmt PUBLIC "-Wa,-mbig-obj")
+  endif()
+endif ()
+
+if (FMT_WERROR)
+  target_compile_options(fmt PRIVATE ${WERROR_FLAG})
+endif ()
+if (FMT_PEDANTIC)
+  target_compile_options(fmt PRIVATE ${PEDANTIC_COMPILE_FLAGS})
+endif ()
+if (FMT_MODULE)
+  enable_module(fmt)
+endif ()
+
+target_compile_features(fmt INTERFACE ${FMT_REQUIRED_FEATURES})
+
+target_include_directories(fmt PUBLIC
+  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
+  $<INSTALL_INTERFACE:${FMT_INC_DIR}>)
+
+set(FMT_DEBUG_POSTFIX d CACHE STRING "Debug library postfix.")
+
+set_target_properties(fmt PROPERTIES
+  VERSION ${FMT_VERSION} SOVERSION ${CPACK_PACKAGE_VERSION_MAJOR}
+  DEBUG_POSTFIX "${FMT_DEBUG_POSTFIX}")
+
+# Set FMT_LIB_NAME for pkg-config fmt.pc. We cannot use the OUTPUT_NAME target
+# property because it's not set by default.
+set(FMT_LIB_NAME fmt)
+if (CMAKE_BUILD_TYPE STREQUAL "Debug")
+  set(FMT_LIB_NAME ${FMT_LIB_NAME}${FMT_DEBUG_POSTFIX})
+endif ()
+
+if (BUILD_SHARED_LIBS)
+  if (UNIX AND NOT APPLE AND NOT ${CMAKE_SYSTEM_NAME} MATCHES "SunOS" AND
+      NOT EMSCRIPTEN)
+    # Fix rpmlint warning:
+    # unused-direct-shlib-dependency /usr/lib/libformat.so.1.1.0 /lib/libm.so.6.
+    target_link_libraries(fmt -Wl,--as-needed)
+  endif ()
+  target_compile_definitions(fmt PRIVATE FMT_EXPORT INTERFACE FMT_SHARED)
+endif ()
+if (FMT_SAFE_DURATION_CAST)
+  target_compile_definitions(fmt PUBLIC FMT_SAFE_DURATION_CAST)
+endif()
+
+add_library(fmt-header-only INTERFACE)
+add_library(fmt::fmt-header-only ALIAS fmt-header-only)
+
+target_compile_definitions(fmt-header-only INTERFACE FMT_HEADER_ONLY=1)
+target_compile_features(fmt-header-only INTERFACE ${FMT_REQUIRED_FEATURES})
+
+target_include_directories(fmt-header-only INTERFACE
+  $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
+  $<INSTALL_INTERFACE:${FMT_INC_DIR}>)
+
+# Install targets.
+if (FMT_INSTALL)
+  include(CMakePackageConfigHelpers)
+  set_verbose(FMT_CMAKE_DIR ${CMAKE_INSTALL_LIBDIR}/cmake/fmt CACHE STRING
+              "Installation directory for cmake files, a relative path that "
+              "will be joined with ${CMAKE_INSTALL_PREFIX} or an absolute "
+              "path.")
+  set(version_config ${PROJECT_BINARY_DIR}/fmt-config-version.cmake)
+  set(project_config ${PROJECT_BINARY_DIR}/fmt-config.cmake)
+  set(pkgconfig ${PROJECT_BINARY_DIR}/fmt.pc)
+  set(targets_export_name fmt-targets)
+
+  set_verbose(FMT_LIB_DIR ${CMAKE_INSTALL_LIBDIR} CACHE STRING
+              "Installation directory for libraries, a relative path that "
+              "will be joined to ${CMAKE_INSTALL_PREFIX} or an absolute path.")
+
+  set_verbose(FMT_PKGCONFIG_DIR ${CMAKE_INSTALL_LIBDIR}/pkgconfig CACHE PATH
+              "Installation directory for pkgconfig (.pc) files, a relative "
+              "path that will be joined with ${CMAKE_INSTALL_PREFIX} or an "
+              "absolute path.")
+
+  # Generate the version, config and target files into the build directory.
+  write_basic_package_version_file(
+    ${version_config}
+    VERSION ${FMT_VERSION}
+    COMPATIBILITY AnyNewerVersion)
+
+  join_paths(libdir_for_pc_file "\${exec_prefix}" "${FMT_LIB_DIR}")
+  join_paths(includedir_for_pc_file "\${prefix}" "${FMT_INC_DIR}")
+
+  configure_file(
+    "${PROJECT_SOURCE_DIR}/support/cmake/fmt.pc.in"
+    "${pkgconfig}"
+    @ONLY)
+  configure_package_config_file(
+    ${PROJECT_SOURCE_DIR}/support/cmake/fmt-config.cmake.in
+    ${project_config}
+    INSTALL_DESTINATION ${FMT_CMAKE_DIR})
+
+  set(INSTALL_TARGETS fmt fmt-header-only)
+
+  # Install the library and headers.
+  install(TARGETS ${INSTALL_TARGETS} EXPORT ${targets_export_name}
+          LIBRARY DESTINATION ${FMT_LIB_DIR}
+          ARCHIVE DESTINATION ${FMT_LIB_DIR}
+          RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+
+  # Use a namespace because CMake provides better diagnostics for namespaced
+  # imported targets.
+  export(TARGETS ${INSTALL_TARGETS} NAMESPACE fmt::
+         FILE ${PROJECT_BINARY_DIR}/${targets_export_name}.cmake)
+
+  # Install version, config and target files.
+  install(
+    FILES ${project_config} ${version_config}
+    DESTINATION ${FMT_CMAKE_DIR})
+  install(EXPORT ${targets_export_name} DESTINATION ${FMT_CMAKE_DIR}
+          NAMESPACE fmt::)
+
+  install(FILES $<TARGET_PDB_FILE:${INSTALL_TARGETS}>
+          DESTINATION ${FMT_LIB_DIR} OPTIONAL)
+  install(FILES ${FMT_HEADERS} DESTINATION "${FMT_INC_DIR}/fmt")
+  install(FILES "${pkgconfig}" DESTINATION "${FMT_PKGCONFIG_DIR}")
+endif ()
+
+if (FMT_DOC)
+  add_subdirectory(doc)
+endif ()
+
+if (FMT_TEST)
+  enable_testing()
+  add_subdirectory(test)
+endif ()
+
+# Control fuzzing independent of the unit tests.
+if (FMT_FUZZ)
+  add_subdirectory(test/fuzzing)
+
+  # The FMT_FUZZ macro is used to prevent resource exhaustion in fuzzing
+  # mode and make fuzzing practically possible. It is similar to
+  # FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION but uses a different name to
+  # avoid interfering with fuzzing of projects that use {fmt}.
+  # See also https://llvm.org/docs/LibFuzzer.html#fuzzer-friendly-build-mode.
+  target_compile_definitions(fmt PUBLIC FMT_FUZZ)
+endif ()
+
+set(gitignore ${PROJECT_SOURCE_DIR}/.gitignore)
+if (FMT_MASTER_PROJECT AND EXISTS ${gitignore})
+  # Get the list of ignored files from .gitignore.
+  file (STRINGS ${gitignore} lines)
+  list(REMOVE_ITEM lines /doc/html)
+  foreach (line ${lines})
+    string(REPLACE "." "[.]" line "${line}")
+    string(REPLACE "*" ".*" line "${line}")
+    set(ignored_files ${ignored_files} "${line}$" "${line}/")
+  endforeach ()
+  set(ignored_files ${ignored_files}
+    /.git /breathe /format-benchmark sphinx/ .buildinfo .doctrees)
+
+  set(CPACK_SOURCE_GENERATOR ZIP)
+  set(CPACK_SOURCE_IGNORE_FILES ${ignored_files})
+  set(CPACK_SOURCE_PACKAGE_FILE_NAME fmt-${FMT_VERSION})
+  set(CPACK_PACKAGE_NAME fmt)
+  set(CPACK_RESOURCE_FILE_README ${PROJECT_SOURCE_DIR}/README.rst)
+  include(CPack)
+endif ()

contrib/fmt-8.0.1/LICENSE.rst

@@ -0,0 +1,27 @@
+Copyright (c) 2012 - present, Victor Zverovich
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+--- Optional exception to the license ---
+
+As an exception, if, as a result of your compiling your source code, portions
+of this Software are embedded into a machine-executable object form of such
+source code, you may redistribute such embedded portions in such object form
+without including the above copyright and permission notices.

contrib/fmt-8.0.1/include/fmt/args.h

@@ -0,0 +1,232 @@
+// Formatting library for C++ - dynamic format arguments
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_ARGS_H_
+#define FMT_ARGS_H_
+
+#include <functional>  // std::reference_wrapper
+#include <memory>      // std::unique_ptr
+#include <vector>
+
+#include "core.h"
+
+FMT_BEGIN_NAMESPACE
+
+namespace detail {
+
+template <typename T> struct is_reference_wrapper : std::false_type {};
+template <typename T>
+struct is_reference_wrapper<std::reference_wrapper<T>> : std::true_type {};
+
+template <typename T> const T& unwrap(const T& v) { return v; }
+template <typename T> const T& unwrap(const std::reference_wrapper<T>& v) {
+  return static_cast<const T&>(v);
+}
+
+class dynamic_arg_list {
+  // Workaround for clang's -Wweak-vtables. Unlike for regular classes, for
+  // templates it doesn't complain about inability to deduce single translation
+  // unit for placing vtable. So storage_node_base is made a fake template.
+  template <typename = void> struct node {
+    virtual ~node() = default;
+    std::unique_ptr<node<>> next;
+  };
+
+  template <typename T> struct typed_node : node<> {
+    T value;
+
+    template <typename Arg>
+    FMT_CONSTEXPR typed_node(const Arg& arg) : value(arg) {}
+
+    template <typename Char>
+    FMT_CONSTEXPR typed_node(const basic_string_view<Char>& arg)
+        : value(arg.data(), arg.size()) {}
+  };
+
+  std::unique_ptr<node<>> head_;
+
+ public:
+  template <typename T, typename Arg> const T& push(const Arg& arg) {
+    auto new_node = std::unique_ptr<typed_node<T>>(new typed_node<T>(arg));
+    auto& value = new_node->value;
+    new_node->next = std::move(head_);
+    head_ = std::move(new_node);
+    return value;
+  }
+};
+}  // namespace detail
+
+/**
+  \rst
+  A dynamic version of `fmt::format_arg_store`.
+  It's equipped with a storage to potentially temporary objects which lifetimes
+  could be shorter than the format arguments object.
+
+  It can be implicitly converted into `~fmt::basic_format_args` for passing
+  into type-erased formatting functions such as `~fmt::vformat`.
+  \endrst
+ */
+template <typename Context>
+class dynamic_format_arg_store
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+    // Workaround a GCC template argument substitution bug.
+    : public basic_format_args<Context>
+#endif
+{
+ private:
+  using char_type = typename Context::char_type;
+
+  template <typename T> struct need_copy {
+    static constexpr detail::type mapped_type =
+        detail::mapped_type_constant<T, Context>::value;
+
+    enum {
+      value = !(detail::is_reference_wrapper<T>::value ||
+                std::is_same<T, basic_string_view<char_type>>::value ||
+                std::is_same<T, detail::std_string_view<char_type>>::value ||
+                (mapped_type != detail::type::cstring_type &&
+                 mapped_type != detail::type::string_type &&
+                 mapped_type != detail::type::custom_type))
+    };
+  };
+
+  template <typename T>
+  using stored_type = conditional_t<detail::is_string<T>::value &&
+                                        !has_formatter<T, Context>::value &&
+                                        !detail::is_reference_wrapper<T>::value,
+                                    std::basic_string<char_type>, T>;
+
+  // Storage of basic_format_arg must be contiguous.
+  std::vector<basic_format_arg<Context>> data_;
+  std::vector<detail::named_arg_info<char_type>> named_info_;
+
+  // Storage of arguments not fitting into basic_format_arg must grow
+  // without relocation because items in data_ refer to it.
+  detail::dynamic_arg_list dynamic_args_;
+
+  friend class basic_format_args<Context>;
+
+  unsigned long long get_types() const {
+    return detail::is_unpacked_bit | data_.size() |
+           (named_info_.empty()
+                ? 0ULL
+                : static_cast<unsigned long long>(detail::has_named_args_bit));
+  }
+
+  const basic_format_arg<Context>* data() const {
+    return named_info_.empty() ? data_.data() : data_.data() + 1;
+  }
+
+  template <typename T> void emplace_arg(const T& arg) {
+    data_.emplace_back(detail::make_arg<Context>(arg));
+  }
+
+  template <typename T>
+  void emplace_arg(const detail::named_arg<char_type, T>& arg) {
+    if (named_info_.empty()) {
+      constexpr const detail::named_arg_info<char_type>* zero_ptr{nullptr};
+      data_.insert(data_.begin(), {zero_ptr, 0});
+    }
+    data_.emplace_back(detail::make_arg<Context>(detail::unwrap(arg.value)));
+    auto pop_one = [](std::vector<basic_format_arg<Context>>* data) {
+      data->pop_back();
+    };
+    std::unique_ptr<std::vector<basic_format_arg<Context>>, decltype(pop_one)>
+        guard{&data_, pop_one};
+    named_info_.push_back({arg.name, static_cast<int>(data_.size() - 2u)});
+    data_[0].value_.named_args = {named_info_.data(), named_info_.size()};
+    guard.release();
+  }
+
+ public:
+  /**
+    \rst
+    Adds an argument into the dynamic store for later passing to a formatting
+    function.
+
+    Note that custom types and string types (but not string views) are copied
+    into the store dynamically allocating memory if necessary.
+
+    **Example**::
+
+      fmt::dynamic_format_arg_store<fmt::format_context> store;
+      store.push_back(42);
+      store.push_back("abc");
+      store.push_back(1.5f);
+      std::string result = fmt::vformat("{} and {} and {}", store);
+    \endrst
+  */
+  template <typename T> void push_back(const T& arg) {
+    if (detail::const_check(need_copy<T>::value))
+      emplace_arg(dynamic_args_.push<stored_type<T>>(arg));
+    else
+      emplace_arg(detail::unwrap(arg));
+  }
+
+  /**
+    \rst
+    Adds a reference to the argument into the dynamic store for later passing to
+    a formatting function.
+
+    **Example**::
+
+      fmt::dynamic_format_arg_store<fmt::format_context> store;
+      char band[] = "Rolling Stones";
+      store.push_back(std::cref(band));
+      band[9] = 'c'; // Changing str affects the output.
+      std::string result = fmt::vformat("{}", store);
+      // result == "Rolling Scones"
+    \endrst
+  */
+  template <typename T> void push_back(std::reference_wrapper<T> arg) {
+    static_assert(
+        need_copy<T>::value,
+        "objects of built-in types and string views are always copied");
+    emplace_arg(arg.get());
+  }
+
+  /**
+    Adds named argument into the dynamic store for later passing to a formatting
+    function. ``std::reference_wrapper`` is supported to avoid copying of the
+    argument. The name is always copied into the store.
+  */
+  template <typename T>
+  void push_back(const detail::named_arg<char_type, T>& arg) {
+    const char_type* arg_name =
+        dynamic_args_.push<std::basic_string<char_type>>(arg.name).c_str();
+    if (detail::const_check(need_copy<T>::value)) {
+      emplace_arg(
+          fmt::arg(arg_name, dynamic_args_.push<stored_type<T>>(arg.value)));
+    } else {
+      emplace_arg(fmt::arg(arg_name, arg.value));
+    }
+  }
+
+  /** Erase all elements from the store */
+  void clear() {
+    data_.clear();
+    named_info_.clear();
+    dynamic_args_ = detail::dynamic_arg_list();
+  }
+
+  /**
+    \rst
+    Reserves space to store at least *new_cap* arguments including
+    *new_cap_named* named arguments.
+    \endrst
+  */
+  void reserve(size_t new_cap, size_t new_cap_named) {
+    FMT_ASSERT(new_cap >= new_cap_named,
+               "Set of arguments includes set of named arguments");
+    data_.reserve(new_cap);
+    named_info_.reserve(new_cap_named);
+  }
+};
+
+FMT_END_NAMESPACE
+
+#endif  // FMT_ARGS_H_

contrib/fmt-8.0.1/include/fmt/color.h

@@ -0,0 +1,627 @@
+// Formatting library for C++ - color support
+//
+// Copyright (c) 2018 - present, Victor Zverovich and fmt contributors
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_COLOR_H_
+#define FMT_COLOR_H_
+
+#include "format.h"
+
+// __declspec(deprecated) is broken in some MSVC versions.
+#if FMT_MSC_VER
+#  define FMT_DEPRECATED_NONMSVC
+#else
+#  define FMT_DEPRECATED_NONMSVC FMT_DEPRECATED
+#endif
+
+FMT_BEGIN_NAMESPACE
+FMT_MODULE_EXPORT_BEGIN
+
+enum class color : uint32_t {
+  alice_blue = 0xF0F8FF,               // rgb(240,248,255)
+  antique_white = 0xFAEBD7,            // rgb(250,235,215)
+  aqua = 0x00FFFF,                     // rgb(0,255,255)
+  aquamarine = 0x7FFFD4,               // rgb(127,255,212)
+  azure = 0xF0FFFF,                    // rgb(240,255,255)
+  beige = 0xF5F5DC,                    // rgb(245,245,220)
+  bisque = 0xFFE4C4,                   // rgb(255,228,196)
+  black = 0x000000,                    // rgb(0,0,0)
+  blanched_almond = 0xFFEBCD,          // rgb(255,235,205)
+  blue = 0x0000FF,                     // rgb(0,0,255)
+  blue_violet = 0x8A2BE2,              // rgb(138,43,226)
+  brown = 0xA52A2A,                    // rgb(165,42,42)
+  burly_wood = 0xDEB887,               // rgb(222,184,135)
+  cadet_blue = 0x5F9EA0,               // rgb(95,158,160)
+  chartreuse = 0x7FFF00,               // rgb(127,255,0)
+  chocolate = 0xD2691E,                // rgb(210,105,30)
+  coral = 0xFF7F50,                    // rgb(255,127,80)
+  cornflower_blue = 0x6495ED,          // rgb(100,149,237)
+  cornsilk = 0xFFF8DC,                 // rgb(255,248,220)
+  crimson = 0xDC143C,                  // rgb(220,20,60)
+  cyan = 0x00FFFF,                     // rgb(0,255,255)
+  dark_blue = 0x00008B,                // rgb(0,0,139)
+  dark_cyan = 0x008B8B,                // rgb(0,139,139)
+  dark_golden_rod = 0xB8860B,          // rgb(184,134,11)
+  dark_gray = 0xA9A9A9,                // rgb(169,169,169)
+  dark_green = 0x006400,               // rgb(0,100,0)
+  dark_khaki = 0xBDB76B,               // rgb(189,183,107)
+  dark_magenta = 0x8B008B,             // rgb(139,0,139)
+  dark_olive_green = 0x556B2F,         // rgb(85,107,47)
+  dark_orange = 0xFF8C00,              // rgb(255,140,0)
+  dark_orchid = 0x9932CC,              // rgb(153,50,204)
+  dark_red = 0x8B0000,                 // rgb(139,0,0)
+  dark_salmon = 0xE9967A,              // rgb(233,150,122)
+  dark_sea_green = 0x8FBC8F,           // rgb(143,188,143)
+  dark_slate_blue = 0x483D8B,          // rgb(72,61,139)
+  dark_slate_gray = 0x2F4F4F,          // rgb(47,79,79)
+  dark_turquoise = 0x00CED1,           // rgb(0,206,209)
+  dark_violet = 0x9400D3,              // rgb(148,0,211)
+  deep_pink = 0xFF1493,                // rgb(255,20,147)
+  deep_sky_blue = 0x00BFFF,            // rgb(0,191,255)
+  dim_gray = 0x696969,                 // rgb(105,105,105)
+  dodger_blue = 0x1E90FF,              // rgb(30,144,255)
+  fire_brick = 0xB22222,               // rgb(178,34,34)
+  floral_white = 0xFFFAF0,             // rgb(255,250,240)
+  forest_green = 0x228B22,             // rgb(34,139,34)
+  fuchsia = 0xFF00FF,                  // rgb(255,0,255)
+  gainsboro = 0xDCDCDC,                // rgb(220,220,220)
+  ghost_white = 0xF8F8FF,              // rgb(248,248,255)
+  gold = 0xFFD700,                     // rgb(255,215,0)
+  golden_rod = 0xDAA520,               // rgb(218,165,32)
+  gray = 0x808080,                     // rgb(128,128,128)
+  green = 0x008000,                    // rgb(0,128,0)
+  green_yellow = 0xADFF2F,             // rgb(173,255,47)
+  honey_dew = 0xF0FFF0,                // rgb(240,255,240)
+  hot_pink = 0xFF69B4,                 // rgb(255,105,180)
+  indian_red = 0xCD5C5C,               // rgb(205,92,92)
+  indigo = 0x4B0082,                   // rgb(75,0,130)
+  ivory = 0xFFFFF0,                    // rgb(255,255,240)
+  khaki = 0xF0E68C,                    // rgb(240,230,140)
+  lavender = 0xE6E6FA,                 // rgb(230,230,250)
+  lavender_blush = 0xFFF0F5,           // rgb(255,240,245)
+  lawn_green = 0x7CFC00,               // rgb(124,252,0)
+  lemon_chiffon = 0xFFFACD,            // rgb(255,250,205)
+  light_blue = 0xADD8E6,               // rgb(173,216,230)
+  light_coral = 0xF08080,              // rgb(240,128,128)
+  light_cyan = 0xE0FFFF,               // rgb(224,255,255)
+  light_golden_rod_yellow = 0xFAFAD2,  // rgb(250,250,210)
+  light_gray = 0xD3D3D3,               // rgb(211,211,211)
+  light_green = 0x90EE90,              // rgb(144,238,144)
+  light_pink = 0xFFB6C1,               // rgb(255,182,193)
+  light_salmon = 0xFFA07A,             // rgb(255,160,122)
+  light_sea_green = 0x20B2AA,          // rgb(32,178,170)
+  light_sky_blue = 0x87CEFA,           // rgb(135,206,250)
+  light_slate_gray = 0x778899,         // rgb(119,136,153)
+  light_steel_blue = 0xB0C4DE,         // rgb(176,196,222)
+  light_yellow = 0xFFFFE0,             // rgb(255,255,224)
+  lime = 0x00FF00,                     // rgb(0,255,0)
+  lime_green = 0x32CD32,               // rgb(50,205,50)
+  linen = 0xFAF0E6,                    // rgb(250,240,230)
+  magenta = 0xFF00FF,                  // rgb(255,0,255)
+  maroon = 0x800000,                   // rgb(128,0,0)
+  medium_aquamarine = 0x66CDAA,        // rgb(102,205,170)
+  medium_blue = 0x0000CD,              // rgb(0,0,205)
+  medium_orchid = 0xBA55D3,            // rgb(186,85,211)
+  medium_purple = 0x9370DB,            // rgb(147,112,219)
+  medium_sea_green = 0x3CB371,         // rgb(60,179,113)
+  medium_slate_blue = 0x7B68EE,        // rgb(123,104,238)
+  medium_spring_green = 0x00FA9A,      // rgb(0,250,154)
+  medium_turquoise = 0x48D1CC,         // rgb(72,209,204)
+  medium_violet_red = 0xC71585,        // rgb(199,21,133)
+  midnight_blue = 0x191970,            // rgb(25,25,112)
+  mint_cream = 0xF5FFFA,               // rgb(245,255,250)
+  misty_rose = 0xFFE4E1,               // rgb(255,228,225)
+  moccasin = 0xFFE4B5,                 // rgb(255,228,181)
+  navajo_white = 0xFFDEAD,             // rgb(255,222,173)
+  navy = 0x000080,                     // rgb(0,0,128)
+  old_lace = 0xFDF5E6,                 // rgb(253,245,230)
+  olive = 0x808000,                    // rgb(128,128,0)
+  olive_drab = 0x6B8E23,               // rgb(107,142,35)
+  orange = 0xFFA500,                   // rgb(255,165,0)
+  orange_red = 0xFF4500,               // rgb(255,69,0)
+  orchid = 0xDA70D6,                   // rgb(218,112,214)
+  pale_golden_rod = 0xEEE8AA,          // rgb(238,232,170)
+  pale_green = 0x98FB98,               // rgb(152,251,152)
+  pale_turquoise = 0xAFEEEE,           // rgb(175,238,238)
+  pale_violet_red = 0xDB7093,          // rgb(219,112,147)
+  papaya_whip = 0xFFEFD5,              // rgb(255,239,213)
+  peach_puff = 0xFFDAB9,               // rgb(255,218,185)
+  peru = 0xCD853F,                     // rgb(205,133,63)
+  pink = 0xFFC0CB,                     // rgb(255,192,203)
+  plum = 0xDDA0DD,                     // rgb(221,160,221)
+  powder_blue = 0xB0E0E6,              // rgb(176,224,230)
+  purple = 0x800080,                   // rgb(128,0,128)
+  rebecca_purple = 0x663399,           // rgb(102,51,153)
+  red = 0xFF0000,                      // rgb(255,0,0)
+  rosy_brown = 0xBC8F8F,               // rgb(188,143,143)
+  royal_blue = 0x4169E1,               // rgb(65,105,225)
+  saddle_brown = 0x8B4513,             // rgb(139,69,19)
+  salmon = 0xFA8072,                   // rgb(250,128,114)
+  sandy_brown = 0xF4A460,              // rgb(244,164,96)
+  sea_green = 0x2E8B57,                // rgb(46,139,87)
+  sea_shell = 0xFFF5EE,                // rgb(255,245,238)
+  sienna = 0xA0522D,                   // rgb(160,82,45)
+  silver = 0xC0C0C0,                   // rgb(192,192,192)
+  sky_blue = 0x87CEEB,                 // rgb(135,206,235)
+  slate_blue = 0x6A5ACD,               // rgb(106,90,205)
+  slate_gray = 0x708090,               // rgb(112,128,144)
+  snow = 0xFFFAFA,                     // rgb(255,250,250)
+  spring_green = 0x00FF7F,             // rgb(0,255,127)
+  steel_blue = 0x4682B4,               // rgb(70,130,180)
+  tan = 0xD2B48C,                      // rgb(210,180,140)
+  teal = 0x008080,                     // rgb(0,128,128)
+  thistle = 0xD8BFD8,                  // rgb(216,191,216)
+  tomato = 0xFF6347,                   // rgb(255,99,71)
+  turquoise = 0x40E0D0,                // rgb(64,224,208)
+  violet = 0xEE82EE,                   // rgb(238,130,238)
+  wheat = 0xF5DEB3,                    // rgb(245,222,179)
+  white = 0xFFFFFF,                    // rgb(255,255,255)
+  white_smoke = 0xF5F5F5,              // rgb(245,245,245)
+  yellow = 0xFFFF00,                   // rgb(255,255,0)
+  yellow_green = 0x9ACD32              // rgb(154,205,50)
+};                                     // enum class color
+
+enum class terminal_color : uint8_t {
+  black = 30,
+  red,
+  green,
+  yellow,
+  blue,
+  magenta,
+  cyan,
+  white,
+  bright_black = 90,
+  bright_red,
+  bright_green,
+  bright_yellow,
+  bright_blue,
+  bright_magenta,
+  bright_cyan,
+  bright_white
+};
+
+enum class emphasis : uint8_t {
+  bold = 1,
+  italic = 1 << 1,
+  underline = 1 << 2,
+  strikethrough = 1 << 3
+};
+
+// rgb is a struct for red, green and blue colors.
+// Using the name "rgb" makes some editors show the color in a tooltip.
+struct rgb {
+  FMT_CONSTEXPR rgb() : r(0), g(0), b(0) {}
+  FMT_CONSTEXPR rgb(uint8_t r_, uint8_t g_, uint8_t b_) : r(r_), g(g_), b(b_) {}
+  FMT_CONSTEXPR rgb(uint32_t hex)
+      : r((hex >> 16) & 0xFF), g((hex >> 8) & 0xFF), b(hex & 0xFF) {}
+  FMT_CONSTEXPR rgb(color hex)
+      : r((uint32_t(hex) >> 16) & 0xFF),
+        g((uint32_t(hex) >> 8) & 0xFF),
+        b(uint32_t(hex) & 0xFF) {}
+  uint8_t r;
+  uint8_t g;
+  uint8_t b;
+};
+
+FMT_BEGIN_DETAIL_NAMESPACE
+
+// color is a struct of either a rgb color or a terminal color.
+struct color_type {
+  FMT_CONSTEXPR color_type() FMT_NOEXCEPT : is_rgb(), value{} {}
+  FMT_CONSTEXPR color_type(color rgb_color) FMT_NOEXCEPT : is_rgb(true),
+                                                           value{} {
+    value.rgb_color = static_cast<uint32_t>(rgb_color);
+  }
+  FMT_CONSTEXPR color_type(rgb rgb_color) FMT_NOEXCEPT : is_rgb(true), value{} {
+    value.rgb_color = (static_cast<uint32_t>(rgb_color.r) << 16) |
+                      (static_cast<uint32_t>(rgb_color.g) << 8) | rgb_color.b;
+  }
+  FMT_CONSTEXPR color_type(terminal_color term_color) FMT_NOEXCEPT : is_rgb(),
+                                                                     value{} {
+    value.term_color = static_cast<uint8_t>(term_color);
+  }
+  bool is_rgb;
+  union color_union {
+    uint8_t term_color;
+    uint32_t rgb_color;
+  } value;
+};
+
+FMT_END_DETAIL_NAMESPACE
+
+/** A text style consisting of foreground and background colors and emphasis. */
+class text_style {
+ public:
+  FMT_CONSTEXPR text_style(emphasis em = emphasis()) FMT_NOEXCEPT
+      : set_foreground_color(),
+        set_background_color(),
+        ems(em) {}
+
+  FMT_CONSTEXPR text_style& operator|=(const text_style& rhs) {
+    if (!set_foreground_color) {
+      set_foreground_color = rhs.set_foreground_color;
+      foreground_color = rhs.foreground_color;
+    } else if (rhs.set_foreground_color) {
+      if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb)
+        FMT_THROW(format_error("can't OR a terminal color"));
+      foreground_color.value.rgb_color |= rhs.foreground_color.value.rgb_color;
+    }
+
+    if (!set_background_color) {
+      set_background_color = rhs.set_background_color;
+      background_color = rhs.background_color;
+    } else if (rhs.set_background_color) {
+      if (!background_color.is_rgb || !rhs.background_color.is_rgb)
+        FMT_THROW(format_error("can't OR a terminal color"));
+      background_color.value.rgb_color |= rhs.background_color.value.rgb_color;
+    }
+
+    ems = static_cast<emphasis>(static_cast<uint8_t>(ems) |
+                                static_cast<uint8_t>(rhs.ems));
+    return *this;
+  }
+
+  friend FMT_CONSTEXPR text_style operator|(text_style lhs,
+                                            const text_style& rhs) {
+    return lhs |= rhs;
+  }
+
+  FMT_DEPRECATED_NONMSVC FMT_CONSTEXPR text_style& operator&=(
+      const text_style& rhs) {
+    return and_assign(rhs);
+  }
+
+  FMT_DEPRECATED_NONMSVC friend FMT_CONSTEXPR text_style
+  operator&(text_style lhs, const text_style& rhs) {
+    return lhs.and_assign(rhs);
+  }
+
+  FMT_CONSTEXPR bool has_foreground() const FMT_NOEXCEPT {
+    return set_foreground_color;
+  }
+  FMT_CONSTEXPR bool has_background() const FMT_NOEXCEPT {
+    return set_background_color;
+  }
+  FMT_CONSTEXPR bool has_emphasis() const FMT_NOEXCEPT {
+    return static_cast<uint8_t>(ems) != 0;
+  }
+  FMT_CONSTEXPR detail::color_type get_foreground() const FMT_NOEXCEPT {
+    FMT_ASSERT(has_foreground(), "no foreground specified for this style");
+    return foreground_color;
+  }
+  FMT_CONSTEXPR detail::color_type get_background() const FMT_NOEXCEPT {
+    FMT_ASSERT(has_background(), "no background specified for this style");
+    return background_color;
+  }
+  FMT_CONSTEXPR emphasis get_emphasis() const FMT_NOEXCEPT {
+    FMT_ASSERT(has_emphasis(), "no emphasis specified for this style");
+    return ems;
+  }
+
+ private:
+  FMT_CONSTEXPR text_style(bool is_foreground,
+                           detail::color_type text_color) FMT_NOEXCEPT
+      : set_foreground_color(),
+        set_background_color(),
+        ems() {
+    if (is_foreground) {
+      foreground_color = text_color;
+      set_foreground_color = true;
+    } else {
+      background_color = text_color;
+      set_background_color = true;
+    }
+  }
+
+  // DEPRECATED!
+  FMT_CONSTEXPR text_style& and_assign(const text_style& rhs) {
+    if (!set_foreground_color) {
+      set_foreground_color = rhs.set_foreground_color;
+      foreground_color = rhs.foreground_color;
+    } else if (rhs.set_foreground_color) {
+      if (!foreground_color.is_rgb || !rhs.foreground_color.is_rgb)
+        FMT_THROW(format_error("can't AND a terminal color"));
+      foreground_color.value.rgb_color &= rhs.foreground_color.value.rgb_color;
+    }
+
+    if (!set_background_color) {
+      set_background_color = rhs.set_background_color;
+      background_color = rhs.background_color;
+    } else if (rhs.set_background_color) {
+      if (!background_color.is_rgb || !rhs.background_color.is_rgb)
+        FMT_THROW(format_error("can't AND a terminal color"));
+      background_color.value.rgb_color &= rhs.background_color.value.rgb_color;
+    }
+
+    ems = static_cast<emphasis>(static_cast<uint8_t>(ems) &
+                                static_cast<uint8_t>(rhs.ems));
+    return *this;
+  }
+
+  friend FMT_CONSTEXPR_DECL text_style fg(detail::color_type foreground)
+      FMT_NOEXCEPT;
+
+  friend FMT_CONSTEXPR_DECL text_style bg(detail::color_type background)
+      FMT_NOEXCEPT;
+
+  detail::color_type foreground_color;
+  detail::color_type background_color;
+  bool set_foreground_color;
+  bool set_background_color;
+  emphasis ems;
+};
+
+/** Creates a text style from the foreground (text) color. */
+FMT_CONSTEXPR inline text_style fg(detail::color_type foreground) FMT_NOEXCEPT {
+  return text_style(true, foreground);
+}
+
+/** Creates a text style from the background color. */
+FMT_CONSTEXPR inline text_style bg(detail::color_type background) FMT_NOEXCEPT {
+  return text_style(false, background);
+}
+
+FMT_CONSTEXPR inline text_style operator|(emphasis lhs,
+                                          emphasis rhs) FMT_NOEXCEPT {
+  return text_style(lhs) | rhs;
+}
+
+FMT_BEGIN_DETAIL_NAMESPACE
+
+template <typename Char> struct ansi_color_escape {
+  FMT_CONSTEXPR ansi_color_escape(detail::color_type text_color,
+                                  const char* esc) FMT_NOEXCEPT {
+    // If we have a terminal color, we need to output another escape code
+    // sequence.
+    if (!text_color.is_rgb) {
+      bool is_background = esc == string_view("\x1b[48;2;");
+      uint32_t value = text_color.value.term_color;
+      // Background ASCII codes are the same as the foreground ones but with
+      // 10 more.
+      if (is_background) value += 10u;
+
+      size_t index = 0;
+      buffer[index++] = static_cast<Char>('\x1b');
+      buffer[index++] = static_cast<Char>('[');
+
+      if (value >= 100u) {
+        buffer[index++] = static_cast<Char>('1');
+        value %= 100u;
+      }
+      buffer[index++] = static_cast<Char>('0' + value / 10u);
+      buffer[index++] = static_cast<Char>('0' + value % 10u);
+
+      buffer[index++] = static_cast<Char>('m');
+      buffer[index++] = static_cast<Char>('\0');
+      return;
+    }
+
+    for (int i = 0; i < 7; i++) {
+      buffer[i] = static_cast<Char>(esc[i]);
+    }
+    rgb color(text_color.value.rgb_color);
+    to_esc(color.r, buffer + 7, ';');
+    to_esc(color.g, buffer + 11, ';');
+    to_esc(color.b, buffer + 15, 'm');
+    buffer[19] = static_cast<Char>(0);
+  }
+  FMT_CONSTEXPR ansi_color_escape(emphasis em) FMT_NOEXCEPT {
+    uint8_t em_codes[4] = {};
+    uint8_t em_bits = static_cast<uint8_t>(em);
+    if (em_bits & static_cast<uint8_t>(emphasis::bold)) em_codes[0] = 1;
+    if (em_bits & static_cast<uint8_t>(emphasis::italic)) em_codes[1] = 3;
+    if (em_bits & static_cast<uint8_t>(emphasis::underline)) em_codes[2] = 4;
+    if (em_bits & static_cast<uint8_t>(emphasis::strikethrough))
+      em_codes[3] = 9;
+
+    size_t index = 0;
+    for (int i = 0; i < 4; ++i) {
+      if (!em_codes[i]) continue;
+      buffer[index++] = static_cast<Char>('\x1b');
+      buffer[index++] = static_cast<Char>('[');
+      buffer[index++] = static_cast<Char>('0' + em_codes[i]);
+      buffer[index++] = static_cast<Char>('m');
+    }
+    buffer[index++] = static_cast<Char>(0);
+  }
+  FMT_CONSTEXPR operator const Char*() const FMT_NOEXCEPT { return buffer; }
+
+  FMT_CONSTEXPR const Char* begin() const FMT_NOEXCEPT { return buffer; }
+  FMT_CONSTEXPR_CHAR_TRAITS const Char* end() const FMT_NOEXCEPT {
+    return buffer + std::char_traits<Char>::length(buffer);
+  }
+
+ private:
+  Char buffer[7u + 3u * 4u + 1u];
+
+  static FMT_CONSTEXPR void to_esc(uint8_t c, Char* out,
+                                   char delimiter) FMT_NOEXCEPT {
+    out[0] = static_cast<Char>('0' + c / 100);
+    out[1] = static_cast<Char>('0' + c / 10 % 10);
+    out[2] = static_cast<Char>('0' + c % 10);
+    out[3] = static_cast<Char>(delimiter);
+  }
+};
+
+template <typename Char>
+FMT_CONSTEXPR ansi_color_escape<Char> make_foreground_color(
+    detail::color_type foreground) FMT_NOEXCEPT {
+  return ansi_color_escape<Char>(foreground, "\x1b[38;2;");
+}
+
+template <typename Char>
+FMT_CONSTEXPR ansi_color_escape<Char> make_background_color(
+    detail::color_type background) FMT_NOEXCEPT {
+  return ansi_color_escape<Char>(background, "\x1b[48;2;");
+}
+
+template <typename Char>
+FMT_CONSTEXPR ansi_color_escape<Char> make_emphasis(emphasis em) FMT_NOEXCEPT {
+  return ansi_color_escape<Char>(em);
+}
+
+template <typename Char>
+inline void fputs(const Char* chars, FILE* stream) FMT_NOEXCEPT {
+  std::fputs(chars, stream);
+}
+
+template <>
+inline void fputs<wchar_t>(const wchar_t* chars, FILE* stream) FMT_NOEXCEPT {
+  std::fputws(chars, stream);
+}
+
+template <typename Char> inline void reset_color(FILE* stream) FMT_NOEXCEPT {
+  fputs("\x1b[0m", stream);
+}
+
+template <> inline void reset_color<wchar_t>(FILE* stream) FMT_NOEXCEPT {
+  fputs(L"\x1b[0m", stream);
+}
+
+template <typename Char>
+inline void reset_color(buffer<Char>& buffer) FMT_NOEXCEPT {
+  auto reset_color = string_view("\x1b[0m");
+  buffer.append(reset_color.begin(), reset_color.end());
+}
+
+template <typename Char>
+void vformat_to(buffer<Char>& buf, const text_style& ts,
+                basic_string_view<Char> format_str,
+                basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  bool has_style = false;
+  if (ts.has_emphasis()) {
+    has_style = true;
+    auto emphasis = detail::make_emphasis<Char>(ts.get_emphasis());
+    buf.append(emphasis.begin(), emphasis.end());
+  }
+  if (ts.has_foreground()) {
+    has_style = true;
+    auto foreground = detail::make_foreground_color<Char>(ts.get_foreground());
+    buf.append(foreground.begin(), foreground.end());
+  }
+  if (ts.has_background()) {
+    has_style = true;
+    auto background = detail::make_background_color<Char>(ts.get_background());
+    buf.append(background.begin(), background.end());
+  }
+  detail::vformat_to(buf, format_str, args, {});
+  if (has_style) detail::reset_color<Char>(buf);
+}
+
+FMT_END_DETAIL_NAMESPACE
+
+template <typename S, typename Char = char_t<S>>
+void vprint(std::FILE* f, const text_style& ts, const S& format,
+            basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  basic_memory_buffer<Char> buf;
+  detail::vformat_to(buf, ts, to_string_view(format), args);
+  buf.push_back(Char(0));
+  detail::fputs(buf.data(), f);
+}
+
+/**
+  \rst
+  Formats a string and prints it to the specified file stream using ANSI
+  escape sequences to specify text formatting.
+
+  **Example**::
+
+    fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
+               "Elapsed time: {0:.2f} seconds", 1.23);
+  \endrst
+ */
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_string<S>::value)>
+void print(std::FILE* f, const text_style& ts, const S& format_str,
+           const Args&... args) {
+  vprint(f, ts, format_str,
+         fmt::make_args_checked<Args...>(format_str, args...));
+}
+
+/**
+  \rst
+  Formats a string and prints it to stdout using ANSI escape sequences to
+  specify text formatting.
+
+  **Example**::
+
+    fmt::print(fmt::emphasis::bold | fg(fmt::color::red),
+               "Elapsed time: {0:.2f} seconds", 1.23);
+  \endrst
+ */
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_string<S>::value)>
+void print(const text_style& ts, const S& format_str, const Args&... args) {
+  return print(stdout, ts, format_str, args...);
+}
+
+template <typename S, typename Char = char_t<S>>
+inline std::basic_string<Char> vformat(
+    const text_style& ts, const S& format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  basic_memory_buffer<Char> buf;
+  detail::vformat_to(buf, ts, to_string_view(format_str), args);
+  return fmt::to_string(buf);
+}
+
+/**
+  \rst
+  Formats arguments and returns the result as a string using ANSI
+  escape sequences to specify text formatting.
+
+  **Example**::
+
+    #include <fmt/color.h>
+    std::string message = fmt::format(fmt::emphasis::bold | fg(fmt::color::red),
+                                      "The answer is {}", 42);
+  \endrst
+*/
+template <typename S, typename... Args, typename Char = char_t<S>>
+inline std::basic_string<Char> format(const text_style& ts, const S& format_str,
+                                      const Args&... args) {
+  return fmt::vformat(ts, to_string_view(format_str),
+                      fmt::make_args_checked<Args...>(format_str, args...));
+}
+
+/**
+  Formats a string with the given text_style and writes the output to ``out``.
+ */
+template <typename OutputIt, typename Char,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value)>
+OutputIt vformat_to(
+    OutputIt out, const text_style& ts, basic_string_view<Char> format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  auto&& buf = detail::get_buffer<Char>(out);
+  detail::vformat_to(buf, ts, format_str, args);
+  return detail::get_iterator(buf);
+}
+
+/**
+  \rst
+  Formats arguments with the given text_style, writes the result to the output
+  iterator ``out`` and returns the iterator past the end of the output range.
+
+  **Example**::
+
+    std::vector<char> out;
+    fmt::format_to(std::back_inserter(out),
+                   fmt::emphasis::bold | fg(fmt::color::red), "{}", 42);
+  \endrst
+*/
+template <typename OutputIt, typename S, typename... Args,
+          bool enable = detail::is_output_iterator<OutputIt, char_t<S>>::value&&
+              detail::is_string<S>::value>
+inline auto format_to(OutputIt out, const text_style& ts, const S& format_str,
+                      Args&&... args) ->
+    typename std::enable_if<enable, OutputIt>::type {
+  return vformat_to(out, ts, to_string_view(format_str),
+                    fmt::make_args_checked<Args...>(format_str, args...));
+}
+
+FMT_MODULE_EXPORT_END
+FMT_END_NAMESPACE
+
+#endif  // FMT_COLOR_H_

contrib/fmt-8.0.1/include/fmt/compile.h

@@ -0,0 +1,639 @@
+// Formatting library for C++ - experimental format string compilation
+//
+// Copyright (c) 2012 - present, Victor Zverovich and fmt contributors
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_COMPILE_H_
+#define FMT_COMPILE_H_
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+namespace detail {
+
+// An output iterator that counts the number of objects written to it and
+// discards them.
+class counting_iterator {
+ private:
+  size_t count_;
+
+ public:
+  using iterator_category = std::output_iterator_tag;
+  using difference_type = std::ptrdiff_t;
+  using pointer = void;
+  using reference = void;
+  using _Unchecked_type = counting_iterator;  // Mark iterator as checked.
+
+  struct value_type {
+    template <typename T> void operator=(const T&) {}
+  };
+
+  counting_iterator() : count_(0) {}
+
+  size_t count() const { return count_; }
+
+  counting_iterator& operator++() {
+    ++count_;
+    return *this;
+  }
+  counting_iterator operator++(int) {
+    auto it = *this;
+    ++*this;
+    return it;
+  }
+
+  friend counting_iterator operator+(counting_iterator it, difference_type n) {
+    it.count_ += static_cast<size_t>(n);
+    return it;
+  }
+
+  value_type operator*() const { return {}; }
+};
+
+template <typename Char, typename InputIt>
+inline counting_iterator copy_str(InputIt begin, InputIt end,
+                                  counting_iterator it) {
+  return it + (end - begin);
+}
+
+template <typename OutputIt> class truncating_iterator_base {
+ protected:
+  OutputIt out_;
+  size_t limit_;
+  size_t count_ = 0;
+
+  truncating_iterator_base() : out_(), limit_(0) {}
+
+  truncating_iterator_base(OutputIt out, size_t limit)
+      : out_(out), limit_(limit) {}
+
+ public:
+  using iterator_category = std::output_iterator_tag;
+  using value_type = typename std::iterator_traits<OutputIt>::value_type;
+  using difference_type = std::ptrdiff_t;
+  using pointer = void;
+  using reference = void;
+  using _Unchecked_type =
+      truncating_iterator_base;  // Mark iterator as checked.
+
+  OutputIt base() const { return out_; }
+  size_t count() const { return count_; }
+};
+
+// An output iterator that truncates the output and counts the number of objects
+// written to it.
+template <typename OutputIt,
+          typename Enable = typename std::is_void<
+              typename std::iterator_traits<OutputIt>::value_type>::type>
+class truncating_iterator;
+
+template <typename OutputIt>
+class truncating_iterator<OutputIt, std::false_type>
+    : public truncating_iterator_base<OutputIt> {
+  mutable typename truncating_iterator_base<OutputIt>::value_type blackhole_;
+
+ public:
+  using value_type = typename truncating_iterator_base<OutputIt>::value_type;
+
+  truncating_iterator() = default;
+
+  truncating_iterator(OutputIt out, size_t limit)
+      : truncating_iterator_base<OutputIt>(out, limit) {}
+
+  truncating_iterator& operator++() {
+    if (this->count_++ < this->limit_) ++this->out_;
+    return *this;
+  }
+
+  truncating_iterator operator++(int) {
+    auto it = *this;
+    ++*this;
+    return it;
+  }
+
+  value_type& operator*() const {
+    return this->count_ < this->limit_ ? *this->out_ : blackhole_;
+  }
+};
+
+template <typename OutputIt>
+class truncating_iterator<OutputIt, std::true_type>
+    : public truncating_iterator_base<OutputIt> {
+ public:
+  truncating_iterator() = default;
+
+  truncating_iterator(OutputIt out, size_t limit)
+      : truncating_iterator_base<OutputIt>(out, limit) {}
+
+  template <typename T> truncating_iterator& operator=(T val) {
+    if (this->count_++ < this->limit_) *this->out_++ = val;
+    return *this;
+  }
+
+  truncating_iterator& operator++() { return *this; }
+  truncating_iterator& operator++(int) { return *this; }
+  truncating_iterator& operator*() { return *this; }
+};
+
+// A compile-time string which is compiled into fast formatting code.
+class compiled_string {};
+
+template <typename S>
+struct is_compiled_string : std::is_base_of<compiled_string, S> {};
+
+/**
+  \rst
+  Converts a string literal *s* into a format string that will be parsed at
+  compile time and converted into efficient formatting code. Requires C++17
+  ``constexpr if`` compiler support.
+
+  **Example**::
+
+    // Converts 42 into std::string using the most efficient method and no
+    // runtime format string processing.
+    std::string s = fmt::format(FMT_COMPILE("{}"), 42);
+  \endrst
+ */
+#ifdef __cpp_if_constexpr
+#  define FMT_COMPILE(s) \
+    FMT_STRING_IMPL(s, fmt::detail::compiled_string, explicit)
+#else
+#  define FMT_COMPILE(s) FMT_STRING(s)
+#endif
+
+#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
+template <typename Char, size_t N,
+          fmt::detail_exported::fixed_string<Char, N> Str>
+struct udl_compiled_string : compiled_string {
+  using char_type = Char;
+  constexpr operator basic_string_view<char_type>() const {
+    return {Str.data, N - 1};
+  }
+};
+#endif
+
+template <typename T, typename... Tail>
+const T& first(const T& value, const Tail&...) {
+  return value;
+}
+
+#ifdef __cpp_if_constexpr
+template <typename... Args> struct type_list {};
+
+// Returns a reference to the argument at index N from [first, rest...].
+template <int N, typename T, typename... Args>
+constexpr const auto& get([[maybe_unused]] const T& first,
+                          [[maybe_unused]] const Args&... rest) {
+  static_assert(N < 1 + sizeof...(Args), "index is out of bounds");
+  if constexpr (N == 0)
+    return first;
+  else
+    return get<N - 1>(rest...);
+}
+
+template <typename Char, typename... Args>
+constexpr int get_arg_index_by_name(basic_string_view<Char> name,
+                                    type_list<Args...>) {
+  return get_arg_index_by_name<Args...>(name);
+}
+
+template <int N, typename> struct get_type_impl;
+
+template <int N, typename... Args> struct get_type_impl<N, type_list<Args...>> {
+  using type = remove_cvref_t<decltype(get<N>(std::declval<Args>()...))>;
+};
+
+template <int N, typename T>
+using get_type = typename get_type_impl<N, T>::type;
+
+template <typename T> struct is_compiled_format : std::false_type {};
+
+template <typename Char> struct text {
+  basic_string_view<Char> data;
+  using char_type = Char;
+
+  template <typename OutputIt, typename... Args>
+  constexpr OutputIt format(OutputIt out, const Args&...) const {
+    return write<Char>(out, data);
+  }
+};
+
+template <typename Char>
+struct is_compiled_format<text<Char>> : std::true_type {};
+
+template <typename Char>
+constexpr text<Char> make_text(basic_string_view<Char> s, size_t pos,
+                               size_t size) {
+  return {{&s[pos], size}};
+}
+
+template <typename Char> struct code_unit {
+  Char value;
+  using char_type = Char;
+
+  template <typename OutputIt, typename... Args>
+  constexpr OutputIt format(OutputIt out, const Args&...) const {
+    return write<Char>(out, value);
+  }
+};
+
+// This ensures that the argument type is convertible to `const T&`.
+template <typename T, int N, typename... Args>
+constexpr const T& get_arg_checked(const Args&... args) {
+  const auto& arg = get<N>(args...);
+  if constexpr (detail::is_named_arg<remove_cvref_t<decltype(arg)>>()) {
+    return arg.value;
+  } else {
+    return arg;
+  }
+}
+
+template <typename Char>
+struct is_compiled_format<code_unit<Char>> : std::true_type {};
+
+// A replacement field that refers to argument N.
+template <typename Char, typename T, int N> struct field {
+  using char_type = Char;
+
+  template <typename OutputIt, typename... Args>
+  constexpr OutputIt format(OutputIt out, const Args&... args) const {
+    return write<Char>(out, get_arg_checked<T, N>(args...));
+  }
+};
+
+template <typename Char, typename T, int N>
+struct is_compiled_format<field<Char, T, N>> : std::true_type {};
+
+// A replacement field that refers to argument with name.
+template <typename Char> struct runtime_named_field {
+  using char_type = Char;
+  basic_string_view<Char> name;
+
+  template <typename OutputIt, typename T>
+  constexpr static bool try_format_argument(
+      OutputIt& out,
+      // [[maybe_unused]] due to unused-but-set-parameter warning in GCC 7,8,9
+      [[maybe_unused]] basic_string_view<Char> arg_name, const T& arg) {
+    if constexpr (is_named_arg<typename std::remove_cv<T>::type>::value) {
+      if (arg_name == arg.name) {
+        out = write<Char>(out, arg.value);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  template <typename OutputIt, typename... Args>
+  constexpr OutputIt format(OutputIt out, const Args&... args) const {
+    bool found = (try_format_argument(out, name, args) || ...);
+    if (!found) {
+      throw format_error("argument with specified name is not found");
+    }
+    return out;
+  }
+};
+
+template <typename Char>
+struct is_compiled_format<runtime_named_field<Char>> : std::true_type {};
+
+// A replacement field that refers to argument N and has format specifiers.
+template <typename Char, typename T, int N> struct spec_field {
+  using char_type = Char;
+  formatter<T, Char> fmt;
+
+  template <typename OutputIt, typename... Args>
+  constexpr FMT_INLINE OutputIt format(OutputIt out,
+                                       const Args&... args) const {
+    const auto& vargs =
+        fmt::make_format_args<basic_format_context<OutputIt, Char>>(args...);
+    basic_format_context<OutputIt, Char> ctx(out, vargs);
+    return fmt.format(get_arg_checked<T, N>(args...), ctx);
+  }
+};
+
+template <typename Char, typename T, int N>
+struct is_compiled_format<spec_field<Char, T, N>> : std::true_type {};
+
+template <typename L, typename R> struct concat {
+  L lhs;
+  R rhs;
+  using char_type = typename L::char_type;
+
+  template <typename OutputIt, typename... Args>
+  constexpr OutputIt format(OutputIt out, const Args&... args) const {
+    out = lhs.format(out, args...);
+    return rhs.format(out, args...);
+  }
+};
+
+template <typename L, typename R>
+struct is_compiled_format<concat<L, R>> : std::true_type {};
+
+template <typename L, typename R>
+constexpr concat<L, R> make_concat(L lhs, R rhs) {
+  return {lhs, rhs};
+}
+
+struct unknown_format {};
+
+template <typename Char>
+constexpr size_t parse_text(basic_string_view<Char> str, size_t pos) {
+  for (size_t size = str.size(); pos != size; ++pos) {
+    if (str[pos] == '{' || str[pos] == '}') break;
+  }
+  return pos;
+}
+
+template <typename Args, size_t POS, int ID, typename S>
+constexpr auto compile_format_string(S format_str);
+
+template <typename Args, size_t POS, int ID, typename T, typename S>
+constexpr auto parse_tail(T head, S format_str) {
+  if constexpr (POS !=
+                basic_string_view<typename S::char_type>(format_str).size()) {
+    constexpr auto tail = compile_format_string<Args, POS, ID>(format_str);
+    if constexpr (std::is_same<remove_cvref_t<decltype(tail)>,
+                               unknown_format>())
+      return tail;
+    else
+      return make_concat(head, tail);
+  } else {
+    return head;
+  }
+}
+
+template <typename T, typename Char> struct parse_specs_result {
+  formatter<T, Char> fmt;
+  size_t end;
+  int next_arg_id;
+};
+
+constexpr int manual_indexing_id = -1;
+
+template <typename T, typename Char>
+constexpr parse_specs_result<T, Char> parse_specs(basic_string_view<Char> str,
+                                                  size_t pos, int next_arg_id) {
+  str.remove_prefix(pos);
+  auto ctx = basic_format_parse_context<Char>(str, {}, next_arg_id);
+  auto f = formatter<T, Char>();
+  auto end = f.parse(ctx);
+  return {f, pos + fmt::detail::to_unsigned(end - str.data()) + 1,
+          next_arg_id == 0 ? manual_indexing_id : ctx.next_arg_id()};
+}
+
+template <typename Char> struct arg_id_handler {
+  arg_ref<Char> arg_id;
+
+  constexpr int operator()() {
+    FMT_ASSERT(false, "handler cannot be used with automatic indexing");
+    return 0;
+  }
+  constexpr int operator()(int id) {
+    arg_id = arg_ref<Char>(id);
+    return 0;
+  }
+  constexpr int operator()(basic_string_view<Char> id) {
+    arg_id = arg_ref<Char>(id);
+    return 0;
+  }
+
+  constexpr void on_error(const char* message) { throw format_error(message); }
+};
+
+template <typename Char> struct parse_arg_id_result {
+  arg_ref<Char> arg_id;
+  const Char* arg_id_end;
+};
+
+template <int ID, typename Char>
+constexpr auto parse_arg_id(const Char* begin, const Char* end) {
+  auto handler = arg_id_handler<Char>{arg_ref<Char>{}};
+  auto arg_id_end = parse_arg_id(begin, end, handler);
+  return parse_arg_id_result<Char>{handler.arg_id, arg_id_end};
+}
+
+template <typename T, typename Enable = void> struct field_type {
+  using type = remove_cvref_t<T>;
+};
+
+template <typename T>
+struct field_type<T, enable_if_t<detail::is_named_arg<T>::value>> {
+  using type = remove_cvref_t<decltype(T::value)>;
+};
+
+template <typename T, typename Args, size_t END_POS, int ARG_INDEX, int NEXT_ID,
+          typename S>
+constexpr auto parse_replacement_field_then_tail(S format_str) {
+  using char_type = typename S::char_type;
+  constexpr auto str = basic_string_view<char_type>(format_str);
+  constexpr char_type c = END_POS != str.size() ? str[END_POS] : char_type();
+  if constexpr (c == '}') {
+    return parse_tail<Args, END_POS + 1, NEXT_ID>(
+        field<char_type, typename field_type<T>::type, ARG_INDEX>(),
+        format_str);
+  } else if constexpr (c == ':') {
+    constexpr auto result = parse_specs<typename field_type<T>::type>(
+        str, END_POS + 1, NEXT_ID == manual_indexing_id ? 0 : NEXT_ID);
+    return parse_tail<Args, result.end, result.next_arg_id>(
+        spec_field<char_type, typename field_type<T>::type, ARG_INDEX>{
+            result.fmt},
+        format_str);
+  }
+}
+
+// Compiles a non-empty format string and returns the compiled representation
+// or unknown_format() on unrecognized input.
+template <typename Args, size_t POS, int ID, typename S>
+constexpr auto compile_format_string(S format_str) {
+  using char_type = typename S::char_type;
+  constexpr auto str = basic_string_view<char_type>(format_str);
+  if constexpr (str[POS] == '{') {
+    if constexpr (POS + 1 == str.size())
+      throw format_error("unmatched '{' in format string");
+    if constexpr (str[POS + 1] == '{') {
+      return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str);
+    } else if constexpr (str[POS + 1] == '}' || str[POS + 1] == ':') {
+      static_assert(ID != manual_indexing_id,
+                    "cannot switch from manual to automatic argument indexing");
+      constexpr auto next_id =
+          ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
+      return parse_replacement_field_then_tail<get_type<ID, Args>, Args,
+                                               POS + 1, ID, next_id>(
+          format_str);
+    } else {
+      constexpr auto arg_id_result =
+          parse_arg_id<ID>(str.data() + POS + 1, str.data() + str.size());
+      constexpr auto arg_id_end_pos = arg_id_result.arg_id_end - str.data();
+      constexpr char_type c =
+          arg_id_end_pos != str.size() ? str[arg_id_end_pos] : char_type();
+      static_assert(c == '}' || c == ':', "missing '}' in format string");
+      if constexpr (arg_id_result.arg_id.kind == arg_id_kind::index) {
+        static_assert(
+            ID == manual_indexing_id || ID == 0,
+            "cannot switch from automatic to manual argument indexing");
+        constexpr auto arg_index = arg_id_result.arg_id.val.index;
+        return parse_replacement_field_then_tail<get_type<arg_index, Args>,
+                                                 Args, arg_id_end_pos,
+                                                 arg_index, manual_indexing_id>(
+            format_str);
+      } else if constexpr (arg_id_result.arg_id.kind == arg_id_kind::name) {
+        constexpr auto arg_index =
+            get_arg_index_by_name(arg_id_result.arg_id.val.name, Args{});
+        if constexpr (arg_index != invalid_arg_index) {
+          constexpr auto next_id =
+              ID != manual_indexing_id ? ID + 1 : manual_indexing_id;
+          return parse_replacement_field_then_tail<
+              decltype(get_type<arg_index, Args>::value), Args, arg_id_end_pos,
+              arg_index, next_id>(format_str);
+        } else {
+          if constexpr (c == '}') {
+            return parse_tail<Args, arg_id_end_pos + 1, ID>(
+                runtime_named_field<char_type>{arg_id_result.arg_id.val.name},
+                format_str);
+          } else if constexpr (c == ':') {
+            return unknown_format();  // no type info for specs parsing
+          }
+        }
+      }
+    }
+  } else if constexpr (str[POS] == '}') {
+    if constexpr (POS + 1 == str.size())
+      throw format_error("unmatched '}' in format string");
+    return parse_tail<Args, POS + 2, ID>(make_text(str, POS, 1), format_str);
+  } else {
+    constexpr auto end = parse_text(str, POS + 1);
+    if constexpr (end - POS > 1) {
+      return parse_tail<Args, end, ID>(make_text(str, POS, end - POS),
+                                       format_str);
+    } else {
+      return parse_tail<Args, end, ID>(code_unit<char_type>{str[POS]},
+                                       format_str);
+    }
+  }
+}
+
+template <typename... Args, typename S,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+constexpr auto compile(S format_str) {
+  constexpr auto str = basic_string_view<typename S::char_type>(format_str);
+  if constexpr (str.size() == 0) {
+    return detail::make_text(str, 0, 0);
+  } else {
+    constexpr auto result =
+        detail::compile_format_string<detail::type_list<Args...>, 0, 0>(
+            format_str);
+    return result;
+  }
+}
+#endif  // __cpp_if_constexpr
+}  // namespace detail
+
+FMT_MODULE_EXPORT_BEGIN
+
+#ifdef __cpp_if_constexpr
+
+template <typename CompiledFormat, typename... Args,
+          typename Char = typename CompiledFormat::char_type,
+          FMT_ENABLE_IF(detail::is_compiled_format<CompiledFormat>::value)>
+FMT_INLINE std::basic_string<Char> format(const CompiledFormat& cf,
+                                          const Args&... args) {
+  auto s = std::basic_string<Char>();
+  cf.format(std::back_inserter(s), args...);
+  return s;
+}
+
+template <typename OutputIt, typename CompiledFormat, typename... Args,
+          FMT_ENABLE_IF(detail::is_compiled_format<CompiledFormat>::value)>
+constexpr FMT_INLINE OutputIt format_to(OutputIt out, const CompiledFormat& cf,
+                                        const Args&... args) {
+  return cf.format(out, args...);
+}
+
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+FMT_INLINE std::basic_string<typename S::char_type> format(const S&,
+                                                           Args&&... args) {
+  if constexpr (std::is_same<typename S::char_type, char>::value) {
+    constexpr auto str = basic_string_view<typename S::char_type>(S());
+    if constexpr (str.size() == 2 && str[0] == '{' && str[1] == '}') {
+      const auto& first = detail::first(args...);
+      if constexpr (detail::is_named_arg<
+                        remove_cvref_t<decltype(first)>>::value) {
+        return fmt::to_string(first.value);
+      } else {
+        return fmt::to_string(first);
+      }
+    }
+  }
+  constexpr auto compiled = detail::compile<Args...>(S());
+  if constexpr (std::is_same<remove_cvref_t<decltype(compiled)>,
+                             detail::unknown_format>()) {
+    return format(static_cast<basic_string_view<typename S::char_type>>(S()),
+                  std::forward<Args>(args)...);
+  } else {
+    return format(compiled, std::forward<Args>(args)...);
+  }
+}
+
+template <typename OutputIt, typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+FMT_CONSTEXPR OutputIt format_to(OutputIt out, const S&, Args&&... args) {
+  constexpr auto compiled = detail::compile<Args...>(S());
+  if constexpr (std::is_same<remove_cvref_t<decltype(compiled)>,
+                             detail::unknown_format>()) {
+    return format_to(out,
+                     static_cast<basic_string_view<typename S::char_type>>(S()),
+                     std::forward<Args>(args)...);
+  } else {
+    return format_to(out, compiled, std::forward<Args>(args)...);
+  }
+}
+#endif
+
+template <typename OutputIt, typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+format_to_n_result<OutputIt> format_to_n(OutputIt out, size_t n,
+                                         const S& format_str, Args&&... args) {
+  auto it = format_to(detail::truncating_iterator<OutputIt>(out, n), format_str,
+                      std::forward<Args>(args)...);
+  return {it.base(), it.count()};
+}
+
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+size_t formatted_size(const S& format_str, const Args&... args) {
+  return format_to(detail::counting_iterator(), format_str, args...).count();
+}
+
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+void print(std::FILE* f, const S& format_str, const Args&... args) {
+  memory_buffer buffer;
+  format_to(std::back_inserter(buffer), format_str, args...);
+  detail::print(f, {buffer.data(), buffer.size()});
+}
+
+template <typename S, typename... Args,
+          FMT_ENABLE_IF(detail::is_compiled_string<S>::value)>
+void print(const S& format_str, const Args&... args) {
+  print(stdout, format_str, args...);
+}
+
+#if FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
+inline namespace literals {
+template <detail_exported::fixed_string Str>
+constexpr detail::udl_compiled_string<
+    remove_cvref_t<decltype(Str.data[0])>,
+    sizeof(Str.data) / sizeof(decltype(Str.data[0])), Str>
+operator""_cf() {
+  return {};
+}
+}  // namespace literals
+#endif
+
+FMT_MODULE_EXPORT_END
+FMT_END_NAMESPACE
+
+#endif  // FMT_COMPILE_H_

contrib/fmt-8.0.1/include/fmt/locale.h

@@ -0,0 +1,2 @@
+#include "xchar.h"
+#warning fmt/locale.h is deprecated, include fmt/format.h or fmt/xchar.h instead

contrib/fmt-8.0.1/include/fmt/os.h

@@ -0,0 +1,515 @@
+// Formatting library for C++ - optional OS-specific functionality
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_OS_H_
+#define FMT_OS_H_
+
+#include <cerrno>
+#include <clocale>  // locale_t
+#include <cstddef>
+#include <cstdio>
+#include <cstdlib>       // strtod_l
+#include <system_error>  // std::system_error
+
+#if defined __APPLE__ || defined(__FreeBSD__)
+#  include <xlocale.h>  // for LC_NUMERIC_MASK on OS X
+#endif
+
+#include "format.h"
+
+// UWP doesn't provide _pipe.
+#if FMT_HAS_INCLUDE("winapifamily.h")
+#  include <winapifamily.h>
+#endif
+#if (FMT_HAS_INCLUDE(<fcntl.h>) || defined(__APPLE__) || \
+     defined(__linux__)) &&                              \
+    (!defined(WINAPI_FAMILY) || (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP))
+#  include <fcntl.h>  // for O_RDONLY
+#  define FMT_USE_FCNTL 1
+#else
+#  define FMT_USE_FCNTL 0
+#endif
+
+#ifndef FMT_POSIX
+#  if defined(_WIN32) && !defined(__MINGW32__)
+// Fix warnings about deprecated symbols.
+#    define FMT_POSIX(call) _##call
+#  else
+#    define FMT_POSIX(call) call
+#  endif
+#endif
+
+// Calls to system functions are wrapped in FMT_SYSTEM for testability.
+#ifdef FMT_SYSTEM
+#  define FMT_POSIX_CALL(call) FMT_SYSTEM(call)
+#else
+#  define FMT_SYSTEM(call) ::call
+#  ifdef _WIN32
+// Fix warnings about deprecated symbols.
+#    define FMT_POSIX_CALL(call) ::_##call
+#  else
+#    define FMT_POSIX_CALL(call) ::call
+#  endif
+#endif
+
+// Retries the expression while it evaluates to error_result and errno
+// equals to EINTR.
+#ifndef _WIN32
+#  define FMT_RETRY_VAL(result, expression, error_result) \
+    do {                                                  \
+      (result) = (expression);                            \
+    } while ((result) == (error_result) && errno == EINTR)
+#else
+#  define FMT_RETRY_VAL(result, expression, error_result) result = (expression)
+#endif
+
+#define FMT_RETRY(result, expression) FMT_RETRY_VAL(result, expression, -1)
+
+FMT_BEGIN_NAMESPACE
+FMT_MODULE_EXPORT_BEGIN
+
+/**
+  \rst
+  A reference to a null-terminated string. It can be constructed from a C
+  string or ``std::string``.
+
+  You can use one of the following type aliases for common character types:
+
+  +---------------+-----------------------------+
+  | Type          | Definition                  |
+  +===============+=============================+
+  | cstring_view  | basic_cstring_view<char>    |
+  +---------------+-----------------------------+
+  | wcstring_view | basic_cstring_view<wchar_t> |
+  +---------------+-----------------------------+
+
+  This class is most useful as a parameter type to allow passing
+  different types of strings to a function, for example::
+
+    template <typename... Args>
+    std::string format(cstring_view format_str, const Args & ... args);
+
+    format("{}", 42);
+    format(std::string("{}"), 42);
+  \endrst
+ */
+template <typename Char> class basic_cstring_view {
+ private:
+  const Char* data_;
+
+ public:
+  /** Constructs a string reference object from a C string. */
+  basic_cstring_view(const Char* s) : data_(s) {}
+
+  /**
+    \rst
+    Constructs a string reference from an ``std::string`` object.
+    \endrst
+   */
+  basic_cstring_view(const std::basic_string<Char>& s) : data_(s.c_str()) {}
+
+  /** Returns the pointer to a C string. */
+  const Char* c_str() const { return data_; }
+};
+
+using cstring_view = basic_cstring_view<char>;
+using wcstring_view = basic_cstring_view<wchar_t>;
+
+template <typename Char> struct formatter<std::error_code, Char> {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  template <typename FormatContext>
+  FMT_CONSTEXPR auto format(const std::error_code& ec, FormatContext& ctx) const
+      -> decltype(ctx.out()) {
+    auto out = ctx.out();
+    out = detail::write_bytes(out, ec.category().name(),
+                              basic_format_specs<Char>());
+    out = detail::write<Char>(out, Char(':'));
+    out = detail::write<Char>(out, ec.value());
+    return out;
+  }
+};
+
+#ifdef _WIN32
+FMT_API const std::error_category& system_category() FMT_NOEXCEPT;
+
+FMT_BEGIN_DETAIL_NAMESPACE
+// A converter from UTF-16 to UTF-8.
+// It is only provided for Windows since other systems support UTF-8 natively.
+class utf16_to_utf8 {
+ private:
+  memory_buffer buffer_;
+
+ public:
+  utf16_to_utf8() {}
+  FMT_API explicit utf16_to_utf8(basic_string_view<wchar_t> s);
+  operator string_view() const { return string_view(&buffer_[0], size()); }
+  size_t size() const { return buffer_.size() - 1; }
+  const char* c_str() const { return &buffer_[0]; }
+  std::string str() const { return std::string(&buffer_[0], size()); }
+
+  // Performs conversion returning a system error code instead of
+  // throwing exception on conversion error. This method may still throw
+  // in case of memory allocation error.
+  FMT_API int convert(basic_string_view<wchar_t> s);
+};
+
+FMT_API void format_windows_error(buffer<char>& out, int error_code,
+                                  const char* message) FMT_NOEXCEPT;
+FMT_END_DETAIL_NAMESPACE
+
+FMT_API std::system_error vwindows_error(int error_code, string_view format_str,
+                                         format_args args);
+
+/**
+ \rst
+ Constructs a :class:`std::system_error` object with the description
+ of the form
+
+ .. parsed-literal::
+   *<message>*: *<system-message>*
+
+ where *<message>* is the formatted message and *<system-message>* is the
+ system message corresponding to the error code.
+ *error_code* is a Windows error code as given by ``GetLastError``.
+ If *error_code* is not a valid error code such as -1, the system message
+ will look like "error -1".
+
+ **Example**::
+
+   // This throws a system_error with the description
+   //   cannot open file 'madeup': The system cannot find the file specified.
+   // or similar (system message may vary).
+   const char *filename = "madeup";
+   LPOFSTRUCT of = LPOFSTRUCT();
+   HFILE file = OpenFile(filename, &of, OF_READ);
+   if (file == HFILE_ERROR) {
+     throw fmt::windows_error(GetLastError(),
+                              "cannot open file '{}'", filename);
+   }
+ \endrst
+*/
+template <typename... Args>
+std::system_error windows_error(int error_code, string_view message,
+                                const Args&... args) {
+  return vwindows_error(error_code, message, fmt::make_format_args(args...));
+}
+
+// Reports a Windows error without throwing an exception.
+// Can be used to report errors from destructors.
+FMT_API void report_windows_error(int error_code,
+                                  const char* message) FMT_NOEXCEPT;
+#else
+inline const std::error_category& system_category() FMT_NOEXCEPT {
+  return std::system_category();
+}
+#endif  // _WIN32
+
+// std::system is not available on some platforms such as iOS (#2248).
+#ifdef __OSX__
+template <typename S, typename... Args, typename Char = char_t<S>>
+void say(const S& format_str, Args&&... args) {
+  std::system(format("say \"{}\"", format(format_str, args...)).c_str());
+}
+#endif
+
+// A buffered file.
+class buffered_file {
+ private:
+  FILE* file_;
+
+  friend class file;
+
+  explicit buffered_file(FILE* f) : file_(f) {}
+
+ public:
+  buffered_file(const buffered_file&) = delete;
+  void operator=(const buffered_file&) = delete;
+
+  // Constructs a buffered_file object which doesn't represent any file.
+  buffered_file() FMT_NOEXCEPT : file_(nullptr) {}
+
+  // Destroys the object closing the file it represents if any.
+  FMT_API ~buffered_file() FMT_NOEXCEPT;
+
+ public:
+  buffered_file(buffered_file&& other) FMT_NOEXCEPT : file_(other.file_) {
+    other.file_ = nullptr;
+  }
+
+  buffered_file& operator=(buffered_file&& other) {
+    close();
+    file_ = other.file_;
+    other.file_ = nullptr;
+    return *this;
+  }
+
+  // Opens a file.
+  FMT_API buffered_file(cstring_view filename, cstring_view mode);
+
+  // Closes the file.
+  FMT_API void close();
+
+  // Returns the pointer to a FILE object representing this file.
+  FILE* get() const FMT_NOEXCEPT { return file_; }
+
+  // We place parentheses around fileno to workaround a bug in some versions
+  // of MinGW that define fileno as a macro.
+  FMT_API int(fileno)() const;
+
+  void vprint(string_view format_str, format_args args) {
+    fmt::vprint(file_, format_str, args);
+  }
+
+  template <typename... Args>
+  inline void print(string_view format_str, const Args&... args) {
+    vprint(format_str, fmt::make_format_args(args...));
+  }
+};
+
+#if FMT_USE_FCNTL
+// A file. Closed file is represented by a file object with descriptor -1.
+// Methods that are not declared with FMT_NOEXCEPT may throw
+// fmt::system_error in case of failure. Note that some errors such as
+// closing the file multiple times will cause a crash on Windows rather
+// than an exception. You can get standard behavior by overriding the
+// invalid parameter handler with _set_invalid_parameter_handler.
+class file {
+ private:
+  int fd_;  // File descriptor.
+
+  // Constructs a file object with a given descriptor.
+  explicit file(int fd) : fd_(fd) {}
+
+ public:
+  // Possible values for the oflag argument to the constructor.
+  enum {
+    RDONLY = FMT_POSIX(O_RDONLY),  // Open for reading only.
+    WRONLY = FMT_POSIX(O_WRONLY),  // Open for writing only.
+    RDWR = FMT_POSIX(O_RDWR),      // Open for reading and writing.
+    CREATE = FMT_POSIX(O_CREAT),   // Create if the file doesn't exist.
+    APPEND = FMT_POSIX(O_APPEND),  // Open in append mode.
+    TRUNC = FMT_POSIX(O_TRUNC)     // Truncate the content of the file.
+  };
+
+  // Constructs a file object which doesn't represent any file.
+  file() FMT_NOEXCEPT : fd_(-1) {}
+
+  // Opens a file and constructs a file object representing this file.
+  FMT_API file(cstring_view path, int oflag);
+
+ public:
+  file(const file&) = delete;
+  void operator=(const file&) = delete;
+
+  file(file&& other) FMT_NOEXCEPT : fd_(other.fd_) { other.fd_ = -1; }
+
+  // Move assignment is not noexcept because close may throw.
+  file& operator=(file&& other) {
+    close();
+    fd_ = other.fd_;
+    other.fd_ = -1;
+    return *this;
+  }
+
+  // Destroys the object closing the file it represents if any.
+  FMT_API ~file() FMT_NOEXCEPT;
+
+  // Returns the file descriptor.
+  int descriptor() const FMT_NOEXCEPT { return fd_; }
+
+  // Closes the file.
+  FMT_API void close();
+
+  // Returns the file size. The size has signed type for consistency with
+  // stat::st_size.
+  FMT_API long long size() const;
+
+  // Attempts to read count bytes from the file into the specified buffer.
+  FMT_API size_t read(void* buffer, size_t count);
+
+  // Attempts to write count bytes from the specified buffer to the file.
+  FMT_API size_t write(const void* buffer, size_t count);
+
+  // Duplicates a file descriptor with the dup function and returns
+  // the duplicate as a file object.
+  FMT_API static file dup(int fd);
+
+  // Makes fd be the copy of this file descriptor, closing fd first if
+  // necessary.
+  FMT_API void dup2(int fd);
+
+  // Makes fd be the copy of this file descriptor, closing fd first if
+  // necessary.
+  FMT_API void dup2(int fd, std::error_code& ec) FMT_NOEXCEPT;
+
+  // Creates a pipe setting up read_end and write_end file objects for reading
+  // and writing respectively.
+  FMT_API static void pipe(file& read_end, file& write_end);
+
+  // Creates a buffered_file object associated with this file and detaches
+  // this file object from the file.
+  FMT_API buffered_file fdopen(const char* mode);
+};
+
+// Returns the memory page size.
+long getpagesize();
+
+FMT_BEGIN_DETAIL_NAMESPACE
+
+struct buffer_size {
+  buffer_size() = default;
+  size_t value = 0;
+  buffer_size operator=(size_t val) const {
+    auto bs = buffer_size();
+    bs.value = val;
+    return bs;
+  }
+};
+
+struct ostream_params {
+  int oflag = file::WRONLY | file::CREATE | file::TRUNC;
+  size_t buffer_size = BUFSIZ > 32768 ? BUFSIZ : 32768;
+
+  ostream_params() {}
+
+  template <typename... T>
+  ostream_params(T... params, int new_oflag) : ostream_params(params...) {
+    oflag = new_oflag;
+  }
+
+  template <typename... T>
+  ostream_params(T... params, detail::buffer_size bs)
+      : ostream_params(params...) {
+    this->buffer_size = bs.value;
+  }
+};
+
+FMT_END_DETAIL_NAMESPACE
+
+constexpr detail::buffer_size buffer_size;
+
+/** A fast output stream which is not thread-safe. */
+class FMT_API ostream final : private detail::buffer<char> {
+ private:
+  file file_;
+
+  void flush() {
+    if (size() == 0) return;
+    file_.write(data(), size());
+    clear();
+  }
+
+  void grow(size_t) override;
+
+  ostream(cstring_view path, const detail::ostream_params& params)
+      : file_(path, params.oflag) {
+    set(new char[params.buffer_size], params.buffer_size);
+  }
+
+ public:
+  ostream(ostream&& other)
+      : detail::buffer<char>(other.data(), other.size(), other.capacity()),
+        file_(std::move(other.file_)) {
+    other.clear();
+    other.set(nullptr, 0);
+  }
+  ~ostream() {
+    flush();
+    delete[] data();
+  }
+
+  template <typename... T>
+  friend ostream output_file(cstring_view path, T... params);
+
+  void close() {
+    flush();
+    file_.close();
+  }
+
+  /**
+    Formats ``args`` according to specifications in ``fmt`` and writes the
+    output to the file.
+   */
+  template <typename... T> void print(format_string<T...> fmt, T&&... args) {
+    vformat_to(detail::buffer_appender<char>(*this), fmt,
+               fmt::make_format_args(args...));
+  }
+};
+
+/**
+  \rst
+  Opens a file for writing. Supported parameters passed in *params*:
+
+  * ``<integer>``: Flags passed to `open
+    <https://pubs.opengroup.org/onlinepubs/007904875/functions/open.html>`_
+    (``file::WRONLY | file::CREATE`` by default)
+  * ``buffer_size=<integer>``: Output buffer size
+
+  **Example**::
+
+    auto out = fmt::output_file("guide.txt");
+    out.print("Don't {}", "Panic");
+  \endrst
+ */
+template <typename... T>
+inline ostream output_file(cstring_view path, T... params) {
+  return {path, detail::ostream_params(params...)};
+}
+#endif  // FMT_USE_FCNTL
+
+#ifdef FMT_LOCALE
+// A "C" numeric locale.
+class locale {
+ private:
+#  ifdef _WIN32
+  using locale_t = _locale_t;
+
+  static void freelocale(locale_t loc) { _free_locale(loc); }
+
+  static double strtod_l(const char* nptr, char** endptr, _locale_t loc) {
+    return _strtod_l(nptr, endptr, loc);
+  }
+#  endif
+
+  locale_t locale_;
+
+ public:
+  using type = locale_t;
+  locale(const locale&) = delete;
+  void operator=(const locale&) = delete;
+
+  locale() {
+#  ifndef _WIN32
+    locale_ = FMT_SYSTEM(newlocale(LC_NUMERIC_MASK, "C", nullptr));
+#  else
+    locale_ = _create_locale(LC_NUMERIC, "C");
+#  endif
+    if (!locale_) FMT_THROW(system_error(errno, "cannot create locale"));
+  }
+  ~locale() { freelocale(locale_); }
+
+  type get() const { return locale_; }
+
+  // Converts string to floating-point number and advances str past the end
+  // of the parsed input.
+  double strtod(const char*& str) const {
+    char* end = nullptr;
+    double result = strtod_l(str, &end, locale_);
+    str = end;
+    return result;
+  }
+};
+using Locale FMT_DEPRECATED_ALIAS = locale;
+#endif  // FMT_LOCALE
+FMT_MODULE_EXPORT_END
+FMT_END_NAMESPACE
+
+#endif  // FMT_OS_H_

contrib/fmt-8.0.1/include/fmt/ostream.h

@@ -0,0 +1,181 @@
+// Formatting library for C++ - std::ostream support
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_OSTREAM_H_
+#define FMT_OSTREAM_H_
+
+#include <ostream>
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+
+template <typename Char> class basic_printf_parse_context;
+template <typename OutputIt, typename Char> class basic_printf_context;
+
+namespace detail {
+
+template <class Char> class formatbuf : public std::basic_streambuf<Char> {
+ private:
+  using int_type = typename std::basic_streambuf<Char>::int_type;
+  using traits_type = typename std::basic_streambuf<Char>::traits_type;
+
+  buffer<Char>& buffer_;
+
+ public:
+  formatbuf(buffer<Char>& buf) : buffer_(buf) {}
+
+ protected:
+  // The put-area is actually always empty. This makes the implementation
+  // simpler and has the advantage that the streambuf and the buffer are always
+  // in sync and sputc never writes into uninitialized memory. The obvious
+  // disadvantage is that each call to sputc always results in a (virtual) call
+  // to overflow. There is no disadvantage here for sputn since this always
+  // results in a call to xsputn.
+
+  int_type overflow(int_type ch = traits_type::eof()) FMT_OVERRIDE {
+    if (!traits_type::eq_int_type(ch, traits_type::eof()))
+      buffer_.push_back(static_cast<Char>(ch));
+    return ch;
+  }
+
+  std::streamsize xsputn(const Char* s, std::streamsize count) FMT_OVERRIDE {
+    buffer_.append(s, s + count);
+    return count;
+  }
+};
+
+struct converter {
+  template <typename T, FMT_ENABLE_IF(is_integral<T>::value)> converter(T);
+};
+
+template <typename Char> struct test_stream : std::basic_ostream<Char> {
+ private:
+  void_t<> operator<<(converter);
+};
+
+// Hide insertion operators for built-in types.
+template <typename Char, typename Traits>
+void_t<> operator<<(std::basic_ostream<Char, Traits>&, Char);
+template <typename Char, typename Traits>
+void_t<> operator<<(std::basic_ostream<Char, Traits>&, char);
+template <typename Traits>
+void_t<> operator<<(std::basic_ostream<char, Traits>&, char);
+template <typename Traits>
+void_t<> operator<<(std::basic_ostream<char, Traits>&, signed char);
+template <typename Traits>
+void_t<> operator<<(std::basic_ostream<char, Traits>&, unsigned char);
+
+// Checks if T has a user-defined operator<< (e.g. not a member of
+// std::ostream).
+template <typename T, typename Char> class is_streamable {
+ private:
+  template <typename U>
+  static bool_constant<!std::is_same<decltype(std::declval<test_stream<Char>&>()
+                                              << std::declval<U>()),
+                                     void_t<>>::value>
+  test(int);
+
+  template <typename> static std::false_type test(...);
+
+  using result = decltype(test<T>(0));
+
+ public:
+  is_streamable() = default;
+
+  static const bool value = result::value;
+};
+
+// Write the content of buf to os.
+template <typename Char>
+void write_buffer(std::basic_ostream<Char>& os, buffer<Char>& buf) {
+  const Char* buf_data = buf.data();
+  using unsigned_streamsize = std::make_unsigned<std::streamsize>::type;
+  unsigned_streamsize size = buf.size();
+  unsigned_streamsize max_size = to_unsigned(max_value<std::streamsize>());
+  do {
+    unsigned_streamsize n = size <= max_size ? size : max_size;
+    os.write(buf_data, static_cast<std::streamsize>(n));
+    buf_data += n;
+    size -= n;
+  } while (size != 0);
+}
+
+template <typename Char, typename T>
+void format_value(buffer<Char>& buf, const T& value,
+                  locale_ref loc = locale_ref()) {
+  formatbuf<Char> format_buf(buf);
+  std::basic_ostream<Char> output(&format_buf);
+#if !defined(FMT_STATIC_THOUSANDS_SEPARATOR)
+  if (loc) output.imbue(loc.get<std::locale>());
+#endif
+  output << value;
+  output.exceptions(std::ios_base::failbit | std::ios_base::badbit);
+  buf.try_resize(buf.size());
+}
+
+// Formats an object of type T that has an overloaded ostream operator<<.
+template <typename T, typename Char>
+struct fallback_formatter<T, Char, enable_if_t<is_streamable<T, Char>::value>>
+    : private formatter<basic_string_view<Char>, Char> {
+  FMT_CONSTEXPR auto parse(basic_format_parse_context<Char>& ctx)
+      -> decltype(ctx.begin()) {
+    return formatter<basic_string_view<Char>, Char>::parse(ctx);
+  }
+  template <typename ParseCtx,
+            FMT_ENABLE_IF(std::is_same<
+                          ParseCtx, basic_printf_parse_context<Char>>::value)>
+  auto parse(ParseCtx& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  template <typename OutputIt>
+  auto format(const T& value, basic_format_context<OutputIt, Char>& ctx)
+      -> OutputIt {
+    basic_memory_buffer<Char> buffer;
+    format_value(buffer, value, ctx.locale());
+    basic_string_view<Char> str(buffer.data(), buffer.size());
+    return formatter<basic_string_view<Char>, Char>::format(str, ctx);
+  }
+  template <typename OutputIt>
+  auto format(const T& value, basic_printf_context<OutputIt, Char>& ctx)
+      -> OutputIt {
+    basic_memory_buffer<Char> buffer;
+    format_value(buffer, value, ctx.locale());
+    return std::copy(buffer.begin(), buffer.end(), ctx.out());
+  }
+};
+}  // namespace detail
+
+FMT_MODULE_EXPORT
+template <typename Char>
+void vprint(std::basic_ostream<Char>& os, basic_string_view<Char> format_str,
+            basic_format_args<buffer_context<type_identity_t<Char>>> args) {
+  basic_memory_buffer<Char> buffer;
+  detail::vformat_to(buffer, format_str, args);
+  detail::write_buffer(os, buffer);
+}
+
+/**
+  \rst
+  Prints formatted data to the stream *os*.
+
+  **Example**::
+
+    fmt::print(cerr, "Don't {}!", "panic");
+  \endrst
+ */
+FMT_MODULE_EXPORT
+template <typename S, typename... Args,
+          typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>
+void print(std::basic_ostream<Char>& os, const S& format_str, Args&&... args) {
+  vprint(os, to_string_view(format_str),
+         fmt::make_args_checked<Args...>(format_str, args...));
+}
+FMT_END_NAMESPACE
+
+#endif  // FMT_OSTREAM_H_

contrib/fmt-8.0.1/include/fmt/printf.h

@@ -0,0 +1,652 @@
+// Formatting library for C++ - legacy printf implementation
+//
+// Copyright (c) 2012 - 2016, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_PRINTF_H_
+#define FMT_PRINTF_H_
+
+#include <algorithm>  // std::max
+#include <limits>     // std::numeric_limits
+#include <ostream>
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+FMT_MODULE_EXPORT_BEGIN
+
+template <typename T> struct printf_formatter { printf_formatter() = delete; };
+
+template <typename Char>
+class basic_printf_parse_context : public basic_format_parse_context<Char> {
+  using basic_format_parse_context<Char>::basic_format_parse_context;
+};
+
+template <typename OutputIt, typename Char> class basic_printf_context {
+ private:
+  OutputIt out_;
+  basic_format_args<basic_printf_context> args_;
+
+ public:
+  using char_type = Char;
+  using format_arg = basic_format_arg<basic_printf_context>;
+  using parse_context_type = basic_printf_parse_context<Char>;
+  template <typename T> using formatter_type = printf_formatter<T>;
+
+  /**
+    \rst
+    Constructs a ``printf_context`` object. References to the arguments are
+    stored in the context object so make sure they have appropriate lifetimes.
+    \endrst
+   */
+  basic_printf_context(OutputIt out,
+                       basic_format_args<basic_printf_context> args)
+      : out_(out), args_(args) {}
+
+  OutputIt out() { return out_; }
+  void advance_to(OutputIt it) { out_ = it; }
+
+  detail::locale_ref locale() { return {}; }
+
+  format_arg arg(int id) const { return args_.get(id); }
+
+  FMT_CONSTEXPR void on_error(const char* message) {
+    detail::error_handler().on_error(message);
+  }
+};
+
+FMT_BEGIN_DETAIL_NAMESPACE
+
+// Checks if a value fits in int - used to avoid warnings about comparing
+// signed and unsigned integers.
+template <bool IsSigned> struct int_checker {
+  template <typename T> static bool fits_in_int(T value) {
+    unsigned max = max_value<int>();
+    return value <= max;
+  }
+  static bool fits_in_int(bool) { return true; }
+};
+
+template <> struct int_checker<true> {
+  template <typename T> static bool fits_in_int(T value) {
+    return value >= (std::numeric_limits<int>::min)() &&
+           value <= max_value<int>();
+  }
+  static bool fits_in_int(int) { return true; }
+};
+
+class printf_precision_handler {
+ public:
+  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+  int operator()(T value) {
+    if (!int_checker<std::numeric_limits<T>::is_signed>::fits_in_int(value))
+      FMT_THROW(format_error("number is too big"));
+    return (std::max)(static_cast<int>(value), 0);
+  }
+
+  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+  int operator()(T) {
+    FMT_THROW(format_error("precision is not integer"));
+    return 0;
+  }
+};
+
+// An argument visitor that returns true iff arg is a zero integer.
+class is_zero_int {
+ public:
+  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+  bool operator()(T value) {
+    return value == 0;
+  }
+
+  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+  bool operator()(T) {
+    return false;
+  }
+};
+
+template <typename T> struct make_unsigned_or_bool : std::make_unsigned<T> {};
+
+template <> struct make_unsigned_or_bool<bool> { using type = bool; };
+
+template <typename T, typename Context> class arg_converter {
+ private:
+  using char_type = typename Context::char_type;
+
+  basic_format_arg<Context>& arg_;
+  char_type type_;
+
+ public:
+  arg_converter(basic_format_arg<Context>& arg, char_type type)
+      : arg_(arg), type_(type) {}
+
+  void operator()(bool value) {
+    if (type_ != 's') operator()<bool>(value);
+  }
+
+  template <typename U, FMT_ENABLE_IF(std::is_integral<U>::value)>
+  void operator()(U value) {
+    bool is_signed = type_ == 'd' || type_ == 'i';
+    using target_type = conditional_t<std::is_same<T, void>::value, U, T>;
+    if (const_check(sizeof(target_type) <= sizeof(int))) {
+      // Extra casts are used to silence warnings.
+      if (is_signed) {
+        arg_ = detail::make_arg<Context>(
+            static_cast<int>(static_cast<target_type>(value)));
+      } else {
+        using unsigned_type = typename make_unsigned_or_bool<target_type>::type;
+        arg_ = detail::make_arg<Context>(
+            static_cast<unsigned>(static_cast<unsigned_type>(value)));
+      }
+    } else {
+      if (is_signed) {
+        // glibc's printf doesn't sign extend arguments of smaller types:
+        //   std::printf("%lld", -42);  // prints "4294967254"
+        // but we don't have to do the same because it's a UB.
+        arg_ = detail::make_arg<Context>(static_cast<long long>(value));
+      } else {
+        arg_ = detail::make_arg<Context>(
+            static_cast<typename make_unsigned_or_bool<U>::type>(value));
+      }
+    }
+  }
+
+  template <typename U, FMT_ENABLE_IF(!std::is_integral<U>::value)>
+  void operator()(U) {}  // No conversion needed for non-integral types.
+};
+
+// Converts an integer argument to T for printf, if T is an integral type.
+// If T is void, the argument is converted to corresponding signed or unsigned
+// type depending on the type specifier: 'd' and 'i' - signed, other -
+// unsigned).
+template <typename T, typename Context, typename Char>
+void convert_arg(basic_format_arg<Context>& arg, Char type) {
+  visit_format_arg(arg_converter<T, Context>(arg, type), arg);
+}
+
+// Converts an integer argument to char for printf.
+template <typename Context> class char_converter {
+ private:
+  basic_format_arg<Context>& arg_;
+
+ public:
+  explicit char_converter(basic_format_arg<Context>& arg) : arg_(arg) {}
+
+  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+  void operator()(T value) {
+    arg_ = detail::make_arg<Context>(
+        static_cast<typename Context::char_type>(value));
+  }
+
+  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+  void operator()(T) {}  // No conversion needed for non-integral types.
+};
+
+// An argument visitor that return a pointer to a C string if argument is a
+// string or null otherwise.
+template <typename Char> struct get_cstring {
+  template <typename T> const Char* operator()(T) { return nullptr; }
+  const Char* operator()(const Char* s) { return s; }
+};
+
+// Checks if an argument is a valid printf width specifier and sets
+// left alignment if it is negative.
+template <typename Char> class printf_width_handler {
+ private:
+  using format_specs = basic_format_specs<Char>;
+
+  format_specs& specs_;
+
+ public:
+  explicit printf_width_handler(format_specs& specs) : specs_(specs) {}
+
+  template <typename T, FMT_ENABLE_IF(std::is_integral<T>::value)>
+  unsigned operator()(T value) {
+    auto width = static_cast<uint32_or_64_or_128_t<T>>(value);
+    if (detail::is_negative(value)) {
+      specs_.align = align::left;
+      width = 0 - width;
+    }
+    unsigned int_max = max_value<int>();
+    if (width > int_max) FMT_THROW(format_error("number is too big"));
+    return static_cast<unsigned>(width);
+  }
+
+  template <typename T, FMT_ENABLE_IF(!std::is_integral<T>::value)>
+  unsigned operator()(T) {
+    FMT_THROW(format_error("width is not integer"));
+    return 0;
+  }
+};
+
+// The ``printf`` argument formatter.
+template <typename OutputIt, typename Char>
+class printf_arg_formatter : public arg_formatter<Char> {
+ private:
+  using base = arg_formatter<Char>;
+  using context_type = basic_printf_context<OutputIt, Char>;
+  using format_specs = basic_format_specs<Char>;
+
+  context_type& context_;
+
+  OutputIt write_null_pointer(bool is_string = false) {
+    auto s = this->specs;
+    s.type = 0;
+    return write_bytes(this->out, is_string ? "(null)" : "(nil)", s);
+  }
+
+ public:
+  printf_arg_formatter(OutputIt iter, format_specs& s, context_type& ctx)
+      : base{iter, s, locale_ref()}, context_(ctx) {}
+
+  OutputIt operator()(monostate value) { return base::operator()(value); }
+
+  template <typename T, FMT_ENABLE_IF(detail::is_integral<T>::value)>
+  OutputIt operator()(T value) {
+    // MSVC2013 fails to compile separate overloads for bool and Char so use
+    // std::is_same instead.
+    if (std::is_same<T, Char>::value) {
+      format_specs fmt_specs = this->specs;
+      if (fmt_specs.type && fmt_specs.type != 'c')
+        return (*this)(static_cast<int>(value));
+      fmt_specs.sign = sign::none;
+      fmt_specs.alt = false;
+      fmt_specs.fill[0] = ' ';  // Ignore '0' flag for char types.
+      // align::numeric needs to be overwritten here since the '0' flag is
+      // ignored for non-numeric types
+      if (fmt_specs.align == align::none || fmt_specs.align == align::numeric)
+        fmt_specs.align = align::right;
+      return write<Char>(this->out, static_cast<Char>(value), fmt_specs);
+    }
+    return base::operator()(value);
+  }
+
+  template <typename T, FMT_ENABLE_IF(std::is_floating_point<T>::value)>
+  OutputIt operator()(T value) {
+    return base::operator()(value);
+  }
+
+  /** Formats a null-terminated C string. */
+  OutputIt operator()(const char* value) {
+    if (value) return base::operator()(value);
+    return write_null_pointer(this->specs.type != 'p');
+  }
+
+  /** Formats a null-terminated wide C string. */
+  OutputIt operator()(const wchar_t* value) {
+    if (value) return base::operator()(value);
+    return write_null_pointer(this->specs.type != 'p');
+  }
+
+  OutputIt operator()(basic_string_view<Char> value) {
+    return base::operator()(value);
+  }
+
+  /** Formats a pointer. */
+  OutputIt operator()(const void* value) {
+    return value ? base::operator()(value) : write_null_pointer();
+  }
+
+  /** Formats an argument of a custom (user-defined) type. */
+  OutputIt operator()(typename basic_format_arg<context_type>::handle handle) {
+    auto parse_ctx =
+        basic_printf_parse_context<Char>(basic_string_view<Char>());
+    handle.format(parse_ctx, context_);
+    return this->out;
+  }
+};
+
+template <typename Char>
+void parse_flags(basic_format_specs<Char>& specs, const Char*& it,
+                 const Char* end) {
+  for (; it != end; ++it) {
+    switch (*it) {
+    case '-':
+      specs.align = align::left;
+      break;
+    case '+':
+      specs.sign = sign::plus;
+      break;
+    case '0':
+      specs.fill[0] = '0';
+      break;
+    case ' ':
+      if (specs.sign != sign::plus) {
+        specs.sign = sign::space;
+      }
+      break;
+    case '#':
+      specs.alt = true;
+      break;
+    default:
+      return;
+    }
+  }
+}
+
+template <typename Char, typename GetArg>
+int parse_header(const Char*& it, const Char* end,
+                 basic_format_specs<Char>& specs, GetArg get_arg) {
+  int arg_index = -1;
+  Char c = *it;
+  if (c >= '0' && c <= '9') {
+    // Parse an argument index (if followed by '$') or a width possibly
+    // preceded with '0' flag(s).
+    int value = parse_nonnegative_int(it, end, -1);
+    if (it != end && *it == '$') {  // value is an argument index
+      ++it;
+      arg_index = value != -1 ? value : max_value<int>();
+    } else {
+      if (c == '0') specs.fill[0] = '0';
+      if (value != 0) {
+        // Nonzero value means that we parsed width and don't need to
+        // parse it or flags again, so return now.
+        if (value == -1) FMT_THROW(format_error("number is too big"));
+        specs.width = value;
+        return arg_index;
+      }
+    }
+  }
+  parse_flags(specs, it, end);
+  // Parse width.
+  if (it != end) {
+    if (*it >= '0' && *it <= '9') {
+      specs.width = parse_nonnegative_int(it, end, -1);
+      if (specs.width == -1) FMT_THROW(format_error("number is too big"));
+    } else if (*it == '*') {
+      ++it;
+      specs.width = static_cast<int>(visit_format_arg(
+          detail::printf_width_handler<Char>(specs), get_arg(-1)));
+    }
+  }
+  return arg_index;
+}
+
+template <typename Char, typename Context>
+void vprintf(buffer<Char>& buf, basic_string_view<Char> format,
+             basic_format_args<Context> args) {
+  using OutputIt = buffer_appender<Char>;
+  auto out = OutputIt(buf);
+  auto context = basic_printf_context<OutputIt, Char>(out, args);
+  auto parse_ctx = basic_printf_parse_context<Char>(format);
+
+  // Returns the argument with specified index or, if arg_index is -1, the next
+  // argument.
+  auto get_arg = [&](int arg_index) {
+    if (arg_index < 0)
+      arg_index = parse_ctx.next_arg_id();
+    else
+      parse_ctx.check_arg_id(--arg_index);
+    return detail::get_arg(context, arg_index);
+  };
+
+  const Char* start = parse_ctx.begin();
+  const Char* end = parse_ctx.end();
+  auto it = start;
+  while (it != end) {
+    if (!detail::find<false, Char>(it, end, '%', it)) {
+      it = end;  // detail::find leaves it == nullptr if it doesn't find '%'
+      break;
+    }
+    Char c = *it++;
+    if (it != end && *it == c) {
+      out = detail::write(
+          out, basic_string_view<Char>(start, detail::to_unsigned(it - start)));
+      start = ++it;
+      continue;
+    }
+    out = detail::write(out, basic_string_view<Char>(
+                                 start, detail::to_unsigned(it - 1 - start)));
+
+    basic_format_specs<Char> specs;
+    specs.align = align::right;
+
+    // Parse argument index, flags and width.
+    int arg_index = parse_header(it, end, specs, get_arg);
+    if (arg_index == 0) parse_ctx.on_error("argument not found");
+
+    // Parse precision.
+    if (it != end && *it == '.') {
+      ++it;
+      c = it != end ? *it : 0;
+      if ('0' <= c && c <= '9') {
+        specs.precision = parse_nonnegative_int(it, end, 0);
+      } else if (c == '*') {
+        ++it;
+        specs.precision = static_cast<int>(
+            visit_format_arg(detail::printf_precision_handler(), get_arg(-1)));
+      } else {
+        specs.precision = 0;
+      }
+    }
+
+    auto arg = get_arg(arg_index);
+    // For d, i, o, u, x, and X conversion specifiers, if a precision is
+    // specified, the '0' flag is ignored
+    if (specs.precision >= 0 && arg.is_integral())
+      specs.fill[0] =
+          ' ';  // Ignore '0' flag for non-numeric types or if '-' present.
+    if (specs.precision >= 0 && arg.type() == detail::type::cstring_type) {
+      auto str = visit_format_arg(detail::get_cstring<Char>(), arg);
+      auto str_end = str + specs.precision;
+      auto nul = std::find(str, str_end, Char());
+      arg = detail::make_arg<basic_printf_context<OutputIt, Char>>(
+          basic_string_view<Char>(
+              str, detail::to_unsigned(nul != str_end ? nul - str
+                                                      : specs.precision)));
+    }
+    if (specs.alt && visit_format_arg(detail::is_zero_int(), arg))
+      specs.alt = false;
+    if (specs.fill[0] == '0') {
+      if (arg.is_arithmetic() && specs.align != align::left)
+        specs.align = align::numeric;
+      else
+        specs.fill[0] = ' ';  // Ignore '0' flag for non-numeric types or if '-'
+                              // flag is also present.
+    }
+
+    // Parse length and convert the argument to the required type.
+    c = it != end ? *it++ : 0;
+    Char t = it != end ? *it : 0;
+    using detail::convert_arg;
+    switch (c) {
+    case 'h':
+      if (t == 'h') {
+        ++it;
+        t = it != end ? *it : 0;
+        convert_arg<signed char>(arg, t);
+      } else {
+        convert_arg<short>(arg, t);
+      }
+      break;
+    case 'l':
+      if (t == 'l') {
+        ++it;
+        t = it != end ? *it : 0;
+        convert_arg<long long>(arg, t);
+      } else {
+        convert_arg<long>(arg, t);
+      }
+      break;
+    case 'j':
+      convert_arg<intmax_t>(arg, t);
+      break;
+    case 'z':
+      convert_arg<size_t>(arg, t);
+      break;
+    case 't':
+      convert_arg<std::ptrdiff_t>(arg, t);
+      break;
+    case 'L':
+      // printf produces garbage when 'L' is omitted for long double, no
+      // need to do the same.
+      break;
+    default:
+      --it;
+      convert_arg<void>(arg, c);
+    }
+
+    // Parse type.
+    if (it == end) FMT_THROW(format_error("invalid format string"));
+    specs.type = static_cast<char>(*it++);
+    if (arg.is_integral()) {
+      // Normalize type.
+      switch (specs.type) {
+      case 'i':
+      case 'u':
+        specs.type = 'd';
+        break;
+      case 'c':
+        visit_format_arg(
+            detail::char_converter<basic_printf_context<OutputIt, Char>>(arg),
+            arg);
+        break;
+      }
+    }
+
+    start = it;
+
+    // Format argument.
+    out = visit_format_arg(
+        detail::printf_arg_formatter<OutputIt, Char>(out, specs, context), arg);
+  }
+  detail::write(out, basic_string_view<Char>(start, to_unsigned(it - start)));
+}
+FMT_END_DETAIL_NAMESPACE
+
+template <typename Char>
+using basic_printf_context_t =
+    basic_printf_context<detail::buffer_appender<Char>, Char>;
+
+using printf_context = basic_printf_context_t<char>;
+using wprintf_context = basic_printf_context_t<wchar_t>;
+
+using printf_args = basic_format_args<printf_context>;
+using wprintf_args = basic_format_args<wprintf_context>;
+
+/**
+  \rst
+  Constructs an `~fmt::format_arg_store` object that contains references to
+  arguments and can be implicitly converted to `~fmt::printf_args`.
+  \endrst
+ */
+template <typename... T>
+inline auto make_printf_args(const T&... args)
+    -> format_arg_store<printf_context, T...> {
+  return {args...};
+}
+
+/**
+  \rst
+  Constructs an `~fmt::format_arg_store` object that contains references to
+  arguments and can be implicitly converted to `~fmt::wprintf_args`.
+  \endrst
+ */
+template <typename... T>
+inline auto make_wprintf_args(const T&... args)
+    -> format_arg_store<wprintf_context, T...> {
+  return {args...};
+}
+
+template <typename S, typename Char = char_t<S>>
+inline auto vsprintf(
+    const S& fmt,
+    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
+    -> std::basic_string<Char> {
+  basic_memory_buffer<Char> buffer;
+  vprintf(buffer, to_string_view(fmt), args);
+  return to_string(buffer);
+}
+
+/**
+  \rst
+  Formats arguments and returns the result as a string.
+
+  **Example**::
+
+    std::string message = fmt::sprintf("The answer is %d", 42);
+  \endrst
+*/
+template <typename S, typename... T,
+          typename Char = enable_if_t<detail::is_string<S>::value, char_t<S>>>
+inline auto sprintf(const S& fmt, const T&... args) -> std::basic_string<Char> {
+  using context = basic_printf_context_t<Char>;
+  return vsprintf(to_string_view(fmt), fmt::make_format_args<context>(args...));
+}
+
+template <typename S, typename Char = char_t<S>>
+inline auto vfprintf(
+    std::FILE* f, const S& fmt,
+    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
+    -> int {
+  basic_memory_buffer<Char> buffer;
+  vprintf(buffer, to_string_view(fmt), args);
+  size_t size = buffer.size();
+  return std::fwrite(buffer.data(), sizeof(Char), size, f) < size
+             ? -1
+             : static_cast<int>(size);
+}
+
+/**
+  \rst
+  Prints formatted data to the file *f*.
+
+  **Example**::
+
+    fmt::fprintf(stderr, "Don't %s!", "panic");
+  \endrst
+ */
+template <typename S, typename... T, typename Char = char_t<S>>
+inline auto fprintf(std::FILE* f, const S& fmt, const T&... args) -> int {
+  using context = basic_printf_context_t<Char>;
+  return vfprintf(f, to_string_view(fmt),
+                  fmt::make_format_args<context>(args...));
+}
+
+template <typename S, typename Char = char_t<S>>
+inline auto vprintf(
+    const S& fmt,
+    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
+    -> int {
+  return vfprintf(stdout, to_string_view(fmt), args);
+}
+
+/**
+  \rst
+  Prints formatted data to ``stdout``.
+
+  **Example**::
+
+    fmt::printf("Elapsed time: %.2f seconds", 1.23);
+  \endrst
+ */
+template <typename S, typename... T, FMT_ENABLE_IF(detail::is_string<S>::value)>
+inline auto printf(const S& fmt, const T&... args) -> int {
+  return vprintf(
+      to_string_view(fmt),
+      fmt::make_format_args<basic_printf_context_t<char_t<S>>>(args...));
+}
+
+template <typename S, typename Char = char_t<S>>
+FMT_DEPRECATED auto vfprintf(
+    std::basic_ostream<Char>& os, const S& fmt,
+    basic_format_args<basic_printf_context_t<type_identity_t<Char>>> args)
+    -> int {
+  basic_memory_buffer<Char> buffer;
+  vprintf(buffer, to_string_view(fmt), args);
+  os.write(buffer.data(), static_cast<std::streamsize>(buffer.size()));
+  return static_cast<int>(buffer.size());
+}
+template <typename S, typename... T, typename Char = char_t<S>>
+FMT_DEPRECATED auto fprintf(std::basic_ostream<Char>& os, const S& fmt,
+                            const T&... args) -> int {
+  return vfprintf(os, to_string_view(fmt),
+                  fmt::make_format_args<basic_printf_context_t<Char>>(args...));
+}
+
+FMT_MODULE_EXPORT_END
+FMT_END_NAMESPACE
+
+#endif  // FMT_PRINTF_H_

contrib/fmt-8.0.1/include/fmt/ranges.h

@@ -0,0 +1,468 @@
+// Formatting library for C++ - experimental range support
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+//
+// Copyright (c) 2018 - present, Remotion (Igor Schulz)
+// All Rights Reserved
+// {fmt} support for ranges, containers and types tuple interface.
+
+#ifndef FMT_RANGES_H_
+#define FMT_RANGES_H_
+
+#include <initializer_list>
+#include <type_traits>
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+
+template <typename Char, typename Enable = void> struct formatting_range {
+#ifdef FMT_DEPRECATED_BRACED_RANGES
+  Char prefix = '{';
+  Char postfix = '}';
+#else
+  Char prefix = '[';
+  Char postfix = ']';
+#endif
+
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+};
+
+template <typename Char, typename Enable = void> struct formatting_tuple {
+  Char prefix = '(';
+  Char postfix = ')';
+
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+};
+
+namespace detail {
+
+template <typename RangeT, typename OutputIterator>
+OutputIterator copy(const RangeT& range, OutputIterator out) {
+  for (auto it = range.begin(), end = range.end(); it != end; ++it)
+    *out++ = *it;
+  return out;
+}
+
+template <typename OutputIterator>
+OutputIterator copy(const char* str, OutputIterator out) {
+  while (*str) *out++ = *str++;
+  return out;
+}
+
+template <typename OutputIterator>
+OutputIterator copy(char ch, OutputIterator out) {
+  *out++ = ch;
+  return out;
+}
+
+template <typename OutputIterator>
+OutputIterator copy(wchar_t ch, OutputIterator out) {
+  *out++ = ch;
+  return out;
+}
+
+/// Return true value if T has std::string interface, like std::string_view.
+template <typename T> class is_std_string_like {
+  template <typename U>
+  static auto check(U* p)
+      -> decltype((void)p->find('a'), p->length(), (void)p->data(), int());
+  template <typename> static void check(...);
+
+ public:
+  static FMT_CONSTEXPR_DECL const bool value =
+      is_string<T>::value || !std::is_void<decltype(check<T>(nullptr))>::value;
+};
+
+template <typename Char>
+struct is_std_string_like<fmt::basic_string_view<Char>> : std::true_type {};
+
+template <typename... Ts> struct conditional_helper {};
+
+template <typename T, typename _ = void> struct is_range_ : std::false_type {};
+
+#if !FMT_MSC_VER || FMT_MSC_VER > 1800
+
+#  define FMT_DECLTYPE_RETURN(val)  \
+    ->decltype(val) { return val; } \
+    static_assert(                  \
+        true, "")  // This makes it so that a semicolon is required after the
+                   // macro, which helps clang-format handle the formatting.
+
+// C array overload
+template <typename T, std::size_t N>
+auto range_begin(const T (&arr)[N]) -> const T* {
+  return arr;
+}
+template <typename T, std::size_t N>
+auto range_end(const T (&arr)[N]) -> const T* {
+  return arr + N;
+}
+
+template <typename T, typename Enable = void>
+struct has_member_fn_begin_end_t : std::false_type {};
+
+template <typename T>
+struct has_member_fn_begin_end_t<T, void_t<decltype(std::declval<T>().begin()),
+                                           decltype(std::declval<T>().end())>>
+    : std::true_type {};
+
+// Member function overload
+template <typename T>
+auto range_begin(T&& rng) FMT_DECLTYPE_RETURN(static_cast<T&&>(rng).begin());
+template <typename T>
+auto range_end(T&& rng) FMT_DECLTYPE_RETURN(static_cast<T&&>(rng).end());
+
+// ADL overload. Only participates in overload resolution if member functions
+// are not found.
+template <typename T>
+auto range_begin(T&& rng)
+    -> enable_if_t<!has_member_fn_begin_end_t<T&&>::value,
+                   decltype(begin(static_cast<T&&>(rng)))> {
+  return begin(static_cast<T&&>(rng));
+}
+template <typename T>
+auto range_end(T&& rng) -> enable_if_t<!has_member_fn_begin_end_t<T&&>::value,
+                                       decltype(end(static_cast<T&&>(rng)))> {
+  return end(static_cast<T&&>(rng));
+}
+
+template <typename T, typename Enable = void>
+struct has_const_begin_end : std::false_type {};
+template <typename T, typename Enable = void>
+struct has_mutable_begin_end : std::false_type {};
+
+template <typename T>
+struct has_const_begin_end<
+    T, void_t<decltype(detail::range_begin(
+                  std::declval<const remove_cvref_t<T>&>())),
+              decltype(detail::range_begin(
+                  std::declval<const remove_cvref_t<T>&>()))>>
+    : std::true_type {};
+
+template <typename T>
+struct has_mutable_begin_end<
+    T, void_t<decltype(detail::range_begin(std::declval<T>())),
+              decltype(detail::range_begin(std::declval<T>())),
+              enable_if_t<std::is_copy_constructible<T>::value>>>
+    : std::true_type {};
+
+template <typename T>
+struct is_range_<T, void>
+    : std::integral_constant<bool, (has_const_begin_end<T>::value ||
+                                    has_mutable_begin_end<T>::value)> {};
+
+template <typename T, typename Enable = void> struct range_to_view;
+template <typename T>
+struct range_to_view<T, enable_if_t<has_const_begin_end<T>::value>> {
+  struct view_t {
+    const T* m_range_ptr;
+
+    auto begin() const FMT_DECLTYPE_RETURN(detail::range_begin(*m_range_ptr));
+    auto end() const FMT_DECLTYPE_RETURN(detail::range_end(*m_range_ptr));
+  };
+  static auto view(const T& range) -> view_t { return {&range}; }
+};
+
+template <typename T>
+struct range_to_view<T, enable_if_t<!has_const_begin_end<T>::value &&
+                                    has_mutable_begin_end<T>::value>> {
+  struct view_t {
+    T m_range_copy;
+
+    auto begin() FMT_DECLTYPE_RETURN(detail::range_begin(m_range_copy));
+    auto end() FMT_DECLTYPE_RETURN(detail::range_end(m_range_copy));
+  };
+  static auto view(const T& range) -> view_t { return {range}; }
+};
+#  undef FMT_DECLTYPE_RETURN
+#endif
+
+/// tuple_size and tuple_element check.
+template <typename T> class is_tuple_like_ {
+  template <typename U>
+  static auto check(U* p) -> decltype(std::tuple_size<U>::value, int());
+  template <typename> static void check(...);
+
+ public:
+  static FMT_CONSTEXPR_DECL const bool value =
+      !std::is_void<decltype(check<T>(nullptr))>::value;
+};
+
+// Check for integer_sequence
+#if defined(__cpp_lib_integer_sequence) || FMT_MSC_VER >= 1900
+template <typename T, T... N>
+using integer_sequence = std::integer_sequence<T, N...>;
+template <size_t... N> using index_sequence = std::index_sequence<N...>;
+template <size_t N> using make_index_sequence = std::make_index_sequence<N>;
+#else
+template <typename T, T... N> struct integer_sequence {
+  using value_type = T;
+
+  static FMT_CONSTEXPR size_t size() { return sizeof...(N); }
+};
+
+template <size_t... N> using index_sequence = integer_sequence<size_t, N...>;
+
+template <typename T, size_t N, T... Ns>
+struct make_integer_sequence : make_integer_sequence<T, N - 1, N - 1, Ns...> {};
+template <typename T, T... Ns>
+struct make_integer_sequence<T, 0, Ns...> : integer_sequence<T, Ns...> {};
+
+template <size_t N>
+using make_index_sequence = make_integer_sequence<size_t, N>;
+#endif
+
+template <class Tuple, class F, size_t... Is>
+void for_each(index_sequence<Is...>, Tuple&& tup, F&& f) FMT_NOEXCEPT {
+  using std::get;
+  // using free function get<I>(T) now.
+  const int _[] = {0, ((void)f(get<Is>(tup)), 0)...};
+  (void)_;  // blocks warnings
+}
+
+template <class T>
+FMT_CONSTEXPR make_index_sequence<std::tuple_size<T>::value> get_indexes(
+    T const&) {
+  return {};
+}
+
+template <class Tuple, class F> void for_each(Tuple&& tup, F&& f) {
+  const auto indexes = get_indexes(tup);
+  for_each(indexes, std::forward<Tuple>(tup), std::forward<F>(f));
+}
+
+template <typename Range>
+using value_type =
+    remove_cvref_t<decltype(*detail::range_begin(std::declval<Range>()))>;
+
+template <typename OutputIt> OutputIt write_delimiter(OutputIt out) {
+  *out++ = ',';
+  *out++ = ' ';
+  return out;
+}
+
+template <
+    typename Char, typename OutputIt, typename Arg,
+    FMT_ENABLE_IF(is_std_string_like<typename std::decay<Arg>::type>::value)>
+OutputIt write_range_entry(OutputIt out, const Arg& v) {
+  *out++ = '"';
+  out = write<Char>(out, v);
+  *out++ = '"';
+  return out;
+}
+
+template <typename Char, typename OutputIt, typename Arg,
+          FMT_ENABLE_IF(std::is_same<Arg, Char>::value)>
+OutputIt write_range_entry(OutputIt out, const Arg v) {
+  *out++ = '\'';
+  *out++ = v;
+  *out++ = '\'';
+  return out;
+}
+
+template <
+    typename Char, typename OutputIt, typename Arg,
+    FMT_ENABLE_IF(!is_std_string_like<typename std::decay<Arg>::type>::value &&
+                  !std::is_same<Arg, Char>::value)>
+OutputIt write_range_entry(OutputIt out, const Arg& v) {
+  return write<Char>(out, v);
+}
+
+}  // namespace detail
+
+template <typename T> struct is_tuple_like {
+  static FMT_CONSTEXPR_DECL const bool value =
+      detail::is_tuple_like_<T>::value && !detail::is_range_<T>::value;
+};
+
+template <typename TupleT, typename Char>
+struct formatter<TupleT, Char, enable_if_t<fmt::is_tuple_like<TupleT>::value>> {
+ private:
+  // C++11 generic lambda for format()
+  template <typename FormatContext> struct format_each {
+    template <typename T> void operator()(const T& v) {
+      if (i > 0) out = detail::write_delimiter(out);
+      out = detail::write_range_entry<Char>(out, v);
+      ++i;
+    }
+    formatting_tuple<Char>& formatting;
+    size_t& i;
+    typename std::add_lvalue_reference<
+        decltype(std::declval<FormatContext>().out())>::type out;
+  };
+
+ public:
+  formatting_tuple<Char> formatting;
+
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return formatting.parse(ctx);
+  }
+
+  template <typename FormatContext = format_context>
+  auto format(const TupleT& values, FormatContext& ctx) -> decltype(ctx.out()) {
+    auto out = ctx.out();
+    size_t i = 0;
+
+    detail::copy(formatting.prefix, out);
+    detail::for_each(values, format_each<FormatContext>{formatting, i, out});
+    detail::copy(formatting.postfix, out);
+
+    return ctx.out();
+  }
+};
+
+template <typename T, typename Char> struct is_range {
+  static FMT_CONSTEXPR_DECL const bool value =
+      detail::is_range_<T>::value && !detail::is_std_string_like<T>::value &&
+      !std::is_convertible<T, std::basic_string<Char>>::value &&
+      !std::is_constructible<detail::std_string_view<Char>, T>::value;
+};
+
+template <typename T, typename Char>
+struct formatter<
+    T, Char,
+    enable_if_t<
+        fmt::is_range<T, Char>::value
+// Workaround a bug in MSVC 2017 and earlier.
+#if !FMT_MSC_VER || FMT_MSC_VER >= 1927
+        && (has_formatter<detail::value_type<T>, format_context>::value ||
+            detail::has_fallback_formatter<detail::value_type<T>, Char>::value)
+#endif
+        >> {
+  formatting_range<Char> formatting;
+
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return formatting.parse(ctx);
+  }
+
+  template <typename FormatContext>
+  typename FormatContext::iterator format(const T& values, FormatContext& ctx) {
+    auto out = detail::copy(formatting.prefix, ctx.out());
+    size_t i = 0;
+    auto view = detail::range_to_view<T>::view(values);
+    auto it = view.begin();
+    auto end = view.end();
+    for (; it != end; ++it) {
+      if (i > 0) out = detail::write_delimiter(out);
+      out = detail::write_range_entry<Char>(out, *it);
+      ++i;
+    }
+    return detail::copy(formatting.postfix, out);
+  }
+};
+
+template <typename Char, typename... T> struct tuple_join_view : detail::view {
+  const std::tuple<T...>& tuple;
+  basic_string_view<Char> sep;
+
+  tuple_join_view(const std::tuple<T...>& t, basic_string_view<Char> s)
+      : tuple(t), sep{s} {}
+};
+
+template <typename Char, typename... T>
+using tuple_arg_join = tuple_join_view<Char, T...>;
+
+template <typename Char, typename... T>
+struct formatter<tuple_join_view<Char, T...>, Char> {
+  template <typename ParseContext>
+  FMT_CONSTEXPR auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    return ctx.begin();
+  }
+
+  template <typename FormatContext>
+  auto format(const tuple_join_view<Char, T...>& value, FormatContext& ctx) ->
+      typename FormatContext::iterator {
+    return format(value, ctx, detail::make_index_sequence<sizeof...(T)>{});
+  }
+
+ private:
+  template <typename FormatContext, size_t... N>
+  auto format(const tuple_join_view<Char, T...>& value, FormatContext& ctx,
+              detail::index_sequence<N...>) ->
+      typename FormatContext::iterator {
+    using std::get;
+    return format_args(value, ctx, get<N>(value.tuple)...);
+  }
+
+  template <typename FormatContext>
+  auto format_args(const tuple_join_view<Char, T...>&, FormatContext& ctx) ->
+      typename FormatContext::iterator {
+    // NOTE: for compilers that support C++17, this empty function instantiation
+    // can be replaced with a constexpr branch in the variadic overload.
+    return ctx.out();
+  }
+
+  template <typename FormatContext, typename Arg, typename... Args>
+  auto format_args(const tuple_join_view<Char, T...>& value, FormatContext& ctx,
+                   const Arg& arg, const Args&... args) ->
+      typename FormatContext::iterator {
+    using base = formatter<typename std::decay<Arg>::type, Char>;
+    auto out = base().format(arg, ctx);
+    if (sizeof...(Args) > 0) {
+      out = std::copy(value.sep.begin(), value.sep.end(), out);
+      ctx.advance_to(out);
+      return format_args(value, ctx, args...);
+    }
+    return out;
+  }
+};
+
+FMT_MODULE_EXPORT_BEGIN
+
+/**
+  \rst
+  Returns an object that formats `tuple` with elements separated by `sep`.
+
+  **Example**::
+
+    std::tuple<int, char> t = {1, 'a'};
+    fmt::print("{}", fmt::join(t, ", "));
+    // Output: "1, a"
+  \endrst
+ */
+template <typename... T>
+FMT_CONSTEXPR auto join(const std::tuple<T...>& tuple, string_view sep)
+    -> tuple_join_view<char, T...> {
+  return {tuple, sep};
+}
+
+template <typename... T>
+FMT_CONSTEXPR auto join(const std::tuple<T...>& tuple,
+                        basic_string_view<wchar_t> sep)
+    -> tuple_join_view<wchar_t, T...> {
+  return {tuple, sep};
+}
+
+/**
+  \rst
+  Returns an object that formats `initializer_list` with elements separated by
+  `sep`.
+
+  **Example**::
+
+    fmt::print("{}", fmt::join({1, 2, 3}, ", "));
+    // Output: "1, 2, 3"
+  \endrst
+ */
+template <typename T>
+auto join(std::initializer_list<T> list, string_view sep)
+    -> join_view<const T*, const T*> {
+  return join(std::begin(list), std::end(list), sep);
+}
+
+FMT_MODULE_EXPORT_END
+FMT_END_NAMESPACE
+
+#endif  // FMT_RANGES_H_

contrib/fmt-8.0.1/include/fmt/xchar.h

@@ -0,0 +1,236 @@
+// Formatting library for C++ - optional wchar_t and exotic character support
+//
+// Copyright (c) 2012 - present, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#ifndef FMT_WCHAR_H_
+#define FMT_WCHAR_H_
+
+#include <cwchar>
+#include <tuple>
+
+#include "format.h"
+
+FMT_BEGIN_NAMESPACE
+namespace detail {
+template <typename T>
+using is_exotic_char = bool_constant<!std::is_same<T, char>::value>;
+}
+
+FMT_MODULE_EXPORT_BEGIN
+
+using wstring_view = basic_string_view<wchar_t>;
+using wformat_parse_context = basic_format_parse_context<wchar_t>;
+using wformat_context = buffer_context<wchar_t>;
+using wformat_args = basic_format_args<wformat_context>;
+using wmemory_buffer = basic_memory_buffer<wchar_t>;
+
+#if FMT_GCC_VERSION && FMT_GCC_VERSION < 409
+// Workaround broken conversion on older gcc.
+template <typename... Args> using wformat_string = wstring_view;
+#else
+template <typename... Args>
+using wformat_string = basic_format_string<wchar_t, type_identity_t<Args>...>;
+#endif
+
+template <> struct is_char<wchar_t> : std::true_type {};
+template <> struct is_char<detail::char8_type> : std::true_type {};
+template <> struct is_char<char16_t> : std::true_type {};
+template <> struct is_char<char32_t> : std::true_type {};
+
+template <typename... Args>
+constexpr format_arg_store<wformat_context, Args...> make_wformat_args(
+    const Args&... args) {
+  return {args...};
+}
+
+inline namespace literals {
+constexpr auto operator"" _format(const wchar_t* s, size_t n)
+    -> detail::udl_formatter<wchar_t> {
+  return {{s, n}};
+}
+
+#if FMT_USE_USER_DEFINED_LITERALS && !FMT_USE_NONTYPE_TEMPLATE_PARAMETERS
+constexpr detail::udl_arg<wchar_t> operator"" _a(const wchar_t* s, size_t) {
+  return {s};
+}
+#endif
+}  // namespace literals
+
+template <typename It, typename Sentinel>
+auto join(It begin, Sentinel end, wstring_view sep)
+    -> join_view<It, Sentinel, wchar_t> {
+  return {begin, end, sep};
+}
+
+template <typename Range>
+auto join(Range&& range, wstring_view sep)
+    -> join_view<detail::iterator_t<Range>, detail::sentinel_t<Range>,
+                 wchar_t> {
+  return join(std::begin(range), std::end(range), sep);
+}
+
+template <typename T>
+auto join(std::initializer_list<T> list, wstring_view sep)
+    -> join_view<const T*, const T*, wchar_t> {
+  return join(std::begin(list), std::end(list), sep);
+}
+
+template <typename Char, FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
+auto vformat(basic_string_view<Char> format_str,
+             basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> std::basic_string<Char> {
+  basic_memory_buffer<Char> buffer;
+  detail::vformat_to(buffer, format_str, args);
+  return to_string(buffer);
+}
+
+// Pass char_t as a default template parameter instead of using
+// std::basic_string<char_t<S>> to reduce the symbol size.
+template <typename S, typename... Args, typename Char = char_t<S>,
+          FMT_ENABLE_IF(!std::is_same<Char, char>::value)>
+auto format(const S& format_str, Args&&... args) -> std::basic_string<Char> {
+  const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
+  return vformat(to_string_view(format_str), vargs);
+}
+
+template <typename Locale, typename S, typename Char = char_t<S>,
+          FMT_ENABLE_IF(detail::is_locale<Locale>::value&&
+                            detail::is_exotic_char<Char>::value)>
+inline auto vformat(
+    const Locale& loc, const S& format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> std::basic_string<Char> {
+  return detail::vformat(loc, to_string_view(format_str), args);
+}
+
+template <typename Locale, typename S, typename... Args,
+          typename Char = char_t<S>,
+          FMT_ENABLE_IF(detail::is_locale<Locale>::value&&
+                            detail::is_exotic_char<Char>::value)>
+inline auto format(const Locale& loc, const S& format_str, Args&&... args)
+    -> std::basic_string<Char> {
+  return detail::vformat(loc, to_string_view(format_str),
+                         fmt::make_args_checked<Args...>(format_str, args...));
+}
+
+template <typename OutputIt, typename S, typename Char = char_t<S>,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
+                            detail::is_exotic_char<Char>::value)>
+auto vformat_to(OutputIt out, const S& format_str,
+                basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> OutputIt {
+  auto&& buf = detail::get_buffer<Char>(out);
+  detail::vformat_to(buf, to_string_view(format_str), args);
+  return detail::get_iterator(buf);
+}
+
+template <typename OutputIt, typename S, typename... Args,
+          typename Char = char_t<S>,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
+                            detail::is_exotic_char<Char>::value)>
+inline auto format_to(OutputIt out, const S& fmt, Args&&... args) -> OutputIt {
+  const auto& vargs = fmt::make_args_checked<Args...>(fmt, args...);
+  return vformat_to(out, to_string_view(fmt), vargs);
+}
+
+template <typename S, typename... Args, typename Char, size_t SIZE,
+          typename Allocator, FMT_ENABLE_IF(detail::is_string<S>::value)>
+FMT_DEPRECATED auto format_to(basic_memory_buffer<Char, SIZE, Allocator>& buf,
+                              const S& format_str, Args&&... args) ->
+    typename buffer_context<Char>::iterator {
+  const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
+  detail::vformat_to(buf, to_string_view(format_str), vargs, {});
+  return detail::buffer_appender<Char>(buf);
+}
+
+template <typename Locale, typename S, typename OutputIt, typename... Args,
+          typename Char = char_t<S>,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
+                            detail::is_locale<Locale>::value&&
+                                detail::is_exotic_char<Char>::value)>
+inline auto vformat_to(
+    OutputIt out, const Locale& loc, const S& format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args) -> OutputIt {
+  auto&& buf = detail::get_buffer<Char>(out);
+  vformat_to(buf, to_string_view(format_str), args, detail::locale_ref(loc));
+  return detail::get_iterator(buf);
+}
+
+template <
+    typename OutputIt, typename Locale, typename S, typename... Args,
+    typename Char = char_t<S>,
+    bool enable = detail::is_output_iterator<OutputIt, Char>::value&&
+        detail::is_locale<Locale>::value&& detail::is_exotic_char<Char>::value>
+inline auto format_to(OutputIt out, const Locale& loc, const S& format_str,
+                      Args&&... args) ->
+    typename std::enable_if<enable, OutputIt>::type {
+  const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
+  return vformat_to(out, loc, to_string_view(format_str), vargs);
+}
+
+template <typename OutputIt, typename Char, typename... Args,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
+                            detail::is_exotic_char<Char>::value)>
+inline auto vformat_to_n(
+    OutputIt out, size_t n, basic_string_view<Char> format_str,
+    basic_format_args<buffer_context<type_identity_t<Char>>> args)
+    -> format_to_n_result<OutputIt> {
+  detail::iterator_buffer<OutputIt, Char, detail::fixed_buffer_traits> buf(out,
+                                                                           n);
+  detail::vformat_to(buf, format_str, args);
+  return {buf.out(), buf.count()};
+}
+
+template <typename OutputIt, typename S, typename... Args,
+          typename Char = char_t<S>,
+          FMT_ENABLE_IF(detail::is_output_iterator<OutputIt, Char>::value&&
+                            detail::is_exotic_char<Char>::value)>
+inline auto format_to_n(OutputIt out, size_t n, const S& fmt,
+                        const Args&... args) -> format_to_n_result<OutputIt> {
+  const auto& vargs = fmt::make_args_checked<Args...>(fmt, args...);
+  return vformat_to_n(out, n, to_string_view(fmt), vargs);
+}
+
+template <typename S, typename... Args, typename Char = char_t<S>,
+          FMT_ENABLE_IF(detail::is_exotic_char<Char>::value)>
+inline auto formatted_size(const S& fmt, Args&&... args) -> size_t {
+  detail::counting_buffer<Char> buf;
+  const auto& vargs = fmt::make_args_checked<Args...>(fmt, args...);
+  detail::vformat_to(buf, to_string_view(fmt), vargs);
+  return buf.count();
+}
+
+inline void vprint(std::FILE* f, wstring_view fmt, wformat_args args) {
+  wmemory_buffer buffer;
+  detail::vformat_to(buffer, fmt, args);
+  buffer.push_back(L'\0');
+  if (std::fputws(buffer.data(), f) == -1)
+    FMT_THROW(system_error(errno, FMT_STRING("cannot write to file")));
+}
+
+inline void vprint(wstring_view fmt, wformat_args args) {
+  vprint(stdout, fmt, args);
+}
+
+template <typename... T>
+void print(std::FILE* f, wformat_string<T...> fmt, T&&... args) {
+  return vprint(f, wstring_view(fmt), make_wformat_args(args...));
+}
+
+template <typename... T> void print(wformat_string<T...> fmt, T&&... args) {
+  return vprint(wstring_view(fmt), make_wformat_args(args...));
+}
+
+/**
+  Converts *value* to ``std::wstring`` using the default format for type *T*.
+ */
+template <typename T> inline auto to_wstring(const T& value) -> std::wstring {
+  return format(FMT_STRING(L"{}"), value);
+}
+FMT_MODULE_EXPORT_END
+FMT_END_NAMESPACE
+
+#endif  // FMT_WCHAR_H_

contrib/fmt-8.0.1/src/fmt.cc

@@ -0,0 +1,100 @@
+module;
+#ifndef __cpp_modules
+#  error Module not supported.
+#endif
+
+// put all implementation-provided headers into the global module fragment
+// to prevent attachment to this module
+#if !defined(_CRT_SECURE_NO_WARNINGS) && defined(_MSC_VER)
+#  define _CRT_SECURE_NO_WARNINGS
+#endif
+#if !defined(WIN32_LEAN_AND_MEAN) && defined(_WIN32)
+#  define WIN32_LEAN_AND_MEAN
+#endif
+
+#include <algorithm>
+#include <cctype>
+#include <cerrno>
+#include <chrono>
+#include <climits>
+#include <clocale>
+#include <cmath>
+#include <cstdarg>
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <ctime>
+#include <cwchar>
+#include <exception>
+#include <functional>
+#include <iterator>
+#include <limits>
+#include <locale>
+#include <memory>
+#include <ostream>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <string_view>
+#include <system_error>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#if _MSC_VER
+#  include <intrin.h>
+#endif
+#if defined __APPLE__ || defined(__FreeBSD__)
+#  include <xlocale.h>
+#endif
+#if __has_include(<winapifamily.h>)
+#  include <winapifamily.h>
+#endif
+#if (__has_include(<fcntl.h>) || defined(__APPLE__) || \
+     defined(__linux__)) &&                            \
+    (!defined(WINAPI_FAMILY) || (WINAPI_FAMILY == WINAPI_FAMILY_DESKTOP_APP))
+#  include <fcntl.h>
+#  include <sys/stat.h>
+#  include <sys/types.h>
+#  ifndef _WIN32
+#    include <unistd.h>
+#  else
+#    include <io.h>
+#  endif
+#endif
+#ifdef _WIN32
+#  include <windows.h>
+#endif
+
+export module fmt;
+
+#define FMT_MODULE_EXPORT export
+#define FMT_MODULE_EXPORT_BEGIN export {
+#define FMT_MODULE_EXPORT_END }
+#define FMT_BEGIN_DETAIL_NAMESPACE \
+  }                                \
+  namespace detail {
+#define FMT_END_DETAIL_NAMESPACE \
+  }                              \
+  export {
+
+// all library-provided declarations and definitions
+// must be in the module purview to be exported
+#include "fmt/args.h"
+#include "fmt/chrono.h"
+#include "fmt/color.h"
+#include "fmt/compile.h"
+#include "fmt/format.h"
+#include "fmt/os.h"
+#include "fmt/printf.h"
+#include "fmt/xchar.h"
+
+// gcc doesn't yet implement private module fragments
+#if !FMT_GCC_VERSION
+module : private;
+#endif
+
+#include "format.cc"
+#include "os.cc"

contrib/fmt-8.0.1/src/format.cc

@@ -0,0 +1,78 @@
+// Formatting library for C++
+//
+// Copyright (c) 2012 - 2016, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+#include "fmt/format-inl.h"
+
+FMT_BEGIN_NAMESPACE
+namespace detail {
+
+template <typename T>
+int format_float(char* buf, std::size_t size, const char* format, int precision,
+                 T value) {
+#ifdef FMT_FUZZ
+  if (precision > 100000)
+    throw std::runtime_error(
+        "fuzz mode - avoid large allocation inside snprintf");
+#endif
+  // Suppress the warning about nonliteral format string.
+  int (*snprintf_ptr)(char*, size_t, const char*, ...) = FMT_SNPRINTF;
+  return precision < 0 ? snprintf_ptr(buf, size, format, value)
+                       : snprintf_ptr(buf, size, format, precision, value);
+}
+
+template FMT_API dragonbox::decimal_fp<float> dragonbox::to_decimal(float x)
+    FMT_NOEXCEPT;
+template FMT_API dragonbox::decimal_fp<double> dragonbox::to_decimal(double x)
+    FMT_NOEXCEPT;
+}  // namespace detail
+
+// Workaround a bug in MSVC2013 that prevents instantiation of format_float.
+int (*instantiate_format_float)(double, int, detail::float_specs,
+                                detail::buffer<char>&) = detail::format_float;
+
+#ifndef FMT_STATIC_THOUSANDS_SEPARATOR
+template FMT_API detail::locale_ref::locale_ref(const std::locale& loc);
+template FMT_API std::locale detail::locale_ref::get<std::locale>() const;
+#endif
+
+// Explicit instantiations for char.
+
+template FMT_API auto detail::thousands_sep_impl(locale_ref)
+    -> thousands_sep_result<char>;
+template FMT_API char detail::decimal_point_impl(locale_ref);
+
+template FMT_API void detail::buffer<char>::append(const char*, const char*);
+
+// DEPRECATED!
+// There is no correspondent extern template in format.h because of
+// incompatibility between clang and gcc (#2377).
+template FMT_API void detail::vformat_to(
+    detail::buffer<char>&, string_view,
+    basic_format_args<FMT_BUFFER_CONTEXT(char)>, detail::locale_ref);
+
+template FMT_API int detail::snprintf_float(double, int, detail::float_specs,
+                                            detail::buffer<char>&);
+template FMT_API int detail::snprintf_float(long double, int,
+                                            detail::float_specs,
+                                            detail::buffer<char>&);
+template FMT_API int detail::format_float(double, int, detail::float_specs,
+                                          detail::buffer<char>&);
+template FMT_API int detail::format_float(long double, int, detail::float_specs,
+                                          detail::buffer<char>&);
+
+// Explicit instantiations for wchar_t.
+
+template FMT_API auto detail::thousands_sep_impl(locale_ref)
+    -> thousands_sep_result<wchar_t>;
+template FMT_API wchar_t detail::decimal_point_impl(locale_ref);
+
+template FMT_API void detail::buffer<wchar_t>::append(const wchar_t*,
+                                                      const wchar_t*);
+
+template struct detail::basic_data<void>;
+
+FMT_END_NAMESPACE

contrib/fmt-8.0.1/src/os.cc

@@ -0,0 +1,360 @@
+// Formatting library for C++ - optional OS-specific functionality
+//
+// Copyright (c) 2012 - 2016, Victor Zverovich
+// All rights reserved.
+//
+// For the license information refer to format.h.
+
+// Disable bogus MSVC warnings.
+#if !defined(_CRT_SECURE_NO_WARNINGS) && defined(_MSC_VER)
+#  define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include "fmt/os.h"
+
+#include <climits>
+
+#if FMT_USE_FCNTL
+#  include <sys/stat.h>
+#  include <sys/types.h>
+
+#  ifndef _WIN32
+#    include <unistd.h>
+#  else
+#    ifndef WIN32_LEAN_AND_MEAN
+#      define WIN32_LEAN_AND_MEAN
+#    endif
+#    include <io.h>
+
+#    define O_CREAT _O_CREAT
+#    define O_TRUNC _O_TRUNC
+
+#    ifndef S_IRUSR
+#      define S_IRUSR _S_IREAD
+#    endif
+
+#    ifndef S_IWUSR
+#      define S_IWUSR _S_IWRITE
+#    endif
+
+#    ifdef __MINGW32__
+#      define _SH_DENYNO 0x40
+#    endif
+#  endif  // _WIN32
+#endif    // FMT_USE_FCNTL
+
+#ifdef _WIN32
+#  include <windows.h>
+#endif
+
+#ifdef fileno
+#  undef fileno
+#endif
+
+namespace {
+#ifdef _WIN32
+// Return type of read and write functions.
+using rwresult = int;
+
+// On Windows the count argument to read and write is unsigned, so convert
+// it from size_t preventing integer overflow.
+inline unsigned convert_rwcount(std::size_t count) {
+  return count <= UINT_MAX ? static_cast<unsigned>(count) : UINT_MAX;
+}
+#elif FMT_USE_FCNTL
+// Return type of read and write functions.
+using rwresult = ssize_t;
+
+inline std::size_t convert_rwcount(std::size_t count) { return count; }
+#endif
+}  // namespace
+
+FMT_BEGIN_NAMESPACE
+
+#ifdef _WIN32
+detail::utf16_to_utf8::utf16_to_utf8(basic_string_view<wchar_t> s) {
+  if (int error_code = convert(s)) {
+    FMT_THROW(windows_error(error_code,
+                            "cannot convert string from UTF-16 to UTF-8"));
+  }
+}
+
+int detail::utf16_to_utf8::convert(basic_string_view<wchar_t> s) {
+  if (s.size() > INT_MAX) return ERROR_INVALID_PARAMETER;
+  int s_size = static_cast<int>(s.size());
+  if (s_size == 0) {
+    // WideCharToMultiByte does not support zero length, handle separately.
+    buffer_.resize(1);
+    buffer_[0] = 0;
+    return 0;
+  }
+
+  int length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, nullptr, 0,
+                                   nullptr, nullptr);
+  if (length == 0) return GetLastError();
+  buffer_.resize(length + 1);
+  length = WideCharToMultiByte(CP_UTF8, 0, s.data(), s_size, &buffer_[0],
+                               length, nullptr, nullptr);
+  if (length == 0) return GetLastError();
+  buffer_[length] = 0;
+  return 0;
+}
+
+namespace detail {
+
+class system_message {
+  system_message(const system_message&) = delete;
+  void operator=(const system_message&) = delete;
+
+  unsigned long result_;
+  wchar_t* message_;
+
+  static bool is_whitespace(wchar_t c) FMT_NOEXCEPT {
+    return c == L' ' || c == L'\n' || c == L'\r' || c == L'\t' || c == L'\0';
+  }
+
+ public:
+  explicit system_message(unsigned long error_code)
+      : result_(0), message_(nullptr) {
+    result_ = FormatMessageW(
+        FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
+            FORMAT_MESSAGE_IGNORE_INSERTS,
+        nullptr, error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+        reinterpret_cast<wchar_t*>(&message_), 0, nullptr);
+    if (result_ != 0) {
+      while (result_ != 0 && is_whitespace(message_[result_ - 1])) {
+        --result_;
+      }
+    }
+  }
+  ~system_message() { LocalFree(message_); }
+  explicit operator bool() const FMT_NOEXCEPT { return result_ != 0; }
+  operator basic_string_view<wchar_t>() const FMT_NOEXCEPT {
+    return basic_string_view<wchar_t>(message_, result_);
+  }
+};
+
+class utf8_system_category final : public std::error_category {
+ public:
+  const char* name() const FMT_NOEXCEPT override { return "system"; }
+  std::string message(int error_code) const override {
+    system_message msg(error_code);
+    if (msg) {
+      utf16_to_utf8 utf8_message;
+      if (utf8_message.convert(msg) == ERROR_SUCCESS) {
+        return utf8_message.str();
+      }
+    }
+    return "unknown error";
+  }
+};
+
+}  // namespace detail
+
+FMT_API const std::error_category& system_category() FMT_NOEXCEPT {
+  static const detail::utf8_system_category category;
+  return category;
+}
+
+std::system_error vwindows_error(int err_code, string_view format_str,
+                                 format_args args) {
+  auto ec = std::error_code(err_code, system_category());
+  return std::system_error(ec, vformat(format_str, args));
+}
+
+void detail::format_windows_error(detail::buffer<char>& out, int error_code,
+                                  const char* message) FMT_NOEXCEPT {
+  FMT_TRY {
+    system_message msg(error_code);
+    if (msg) {
+      utf16_to_utf8 utf8_message;
+      if (utf8_message.convert(msg) == ERROR_SUCCESS) {
+        format_to(buffer_appender<char>(out), "{}: {}", message, utf8_message);
+        return;
+      }
+    }
+  }
+  FMT_CATCH(...) {}
+  format_error_code(out, error_code, message);
+}
+
+void report_windows_error(int error_code, const char* message) FMT_NOEXCEPT {
+  report_error(detail::format_windows_error, error_code, message);
+}
+#endif  // _WIN32
+
+buffered_file::~buffered_file() FMT_NOEXCEPT {
+  if (file_ && FMT_SYSTEM(fclose(file_)) != 0)
+    report_system_error(errno, "cannot close file");
+}
+
+buffered_file::buffered_file(cstring_view filename, cstring_view mode) {
+  FMT_RETRY_VAL(file_, FMT_SYSTEM(fopen(filename.c_str(), mode.c_str())),
+                nullptr);
+  if (!file_)
+    FMT_THROW(system_error(errno, "cannot open file {}", filename.c_str()));
+}
+
+void buffered_file::close() {
+  if (!file_) return;
+  int result = FMT_SYSTEM(fclose(file_));
+  file_ = nullptr;
+  if (result != 0) FMT_THROW(system_error(errno, "cannot close file"));
+}
+
+// A macro used to prevent expansion of fileno on broken versions of MinGW.
+#define FMT_ARGS
+
+int buffered_file::fileno() const {
+  int fd = FMT_POSIX_CALL(fileno FMT_ARGS(file_));
+  if (fd == -1) FMT_THROW(system_error(errno, "cannot get file descriptor"));
+  return fd;
+}
+
+#if FMT_USE_FCNTL
+file::file(cstring_view path, int oflag) {
+  int mode = S_IRUSR | S_IWUSR;
+#  if defined(_WIN32) && !defined(__MINGW32__)
+  fd_ = -1;
+  FMT_POSIX_CALL(sopen_s(&fd_, path.c_str(), oflag, _SH_DENYNO, mode));
+#  else
+  FMT_RETRY(fd_, FMT_POSIX_CALL(open(path.c_str(), oflag, mode)));
+#  endif
+  if (fd_ == -1)
+    FMT_THROW(system_error(errno, "cannot open file {}", path.c_str()));
+}
+
+file::~file() FMT_NOEXCEPT {
+  // Don't retry close in case of EINTR!
+  // See http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html
+  if (fd_ != -1 && FMT_POSIX_CALL(close(fd_)) != 0)
+    report_system_error(errno, "cannot close file");
+}
+
+void file::close() {
+  if (fd_ == -1) return;
+  // Don't retry close in case of EINTR!
+  // See http://linux.derkeiler.com/Mailing-Lists/Kernel/2005-09/3000.html
+  int result = FMT_POSIX_CALL(close(fd_));
+  fd_ = -1;
+  if (result != 0) FMT_THROW(system_error(errno, "cannot close file"));
+}
+
+long long file::size() const {
+#  ifdef _WIN32
+  // Use GetFileSize instead of GetFileSizeEx for the case when _WIN32_WINNT
+  // is less than 0x0500 as is the case with some default MinGW builds.
+  // Both functions support large file sizes.
+  DWORD size_upper = 0;
+  HANDLE handle = reinterpret_cast<HANDLE>(_get_osfhandle(fd_));
+  DWORD size_lower = FMT_SYSTEM(GetFileSize(handle, &size_upper));
+  if (size_lower == INVALID_FILE_SIZE) {
+    DWORD error = GetLastError();
+    if (error != NO_ERROR)
+      FMT_THROW(windows_error(GetLastError(), "cannot get file size"));
+  }
+  unsigned long long long_size = size_upper;
+  return (long_size << sizeof(DWORD) * CHAR_BIT) | size_lower;
+#  else
+  using Stat = struct stat;
+  Stat file_stat = Stat();
+  if (FMT_POSIX_CALL(fstat(fd_, &file_stat)) == -1)
+    FMT_THROW(system_error(errno, "cannot get file attributes"));
+  static_assert(sizeof(long long) >= sizeof(file_stat.st_size),
+                "return type of file::size is not large enough");
+  return file_stat.st_size;
+#  endif
+}
+
+std::size_t file::read(void* buffer, std::size_t count) {
+  rwresult result = 0;
+  FMT_RETRY(result, FMT_POSIX_CALL(read(fd_, buffer, convert_rwcount(count))));
+  if (result < 0) FMT_THROW(system_error(errno, "cannot read from file"));
+  return detail::to_unsigned(result);
+}
+
+std::size_t file::write(const void* buffer, std::size_t count) {
+  rwresult result = 0;
+  FMT_RETRY(result, FMT_POSIX_CALL(write(fd_, buffer, convert_rwcount(count))));
+  if (result < 0) FMT_THROW(system_error(errno, "cannot write to file"));
+  return detail::to_unsigned(result);
+}
+
+file file::dup(int fd) {
+  // Don't retry as dup doesn't return EINTR.
+  // http://pubs.opengroup.org/onlinepubs/009695399/functions/dup.html
+  int new_fd = FMT_POSIX_CALL(dup(fd));
+  if (new_fd == -1)
+    FMT_THROW(system_error(errno, "cannot duplicate file descriptor {}", fd));
+  return file(new_fd);
+}
+
+void file::dup2(int fd) {
+  int result = 0;
+  FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));
+  if (result == -1) {
+    FMT_THROW(system_error(errno, "cannot duplicate file descriptor {} to {}",
+                           fd_, fd));
+  }
+}
+
+void file::dup2(int fd, std::error_code& ec) FMT_NOEXCEPT {
+  int result = 0;
+  FMT_RETRY(result, FMT_POSIX_CALL(dup2(fd_, fd)));
+  if (result == -1) ec = std::error_code(errno, std::generic_category());
+}
+
+void file::pipe(file& read_end, file& write_end) {
+  // Close the descriptors first to make sure that assignments don't throw
+  // and there are no leaks.
+  read_end.close();
+  write_end.close();
+  int fds[2] = {};
+#  ifdef _WIN32
+  // Make the default pipe capacity same as on Linux 2.6.11+.
+  enum { DEFAULT_CAPACITY = 65536 };
+  int result = FMT_POSIX_CALL(pipe(fds, DEFAULT_CAPACITY, _O_BINARY));
+#  else
+  // Don't retry as the pipe function doesn't return EINTR.
+  // http://pubs.opengroup.org/onlinepubs/009696799/functions/pipe.html
+  int result = FMT_POSIX_CALL(pipe(fds));
+#  endif
+  if (result != 0) FMT_THROW(system_error(errno, "cannot create pipe"));
+  // The following assignments don't throw because read_fd and write_fd
+  // are closed.
+  read_end = file(fds[0]);
+  write_end = file(fds[1]);
+}
+
+buffered_file file::fdopen(const char* mode) {
+// Don't retry as fdopen doesn't return EINTR.
+#  if defined(__MINGW32__) && defined(_POSIX_)
+  FILE* f = ::fdopen(fd_, mode);
+#  else
+  FILE* f = FMT_POSIX_CALL(fdopen(fd_, mode));
+#  endif
+  if (!f)
+    FMT_THROW(
+        system_error(errno, "cannot associate stream with file descriptor"));
+  buffered_file bf(f);
+  fd_ = -1;
+  return bf;
+}
+
+long getpagesize() {
+#  ifdef _WIN32
+  SYSTEM_INFO si;
+  GetSystemInfo(&si);
+  return si.dwPageSize;
+#  else
+  long size = FMT_POSIX_CALL(sysconf(_SC_PAGESIZE));
+  if (size < 0) FMT_THROW(system_error(errno, "cannot get memory page size"));
+  return size;
+#  endif
+}
+
+FMT_API void ostream::grow(size_t) {
+  if (this->size() == this->capacity()) flush();
+}
+#endif  // FMT_USE_FCNTL
+FMT_END_NAMESPACE

contrib/fmt-8.0.1/support/cmake/FindSetEnv.cmake

@@ -0,0 +1,7 @@
+# A CMake script to find SetEnv.cmd.
+
+find_program(WINSDK_SETENV NAMES SetEnv.cmd
+  PATHS "[HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows;CurrentInstallFolder]/bin")
+if (WINSDK_SETENV AND PRINT_PATH)
+  execute_process(COMMAND ${CMAKE_COMMAND} -E echo "${WINSDK_SETENV}")
+endif ()

contrib/fmt-8.0.1/support/cmake/JoinPaths.cmake

@@ -0,0 +1,26 @@
+# This module provides function for joining paths
+# known from from most languages
+#
+# Original license:
+# SPDX-License-Identifier: (MIT OR CC0-1.0)
+# Explicit permission given to distribute this module under
+# the terms of the project as described in /LICENSE.rst.
+# Copyright 2020 Jan Tojnar
+# https://github.com/jtojnar/cmake-snips
+#
+# Modelled after Python’s os.path.join
+# https://docs.python.org/3.7/library/os.path.html#os.path.join
+# Windows not supported
+function(join_paths joined_path first_path_segment)
+    set(temp_path "${first_path_segment}")
+    foreach(current_segment IN LISTS ARGN)
+        if(NOT ("${current_segment}" STREQUAL ""))
+            if(IS_ABSOLUTE "${current_segment}")
+                set(temp_path "${current_segment}")
+            else()
+                set(temp_path "${temp_path}/${current_segment}")
+            endif()
+        endif()
+    endforeach()
+    set(${joined_path} "${temp_path}" PARENT_SCOPE)
+endfunction()

contrib/fmt-8.0.1/support/cmake/cxx14.cmake

@@ -0,0 +1,70 @@
+# C++14 feature support detection
+
+include(CheckCXXSourceCompiles)
+include(CheckCXXCompilerFlag)
+
+if (NOT CMAKE_CXX_STANDARD)
+  set(CMAKE_CXX_STANDARD 11)
+endif()
+message(STATUS "CXX_STANDARD: ${CMAKE_CXX_STANDARD}")
+
+if (CMAKE_CXX_STANDARD EQUAL 20)
+  check_cxx_compiler_flag(-std=c++20 has_std_20_flag)
+  check_cxx_compiler_flag(-std=c++2a has_std_2a_flag)
+
+  if (has_std_20_flag)
+    set(CXX_STANDARD_FLAG -std=c++20)
+  elseif (has_std_2a_flag)
+    set(CXX_STANDARD_FLAG -std=c++2a)
+  endif ()
+elseif (CMAKE_CXX_STANDARD EQUAL 17)
+  check_cxx_compiler_flag(-std=c++17 has_std_17_flag)
+  check_cxx_compiler_flag(-std=c++1z has_std_1z_flag)
+
+  if (has_std_17_flag)
+    set(CXX_STANDARD_FLAG -std=c++17)
+  elseif (has_std_1z_flag)
+    set(CXX_STANDARD_FLAG -std=c++1z)
+  endif ()
+elseif (CMAKE_CXX_STANDARD EQUAL 14)
+  check_cxx_compiler_flag(-std=c++14 has_std_14_flag)
+  check_cxx_compiler_flag(-std=c++1y has_std_1y_flag)
+
+  if (has_std_14_flag)
+    set(CXX_STANDARD_FLAG -std=c++14)
+  elseif (has_std_1y_flag)
+    set(CXX_STANDARD_FLAG -std=c++1y)
+  endif ()
+elseif (CMAKE_CXX_STANDARD EQUAL 11)
+  check_cxx_compiler_flag(-std=c++11 has_std_11_flag)
+  check_cxx_compiler_flag(-std=c++0x has_std_0x_flag)
+
+  if (has_std_11_flag)
+    set(CXX_STANDARD_FLAG -std=c++11)
+  elseif (has_std_0x_flag)
+    set(CXX_STANDARD_FLAG -std=c++0x)
+  endif ()
+endif ()
+
+set(CMAKE_REQUIRED_FLAGS ${CXX_STANDARD_FLAG})
+
+# Check if user-defined literals are available
+check_cxx_source_compiles("
+  void operator\"\" _udl(long double);
+  int main() {}"
+  SUPPORTS_USER_DEFINED_LITERALS)
+if (NOT SUPPORTS_USER_DEFINED_LITERALS)
+  set (SUPPORTS_USER_DEFINED_LITERALS OFF)
+endif ()
+
+# Check if <variant> is available
+set(CMAKE_REQUIRED_FLAGS -std=c++1z)
+check_cxx_source_compiles("
+  #include <variant>
+  int main() {}"
+  FMT_HAS_VARIANT)
+if (NOT FMT_HAS_VARIANT)
+  set (FMT_HAS_VARIANT OFF)
+endif ()
+
+set(CMAKE_REQUIRED_FLAGS )

contrib/fmt-8.0.1/support/cmake/fmt-config.cmake.in

@@ -0,0 +1,4 @@
+@PACKAGE_INIT@
+
+include(${CMAKE_CURRENT_LIST_DIR}/@targets_export_name@.cmake)
+check_required_components(fmt)

contrib/fmt-8.0.1/support/cmake/fmt.pc.in

@@ -0,0 +1,11 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=@CMAKE_INSTALL_PREFIX@
+libdir=@libdir_for_pc_file@
+includedir=@includedir_for_pc_file@
+
+Name: fmt
+Description: A modern formatting library
+Version: @FMT_VERSION@
+Libs: -L${libdir} -l@FMT_LIB_NAME@
+Cflags: -I${includedir}
+

contrib/pkg_tester/__snapshots__/test_fdb_pkgs.ambr

@@ -46,6 +46,34 @@
   
   '
 ---
+# name: test_execstack_permissions_libfdb_c[centos-versioned]
+  '
+    GNU_STACK      0x0000000000000000 0x0000000000000000 0x0000000000000000
+                   0x0000000000000000 0x0000000000000000  RW     0x0
+  
+  '
+---
+# name: test_execstack_permissions_libfdb_c[centos]
+  '
+    GNU_STACK      0x0000000000000000 0x0000000000000000 0x0000000000000000
+                   0x0000000000000000 0x0000000000000000  RW     0x0
+  
+  '
+---
+# name: test_execstack_permissions_libfdb_c[ubuntu-versioned]
+  '
+    GNU_STACK      0x0000000000000000 0x0000000000000000 0x0000000000000000
+                   0x0000000000000000 0x0000000000000000  RW     0x0
+  
+  '
+---
+# name: test_execstack_permissions_libfdb_c[ubuntu]
+  '
+    GNU_STACK      0x0000000000000000 0x0000000000000000 0x0000000000000000
+                   0x0000000000000000 0x0000000000000000  RW     0x0
+  
+  '
+---
 # name: test_fdbcli_help_text[centos-versioned]
   '
   FoundationDB CLI 7.1 (v7.1.0)
@@ -59,7 +87,7 @@
     --log-dir PATH Specifes the output directory for trace files. If
                    unspecified, defaults to the current directory. Has
                    no effect unless --log is specified.
-    --trace_format FORMAT
+    --trace-format FORMAT
                    Select the format of the log files. xml (the default) and json
                    are supported. Has no effect unless --log is specified.
     --exec CMDS    Immediately executes the semicolon separated CLI commands
@@ -68,24 +96,24 @@
                    the CLI.
     --api-version  APIVERSION
                    Specifies the version of the API for the CLI to use.
-    --tls_certificate_file CERTFILE
+    --tls-certificate-file CERTFILE
                    The path of a file containing the TLS certificate and CA
                    chain.
-    --tls_ca_file CERTAUTHFILE
+    --tls-ca-file CERTAUTHFILE
                    The path of a file containing the CA certificates chain.
-    --tls_key_file KEYFILE
+    --tls-key-file KEYFILE
                    The path of a file containing the private key corresponding
                    to the TLS certificate.
-    --tls_password PASSCODE
+    --tls-password PASSCODE
                    The passphrase of encrypted private key
-    --tls_verify_peers CONSTRAINTS
+    --tls-verify-peers CONSTRAINTS
                    The constraints by which to validate TLS peers. The contents
                    and format of CONSTRAINTS are plugin-specific.
-    --knob_KNOBNAME KNOBVALUE
+    --knob-KNOBNAME KNOBVALUE
                    Changes a knob option. KNOBNAME should be lowercase.
     --debug-tls    Prints the TLS configuration and certificate chain, then exits.
                    Useful in reporting and diagnosing TLS issues.
-    --build_flags  Print build information and exit.
+    --build-flags  Print build information and exit.
     -v, --version  Print FoundationDB CLI version information and exit.
     -h, --help     Display this help and exit.
   
@@ -104,7 +132,7 @@
     --log-dir PATH Specifes the output directory for trace files. If
                    unspecified, defaults to the current directory. Has
                    no effect unless --log is specified.
-    --trace_format FORMAT
+    --trace-format FORMAT
                    Select the format of the log files. xml (the default) and json
                    are supported. Has no effect unless --log is specified.
     --exec CMDS    Immediately executes the semicolon separated CLI commands
@@ -113,24 +141,24 @@
                    the CLI.
     --api-version  APIVERSION
                    Specifies the version of the API for the CLI to use.
-    --tls_certificate_file CERTFILE
+    --tls-certificate-file CERTFILE
                    The path of a file containing the TLS certificate and CA
                    chain.
-    --tls_ca_file CERTAUTHFILE
+    --tls-ca-file CERTAUTHFILE
                    The path of a file containing the CA certificates chain.
-    --tls_key_file KEYFILE
+    --tls-key-file KEYFILE
                    The path of a file containing the private key corresponding
                    to the TLS certificate.
-    --tls_password PASSCODE
+    --tls-password PASSCODE
                    The passphrase of encrypted private key
-    --tls_verify_peers CONSTRAINTS
+    --tls-verify-peers CONSTRAINTS
                    The constraints by which to validate TLS peers. The contents
                    and format of CONSTRAINTS are plugin-specific.
-    --knob_KNOBNAME KNOBVALUE
+    --knob-KNOBNAME KNOBVALUE
                    Changes a knob option. KNOBNAME should be lowercase.
     --debug-tls    Prints the TLS configuration and certificate chain, then exits.
                    Useful in reporting and diagnosing TLS issues.
-    --build_flags  Print build information and exit.
+    --build-flags  Print build information and exit.
     -v, --version  Print FoundationDB CLI version information and exit.
     -h, --help     Display this help and exit.
   
@@ -149,7 +177,7 @@
     --log-dir PATH Specifes the output directory for trace files. If
                    unspecified, defaults to the current directory. Has
                    no effect unless --log is specified.
-    --trace_format FORMAT
+    --trace-format FORMAT
                    Select the format of the log files. xml (the default) and json
                    are supported. Has no effect unless --log is specified.
     --exec CMDS    Immediately executes the semicolon separated CLI commands
@@ -158,24 +186,24 @@
                    the CLI.
     --api-version  APIVERSION
                    Specifies the version of the API for the CLI to use.
-    --tls_certificate_file CERTFILE
+    --tls-certificate-file CERTFILE
                    The path of a file containing the TLS certificate and CA
                    chain.
-    --tls_ca_file CERTAUTHFILE
+    --tls-ca-file CERTAUTHFILE
                    The path of a file containing the CA certificates chain.
-    --tls_key_file KEYFILE
+    --tls-key-file KEYFILE
                    The path of a file containing the private key corresponding
                    to the TLS certificate.
-    --tls_password PASSCODE
+    --tls-password PASSCODE
                    The passphrase of encrypted private key
-    --tls_verify_peers CONSTRAINTS
+    --tls-verify-peers CONSTRAINTS
                    The constraints by which to validate TLS peers. The contents
                    and format of CONSTRAINTS are plugin-specific.
-    --knob_KNOBNAME KNOBVALUE
+    --knob-KNOBNAME KNOBVALUE
                    Changes a knob option. KNOBNAME should be lowercase.
     --debug-tls    Prints the TLS configuration and certificate chain, then exits.
                    Useful in reporting and diagnosing TLS issues.
-    --build_flags  Print build information and exit.
+    --build-flags  Print build information and exit.
     -v, --version  Print FoundationDB CLI version information and exit.
     -h, --help     Display this help and exit.
   
@@ -194,7 +222,7 @@
     --log-dir PATH Specifes the output directory for trace files. If
                    unspecified, defaults to the current directory. Has
                    no effect unless --log is specified.
-    --trace_format FORMAT
+    --trace-format FORMAT
                    Select the format of the log files. xml (the default) and json
                    are supported. Has no effect unless --log is specified.
     --exec CMDS    Immediately executes the semicolon separated CLI commands
@@ -203,24 +231,24 @@
                    the CLI.
     --api-version  APIVERSION
                    Specifies the version of the API for the CLI to use.
-    --tls_certificate_file CERTFILE
+    --tls-certificate-file CERTFILE
                    The path of a file containing the TLS certificate and CA
                    chain.
-    --tls_ca_file CERTAUTHFILE
+    --tls-ca-file CERTAUTHFILE
                    The path of a file containing the CA certificates chain.
-    --tls_key_file KEYFILE
+    --tls-key-file KEYFILE
                    The path of a file containing the private key corresponding
                    to the TLS certificate.
-    --tls_password PASSCODE
+    --tls-password PASSCODE
                    The passphrase of encrypted private key
-    --tls_verify_peers CONSTRAINTS
+    --tls-verify-peers CONSTRAINTS
                    The constraints by which to validate TLS peers. The contents
                    and format of CONSTRAINTS are plugin-specific.
-    --knob_KNOBNAME KNOBVALUE
+    --knob-KNOBNAME KNOBVALUE
                    Changes a knob option. KNOBNAME should be lowercase.
     --debug-tls    Prints the TLS configuration and certificate chain, then exits.
                    Useful in reporting and diagnosing TLS issues.
-    --build_flags  Print build information and exit.
+    --build-flags  Print build information and exit.
     -v, --version  Print FoundationDB CLI version information and exit.
     -h, --help     Display this help and exit.
   

contrib/pkg_tester/test_fdb_pkgs.py

@@ -54,7 +54,9 @@ class Container:
         # https://developers.redhat.com/blog/2016/09/13/running-systemd-in-a-non-privileged-container#the_quest
         extra_initd_args = []
         if initd:
-            extra_initd_args = "--tmpfs /tmp --tmpfs /run -v /sys/fs/cgroup:/sys/fs/cgroup:ro".split()
+            extra_initd_args = (
+                "--tmpfs /tmp --tmpfs /run -v /sys/fs/cgroup:/sys/fs/cgroup:ro".split()
+            )
 
         self.uid = str(uuid.uuid4())
 
@@ -103,6 +105,8 @@ def ubuntu_image_with_fdb_helper(versioned: bool) -> Iterator[Optional[Image]]:
         container = Container("ubuntu")
         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", "dpkg -i /opt/*.deb"])
         container.run(["bash", "-c", "rm /opt/*.deb"])
         image = container.commit()
@@ -146,6 +150,8 @@ def centos_image_with_fdb_helper(versioned: bool) -> Iterator[Optional[Image]]:
         container = Container("centos", initd=True)
         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 /opt/*.rpm"])
         container.run(["bash", "-c", "rm /opt/*.rpm"])
         image = container.commit()
@@ -235,6 +241,17 @@ def test_fdbcli_help_text(linux_container: Container, snapshot):
     assert snapshot == linux_container.run(["fdbcli", "--help"])
 
 
+def test_execstack_permissions_libfdb_c(linux_container: Container, snapshot):
+    linux_container.run(["ldconfig"])
+    assert snapshot == linux_container.run(
+        [
+            "bash",
+            "-c",
+            "readelf -l $(ldconfig -p | grep libfdb_c | awk '{print $(NF)}') | grep -A1 GNU_STACK",
+        ]
+    )
+
+
 def test_backup_restore(linux_container: Container, snapshot, tmp_path: pathlib.Path):
     linux_container.run(["fdbcli", "--exec", "writemode on; set x y"])
     assert snapshot == linux_container.run(
@@ -245,7 +262,7 @@ def test_backup_restore(linux_container: Container, snapshot, tmp_path: pathlib.
         [
             "bash",
             "-c",
-            "fdbrestore start -r file://$(echo /tmp/fdb_backup/*) -w --dest_cluster_file /etc/foundationdb/fdb.cluster",
+            "fdbrestore start -r file://$(echo /tmp/fdb_backup/*) -w --dest-cluster-file /etc/foundationdb/fdb.cluster",
         ]
     )
     assert snapshot == linux_container.run(["fdbcli", "--exec", "get x"])

design/backup_v2_partitioned_logs.md

@@ -223,7 +223,7 @@ We strive to keep the operational interface the same as the old backup system. T
 
 By default, backup workers are not enabled in the system. When operators submit a new backup request for the first time, the database performs a configuration change (`backup_worker_enabled:=1`) that enables backup workers.
 
-The operator’s backup request can indicate if an old backup or a new backup is used. This is a command line option (i.e., `-p` or `--partitioned_log`) in the `fdbbackup` command. A backup request of the new type is started in the following steps:
+The operator’s backup request can indicate if an old backup or a new backup is used. This is a command line option (i.e., `-p` or `--partitioned-log`) in the `fdbbackup` command. A backup request of the new type is started in the following steps:
 
 1. Operators use `fdbbackup` tool to write the backup range to a system key, i.e., `\xff\x02/backupStarted`.
 2. All backup workers monitor the key `\xff\x02/backupStarted`, see the change, and start logging mutations.

design/recovery-internals.md

@@ -39,7 +39,7 @@ Once coordinators think there is no CC in a cluster, they will start leader elec
 
 Although only one CC can succeed in recovery, which is guaranteed by Paxos algorithm, there exist scenarios when multiple CCs can exist in a  transient time period.
 
-Scenario 1: A majority of coordinators reboot at the same time and the current running CC is still alive. When those coordinators reboot, they may likely choose a different process as CC. The new CC will start to recruit a new master and kicks off the recovery. The old CC will know the existence of the new CC when it sends heart-beat to coordinators periodically (in sub-seconds). The old CC will kill itself, once it was told by a majority of coordinators about the existence of the new CC. Old roles (say master) will commit suicide as well after the old CC dies. This prevents the cluster to have two sets of transaction systems. In summary, the cluster may have both the old CC and new CC alive in sub-seconds before the old CC confirms the existence of the new CC.
+Scenario 1: A majority of coordinators reboot at the same time and the current running CC is still alive. When those coordinators reboot, they may likely choose a different process as CC. The new CC will start to recruit a new master and kicks off  `ClusterRecovery` actor that drives the recovery. The old CC will know the existence of the new CC when it sends heart-beat to coordinators periodically (in sub-seconds). The old CC will kill itself, once it was told by a majority of coordinators about the existence of the new CC. Old roles (say master) will commit suicide as well after the old CC dies. This prevents the cluster to have two sets of transaction systems. In summary, the cluster may have both the old CC and new CC alive in sub-seconds before the old CC confirms the existence of the new CC.
 
 Scenario 2: Network partition makes the current running CC unable to connect to a majority of coordinators. Before the CC detects it, the coordinators can elect a new CC and recovery will happen. Typically, the old CC can quickly realize it cannot connect to a majority of coordinators and kill itself. In the rare situation when the old CC does not die within a short time period *and* the network partition is resolved before the old CC dies, the new CC can recruit a new master, which leads to two masters in the cluster. Only one master can succeed the recovery because only one master can lock the cstate (see Phase 2: LOCKING_CSTATE).
 
@@ -52,10 +52,9 @@ Cluster controller (CC) decides if recovery should be triggered. In case the cur
 
 Recovery has 9 phases, which are defined as the 9 states in the source code: READING_CSTATE = 1, LOCKING_CSTATE = 2, RECRUITING = 3, RECOVERY_TRANSACTION = 4, WRITING_CSTATE = 5, ACCEPTING_COMMITS = 6, ALL_LOGS_RECRUITED = 7, STORAGE_RECOVERED = 8, FULLY_RECOVERED = 9.
 
-The recovery process is like a state machine, changing from one state to the next state. 
-We will describe in the rest of this document what each phase does to drive the recovery to the next state.
+The recovery process is like a state machine, changing from one state to the next state. `ClusterRecovery.actor` implements the cluster recovery. We will describe in the rest of this document what each phase does to drive the recovery to the next state.
 
-Recovery tracks the information of each recovery phase in `MasterRecoveryState` trace event. By checking the message, we can find which phase the recovery is stuck at. The status used in the `MasterRecoveryState` trace event is defined as `RecoveryStatus` structure in `RecoveryState.h`. The status, instead of the name of the 9 phases, is typically used in diagnosing production issues.
+The system tracks the information of each recovery phase via trace events. In past recovery state machine was driven by the `Master` process, hence, the events used `Master` as event prefix name (for instance: `MasterRecoveryState`). Given the recovery state machine is currently driven by CC, updating name to `ClusterRecoveryState` would have been more appropriate, however, it breaks existing tooling scripts. For now, `ServerKnob::CLUSTER_RECOVERY_EVENT_NAME_PREFIX` determines the event name prefix, default prefix value is `Master`. Recovery tracks the information of each recovery phase in `<Prefix>RecoveryState` trace event. By checking the message, we can find which phase the recovery is stuck at. The status used in the `<Prefix>RecoveryState` trace event is defined as `RecoveryStatus` structure in `RecoveryState.h`. The status, instead of the name of the 9 phases, is typically used in diagnosing production issues.
 
 
 ## Phase 1: READING_CSTATE
@@ -94,34 +93,34 @@ Master interface is stored in `serverDBInfo`. Once the CC recruits the master, i
 
 ## Phase 3: RECRUITING
 
-Once the master locks the cstate, it will recruit the still-alive tLogs from the previous generation for the benefit of faster recovery. The master gets the old tLogs’ interfaces from the READING_CSTATE phase and uses those interfaces to track which old tLog are still alive, the implementation of which is in `trackRejoins()`.
+Once the CC locks the cstate, it will recruit the still-alive tLogs from the previous generation for the benefit of faster recovery. The CC gets the old tLogs’ interfaces from the READING_CSTATE phase and uses those interfaces to track which old tLog are still alive, the implementation of which is in `trackRejoins()`.
 
 
-Once the master gets enough tLogs, it calculates the known committed version (i.e., `knownCommittedVersion` in code). `knownCommittedVersion` is the highest version that a commit proxy tells a given tLog that it had durably committed on *all* tLogs. The master's is the maximum of all of that. `knownCommittedVersion` is  important, because it defines the lower bound of what version range of mutations need to be copied to the new generation. That is, any versions larger than the master's `knownCommittedVersion` is not guaranteed to persist on all replicas. The master chooses a *recovery version*, which is the minimum of durable versions on all tLogs of the old generation, and recruits a new set of tLogs that copy all data between `knownCommittedVersion + 1` and `recoveryVersion` from old tLogs. This copy makes sure data within the range has enough replicas to satisfy the replication policy.
+Once the CC gets enough tLogs, it calculates the known committed version (i.e., `knownCommittedVersion` in code). `knownCommittedVersion` is the highest version that a commit proxy tells a given tLog that it had durably committed on *all* tLogs. The CC's is the maximum of all of that. `knownCommittedVersion` is  important, because it defines the lower bound of what version range of mutations need to be copied to the new generation. That is, any versions larger than the master's `knownCommittedVersion` is not guaranteed to persist on all replicas. The CC chooses a *recovery version*, which is the minimum of durable versions on all tLogs of the old generation, and recruits a new set of tLogs that copy all data between `knownCommittedVersion + 1` and `recoveryVersion` from old tLogs. This copy makes sure data within the range has enough replicas to satisfy the replication policy.
 
-Later, the master will use the recruited tLogs to create a new `TagPartitionedLogSystem` for the new generation.
+Later, the CC will use the recruited tLogs to create a new `TagPartitionedLogSystem` for the new generation.
 
 **An example of `knownCommittedVersion` and `recoveryVersion`:**
 
 Consider an old generation with three TLogs: `A, B, C`. Their durable versions are `100, 110, 120`, respectively, and their `knownCommittedVersion` are at `80, 90, 95`, respectively.
 
-* If all of them are alive during recovery, master will choose `max(80, 90, 95) = 95` as the last epoch's end version and `min(100, 110, 120)=100` as the recovery version. Versions between `96` and `100` will be copied to new generation's tLogs. Note some of them `101` to `120` are actually durable on one or two tLogs, but the master chooses to discard them. If a storage server has peeked versions in the range of `[101, 120]`, these versions are in memory of the storage server and will be rolled back (i.e., discarded).
+* If all of them are alive during recovery, CC will choose `max(80, 90, 95) = 95` as the last epoch's end version and `min(100, 110, 120)=100` as the recovery version. Versions between `96` and `100` will be copied to new generation's tLogs. Note some of them `101` to `120` are actually durable on one or two tLogs, but the CC chooses to discard them. If a storage server has peeked versions in the range of `[101, 120]`, these versions are in memory of the storage server and will be rolled back (i.e., discarded).
 
-* Another scenario is `C` is down during recovery. In this case, the master chooses `max(80, 90) = 90` as the last epoch's end version and `min(100, 110) = 100` as the recovery version. In this case, versions between `[91, 100]` will be copied to new generation's tLogs.
+* Another scenario is `C` is down during recovery. In this case, the CC chooses `max(80, 90) = 90` as the last epoch's end version and `min(100, 110) = 100` as the recovery version. In this case, versions between `[91, 100]` will be copied to new generation's tLogs.
 
 * If all `A, B, and C` are down. The operator can manually force recovery to any version, e.g., `98`. Then `99` to `120` are discarded, even though `99` to `100` are durable on the whole set.
 
 **Two situations may invalidate the calculated knownCommittedVersion:**
 
-* Situation 1: Too many tLogs in the previous generation permanently died, say due to hardware failure. If force recovery is allowed by system administrator, the master can choose to force recovery, which can cause data loss; otherwise, to unblock the recovery, system administrator has to bring up those died tLogs, for example by copying their files onto new hardware.
+* Situation 1: Too many tLogs in the previous generation permanently died, say due to hardware failure. If force recovery is allowed by system administrator, the CC can choose to force recovery, which can cause data loss; otherwise, to unblock the recovery, system administrator has to bring up those died tLogs, for example by copying their files onto new hardware.
 
 
-* Situation 2: A tLog may die after it reports alive to the master in the RECRUITING phase. This may cause the `knownCommittedVersion` calculated by the master in this phase to no longer be valid in the next phases. When this happens, the master will detect it, terminate the current recovery, and start a new recovery.
+* Situation 2: A tLog may die after it reports alive to the CC in the RECRUITING phase. This may cause the `knownCommittedVersion` calculated by the CC in this phase to no longer be valid in the next phases. When this happens, the CC will detect it, terminate the current recovery, and start a new recovery.
 
 
-Once we have a `knownCommittedVersion`, the master will reconstruct the transaction state store (txnStateStore) by peeking the txnStateTag in oldLogSystem.
+Once we have a `knownCommittedVersion`, the CC will reconstruct the [transaction state store](https://github.com/apple/foundationdb/blob/master/design/transaction-state-store.md) by peeking the txnStateTag in oldLogSystem.
 Recall that the txnStateStore includes the transaction system’s configuration, such as the assignment of shards to SS and to tLogs and that the txnStateStore was durable on disk in the oldLogSystem.
-Once we get the txnStateStore, we know the configuration of the transaction system, such as the number of GRV proxies and commit proxies. The master then can ask the CC to recruit roles for the new generation in the `recruitEverything()` function. Those recruited roles includes GRV proxies, commit proxies, tLogs and seed SSes, which are the storage servers created for an empty database in the first generation to host the first shard and serve as the starting point of the bootstrap process to recruit more SSes. Once all roles are recruited, the master starts a new epoch in `newEpoch()`.
+Once we get the txnStateStore, we know the configuration of the transaction system, such as the number of GRV proxies and commit proxies. The CC recruits roles for the new generation in the `recruitEverything()` function. Those recruited roles includes GRV proxies, commit proxies, tLogs and seed SSes, which are the storage servers created for an empty database in the first generation to host the first shard and serve as the starting point of the bootstrap process to recruit more SSes. Once all roles are recruited, the CC starts a new epoch in `newEpoch()`.
 
 At this point, we have recovered the txnStateStore, recruited new GRV proxies, commit proxies and tLogs, and copied data from old tLogs to new tLogs. We have a working transaction system in the new generation now.
 
@@ -130,17 +129,18 @@ At this point, we have recovered the txnStateStore, recruited new GRV proxies, c
 Recovery can get stuck at the following two steps:
 
 **Reading the txnStateStore step.**
-Recovery typically won’t get stuck at reading the txnStateStore step because once the master can lock tLogs, it should always be able to read the txnStateStore for the tLogs.
+Recovery typically won’t get stuck at reading the txnStateStore step because once the CC can lock tLogs, it should always be able to read the txnStateStore for the tLogs.
 
 
 However, reading the txnStateStore can be slow because it needs to read from disk (through `openDiskQueueAdapter()` function) and the txnStateStore size increases as the cluster size increases. Recovery can take a long time if reading the txnStateStore is slow. To achieve faster recovery, we have improved the speed of reading the txnStateStore in FDB 6.2 by parallelly reading the txnStateStore on multiple tLogs based on tags.
 
 
 **Recruiting roles step.**
-There are cases where the recovery can get stuck at recruiting enough roles for the txn system configuration. For example, if a cluster with replica factor equal to three has only three tLogs and one of them dies during the recovery, the cluster will not succeed in recruiting 3 tLogs and the recovery will get stuck. Another example is when a new database is created and the cluster does not have a valid txnStateStore. To get out of this situation, the master will use an emergency transaction to forcibly change the configuration such that the recruitment can succeed. This configuration change may temporarily violate the contract of the desired configuration, but it is only temporary.
+There are cases where the recovery can get stuck at recruiting enough roles for the txn system configuration. For example, if a cluster with replica factor equal to three has only three tLogs and one of them dies during the recovery, the cluster will not succeed in recruiting 3 tLogs and the recovery will get stuck. Another example is when a new database is created and the cluster does not have a valid txnStateStore. To get out of this situation, the CC will use an emergency transaction to forcibly change the configuration such that the recruitment can succeed. This configuration change may temporarily violate the contract of the desired configuration, but it is only temporary.
 
+ServerKnob::CLUSTER_RECOVERY_EVENT_NAME_PREFIX defines the prefix for cluster recovery trace events. Hereafter, refered as 'RecoveryEventPrefix' in this document.
 
-We can use the trace event `MasterRecoveredConfig`, which dumps the information of the new transaction system’s configuration, to diagnose why the recovery is blocked in this phase.
+We can use the trace event `<RecoveryEventPrefix>RecoveredConfig`, which dumps the information of the new transaction system’s configuration, to diagnose why the recovery is blocked in this phase.
 
 
 ## Phase 4: RECOVERY_TRANSACTION
@@ -148,13 +148,13 @@ We can use the trace event `MasterRecoveredConfig`, which dumps the information
 Not every FDB role participates in the recovery phases 1-3. This phase tells the other roles about the recovery information and triggers the recovery of those roles when necessary.
 
 
-Storage servers (SSes) are not involved in the recovery phase 1 - 3. To notify SSes about the recovery, the master commits a recovery transaction, the first transaction in the new generation, which contains the txnStateStore information. Once storage servers receive the recovery transaction, it will compare its latest data version and the recovery version, and rollback to the recovery version if its data version is newer. Note that storage servers may have newer data than the recovery version because they pre-fetch mutations from tLogs before the mutations are durable to reduce the latency to read newly written data.
+Storage servers (SSes) are not involved in the recovery phase 1 - 3. To notify SSes about the recovery, the CC commits a recovery transaction, the first transaction in the new generation, which contains the txnStateStore information. Once storage servers receive the recovery transaction, it will compare its latest data version and the recovery version, and rollback to the recovery version if its data version is newer. Note that storage servers may have newer data than the recovery version because they pre-fetch mutations from tLogs before the mutations are durable to reduce the latency to read newly written data.
 
 
-Commit proxies haven’t recovered the transaction system state and cannot accept transactions yet. The master recovers proxies’ states by sending the txnStateStore to commit proxies through commit proxies’ (`txnState`) interfaces in `sendInitialCommitToResolvers()` function. Once commit proxies have recovered their states, they can start processing transactions. The recovery transaction that was waiting on commit proxies will be processed.
+Commit proxies haven’t recovered the transaction system state and cannot accept transactions yet. The CC recovers proxies’ states by sending the txnStateStore to commit proxies through commit proxies’ (`txnState`) interfaces in `sendInitialCommitToResolvers()` function. Once commit proxies have recovered their states, they can start processing transactions. The recovery transaction that was waiting on commit proxies will be processed.
 
 
-The resolvers haven’t known the recovery version either. The master needs to send the lastEpochEnd version (i.e., last commit of the previous generation) to resolvers via resolvers’ (`resolve`) interface.
+The resolvers haven’t known the recovery version either. The CC would update `recoveryTransactionVersion`, `lastEpochEnd` and elected `commitProxies` details to the master. The master needs to send the `lastEpochEnd` version (i.e., last commit of the previous generation) to resolvers via resolvers’ (`resolve`) interface.
 
 
 At the end of this phase, every role should be aware of the recovery and start recovering their states.
@@ -162,22 +162,22 @@ At the end of this phase, every role should be aware of the recovery and start r
 
 ## Phase 5: WRITING_CSTATE
 
-Coordinators store the transaction systems’ information. The master needs to write the new tLogs into coordinators’ states to achieve consensus and fault tolerance. Only when the coordinators’ states are updated with the new transaction system’s configuration will the cluster controller tell clients about the new transaction system (such as the new GRV proxies and commit proxies).
+Coordinators store the transaction systems’ information. The CC needs to write the new tLogs into coordinators’ states to achieve consensus and fault tolerance. Only when the coordinators’ states are updated with the new transaction system’s configuration will the cluster controller tell clients about the new transaction system (such as the new GRV proxies and commit proxies).
 
-The master only needs to write the new tLogs to a quorum of coordinators for a running cluster. The only time the master has to write all coordinators is when creating a brand new database.
+The CC only needs to write the new tLogs to a quorum of coordinators for a running cluster. The only time the CC has to write all coordinators is when creating a brand new database.
 
 
-Once the cstate is written, the master sets the `cstateUpdated` promise and moves to the ACCEPTING_COMMITS phase.
+Once the cstate is written, the CC sets the `cstateUpdated` promise and moves to the ACCEPTING_COMMITS phase.
 
 
 The cstate update is done in `trackTlogRecovery()` actor.
 The actor keeps running until the recovery finishes the FULLY_RECOVERED phase.
 The actor needs to update the cstates at the following phases:
 ALL_LOGS_RECRUITED, STORAGE_RECOVERED, and FULLY_RECOVERED.
-For example, when the old tLogs are no longer needed, the master will write the coordinators’ state again.
+For example, when the old tLogs are no longer needed, the CC will write the coordinators’ state again.
 
 
-Now the main steps in recovery have finished. The master keeps waiting for all tLogs to join the system and for all storage servers to roll back their prefetched *uncommitted* data before claiming the system is fully recovered.
+Now the main steps in recovery have finished. The CC keeps waiting for all tLogs to join the system and for all storage servers to roll back their prefetched *uncommitted* data before claiming the system is fully recovered.
 
 
 ## Phase 6: ACCEPTING_COMMITS
@@ -187,17 +187,17 @@ The transaction system starts to accept new transactions. This doesn't mean that
 
 ## Phase 7: ALL_LOGS_RECRUITED
 
-The master sets the recovery phase to ALL_LOGS_RECRUITED when the number of new tLogs it receives is equal to the expected tLogs based on the cluster configuration. This is done in the `trackTlogRecovery()` actor.
+The CC sets the recovery phase to ALL_LOGS_RECRUITED when the number of new tLogs it receives is equal to the expected tLogs based on the cluster configuration. This is done in the `trackTlogRecovery()` actor.
 
-The difference between this phase and getting to Phase 3 is that the master is waiting for *older generations* of tLogs to be cleaned up at this phase.
+The difference between this phase and getting to Phase 3 is that the CC is waiting for *older generations* of tLogs to be cleaned up at this phase.
 
 ## Phase 8: STORAGE_RECOVERED
 
 Storage servers need old tLogs in previous generations to recover storage servers’ state. For example, a storage server may be offline for a long time, lagging behind in pulling mutations assigned to it. We have to keep the old tLogs who have those mutations until no storage server needs them.
 
-When all tLogs are no longer needed and deleted, the master moves to the STORAGE_RECOVERED phase. This is done by checking if oldTLogData is empty in the `trackTlogRecovery()` actor.
+When all tLogs are no longer needed and deleted, the CC moves to the STORAGE_RECOVERED phase. This is done by checking if oldTLogData is empty in the `trackTlogRecovery()` actor.
 
 
 ## Phase 9: FULLY_RECOVERED
 
-When the master has all new tLogs and has removed all old tLogs -- both STORAGE_RECOVERED and ALL_LOGS_RECRUITED have been satisfied -- the master will mark the recovery state as FULLY_RECOVERED.
+When the CC has all new tLogs and has removed all old tLogs -- both STORAGE_RECOVERED and ALL_LOGS_RECRUITED have been satisfied -- the CC will mark the recovery state as FULLY_RECOVERED.

design/tlog-spilling.md.html

@@ -613,7 +613,7 @@ minor impacts on recovery times:
 : How many bytes of memory can be allocated to hold the results of reads from disk to respond to peek requests.<br>
   Increasing it will increase the number of parallel peek requests a TLog can handle at once.<br>
 	Decreasing it will reduce TLog memory usage.<br>
-	If increased, `--max_memory` should be increased by the same amount.<br>
+	If increased, `--memory` should be increased by the same amount.<br>
 
 `TLOG_DISK_QUEUE_EXTENSION_BYTES`
 : When a DiskQueue needs to extend a file, by how many bytes should it extend the file.<br>

design/transaction-state-store.md

@@ -0,0 +1,117 @@
+# Transaction State Store (txnStateStore)
+
+This document describes the transaction state store (often is referred as `txnStateStore` in the code) in FDB. The transaction state store keeps important metadata about the database to bootstrap the database, to guide the transaction system to persist writes (i.e., help assign storage tags to mutations at commit proxies), and to manage data (i.e., shard) movement metadata. This is a critical piece of information that have to be consistent across many processes and to be persistent for recovery.
+
+Acknowledgment: A lot of contents are taken from [Evan's FDB brownbag talk](https://drive.google.com/file/d/15UvKiNc-jSFfDGygNmLQP_d4b14X3DAS/).
+
+## What information is stored in transaction state store?
+
+The information includes: shard mapping (key range to storage server mapping, i.e.,
+`keyServers`), storage server tags (`serverTags`), tagLocalityList, storage server tag
+history, database locked flag, metadata version, mustContainSystemMutations, coordinators,
+storage server interface (`serverList`), database configurations, TSS mappings and
+quarantines, backup apply mutation ranges and log ranges, etc.
+
+The information of transaction state store is kept in the system key space, i.e., using the
+`\xff` prefix. Note all data in the system key space are saved on storage servers. The
+`txnStateStore` is only a part of the `\xff` key space, and is additionally kept in the
+memory of commit proxies as well as disks of the log system (i.e., TLogs). Changes to
+the `txnStateStore` are special mutations to the `\xff` key space, and are called
+inconsistently in the code base as "metadata mutations" in commit proxies and
+"state mutations" in Resolvers.
+
+## Why do we need transaction state store?
+
+When bootstraping an FDB cluster, the cluster controller (CC) role recruits a
+new transaction system and initializes them. In particular, the transaction state store
+is first read by the CC from previous generation's log system, and then broadcast to
+all commit proxies of the new transaction system. After initializing `txnStateStore`, these
+commit proxies know how to assign mutations with storage server tags: `txnStateStore`
+contains the shard map from key range to storage servers; commit proxies use the shard
+map to find and attach the destination storage tags for each mutation.
+
+## How is transaction state store replicated?
+
+The `txnStateStore` is replicated in all commit proxies' memories. It is very important
+that `txnStateStore` data are consistent, otherwise, a shard change issued by one commit
+proxy could result in a situation where different proxies think they should send a
+mutation to different storage servers, thus causing data corruptions.
+
+FDB solves this problem by state machine replication: all commit proxies start with the
+same `txnStateStore` data (from CC broadcast), and apply the same sequence of mutations.
+Because commits happen at all proxies, it is difficult to maintain the same order as well
+as minimize the communication among them. Fortunately, every transaction has to send a
+conflict resolution request to all Resolvers and they process transactions in strict order
+of commit versions. Leveraging this mechanism, each commit proxy sends all metadata
+(i.e., system key) mutations to all Resolvers. Resolvers keep these mutations in memory
+and forward to other commit proxies in separate resolution response. Each commit proxy
+receive resolution response, along with metadata mutations happend at other proxies before
+its commit version, and apply all these metadata mutations in the commit order.
+Finally, this proxy only writes metadata mutations in its own transaction batch to TLogs,
+i.e., do not write other proxies' metadata mutations to TLogs to avoid repeated writes.
+
+It's worth calling out that everything in the `txnStateStore` is stored at some storage
+servers and a client (e.g., `fdbcli`) can read from these storage servers. During the
+commit process, commit proxies parse all mutations in a batch of transactions, and apply
+changes (i.e., metadata mutations) to its in-memory copy of `txnStateStore`. Later, the
+same changes are applied at storage servers for persistence. Additionally, the process
+to store `txnStateStore` at log system is described below.
+
+Notably `applyMetadataMutations()` is the function that commit proxies use to make changes
+to `txnStateStore`. The key ranges stored in `txnStateStore` include `[\xff, \xff\x02)` and
+`[\xff\x03, \xff\xff)`, but not everything in these ranges. There is no data in the range
+of `[\xff\x02, \xff\x03)` belong to `txnStateStore`, e.g., `\xff\x02` prefix is used for
+backup data and is *NOT* metadata mutations.
+
+## How is transaction state store persisted at log system?
+
+When a commit proxy writes metadata mutations to the log system, the proxy assigns a
+"txs" tag to the mutation. Depending on FDB versions, the "txs" tag can be one special
+tag `txsTag{ tagLocalitySpecial, 1 }` for `TLogVersion::V3` (FDB 6.1) or a randomized
+"txs" tag for `TLogVersion::V4` (FDB 6.2 and later) and larger. The idea of randomized
+"txs" tag is to spread metadata mutations to all TLogs for faster parallel recovery of
+`txnStateStore`.
+
+At TLogs, all mutation data are indexed by tags. "txs" tag data is special, since it is
+only peeked by the cluster controller (CC) during the transaction system recovery.
+See [TLog Spilling doc](tlog-spilling.md.html) for more detailed discussion on the
+topic of spilling "txs" data. In short, `txsTag` is spilled by value.
+"txs" tag data is indexed and stored in both primary TLogs and satellite TLogs.
+Note satellite TLogs only index log router tags and "txs" tags.
+
+## How is transaction state store implemented?
+
+`txnStateStore` is kept in memory at commit proxies using `KeyValueStoreMemory`, which
+uses `LogSystemDiskQueueAdapter` to be durable with the log system. As a result, reading
+from `txnStateStore` never blocks, which means the futures returned by read calls should
+always be ready. Writes to `txnStateStore` are first buffered by the `LogSystemDiskQueueAdapter`
+in memory. After a commit proxy pushes transaction data to the log system and the data
+becomes durable, the proxy clears the buffered data in `LogSystemDiskQueueAdapter`.
+
+Note `KeyValueStoreMemory` periodically checkpoints its data to disks to speed up its
+recovery. For `txnStateStore`, this checkpoint allows versions before it to be popped,
+i.e., "txs" tag data on the log system can be reclaimed so that log queue does not grow
+unbounded. Thus, the `txsPoppedVersion` is the version right before a checkpoint, and
+during recovery, `txnStateStore` is recovered by reading all data from this version.
+
+* CC reads `txnStateStore` from old log system starting at `txsPoppedVersion`: https://github.com/apple/foundationdb/blob/6e31821bf578073409087779c567e26de317acd5/fdbserver/ClusterRecovery.actor.cpp#L1418
+
+* CC broadcasts `txnStateStore` to commit proxies: https://github.com/apple/foundationdb/blob/6e31821bf578073409087779c567e26de317acd5/fdbserver/ClusterRecovery.actor.cpp#L1286-L1313
+
+* Commit proxies receive txnStateStore broadcast and builds the `keyInfo` map: https://github.com/apple/foundationdb/blob/6281e647784e74dccb3a6cb88efb9d8b9cccd376/fdbserver/CommitProxyServer.actor.cpp#L1886-L1927
+  * Look up `keyInfo` map for `GetKeyServerLocationsRequest`: https://github.com/apple/foundationdb/blob/6281e647784e74dccb3a6cb88efb9d8b9cccd376/fdbserver/CommitProxyServer.actor.cpp#L1464
+  * Look up `keyInfo` map for assign mutations with storage tags: https://github.com/apple/foundationdb/blob/6281e647784e74dccb3a6cb88efb9d8b9cccd376/fdbserver/CommitProxyServer.actor.cpp#L926 and https://github.com/apple/foundationdb/blob/6281e647784e74dccb3a6cb88efb9d8b9cccd376/fdbserver/CommitProxyServer.actor.cpp#L965-L1010
+
+* Commit proxies recover database lock flag and metadata version: https://github.com/apple/foundationdb/blob/6281e647784e74dccb3a6cb88efb9d8b9cccd376/fdbserver/CommitProxyServer.actor.cpp#L1942-L1944
+
+* Commit proxies add metadata mutations to Resolver request: https://github.com/apple/foundationdb/blob/6281e647784e74dccb3a6cb88efb9d8b9cccd376/fdbserver/CommitProxyServer.actor.cpp#L137-L140
+
+* Resolvers keep these mutations in memory: https://github.com/apple/foundationdb/blob/6281e647784e74dccb3a6cb88efb9d8b9cccd376/fdbserver/Resolver.actor.cpp#L220-L230
+
+* Resolvers copy metadata mutations to resolution reply message: https://github.com/apple/foundationdb/blob/6281e647784e74dccb3a6cb88efb9d8b9cccd376/fdbserver/Resolver.actor.cpp#L244-L249
+
+* Commit proxies apply all metadata mutations (including those from other proxies) in the commit order: https://github.com/apple/foundationdb/blob/6281e647784e74dccb3a6cb88efb9d8b9cccd376/fdbserver/CommitProxyServer.actor.cpp#L740-L770
+
+* Commit proxies only write metadata mutations in its own transaction batch to TLogs: https://github.com/apple/foundationdb/blob/6281e647784e74dccb3a6cb88efb9d8b9cccd376/fdbserver/CommitProxyServer.actor.cpp#L772-L774 adds mutations to `storeCommits`. Later in `postResolution()`, https://github.com/apple/foundationdb/blob/6281e647784e74dccb3a6cb88efb9d8b9cccd376/fdbserver/CommitProxyServer.actor.cpp#L1162-L1176, only the last one in `storeCommits` are send to TLogs.
+
+* Commit proxies clear the buffered data in `LogSystemDiskQueueAdapter` after TLog push: https://github.com/apple/foundationdb/blob/6281e647784e74dccb3a6cb88efb9d8b9cccd376/fdbserver/CommitProxyServer.actor.cpp#L1283-L1287

documentation/sphinx/conf.py

@@ -53,7 +53,7 @@ copyright = u'2013-2021 Apple, Inc and the FoundationDB project authors'
 
 # Load the version information from 'versions.target'
 import xml.etree.ElementTree as ET
-version_path = os.path.join(os.path.dirname(__file__), '..', '..', 'versions.target')
+version_path = os.path.join(os.path.dirname(sys.executable), '..', '..', '..', 'versions.target')
 tree = ET.parse(version_path)
 root = tree.getroot()
 

documentation/sphinx/source/administration.rst

@@ -668,7 +668,7 @@ Datacenters
 
 FoundationDB is datacenter aware and supports operation across datacenters. In a multiple-datacenter configuration, it is recommended that you set the :ref:`redundancy mode <configuration-choosing-redundancy-mode>` to ``three_datacenter`` and that you set the ``locality_dcid`` parameter for all FoundationDB processes in :ref:`foundationdb.conf <foundationdb-conf>`.
 
-If you specify the ``--datacenter_id`` option to any FoundationDB process in your cluster, you should specify it to all such processes. Processes which do not have a specified datacenter ID on the command line are considered part of a default "unset" datacenter. FoundationDB will incorrectly believe that these processes are failure-isolated from other datacenters, which can reduce performance and fault tolerance.
+If you specify the ``--datacenter-id`` option to any FoundationDB process in your cluster, you should specify it to all such processes. Processes which do not have a specified datacenter ID on the command line are considered part of a default "unset" datacenter. FoundationDB will incorrectly believe that these processes are failure-isolated from other datacenters, which can reduce performance and fault tolerance.
 
 (Re)creating a database
 -----------------------

documentation/sphinx/source/api-common.rst.inc

@@ -588,3 +588,43 @@
 .. |locality-get-addresses-for-key-blurb| replace::
 
     Returns a list of public network addresses as strings, one for each of the storage servers responsible for storing ``key`` and its associated value.
+
+.. |option-knob| replace::
+   
+   Sets internal tuning or debugging knobs. The argument to this function should be a string representing the knob name and the value, e.g. "transaction_size_limit=1000".
+
+.. |option-tls-verify-peers| replace::
+
+   Sets the peer certificate field verification criteria. 
+
+.. |option-tls-ca-bytes| replace::
+    
+   Sets the certificate authority bundle.
+
+.. |option-tls-ca-path| replace::
+
+   Sets the file from which to load the certificate authority bundle.
+
+.. |option-tls-password| replace::
+
+    Sets the passphrase for encrypted private key. Password should be set before setting the key for the password to be used.
+
+.. |option-set-disable-local-client| replace::
+
+    Prevents connections through the local client, allowing only connections through externally loaded client libraries.
+
+.. |option-set-client-threads-per-version| replace::
+   
+    Spawns multiple worker threads for each version of the client that is loaded.  Setting this to a number greater than one implies disable_local_client.
+
+.. |option-disable-client-statistics-logging| replace::
+
+    Disables logging of client statistics, such as sampled transaction activity.
+       
+.. |option-enable-run-loop-profiling| replace::
+
+    Enables debugging feature to perform run loop profiling. Requires trace logging to be enabled. WARNING: this feature is not recommended for use in production.
+
+.. |option-set-distributed-client-tracer| replace::
+
+    Sets a tracer to run on the client. Should be set to the same value as the tracer set on the server.

documentation/sphinx/source/api-python.rst

@@ -125,6 +125,10 @@ After importing the ``fdb`` module and selecting an API version, you probably wa
 
     .. note:: |network-options-warning|
 
+    .. method :: fdb.options.set_knob(knob)
+       
+        |option-knob|
+
     .. method :: fdb.options.set_trace_enable( output_directory=None )
 
         |option-trace-enable-blurb|
@@ -188,6 +192,48 @@ After importing the ``fdb`` module and selecting an API version, you probably wa
     .. method :: fdb.options.set_tls_key_bytes(bytes)
 
        |option-tls-key-bytes|
+    
+    .. method :: fdb.options.set_tls_verify_peers(verification_pattern)
+
+       |option-tls-verify-peers|
+    
+    .. method :: fdb.options.set_tls_ca_bytes(ca_bundle)
+
+       |option-tls-ca-bytes|
+
+    .. method :: fdb.options.set_tls_ca_path(path)
+
+       |option-tls-ca-path|
+
+    .. method :: fdb.options.set_tls_password(password)
+
+       |option-tls-password|
+
+    .. method :: fdb.options.set_disable_multi_version_client_api()
+
+       |option-disable-multi-version-client-api|
+
+    .. method :: fdb.options.set_disable_local_client()
+
+      |option-set-disable-local-client|
+
+    .. method :: fdb.options.set_client_threads_per_version(number)
+
+       |option-set-client-threads-per-version|
+
+    .. method :: fdb.options.set_disable_client_statistics_logging()
+
+       |option-disable-client-statistics-logging|
+
+    .. method :: fdb.options.set_enable_run_loop_profiling()
+       
+       |option-enable-run-loop-profiling|
+
+    .. method :: fdb.options.set_distributed_client_tracer(tracer_type)
+       
+       |option-set-distributed-client-tracer|
+    
+    Please refer to fdboptions.py (generated) for a comprehensive list of options.
 
 .. _api-python-keys:
 

documentation/sphinx/source/backups.rst

@@ -161,7 +161,7 @@ Blob Credential Files
 
 In order to help safeguard blob store credentials, the <SECRET> can optionally be omitted from blobstore:// URLs on the command line.  Omitted secrets will be resolved at connect time using 1 or more Blob Credential files.
 
-Blob Credential files can be specified on the command line (via --blob_credentials <FILE>) or via the environment variable FDB_BLOB_CREDENTIALS which can be set to a colon-separated list of files.  The command line takes priority over the environment variable however all files from both sources will be used.
+Blob Credential files can be specified on the command line (via --blob-credentials <FILE>) or via the environment variable FDB_BLOB_CREDENTIALS which can be set to a colon-separated list of files.  The command line takes priority over the environment variable however all files from both sources will be used.
 
 At connect time, the specified files are read in order and the first matching account specification (user@host)
 will be used to obtain the secret key.
@@ -222,7 +222,7 @@ The following options apply to most subcommands:
 ``-t <TAG>``
   A "tag" is a named slot in which a backup task executes.  Backups on different named tags make progress and are controlled independently, though their executions are handled by the same set of backup agent processes.  Any number of unique backup tags can be active at once.  It the tag is not specified, the default tag name "default" is used.
 
-``--blob_credentials <FILE>``
+``--blob-credentials <FILE>``
   Use FILE as a :ref:`Blob Credential File<blob-credential-files>`.  Can be used multiple times.
 
 .. _backup-start:
@@ -236,18 +236,18 @@ The ``start`` subcommand is used to start a backup.  If there is already a backu
 
 ::
 
-   user@host$ fdbbackup start [-t <TAG>] -d <BACKUP_URL> [-z] [-s <DURATION>] [--partitioned_log_experimental] [-w] [-k '<BEGIN>[ <END>]']...
+   user@host$ fdbbackup start [-t <TAG>] -d <BACKUP_URL> [-z] [-s <DURATION>] [--partitioned-log-experimental] [-w] [-k '<BEGIN>[ <END>]']...
 
 ``-z``
   Perform the backup continuously rather than terminating once a restorable backup is achieved.  Database mutations within the backup's target key ranges will be continuously written to the backup as well as repeated inconsistent snapshots at the configured snapshot rate.
 
-``-s <DURATION>`` or ``--snapshot_interval <DURATION>``  
+``-s <DURATION>`` or ``--snapshot-interval <DURATION>``  
   Specifies the duration, in seconds, of the inconsistent snapshots written to the backup in continuous mode.  The default is 864000 which is 10 days.
 
-``--initial_snapshot_interval <DURATION>``  
+``--initial-snapshot-interval <DURATION>``  
   Specifies the duration, in seconds, of the first inconsistent snapshot written to the backup.  The default is 0, which means as fast as possible.
 
-``--partitioned_log_experimental``
+``--partitioned-log-experimental``
   Specifies the backup uses the partitioned mutation logs generated by backup workers. Since FDB version 6.3, this option is experimental and requires using fast restore for restoring the database from the generated files. The default is to use non-partitioned mutation logs generated by backup agents.
 
 ``-w``
@@ -270,18 +270,18 @@ The ``modify`` subcommand is used to modify parameters of a running backup.  All
 
 ::
 
-   user@host$ fdbbackup modify [-t <TAG>] [-d <BACKUP_URL>] [-s <DURATION>] [--active_snapshot_interval <DURATION>] [--verify_uid <UID>]
+   user@host$ fdbbackup modify [-t <TAG>] [-d <BACKUP_URL>] [-s <DURATION>] [--active-snapshot-interval <DURATION>] [--verify-uid <UID>]
 
 ``-d <BACKUP_URL>``
   Sets a new Backup URL for the backup to write to.  This is most likely to be used to change only URL parameters or account information.  However, it can also be used to start writing to a new destination mid-backup.  The new old location will cease gaining any additional restorability, while the new location will not be restorable until a new snapshot begins and completes.  Full restorability would be regained, however, if the contents of the two destinations were to be combined by the user.
 
-``-s <DURATION>`` or ``--snapshot_interval <DURATION>``  
+``-s <DURATION>`` or ``--snapshot-interval <DURATION>``  
   Sets a new duration for backup snapshots, in seconds.
 
-``--active_snapshot_interval <DURATION>``  
+``--active-snapshot-interval <DURATION>``  
   Sets new duration for the backup's currently active snapshot, in seconds, relative to the start of the snapshot.
 
-``--verify_uid <UID>``
+``--verify-uid <UID>``
   Specifies a UID to verify against the BackupUID of the running backup.  If provided, the UID is verified in the same transaction which sets the new backup parameters (if the UID matches).
 
 .. program:: fdbbackup abort
@@ -359,18 +359,18 @@ The ``expire`` subcommand will remove data from a backup prior to some point in
 
 The expiration CUTOFF must be specified by one of the two following arguments:
    
-  ``--expire_before_timestamp <DATETIME>``
+  ``--expire-before-timestamp <DATETIME>``
     Specifies the expiration cutoff to DATETIME.  Requires a cluster file and will use version/timestamp metadata in the database to convert DATETIME to a database commit version.  DATETIME must be in the form "YYYY/MM/DD.HH:MI:SS+hhmm", for example "2018/12/31.23:59:59-0800".
 
-  ``--expire_before_version <VERSION>``
+  ``--expire-before-version <VERSION>``
     Specifies the cutoff by a database commit version.
 
 Optionally, the user can specify a minimum RESTORABILITY guarantee with one of the following options.
 
-  ``--restorable_after_timestamp <DATETIME>``
+  ``--restorable-after-timestamp <DATETIME>``
     Specifies that the backup must be restorable to DATETIME and later.  Requires a cluster file and will use version/timestamp metadata in the database to convert DATETIME to a database commit version.  DATETIME must be in the form "YYYY/MM/DD.HH:MI:SS+hhmm", for example "2018/12/31.23:59:59-0800".
 
-  ``--restorable_after_version <VERSION>``
+  ``--restorable-after-version <VERSION>``
     Specifies that the backup must be restorable as of VERSION and later.
 
 ``-f`` or ``--force``
@@ -385,9 +385,9 @@ The ``describe`` subcommand will analyze the given backup and print a summary of
 
 ::
 
-   user@host$ fdbbackup describe -d <BACKUP_URL> [--version_timestamps] [-C <CLUSTER_FILE>] 
+   user@host$ fdbbackup describe -d <BACKUP_URL> [--version-timestamps] [-C <CLUSTER_FILE>] 
 
-``--version_timestamps``
+``--version-timestamps``
   If the originating cluster is still available and is passed on the command line, this option can be specified in order for all versions in the output to also be converted to timestamps for better human readability.
 
 
@@ -402,7 +402,7 @@ The ``list`` subcommand will list the backups at a given 'base' or shortened Bac
 
    user@host$ fdbbackup list -b <BASE_URL>
 
-``-b <BASE_URL>`` or ``--base_url <BASE_URL>``
+``-b <BASE_URL>`` or ``--base-url <BASE_URL>``
   This a shortened Backup URL which looks just like a Backup URL but without the backup <name> so that the list command will discover and list all of the backups in the bucket.
 
 
@@ -415,12 +415,12 @@ The ``cleanup`` subcommand will list orphaned backups and DRs and optionally rem
 
 ::
 
-   user@host$ fdbbackup cleanup [--delete_data] [--min_cleanup_seconds] [-C <CLUSTER_FILE>] 
+   user@host$ fdbbackup cleanup [--delete-data] [--min-cleanup-seconds] [-C <CLUSTER_FILE>] 
 
-``--delete_data``
+``--delete-data``
   This flag will cause ``cleanup`` to remove mutations for the most stale backup or DR.
 
-``--min_cleanup_seconds``
+``--min-cleanup-seconds``
   Specifies the amount of time a backup or DR needs to be stale before ``cleanup`` will remove mutations for it. By default this is set to one hour.
 
 
@@ -447,10 +447,10 @@ The following options apply to all commands:
 
   .. warning:: If multiple restore tasks are in progress they should be restoring to different prefixes or the result is undefined.
 
-``--blob_credentials <FILE>``
+``--blob-credentials <FILE>``
   Use FILE as a :ref:`Blob Credential File<blob-credential-files>`.  Can be used multiple times.
 
-``--dest_cluster_file <CONNFILE>``
+``--dest-cluster-file <CONNFILE>``
   Required.  Path to the cluster file that should be used to connect to the FoundationDB cluster you are restoring to.
 
 .. _restore-start:
@@ -472,10 +472,10 @@ The ``start`` command will start a new restore on the specified (or default) tag
 ``-k <KEYS>``
   Specify list of key ranges from the backup to restore to the database
 
-``--remove_prefix <PREFIX>``
+``--remove-prefix <PREFIX>``
   Remove PREFIX from the keys read from the backup
 
-``--add_prefix <PREFIX>``
+``--add-prefix <PREFIX>``
   Add PREFIX to restored keys before writing them to the database
 
 ``-n``
@@ -487,10 +487,10 @@ The ``start`` command will start a new restore on the specified (or default) tag
 ``--timestamp <DATETIME>``
   Instead of the latest version the backup can be restored to, restore to a version from approximately the given timestamp.  Requires orig_cluster_file to be specified.  DATETIME must be in the form "YYYY/MM/DD.HH:MI:SS+hhmm", for example "2018/12/31.23:59:59-0800".
 
-``--orig_cluster_file <CONNFILE>``
+``--orig-cluster-file <CONNFILE>``
   The cluster file for the original database from which the backup was created.  The original database is only needed to convert a --timestamp argument to a database version.
 
-``--inconsistent_snapshot_only``
+``--inconsistent-snapshot-only``
   Ignore mutation log files during the restore to speedup the process. Because only range files are restored, this option gives an inconsistent snapshot in most cases and is not recommended to use.
 
 .. program:: fdbrestore abort
@@ -532,7 +532,7 @@ The ``status`` command will print a detailed status report on restore job progre
  
   If not specified, a :ref:`default cluster file <default-cluster-file>` will be used.
 
-``--blob_credentials <FILE>``
+``--blob-credentials <FILE>``
   Use FILE as a :ref:`Blob Credential File<blob-credential-files>`.  Can be used multiple times.
 
 .. _fdbdr-intro:

documentation/sphinx/source/client-testing.rst

@@ -341,14 +341,14 @@ example this file would create a server with 8 processes of which 4 would act as
     group = foundationdb
 
     [general]
-    restart_delay = 60
-    cluster_file = /etc/foundationdb/fdb.cluster
+    restart-delay = 60
+    cluster-file = /etc/foundationdb/fdb.cluster
 
     ## Default parameters for individual fdbserver processes
     [fdbserver]
     command = /usr/sbin/fdbserver
-    public_address = auto:$ID
-    listen_address = public
+    public-address = auto:$ID
+    listen-address = public
     datadir = /var/lib/foundationdb/data/$ID
     logdir = /var/log/foundationdb
 

documentation/sphinx/source/configuration.rst

@@ -212,46 +212,46 @@ Contains basic configuration parameters of the ``fdbmonitor`` process. ``user``
 .. code-block:: ini
 
     [general]
-    cluster_file = /etc/foundationdb/fdb.cluster
-    restart_delay = 60
-    ## restart_backoff and restart_delay_reset_interval default to the value that is used for restart_delay
-    # initial_restart_delay = 0
-    # restart_backoff = 60.0
-    # restart_delay_reset_interval = 60
-    # delete_envvars =
-    # kill_on_configuration_change = true
-    # disable_lifecycle_logging = false
+    cluster-file = /etc/foundationdb/fdb.cluster
+    restart-delay = 60
+    ## restart-backoff and restart-delay-reset-interval default to the value that is used for restart-delay
+    # initial-restart-delay = 0
+    # restart-backoff = 60.0
+    # restart-delay-reset-interval = 60
+    # delete-envvars =
+    # kill-on-configuration-change = true
+    # disable-lifecycle-logging = false
 
 Contains settings applicable to all processes (e.g. fdbserver, backup_agent).
 
-* ``cluster_file``: Specifies the location of the cluster file. This file and the directory that contains it must be writable by all processes (i.e. by the user or group set in the ``[fdbmonitor]`` section).
-* ``delete_envvars``: A space separated list of environment variables to remove from the environments of child processes. This can be used if the ``fdbmonitor`` process needs to be run with environment variables that are undesired in its children.
-* ``kill_on_configuration_change``: If ``true``, affected processes will be restarted whenever the configuration file changes. Defaults to ``true``.
-* ``disable_lifecycle_logging``: If ``true``, ``fdbmonitor`` will not write log events when processes start or terminate. Defaults to ``false``.
+* ``cluster-file``: Specifies the location of the cluster file. This file and the directory that contains it must be writable by all processes (i.e. by the user or group set in the ``[fdbmonitor]`` section).
+* ``delete-envvars``: A space separated list of environment variables to remove from the environments of child processes. This can be used if the ``fdbmonitor`` process needs to be run with environment variables that are undesired in its children.
+* ``kill-on-configuration-change``: If ``true``, affected processes will be restarted whenever the configuration file changes. Defaults to ``true``.
+* ``disable-lifecycle-logging``: If ``true``, ``fdbmonitor`` will not write log events when processes start or terminate. Defaults to ``false``.
 
 .. _configuration-restarting:
 
 The ``[general]`` section also contains some parameters to control how processes are restarted when they die. ``fdbmonitor`` uses backoff logic to prevent a process that dies repeatedly from cycling too quickly, and it also introduces up to +/-10% random jitter into the delay to avoid multiple processes all restarting simultaneously. ``fdbmonitor`` tracks separate backoff state for each process, so the restarting of one process will have no effect on the backoff behavior of another.
 
-* ``restart_delay``: The maximum number of seconds (subject to jitter) that fdbmonitor will delay before restarting a failed process.
-* ``initial_restart_delay``: The number of seconds ``fdbmonitor`` waits to restart a process the first time it dies. Defaults to 0 (i.e. the process gets restarted immediately). 
-* ``restart_backoff``: Controls how quickly ``fdbmonitor`` backs off when a process dies repeatedly. The previous delay (or 1, if the previous delay is 0) is multiplied by ``restart_backoff`` to get the next delay, maxing out at the value of ``restart_delay``. Defaults to the value of ``restart_delay``, meaning that the second and subsequent failures will all delay ``restart_delay`` between restarts.
-* ``restart_delay_reset_interval``: The number of seconds a process must be running before resetting the backoff back to the value of ``initial_restart_delay``. Defaults to the value of ``restart_delay``.
+* ``restart-delay``: The maximum number of seconds (subject to jitter) that fdbmonitor will delay before restarting a failed process.
+* ``initial-restart-delay``: The number of seconds ``fdbmonitor`` waits to restart a process the first time it dies. Defaults to 0 (i.e. the process gets restarted immediately). 
+* ``restart-backoff``: Controls how quickly ``fdbmonitor`` backs off when a process dies repeatedly. The previous delay (or 1, if the previous delay is 0) is multiplied by ``restart-backoff`` to get the next delay, maxing out at the value of ``restart-delay``. Defaults to the value of ``restart-delay``, meaning that the second and subsequent failures will all delay ``restart-delay`` between restarts.
+* ``restart-delay-reset-interval``: The number of seconds a process must be running before resetting the backoff back to the value of ``initial-restart-delay``. Defaults to the value of ``restart-delay``.
 
- These ``restart_`` parameters are not applicable to the ``fdbmonitor`` process itself. See :ref:`Configuring autorestart of fdbmonitor <configuration-restart-fdbmonitor>` for details.
+ These ``restart-`` parameters are not applicable to the ``fdbmonitor`` process itself. See :ref:`Configuring autorestart of fdbmonitor <configuration-restart-fdbmonitor>` for details.
 
 As an example, let's say the following parameters have been set:
 
 .. code-block:: ini
 
-    restart_delay = 60
-    initial_restart_delay = 0
-    restart_backoff = 2.0
-    restart_delay_reset_interval = 180
+    restart-delay = 60
+    initial-restart-delay = 0
+    restart-backoff = 2.0
+    restart-delay-reset-interval = 180
 
 The progression of delays for a process that fails repeatedly would be ``0, 2, 4, 8, 16, 32, 60, 60, ...``, each subject to a 10% random jitter. After the process stays alive for 180 seconds, the backoff would reset and the next failure would restart the process immediately.
 
-Using the default parameters, a process will restart immediately if it fails and then delay ``restart_delay`` seconds if it fails again within ``restart_delay`` seconds. 
+Using the default parameters, a process will restart immediately if it fails and then delay ``restart-delay`` seconds if it fails again within ``restart-delay`` seconds. 
 
 .. _foundationdb-conf-fdbserver:
 
@@ -263,43 +263,43 @@ Using the default parameters, a process will restart immediately if it fails and
     ## Default parameters for individual fdbserver processes
     [fdbserver]
     command = /usr/sbin/fdbserver
-    public_address = auto:$ID
-    listen_address = public
+    public-address = auto:$ID
+    listen-address = public
     datadir = /var/lib/foundationdb/data/$ID
     logdir = /var/log/foundationdb
     # logsize = 10MiB
     # maxlogssize = 100MiB
     # class = 
     # memory = 8GiB
-    # storage_memory = 1GiB
-    # cache_memory = 2GiB
-    # locality_machineid = 
-    # locality_zoneid = 
-    # locality_data_hall = 
-    # locality_dcid = 
-    # io_trust_seconds = 20
+    # storage-memory = 1GiB
+    # cache-memory = 2GiB
+    # locality-machineid =
+    # locality-zoneid =
+    # locality-data-hall =
+    # locality-dcid =
+    # io-trust-seconds = 20
 
-Contains default parameters for all fdbserver processes on this machine. These same options can be overridden for individual processes in their respective ``[fdbserver.<ID>]`` sections. In this section, the ID of the individual fdbserver can be substituted by using the ``$ID`` variable in the value. For example, ``public_address = auto:$ID`` makes each fdbserver listen on a port equal to its ID.
+Contains default parameters for all fdbserver processes on this machine. These same options can be overridden for individual processes in their respective ``[fdbserver.<ID>]`` sections. In this section, the ID of the individual fdbserver can be substituted by using the ``$ID`` variable in the value. For example, ``public-address = auto:$ID`` makes each fdbserver listen on a port equal to its ID.
 
 .. note:: |multiplicative-suffixes|
 .. note:: In general locality id's are used to specify the location of processes which in turn is used to determine fault and replication domains.
 
 * ``command``: The location of the ``fdbserver`` binary.
-* ``public_address``: The publicly visible IP:Port of the process. If ``auto``, the address will be the one used to communicate with the coordination servers.
-* ``listen_address``: The IP:Port that the server socket should bind to. If ``public``, it will be the same as the public_address.
+* ``public-address``: The publicly visible IP:Port of the process. If ``auto``, the address will be the one used to communicate with the coordination servers.
+* ``listen-address``: The IP:Port that the server socket should bind to. If ``public``, it will be the same as the public-address.
 * ``datadir``: A writable directory (by root or by the user set in the [fdbmonitor] section) where persistent data files will be stored.
 * ``logdir``: A writable directory (by root or by the user set in the [fdbmonitor] section) where FoundationDB will store log files.
 * ``logsize``: Roll over to a new log file after the current log file reaches the specified size. The default value is 10MiB.
 * ``maxlogssize``: Delete the oldest log file when the total size of all log files exceeds the specified size. If set to 0B, old log files will not be deleted. The default value is 100MiB.
 * ``class``: Process class specifying the roles that will be taken in the cluster. Recommended options are ``storage``, ``transaction``, ``stateless``. See :ref:`guidelines-process-class-config` for process class config recommendations.
-* ``memory``: Maximum memory used by the process. The default value is 8GiB. When specified without a unit, MiB is assumed. This parameter does not change the memory allocation of the program. Rather, it sets a hard limit beyond which the process will kill itself and be restarted. The default value of 8GiB is double the intended memory usage in the default configuration (providing an emergency buffer to deal with memory leaks or similar problems). It is *not* recommended to decrease the value of this parameter below its default value. It may be *increased* if you wish to allocate a very large amount of storage engine memory or cache. In particular, when the ``storage_memory``  or ``cache_memory`` parameters are increased, the ``memory`` parameter should be increased by an equal amount.
-* ``storage_memory``: Maximum memory used for data storage. This parameter is used *only* with memory storage engine, not the ssd storage engine. The default value is 1GiB. When specified without a unit, MB is assumed. Clusters will be restricted to using this amount of memory per process for purposes of data storage. Memory overhead associated with storing the data is counted against this total. If you increase the ``storage_memory`` parameter, you should also increase the ``memory`` parameter by the same amount.
-* ``cache_memory``: Maximum memory used for caching pages from disk. The default value is 2GiB. When specified without a unit, MiB is assumed. If you increase the ``cache_memory`` parameter, you should also increase the ``memory`` parameter by the same amount.
-* ``locality_machineid``: Machine identifier key. All processes on a machine should share a unique id. By default, processes on a machine determine a unique id to share. This does not generally need to be set.
-* ``locality_zoneid``: Zone identifier key.  Processes that share a zone id are considered non-unique for the purposes of data replication. If unset, defaults to machine id.
-* ``locality_dcid``: Datacenter identifier key. All processes physically located in a datacenter should share the id. No default value. If you are depending on datacenter based replication this must be set on all processes.
-* ``locality_data_hall``: Data hall identifier key. All processes physically located in a data hall should share the id. No default value. If you are depending on data hall based replication this must be set on all processes.
-* ``io_trust_seconds``: Time in seconds that a read or write operation is allowed to take before timing out with an error. If an operation times out, all future operations on that file will fail with an error as well. Only has an effect when using AsyncFileKAIO in Linux. If unset, defaults to 0 which means timeout is disabled.
+* ``memory``: Maximum memory used by the process. The default value is 8GiB. When specified without a unit, MiB is assumed. This parameter does not change the memory allocation of the program. Rather, it sets a hard limit beyond which the process will kill itself and be restarted. The default value of 8GiB is double the intended memory usage in the default configuration (providing an emergency buffer to deal with memory leaks or similar problems). It is *not* recommended to decrease the value of this parameter below its default value. It may be *increased* if you wish to allocate a very large amount of storage engine memory or cache. In particular, when the ``storage-memory``  or ``cache-memory`` parameters are increased, the ``memory`` parameter should be increased by an equal amount.
+* ``storage-memory``: Maximum memory used for data storage. This parameter is used *only* with memory storage engine, not the ssd storage engine. The default value is 1GiB. When specified without a unit, MB is assumed. Clusters will be restricted to using this amount of memory per process for purposes of data storage. Memory overhead associated with storing the data is counted against this total. If you increase the ``storage-memory`` parameter, you should also increase the ``memory`` parameter by the same amount.
+* ``cache-memory``: Maximum memory used for caching pages from disk. The default value is 2GiB. When specified without a unit, MiB is assumed. If you increase the ``cache-memory`` parameter, you should also increase the ``memory`` parameter by the same amount.
+* ``locality-machineid``: Machine identifier key. All processes on a machine should share a unique id. By default, processes on a machine determine a unique id to share. This does not generally need to be set.
+* ``locality-zoneid``: Zone identifier key.  Processes that share a zone id are considered non-unique for the purposes of data replication. If unset, defaults to machine id.
+* ``locality-dcid``: Datacenter identifier key. All processes physically located in a datacenter should share the id. No default value. If you are depending on datacenter based replication this must be set on all processes.
+* ``locality-data-hall``: Data hall identifier key. All processes physically located in a data hall should share the id. No default value. If you are depending on data hall based replication this must be set on all processes.
+* ``io-trust-seconds``: Time in seconds that a read or write operation is allowed to take before timing out with an error. If an operation times out, all future operations on that file will fail with an error as well. Only has an effect when using AsyncFileKAIO in Linux. If unset, defaults to 0 which means timeout is disabled.
 
 .. note:: In addition to the options above, TLS settings as described for the :ref:`TLS plugin <configuring-tls>` can be specified in the [fdbserver] section.
 
@@ -598,9 +598,9 @@ If a region failover occurs, clients will generally only see a latency spike of
 Specifying datacenters
 ----------------------
 
-To use region configurations all processes in the cluster need to specify in which datacenter they are located. This can be done on the command line with either ``--locality_dcid`` or ``--datacenter_id``. This datacenter identifier is case sensitive.
+To use region configurations all processes in the cluster need to specify in which datacenter they are located. This can be done on the command line with either ``--locality-dcid`` or ``--datacenter-id``. This datacenter identifier is case sensitive.
 
-Clients should also specify their datacenter with the database option ``datacenter_id``. If a client does not specify their datacenter, they will use latency estimates to balance traffic between the two regions. This will result in about 5% of requests being served by the remote regions, so reads will suffer from high tail latencies.
+Clients should also specify their datacenter with the database option ``datacenter-id``. If a client does not specify their datacenter, they will use latency estimates to balance traffic between the two regions. This will result in about 5% of requests being served by the remote regions, so reads will suffer from high tail latencies.
 
 Changing the region configuration
 ---------------------------------

documentation/sphinx/source/downloads.rst

@@ -10,38 +10,31 @@ macOS
 
 The macOS installation package is supported on macOS 10.7+. It includes the client and (optionally) the server.
 
-* `FoundationDB-6.3.10.pkg <https://www.foundationdb.org/downloads/6.3.10/macOS/installers/FoundationDB-6.3.10.pkg>`_
+* `FoundationDB-6.3.23.pkg <https://github.com/apple/foundationdb/releases/download/6.3.23/FoundationDB-6.3.23.pkg>`_
 
 Ubuntu
 ------
 
 The Ubuntu packages are supported on 64-bit Ubuntu 12.04+, but beware of the Linux kernel bug in Ubuntu 12.x.
 
-* `foundationdb-clients-6.3.10-1_amd64.deb <https://www.foundationdb.org/downloads/6.3.10/ubuntu/installers/foundationdb-clients_6.3.10-1_amd64.deb>`_
-* `foundationdb-server-6.3.10-1_amd64.deb <https://www.foundationdb.org/downloads/6.3.10/ubuntu/installers/foundationdb-server_6.3.10-1_amd64.deb>`_ (depends on the clients package)
+* `foundationdb-clients_6.3.23-1_amd64.deb <https://github.com/apple/foundationdb/releases/download/6.3.23/foundationdb-clients_6.3.23-1_amd64.deb>`_
+* `foundationdb-server_6.3.23-1_amd64.deb <https://github.com/apple/foundationdb/releases/download/6.3.23/foundationdb-server_6.3.23-1_amd64.deb>`_ (depends on the clients package)
 
-RHEL/CentOS EL6
----------------
 
-The RHEL/CentOS EL6 packages are supported on 64-bit RHEL/CentOS 6.x.
-
-* `foundationdb-clients-6.3.10-1.el6.x86_64.rpm <https://www.foundationdb.org/downloads/6.3.10/rhel6/installers/foundationdb-clients-6.3.10-1.el6.x86_64.rpm>`_
-* `foundationdb-server-6.3.10-1.el6.x86_64.rpm <https://www.foundationdb.org/downloads/6.3.10/rhel6/installers/foundationdb-server-6.3.10-1.el6.x86_64.rpm>`_ (depends on the clients package)
-
-RHEL/CentOS EL7
+RHEL/CentOS 7
 ---------------
 
 The RHEL/CentOS EL7 packages are supported on 64-bit RHEL/CentOS 7.x.
 
-* `foundationdb-clients-6.3.10-1.el7.x86_64.rpm <https://www.foundationdb.org/downloads/6.3.10/rhel7/installers/foundationdb-clients-6.3.10-1.el7.x86_64.rpm>`_
-* `foundationdb-server-6.3.10-1.el7.x86_64.rpm <https://www.foundationdb.org/downloads/6.3.10/rhel7/installers/foundationdb-server-6.3.10-1.el7.x86_64.rpm>`_ (depends on the clients package)
+* `foundationdb-clients-6.3.23-1.el7.x86_64.rpm <https://github.com/apple/foundationdb/releases/download/6.3.12/foundationdb-clients-6.3.23-1.el7.x86_64.rpm>`_
+* `foundationdb-server-6.3.23-1.el7.x86_64.rpm <https://github.com/apple/foundationdb/releases/download/6.3.12/foundationdb-server-6.3.23-1.el7.x86_64.rpm>`_ (depends on the clients package)
 
 Windows
 -------
 
-The Windows installer is supported on 64-bit Windows XP and later. It includes the client and (optionally) the server.
+The Windows installer is supported on 64-bit Windows XP and later. It includes the client and (optionally) the server (for FoundationDB versions 6.3.12 and older).
 
-* `foundationdb-6.3.10-x64.msi <https://www.foundationdb.org/downloads/6.3.10/windows/installers/foundationdb-6.3.10-x64.msi>`_
+* `foundationdb-6.3.12-x64.msi <https://github.com/apple/foundationdb/releases/download/6.3.12/foundationdb-6.3.12-x64.msi>`_
 
 API Language Bindings
 =====================
@@ -51,27 +44,23 @@ C
 
 FoundationDB's C bindings are installed with the FoundationDB client binaries. You can find more details in the :doc:`C API Documentation <api-c>`.
 
-Python 2.7 - 3.7
-----------------
+Python 3.7+
+-----------
 
-On macOS and Windows, the FoundationDB Python API bindings are installed as part of your FoundationDB installation.
+Python package is available from `PiPy <https://pypi.org/project/foundationdb/>`_
 
-If you need to use the FoundationDB Python API from other Python installations or paths, use the Python package manager ``pip`` (``pip install foundationdb``) or download the Python package:
 
-* `foundationdb-6.3.10.tar.gz <https://www.foundationdb.org/downloads/6.3.10/bindings/python/foundationdb-6.3.10.tar.gz>`_
+Ruby 2.0.0+
+-----------
 
-Ruby 1.9.3/2.0.0+
------------------
-
-* `fdb-6.3.10.gem <https://www.foundationdb.org/downloads/6.3.10/bindings/ruby/fdb-6.3.10.gem>`_
+Ruby Gem is available on `rubygems.org <https://rubygems.org/gems/fdb>`_
 
 Java 8+
 -------
 
-* `fdb-java-6.3.10.jar <https://www.foundationdb.org/downloads/6.3.10/bindings/java/fdb-java-6.3.10.jar>`_
-* `fdb-java-6.3.10-javadoc.jar <https://www.foundationdb.org/downloads/6.3.10/bindings/java/fdb-java-6.3.10-javadoc.jar>`_
+Java jars are available from `Maven Central <https://search.maven.org/artifact/org.foundationdb/fdb-java>`_
 
 Go 1.11+
 --------
 
-The FoundationDB Go package is available on `GitHub <https://github.com/apple/foundationdb/tree/master/bindings/go>`_.
+The FoundationDB Go package is available on `GitHub <https://github.com/apple/foundationdb/tree/master/bindings/go>`_

documentation/sphinx/source/mr-status-json-schemas.rst.inc

@@ -700,7 +700,7 @@
              "ssd",
              "ssd-1",
              "ssd-2",
-             "ssd-redwood-experimental",
+             "ssd-redwood-1-experimental",
              "ssd-rocksdb-experimental",
              "memory",
              "memory-1",
@@ -713,7 +713,7 @@
              "ssd",
              "ssd-1",
              "ssd-2",
-             "ssd-redwood-experimental",
+             "ssd-redwood-1-experimental",
              "ssd-rocksdb-experimental",
              "memory",
              "memory-1",

documentation/sphinx/source/release-notes/release-notes-630.rst

@@ -2,6 +2,12 @@
 Release Notes
 #############
 
+6.3.23
+======
+* Fixed a bug that remoteDCIsHealthy logic is not guarded by CC_ENABLE_WORKER_HEALTH_MONITOR, which may prevent HA failback. `(PR #6106) <https://github.com/apple/foundationdb/pull/6106>`_
+* Fixed a race condition with updating the coordinated state and updating the master registration. `(PR #6088) <https://github.com/apple/foundationdb/pull/6088>`_
+* Changed dbinfo broadcast to be explicitly requested by the worker registration message. `(PR #6073) <https://github.com/apple/foundationdb/pull/6073>`_
+
 6.3.22
 ======
 * Added histograms to client GRV batcher. `(PR #5760) <https://github.com/apple/foundationdb/pull/5760>`_

documentation/sphinx/source/release-notes/release-notes-700.rst

@@ -30,6 +30,7 @@ Features
 * Improved the efficiency with which storage servers replicate data between themselves. `(PR #5017) <https://github.com/apple/foundationdb/pull/5017>`_
 * Added support to ``exclude command`` to exclude based on locality match. `(PR #5113) <https://github.com/apple/foundationdb/pull/5113>`_
 * Add the ``trace_partial_file_suffix`` network option. This option will give unfinished trace files a special suffix to indicate they're not complete yet. When the trace file is complete, it is renamed to remove the suffix. `(PR #5328) <https://github.com/apple/foundationdb/pull/5328>`_
+* Added "get range and flat map" feature with new APIs (see Bindings section). Storage servers are able to generate the keys in the queries based on another query. With this, upper layer can push some computations down to FDB, to improve latency and bandwidth when read. `(PR #5609) <https://github.com/apple/foundationdb/pull/5609>`_
 
 Performance
 -----------
@@ -86,6 +87,8 @@ Bindings
 * C: Added a function, ``fdb_database_create_snapshot``, to create a snapshot of the database. `(PR #4241) <https://github.com/apple/foundationdb/pull/4241/files>`_
 * C: Added ``fdb_database_get_main_thread_busyness`` function to report how busy a client's main thread is. `(PR #4504) <https://github.com/apple/foundationdb/pull/4504>`_
 * Java: Added ``Database.getMainThreadBusyness`` function to report how busy a client's main thread is. `(PR #4564) <https://github.com/apple/foundationdb/pull/4564>`_
+* C: Added ``fdb_transaction_get_range_and_flat_map`` function to support running queries based on another query in one request. `(PR #5609) <https://github.com/apple/foundationdb/pull/5609>`_
+* Java: Added ``Transaction.getRangeAndFlatMap`` function to support running queries based on another query in one request. `(PR #5609) <https://github.com/apple/foundationdb/pull/5609>`_
 
 Other Changes
 -------------

documentation/sphinx/source/request-tracing.rst

@@ -85,23 +85,12 @@ Control options
 In addition to the command line parameter described above, tracing can be set
 at a database and transaction level.
 
-Tracing can be globally disabled by setting the
-``distributed_transaction_trace_disable`` database option. It can be enabled by
-setting the ``distributed_transaction_trace_enable`` database option. If
-neither option is specified but a tracer option is set as described above,
-tracing will be enabled.
+Tracing can be controlled on a global level by setting the
+``TRACING_SAMPLE_RATE`` knob. Set the knob to 0.0 to record no traces, to 1.0
+to record all traces, or somewhere in the middle. Traces are sampled as a unit.
+All individual spans in the trace will be included in the sample.
 
 Tracing can be enabled or disabled for individual transactions. The special key
 space exposes an API to set a custom trace ID for a transaction, or to disable
 tracing for the transaction. See the special key space :ref:`tracing module
 documentation <special-key-space-tracing-module>` to learn more.
-
-^^^^^^^^^^^^^^
-Trace sampling
-^^^^^^^^^^^^^^
-
-By default, all traces are recorded. If tracing is producing too much data,
-adjust the trace sample rate with the ``TRACING_SAMPLE_RATE`` knob. Set the
-knob to 0.0 to record no traces, to 1.0 to record all traces, or somewhere in
-the middle. Traces are sampled as a unit. All individual spans in the trace
-will be included in the sample.

documentation/sphinx/source/tls.rst

@@ -156,7 +156,7 @@ The TLS certificate will be automatically refreshed on a configurable cadence. T
 * They are valid certificates.
 * The key file matches the certificate file.
 
-The refresh rate is controlled by ``--knob_tls_cert_refresh_delay_seconds``. Setting it to 0 will disable the refresh.
+The refresh rate is controlled by ``--knob-tls-cert-refresh-delay-seconds``. Setting it to 0 will disable the refresh.
 
 The default LibreSSL-based implementation
 =========================================

documentation/sphinx/source/transaction-tagging.rst

@@ -13,14 +13,14 @@ Adding tags to transactions
 
 Tags are added to transaction by using transaction options. Each transaction can include up to five tags, and each tag must not exceed 16 characters. There are two options that can be used to add tags:
 
-* ``TAG`` - Adds a tag to the transaction. This tag will not be used for auto-throttling and is not included with read requests. Tags set in this way can only be throttled manually.
-* ``AUTO_THROTTLE_TAG`` - Adds a tag to the transaction that can be both automatically and manually throttled. To support busy tag detection, these tags may be sent as part of read requests.
+* ``TAG`` - Adds a tag to the transaction. This tag will not be used for auto-throttling and is not included with read or commit requests. Tags set in this way can only be throttled manually.
+* ``AUTO_THROTTLE_TAG`` - Adds a tag to the transaction that can be both automatically and manually throttled. To support busy tag detection, these tags may be sent as part of read or commit requests.
 
 See the documentation for your particular language binding for details about setting this option.
 
 .. note:: If setting hierarchical tags, it is recommended that you not use auto-throttle tags at multiple levels of the hierarchy. Otherwise, the cluster will favor throttling those tags set at higher levels, as they will include more transactions.
 
-.. note:: Tags must be included as part of all get read version requests, and a sample of read requests will include auto-throttled tags. Additionally, each tag imposes additional costs with those requests. It is therefore recommended that you not use excessive numbers or lengths of transaction tags.
+.. note:: Tags must be included as part of all get read version requests, and a sample of read and commit requests will include auto-throttled tags. Additionally, each tag imposes additional costs with those requests. It is therefore recommended that you not use excessive numbers or lengths of transaction tags.
 
 Tag throttling overview
 =======================
@@ -48,7 +48,7 @@ When a transaction tag is throttled, this information will be communicated to th
 Automatic transaction tag throttling
 ====================================
 
-When using the ``AUTO_THROTTLE_TAG`` transaction option, the cluster will monitor read activity for the chosen tags and may choose to reduce a tag's transaction rate limit if a storage server gets busy enough and has a sufficient portion of its read traffic coming from that one tag. 
+When using the ``AUTO_THROTTLE_TAG`` transaction option, the cluster will monitor activity for the chosen tags and may choose to reduce a tag's transaction rate limit if a storage server gets busy enough and has a sufficient portion of its traffic coming from that one tag.
 
 When a tag is auto-throttled, the default priority transaction rate will be decreased to reduce the percentage of traffic attributable to that tag to a reasonable amount of total traffic on the affected storage server(s), and batch priority transactions for that tag will be stopped completely. 
 

documentation/sphinx/source/tss.rst

@@ -31,7 +31,7 @@ Because TSS recruitment only pairs *new* storage processes, you must add process
 Example commands
 ----------------
 
-Set the desired TSS processes count to 4, using the redwood storage engine: ``configure tss ssd-redwood-experimental count=4``.
+Set the desired TSS processes count to 4, using the redwood storage engine: ``configure tss ssd-redwood-1-experimental count=4``.
 
 Change the desired TSS process count to 2: ``configure tss count=2``.
 

fdbbackup/FileConverter.actor.cpp

@@ -49,10 +49,10 @@ void printConvertUsage() {
 	          << "  --loggroup LOG_GROUP\n"
 	          << "                  Sets the LogGroup field with the specified value for all\n"
 	          << "                  events in the trace output (defaults to `default').\n"
-	          << "  --trace_format FORMAT\n"
+	          << "  --trace-format FORMAT\n"
 	          << "                  Select the format of the trace files. xml (the default) and json are supported.\n"
 	          << "                  Has no effect unless --log is specified.\n"
-	          << "  --build_flags   Print build information and exit.\n"
+	          << "  --build-flags   Print build information and exit.\n"
 	          << "  -h, --help      Display this help and exit.\n"
 	          << "\n";
 
@@ -571,7 +571,8 @@ int parseCommandLine(ConvertParams* param, CSimpleOpt* args) {
 
 int main(int argc, char** argv) {
 	try {
-		CSimpleOpt* args = new CSimpleOpt(argc, argv, file_converter::gConverterOptions, SO_O_EXACT);
+		CSimpleOpt* args =
+		    new CSimpleOpt(argc, argv, file_converter::gConverterOptions, SO_O_EXACT | SO_O_HYPHEN_TO_UNDERSCORE);
 		file_converter::ConvertParams param;
 		int status = file_converter::parseCommandLine(&param, args);
 		std::cout << "Params: " << param.toString() << "\n";

fdbbackup/FileConverter.h

@@ -58,20 +58,20 @@ CSimpleOpt::SOption gConverterOptions[] = { { OPT_CONTAINER, "-r", SO_REQ_SEP },
 	                                        { OPT_END_VERSION, "--end", SO_REQ_SEP },
 	                                        { OPT_TRACE, "--log", SO_NONE },
 	                                        { OPT_TRACE_DIR, "--logdir", SO_REQ_SEP },
-	                                        { OPT_TRACE_FORMAT, "--trace_format", SO_REQ_SEP },
+	                                        { OPT_TRACE_FORMAT, "--trace-format", SO_REQ_SEP },
 	                                        { OPT_TRACE_LOG_GROUP, "--loggroup", SO_REQ_SEP },
 	                                        { OPT_INPUT_FILE, "-i", SO_REQ_SEP },
 	                                        { OPT_INPUT_FILE, "--input", SO_REQ_SEP },
-	                                        { OPT_BLOB_CREDENTIALS, "--blob_credentials", SO_REQ_SEP },
+	                                        { OPT_BLOB_CREDENTIALS, "--blob-credentials", SO_REQ_SEP },
 #ifndef TLS_DISABLED
 	                                        TLS_OPTION_FLAGS
 #endif
-	                                        { OPT_BUILD_FLAGS, "--build_flags", SO_NONE },
-	                                        { OPT_LIST_ONLY, "--list_only", SO_NONE },
+	                                        { OPT_BUILD_FLAGS, "--build-flags", SO_NONE },
+	                                        { OPT_LIST_ONLY, "--list-only", SO_NONE },
 	                                        { OPT_KEY_PREFIX, "-k", SO_REQ_SEP },
-	                                        { OPT_HEX_KEY_PREFIX, "--hex_prefix", SO_REQ_SEP },
-	                                        { OPT_BEGIN_VERSION_FILTER, "--begin_version_filter", SO_REQ_SEP },
-	                                        { OPT_END_VERSION_FILTER, "--end_version_filter", SO_REQ_SEP },
+	                                        { OPT_HEX_KEY_PREFIX, "--hex-prefix", SO_REQ_SEP },
+	                                        { OPT_BEGIN_VERSION_FILTER, "--begin-version-filter", SO_REQ_SEP },
+	                                        { OPT_END_VERSION_FILTER, "--end-version-filter", SO_REQ_SEP },
 	                                        { OPT_HELP, "-?", SO_NONE },
 	                                        { OPT_HELP, "-h", SO_NONE },
 	                                        { OPT_HELP, "--help", SO_NONE },

fdbbackup/FileDecoder.actor.cpp

@@ -59,24 +59,24 @@ void printDecodeUsage() {
 	             "  --loggroup     LOG_GROUP\n"
 	             "                 Sets the LogGroup field with the specified value for all\n"
 	             "                 events in the trace output (defaults to `default').\n"
-	             "  --trace_format FORMAT\n"
+	             "  --trace-format FORMAT\n"
 	             "                 Select the format of the trace files, xml (the default) or json.\n"
 	             "                 Has no effect unless --log is specified.\n"
 	             "  --crash        Crash on serious error.\n"
-	             "  --blob_credentials FILE\n"
+	             "  --blob-credentials FILE\n"
 	             "                 File containing blob credentials in JSON format.\n"
 	             "                 The same credential format/file fdbbackup uses.\n"
 #ifndef TLS_DISABLED
 	    TLS_HELP
 #endif
-	             "  --build_flags  Print build information and exit.\n"
-	             "  --list_only    Print file list and exit.\n"
+	             "  --build-flags  Print build information and exit.\n"
+	             "  --list-only    Print file list and exit.\n"
 	             "  -k KEY_PREFIX  Use the prefix for filtering mutations\n"
-	             "  --hex_prefix   HEX_PREFIX\n"
+	             "  --hex-prefix   HEX_PREFIX\n"
 	             "                 The prefix specified in HEX format, e.g., \\x05\\x01.\n"
-	             "  --begin_version_filter BEGIN_VERSION\n"
+	             "  --begin-version-filter BEGIN_VERSION\n"
 	             "                 The version range's begin version (inclusive) for filtering.\n"
-	             "  --end_version_filter END_VERSION\n"
+	             "  --end-version-filter END_VERSION\n"
 	             "                 The version range's end version (exclusive) for filtering.\n"
 	             "\n";
 	return;
@@ -514,7 +514,8 @@ ACTOR Future<Void> decode_logs(DecodeParams params) {
 
 int main(int argc, char** argv) {
 	try {
-		CSimpleOpt* args = new CSimpleOpt(argc, argv, file_converter::gConverterOptions, SO_O_EXACT);
+		CSimpleOpt* args =
+		    new CSimpleOpt(argc, argv, file_converter::gConverterOptions, SO_O_EXACT | SO_O_HYPHEN_TO_UNDERSCORE);
 		file_converter::DecodeParams param;
 		int status = file_converter::parseDecodeCommandLine(&param, args);
 		std::cout << "Params: " << param.toString() << "\n";

fdbcli/ChangeFeedCommand.actor.cpp

@@ -18,6 +18,8 @@
  * limitations under the License.
  */
 
+#include "contrib/fmt-8.0.1/include/fmt/format.h"
+
 #include "fdbcli/fdbcli.actor.h"
 
 #include "fdbclient/FDBOptions.g.h"
@@ -62,6 +64,17 @@ ACTOR Future<Void> changeFeedList(Database db) {
 
 namespace fdb_cli {
 
+ACTOR Future<Void> requestVersionUpdate(Database localDb, Reference<ChangeFeedData> feedData) {
+	loop {
+		wait(delay(5.0));
+		Transaction tr(localDb);
+		state Version ver = wait(tr.getReadVersion());
+		fmt::print("Requesting version {}\n", ver);
+		wait(feedData->whenAtLeast(ver));
+		fmt::print("Feed at version {}\n", ver);
+	}
+}
+
 ACTOR Future<bool> changeFeedCommandActor(Database localDb, std::vector<StringRef> tokens, Future<Void> warn) {
 	if (tokens.size() == 1) {
 		printUsage(tokens[0]);
@@ -109,7 +122,7 @@ ACTOR Future<bool> changeFeedCommandActor(Database localDb, std::vector<StringRe
 		}
 		if (tokens.size() > 4) {
 			int n = 0;
-			if (sscanf(tokens[4].toString().c_str(), "%ld%n", &end, &n) != 1 || n != tokens[4].size()) {
+			if (sscanf(tokens[4].toString().c_str(), "%" PRId64 "%n", &end, &n) != 1 || n != tokens[4].size()) {
 				printUsage(tokens[0]);
 				return false;
 			}
@@ -117,24 +130,26 @@ ACTOR Future<bool> changeFeedCommandActor(Database localDb, std::vector<StringRe
 		if (warn.isValid()) {
 			warn.cancel();
 		}
-		state PromiseStream<Standalone<VectorRef<MutationsAndVersionRef>>> feedResults;
-		state Future<Void> feed = localDb->getChangeFeedStream(feedResults, tokens[2], begin, end);
+		state Reference<ChangeFeedData> feedData = makeReference<ChangeFeedData>();
+		state Future<Void> feed = localDb->getChangeFeedStream(feedData, tokens[2], begin, end);
+		state Future<Void> versionUpdates = requestVersionUpdate(localDb, feedData);
 		printf("\n");
 		try {
 			state Future<Void> feedInterrupt = LineNoise::onKeyboardInterrupt();
 			loop {
 				choose {
-					when(Standalone<VectorRef<MutationsAndVersionRef>> res = waitNext(feedResults.getFuture())) {
+					when(Standalone<VectorRef<MutationsAndVersionRef>> res =
+					         waitNext(feedData->mutations.getFuture())) {
 						for (auto& it : res) {
 							for (auto& it2 : it.mutations) {
-								printf("%lld %s\n", it.version, it2.toString().c_str());
+								fmt::print("{0} {1}\n", it.version, it2.toString());
 							}
 						}
 					}
 					when(wait(feedInterrupt)) {
 						feedInterrupt = Future<Void>();
 						feed.cancel();
-						feedResults = PromiseStream<Standalone<VectorRef<MutationsAndVersionRef>>>();
+						feedData = makeReference<ChangeFeedData>();
 						break;
 					}
 				}

fdbcli/ExcludeCommand.actor.cpp

@@ -33,7 +33,7 @@
 
 namespace {
 
-// Exclue the given servers and localities
+// Exclude the given servers and localities
 ACTOR Future<bool> excludeServersAndLocalities(Reference<IDatabase> db,
                                                std::vector<AddressExclusion> servers,
                                                std::unordered_set<std::string> localities,

fdbcli/MaintenanceCommand.actor.cpp

@@ -21,6 +21,7 @@
 #include <cinttypes>
 
 #include "boost/lexical_cast.hpp"
+#include "contrib/fmt-8.0.1/include/fmt/format.h"
 
 #include "fdbcli/fdbcli.actor.h"
 
@@ -55,7 +56,7 @@ ACTOR Future<Void> printHealthyZone(Reference<IDatabase> db) {
 			} else {
 				std::string zoneId = res[0].key.removePrefix(fdb_cli::maintenanceSpecialKeyRange.begin).toString();
 				int64_t seconds = static_cast<int64_t>(boost::lexical_cast<double>(res[0].value.toString()));
-				printf("Maintenance for zone %s will continue for %" PRId64 " seconds.\n", zoneId.c_str(), seconds);
+				fmt::print("Maintenance for zone {0} will continue for {1} seconds.\n", zoneId, seconds);
 			}
 			return Void();
 		} catch (Error& e) {

fdbcli/SetClassCommand.actor.cpp

@@ -18,6 +18,8 @@
  * limitations under the License.
  */
 
+#include "contrib/fmt-8.0.1/include/fmt/format.h"
+
 #include "fdbcli/fdbcli.actor.h"
 
 #include "fdbclient/FDBOptions.g.h"
@@ -48,7 +50,7 @@ ACTOR Future<Void> printProcessClass(Reference<IDatabase> db) {
 			ASSERT(processSourceList.size() == processTypeList.size());
 			if (!processTypeList.size())
 				printf("No processes are registered in the database.\n");
-			printf("There are currently %zu processes in the database:\n", processTypeList.size());
+			fmt::print("There are currently {} processes in the database:\n", processTypeList.size());
 			for (int index = 0; index < processTypeList.size(); index++) {
 				std::string address =
 				    processTypeList[index].key.removePrefix(fdb_cli::processClassTypeSpecialKeyRange.begin).toString();

fdbcli/fdbcli.actor.cpp

@@ -19,6 +19,7 @@
  */
 
 #include "boost/lexical_cast.hpp"
+#include "contrib/fmt-8.0.1/include/fmt/format.h"
 #include "fdbclient/ClusterConnectionFile.h"
 #include "fdbclient/NativeAPI.actor.h"
 #include "fdbclient/FDBTypes.h"
@@ -41,6 +42,7 @@
 #include "fdbclient/Tuple.h"
 
 #include "fdbclient/ThreadSafeTransaction.h"
+#include "flow/ArgParseUtil.h"
 #include "flow/DeterministicRandom.h"
 #include "flow/FastRef.h"
 #include "flow/Platform.h"
@@ -97,7 +99,7 @@ enum {
 };
 
 CSimpleOpt::SOption g_rgOptions[] = { { OPT_CONNFILE, "-C", SO_REQ_SEP },
-	                                  { OPT_CONNFILE, "--cluster_file", SO_REQ_SEP },
+	                                  { OPT_CONNFILE, "--cluster-file", SO_REQ_SEP },
 	                                  { OPT_DATABASE, "-d", SO_REQ_SEP },
 	                                  { OPT_TRACE, "--log", SO_NONE },
 	                                  { OPT_TRACE_DIR, "--log-dir", SO_REQ_SEP },
@@ -111,9 +113,9 @@ CSimpleOpt::SOption g_rgOptions[] = { { OPT_CONNFILE, "-C", SO_REQ_SEP },
 	                                  { OPT_STATUS_FROM_JSON, "--status-from-json", SO_REQ_SEP },
 	                                  { OPT_VERSION, "--version", SO_NONE },
 	                                  { OPT_VERSION, "-v", SO_NONE },
-	                                  { OPT_BUILD_FLAGS, "--build_flags", SO_NONE },
-	                                  { OPT_TRACE_FORMAT, "--trace_format", SO_REQ_SEP },
-	                                  { OPT_KNOB, "--knob_", SO_REQ_SEP },
+	                                  { OPT_BUILD_FLAGS, "--build-flags", SO_NONE },
+	                                  { OPT_TRACE_FORMAT, "--trace-format", SO_REQ_SEP },
+	                                  { OPT_KNOB, "--knob-", SO_REQ_SEP },
 	                                  { OPT_DEBUG_TLS, "--debug-tls", SO_NONE },
 	                                  { OPT_API_VERSION, "--api-version", SO_REQ_SEP },
 
@@ -425,7 +427,7 @@ static void printProgramUsage(const char* name) {
 	       "  --log-dir PATH Specifes the output directory for trace files. If\n"
 	       "                 unspecified, defaults to the current directory. Has\n"
 	       "                 no effect unless --log is specified.\n"
-	       "  --trace_format FORMAT\n"
+	       "  --trace-format FORMAT\n"
 	       "                 Select the format of the log files. xml (the default) and json\n"
 	       "                 are supported. Has no effect unless --log is specified.\n"
 	       "  --exec CMDS    Immediately executes the semicolon separated CLI commands\n"
@@ -437,11 +439,11 @@ static void printProgramUsage(const char* name) {
 #ifndef TLS_DISABLED
 	       TLS_HELP
 #endif
-	       "  --knob_KNOBNAME KNOBVALUE\n"
+	       "  --knob-KNOBNAME KNOBVALUE\n"
 	       "                 Changes a knob option. KNOBNAME should be lowercase.\n"
 	       "  --debug-tls    Prints the TLS configuration and certificate chain, then exits.\n"
 	       "                 Useful in reporting and diagnosing TLS issues.\n"
-	       "  --build_flags  Print build information and exit.\n"
+	       "  --build-flags  Print build information and exit.\n"
 	       "  -v, --version  Print FoundationDB CLI version information and exit.\n"
 	       "  -h, --help     Display this help and exit.\n");
 }
@@ -631,9 +633,9 @@ ACTOR Future<Void> commitTransaction(Reference<ITransaction> tr) {
 	wait(makeInterruptable(safeThreadFutureToFuture(tr->commit())));
 	auto ver = tr->getCommittedVersion();
 	if (ver != invalidVersion)
-		printf("Committed (%" PRId64 ")\n", ver);
+		fmt::print("Committed ({})\n", ver);
 	else
-		printf("Nothing to commit\n");
+		fmt::print("Nothing to commit\n");
 	return Void();
 }
 
@@ -1388,7 +1390,7 @@ struct CLIOptions {
 			commandLine += argv[a];
 		}
 
-		CSimpleOpt args(argc, argv, g_rgOptions);
+		CSimpleOpt args(argc, argv, g_rgOptions, SO_O_HYPHEN_TO_UNDERSCORE);
 
 		while (args.Next()) {
 			int ec = processArg(args);
@@ -1402,7 +1404,9 @@ struct CLIOptions {
 			exit_code = FDB_EXIT_ERROR;
 			return;
 		}
+	}
 
+	void setupKnobs() {
 		auto& g_knobs = IKnobCollection::getMutableGlobalKnobCollection();
 		for (const auto& [knobName, knobValueString] : knobs) {
 			try {
@@ -1515,13 +1519,12 @@ struct CLIOptions {
 			traceFormat = args.OptionArg();
 			break;
 		case OPT_KNOB: {
-			std::string syn = args.OptionSyntax();
-			if (!StringRef(syn).startsWith(LiteralStringRef("--knob_"))) {
-				fprintf(stderr, "ERROR: unable to parse knob option '%s'\n", syn.c_str());
+			Optional<std::string> knobName = extractPrefixedArgument("--knob", args.OptionSyntax());
+			if (!knobName.present()) {
+				fprintf(stderr, "ERROR: unable to parse knob option '%s'\n", args.OptionSyntax());
 				return FDB_EXIT_ERROR;
 			}
-			syn = syn.substr(7);
-			knobs.emplace_back(syn, args.OptionArg());
+			knobs.emplace_back(knobName.get(), args.OptionArg());
 			break;
 		}
 		case OPT_DEBUG_TLS:
@@ -2432,8 +2435,6 @@ int main(int argc, char** argv) {
 
 	registerCrashHandler();
 
-	IKnobCollection::setGlobalKnobCollection(IKnobCollection::Type::CLIENT, Randomize::False, IsSimulated::False);
-
 #ifdef __unixish__
 	struct sigaction act;
 
@@ -2534,6 +2535,10 @@ int main(int argc, char** argv) {
 	try {
 		API->selectApiVersion(opt.api_version);
 		API->setupNetwork();
+		opt.setupKnobs();
+		if (opt.exit_code != -1) {
+			return opt.exit_code;
+		}
 		Future<int> cliFuture = runCli(opt);
 		Future<Void> timeoutFuture = opt.exit_timeout ? timeExit(opt.exit_timeout) : Never();
 		auto f = stopNetworkAfter(success(cliFuture) || timeoutFuture);
@@ -2548,4 +2553,4 @@ int main(int argc, char** argv) {
 		fprintf(stderr, "ERROR: %s (%d)\n", e.what(), e.code());
 		return 1;
 	}
-}
+}

fdbclient/ActorLineageProfiler.h

@@ -96,7 +96,7 @@ struct ConfigError {
 class ProfilerConfigT {
 private: // private types
 	using Lock = std::unique_lock<std::mutex>;
-	friend class crossbow::create_static<ProfilerConfigT>;
+	friend struct crossbow::create_static<ProfilerConfigT>;
 
 private: // members
 	std::shared_ptr<SampleIngestor> ingestor = std::make_shared<NoneIngestor>();

fdbclient/BackupAgentBase.actor.cpp

@@ -1001,20 +1001,20 @@ ACTOR Future<Void> cleanupLogMutations(Database cx, Value destUidValue, bool del
 					printf("\nSuccessfully removed the tag that was %.4f hours behind.\n\n",
 					       (readVer - minVersion) / (3600.0 * CLIENT_KNOBS->CORE_VERSIONSPERSECOND));
 				} else if (removingLogUid.present() && minVersionLogUid != removingLogUid.get()) {
-					printf("\nWARNING: The oldest tag was possibly removed, run again without `--delete_data' to "
+					printf("\nWARNING: The oldest tag was possibly removed, run again without `--delete-data' to "
 					       "check.\n\n");
 				} else {
 					printf("\nWARNING: Did not delete data because the tag is not at least %.4f hours behind. Change "
-					       "`--min_cleanup_seconds' to adjust this threshold.\n\n",
+					       "`--min-cleanup-seconds' to adjust this threshold.\n\n",
 					       CLIENT_KNOBS->MIN_CLEANUP_SECONDS / 3600.0);
 				}
 			} else if (readVer - minVersion >
 			           CLIENT_KNOBS->MIN_CLEANUP_SECONDS * CLIENT_KNOBS->CORE_VERSIONSPERSECOND) {
-				printf("\nPassing `--delete_data' would delete the tag that is %.4f hours behind.\n\n",
+				printf("\nPassing `--delete-data' would delete the tag that is %.4f hours behind.\n\n",
 				       (readVer - minVersion) / (3600.0 * CLIENT_KNOBS->CORE_VERSIONSPERSECOND));
 			} else {
-				printf("\nPassing `--delete_data' would not delete the tag that is %.4f hours behind. Change "
-				       "`--min_cleanup_seconds' to adjust the cleanup threshold.\n\n",
+				printf("\nPassing `--delete-data' would not delete the tag that is %.4f hours behind. Change "
+				       "`--min-cleanup-seconds' to adjust the cleanup threshold.\n\n",
 				       (readVer - minVersion) / (3600.0 * CLIENT_KNOBS->CORE_VERSIONSPERSECOND));
 			}
 

fdbclient/BackupContainer.actor.cpp

@@ -22,6 +22,7 @@
 #include <ostream>
 
 // FIXME: Trim this down
+#include "contrib/fmt-8.0.1/include/fmt/format.h"
 #include "flow/Platform.actor.h"
 #include "fdbclient/AsyncTaskThread.h"
 #include "fdbclient/BackupContainer.h"
@@ -75,13 +76,13 @@ std::string IBackupContainer::ExpireProgress::toString() const {
 
 void BackupFileList::toStream(FILE* fout) const {
 	for (const RangeFile& f : ranges) {
-		fprintf(fout, "range %" PRId64 " %s\n", f.fileSize, f.fileName.c_str());
+		fmt::print(fout, "range {0} {1}\n", f.fileSize, f.fileName);
 	}
 	for (const LogFile& f : logs) {
-		fprintf(fout, "log %" PRId64 " %s\n", f.fileSize, f.fileName.c_str());
+		fmt::print(fout, "log {0} {1}\n", f.fileSize, f.fileName);
 	}
 	for (const KeyspaceSnapshotFile& f : snapshots) {
-		fprintf(fout, "snapshotManifest %" PRId64 " %s\n", f.totalSize, f.fileName.c_str());
+		fmt::print(fout, "snapshotManifest {0} {1}\n", f.totalSize, f.fileName);
 	}
 }
 

fdbclient/BackupContainerFileSystem.actor.cpp

@@ -1757,7 +1757,7 @@ ACTOR Future<Void> testBackupContainer(std::string url, Optional<std::string> en
 		state Version expireVersion = listing.snapshots[i].endVersion;
 
 		// Expire everything up to but not including the snapshot end version
-		printf("EXPIRE TO %" PRId64 "\n", expireVersion);
+		fmt::print("EXPIRE TO {}\n", expireVersion);
 		state Future<Void> f = c->expireData(expireVersion);
 		wait(ready(f));
 

fdbclient/BackupContainerFileSystem.h

@@ -22,6 +22,7 @@
 #define FDBCLIENT_BACKUP_CONTAINER_FILESYSTEM_H
 #pragma once
 
+#include "contrib/fmt-8.0.1/include/fmt/format.h"
 #include "fdbclient/BackupContainer.h"
 #include "fdbclient/FDBTypes.h"
 #include "flow/Trace.h"

fdbclient/BlobGranuleFiles.cpp

@@ -0,0 +1,427 @@
+/*
+ * BlobGranuleFiles.cpp
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2013-2018 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 "contrib/fmt-8.0.1/include/fmt/format.h"
+#include "flow/serialize.h"
+#include "fdbclient/BlobGranuleFiles.h"
+#include "fdbclient/SystemData.h" // for allKeys unit test - could remove
+#include "flow/UnitTest.h"
+
+#define BG_READ_DEBUG false
+
+// FIXME: implement actual proper file format for this
+
+// Implements granule file parsing and materialization with normal c++ functions (non-actors) so that this can be used
+// outside the FDB network thread.
+
+static Arena loadSnapshotFile(const StringRef& snapshotData,
+                              KeyRangeRef keyRange,
+                              std::map<KeyRef, ValueRef>& dataMap) {
+
+	Arena parseArena;
+	GranuleSnapshot snapshot;
+	ObjectReader reader(snapshotData.begin(), Unversioned());
+	reader.deserialize(FileIdentifierFor<GranuleSnapshot>::value, snapshot, parseArena);
+
+	// TODO REMOVE sanity check eventually
+	for (int i = 0; i < snapshot.size() - 1; i++) {
+		if (snapshot[i].key >= snapshot[i + 1].key) {
+			printf("BG SORT ORDER VIOLATION IN SNAPSHOT FILE: '%s', '%s'\n",
+			       snapshot[i].key.printable().c_str(),
+			       snapshot[i + 1].key.printable().c_str());
+		}
+		ASSERT(snapshot[i].key < snapshot[i + 1].key);
+	}
+
+	int i = 0;
+	while (i < snapshot.size() && snapshot[i].key < keyRange.begin) {
+		/*if (snapshot.size() < 10) { // debug
+		    printf("  Pruning %s < %s\n", snapshot[i].key.printable().c_str(), keyRange.begin.printable().c_str());
+		}*/
+		i++;
+	}
+	while (i < snapshot.size() && snapshot[i].key < keyRange.end) {
+		dataMap.insert({ snapshot[i].key, snapshot[i].value });
+		/*if (snapshot.size() < 10) { // debug
+		    printf("  Including %s\n", snapshot[i].key.printable().c_str());
+		}*/
+		i++;
+	}
+	/*if (snapshot.size() < 10) { // debug
+	    while (i < snapshot.size()) {
+	        printf("  Pruning %s >= %s\n", snapshot[i].key.printable().c_str(), keyRange.end.printable().c_str());
+	        i++;
+	    }
+	}*/
+	if (BG_READ_DEBUG) {
+		fmt::print("Started with {0} rows from snapshot after pruning to [{1} - {2})\n",
+		           dataMap.size(),
+		           keyRange.begin.printable(),
+		           keyRange.end.printable());
+	}
+
+	return parseArena;
+}
+
+static void applyDelta(KeyRangeRef keyRange, MutationRef m, std::map<KeyRef, ValueRef>& dataMap) {
+	if (m.type == MutationRef::ClearRange) {
+		if (m.param2 <= keyRange.begin || m.param1 >= keyRange.end) {
+			return;
+		}
+		// keyRange is inclusive on start, lower_bound is inclusive with the argument, and erase is inclusive for the
+		// begin. So if lower bound didn't find the exact key, we need to go up one so it doesn't erase an extra key
+		// outside the range.
+		std::map<KeyRef, ValueRef>::iterator itStart = dataMap.lower_bound(m.param1);
+		if (itStart != dataMap.end() && itStart->first < m.param1) {
+			itStart++;
+		}
+
+		// keyRange is exclusive on end, lower bound is inclusive with the argument, and erase is exclusive for the end
+		// key. So if lower bound didn't find the exact key, we need to go up one so it doesn't skip the last key it
+		// should erase
+		std::map<KeyRef, ValueRef>::iterator itEnd = dataMap.lower_bound(m.param2);
+		if (itEnd != dataMap.end() && itEnd->first < m.param2) {
+			itEnd++;
+		}
+		dataMap.erase(itStart, itEnd);
+	} else {
+		// We don't need atomics here since eager reads handles it
+		ASSERT(m.type == MutationRef::SetValue);
+		if (m.param1 < keyRange.begin || m.param1 >= keyRange.end) {
+			return;
+		}
+
+		std::map<KeyRef, ValueRef>::iterator it = dataMap.find(m.param1);
+		if (it == dataMap.end()) {
+			dataMap.insert({ m.param1, m.param2 });
+		} else {
+			it->second = m.param2;
+		}
+	}
+}
+
+static void applyDeltas(const GranuleDeltas& deltas,
+                        KeyRangeRef keyRange,
+                        Version readVersion,
+                        Version& lastFileEndVersion,
+                        std::map<KeyRef, ValueRef>& dataMap) {
+	if (!deltas.empty()) {
+		// check that consecutive delta file versions are disjoint
+		ASSERT(lastFileEndVersion < deltas.front().version);
+	}
+	for (const MutationsAndVersionRef& delta : deltas) {
+		if (delta.version > readVersion) {
+			lastFileEndVersion = readVersion;
+			return;
+		}
+		for (auto& m : delta.mutations) {
+			applyDelta(keyRange, m, dataMap);
+		}
+	}
+	if (!deltas.empty()) {
+		lastFileEndVersion = deltas.back().version;
+	}
+}
+
+static Arena loadDeltaFile(StringRef deltaData,
+                           KeyRangeRef keyRange,
+                           Version readVersion,
+                           Version& lastFileEndVersion,
+                           std::map<KeyRef, ValueRef>& dataMap) {
+	Arena parseArena;
+	GranuleDeltas deltas;
+	ObjectReader reader(deltaData.begin(), Unversioned());
+	reader.deserialize(FileIdentifierFor<GranuleDeltas>::value, deltas, parseArena);
+
+	if (BG_READ_DEBUG) {
+		fmt::print("Parsed {}} deltas from file\n", deltas.size());
+	}
+
+	// TODO REMOVE sanity check
+	for (int i = 0; i < deltas.size() - 1; i++) {
+		if (deltas[i].version > deltas[i + 1].version) {
+			fmt::print(
+			    "BG VERSION ORDER VIOLATION IN DELTA FILE: '{0}', '{1}'\n", deltas[i].version, deltas[i + 1].version);
+		}
+		ASSERT(deltas[i].version <= deltas[i + 1].version);
+	}
+
+	applyDeltas(deltas, keyRange, readVersion, lastFileEndVersion, dataMap);
+	return parseArena;
+}
+
+RangeResult materializeBlobGranule(const BlobGranuleChunkRef& chunk,
+                                   KeyRangeRef keyRange,
+                                   Version readVersion,
+                                   Optional<StringRef> snapshotData,
+                                   StringRef deltaFileData[]) {
+	// TODO REMOVE with V2 of protocol
+	ASSERT(readVersion == chunk.includedVersion);
+	ASSERT(chunk.snapshotFile.present());
+	ASSERT(snapshotData.present());
+
+	// Arena to hold all allocations for applying deltas. Most of it, and the arenas produced by reading the files,
+	// will likely be tossed if there are a significant number of mutations, so we copy at the end instead of doing a
+	// dependsOn.
+	// FIXME: probably some threshold of a small percentage of the data is actually changed, where it makes sense to
+	// just to dependsOn instead of copy, to use a little extra memory footprint to help cpu?
+	Arena arena;
+	std::map<KeyRef, ValueRef> dataMap;
+	Version lastFileEndVersion = invalidVersion;
+
+	if (snapshotData.present()) {
+		Arena snapshotArena = loadSnapshotFile(snapshotData.get(), keyRange, dataMap);
+		arena.dependsOn(snapshotArena);
+	}
+
+	if (BG_READ_DEBUG) {
+		fmt::print("Applying {} delta files\n", chunk.deltaFiles.size());
+	}
+	for (int deltaIdx = 0; deltaIdx < chunk.deltaFiles.size(); deltaIdx++) {
+		Arena deltaArena = loadDeltaFile(deltaFileData[deltaIdx], keyRange, readVersion, lastFileEndVersion, dataMap);
+		arena.dependsOn(deltaArena);
+	}
+	if (BG_READ_DEBUG) {
+		fmt::print("Applying {} memory deltas\n", chunk.newDeltas.size());
+	}
+	applyDeltas(chunk.newDeltas, keyRange, readVersion, lastFileEndVersion, dataMap);
+
+	RangeResult ret;
+	for (auto& it : dataMap) {
+		ret.push_back_deep(ret.arena(), KeyValueRef(it.first, it.second));
+	}
+
+	return ret;
+}
+
+ErrorOr<RangeResult> loadAndMaterializeBlobGranules(const Standalone<VectorRef<BlobGranuleChunkRef>>& files,
+                                                    const KeyRangeRef& keyRange,
+                                                    Version beginVersion,
+                                                    Version readVersion,
+                                                    ReadBlobGranuleContext granuleContext) {
+	try {
+		RangeResult results;
+		// FIXME: could submit multiple chunks to start_load_f in parallel?
+		for (const BlobGranuleChunkRef& chunk : files) {
+			RangeResult chunkRows;
+
+			int64_t snapshotLoadId;
+			int64_t deltaLoadIds[chunk.deltaFiles.size()];
+
+			// Start load process for all files in chunk
+			// In V1 of api snapshot is required, optional is just for forward compatibility
+			ASSERT(chunk.snapshotFile.present());
+			std::string snapshotFname = chunk.snapshotFile.get().filename.toString();
+			snapshotLoadId = granuleContext.start_load_f(snapshotFname.c_str(),
+			                                             snapshotFname.size(),
+			                                             chunk.snapshotFile.get().offset,
+			                                             chunk.snapshotFile.get().length,
+			                                             granuleContext.userContext);
+			int64_t deltaLoadLengths[chunk.deltaFiles.size()];
+			StringRef deltaData[chunk.deltaFiles.size()];
+			for (int deltaFileIdx = 0; deltaFileIdx < chunk.deltaFiles.size(); deltaFileIdx++) {
+				std::string deltaFName = chunk.deltaFiles[deltaFileIdx].filename.toString();
+				deltaLoadIds[deltaFileIdx] = granuleContext.start_load_f(deltaFName.c_str(),
+				                                                         deltaFName.size(),
+				                                                         chunk.deltaFiles[deltaFileIdx].offset,
+				                                                         chunk.deltaFiles[deltaFileIdx].length,
+				                                                         granuleContext.userContext);
+				deltaLoadLengths[deltaFileIdx] = chunk.deltaFiles[deltaFileIdx].length;
+			}
+
+			// once all loads kicked off, load data for chunk
+			StringRef snapshotData(granuleContext.get_load_f(snapshotLoadId, granuleContext.userContext),
+			                       chunk.snapshotFile.get().length);
+			if (!snapshotData.begin()) {
+				return ErrorOr<RangeResult>(blob_granule_file_load_error());
+			}
+			for (int i = 0; i < chunk.deltaFiles.size(); i++) {
+				deltaData[i] = StringRef(granuleContext.get_load_f(deltaLoadIds[i], granuleContext.userContext),
+				                         chunk.deltaFiles[i].length);
+				// null data is error
+				if (!deltaData[i].begin()) {
+					return ErrorOr<RangeResult>(blob_granule_file_load_error());
+				}
+			}
+
+			// materialize rows from chunk
+			chunkRows = materializeBlobGranule(chunk, keyRange, readVersion, snapshotData, deltaData);
+
+			results.arena().dependsOn(chunkRows.arena());
+			results.append(results.arena(), chunkRows.begin(), chunkRows.size());
+
+			granuleContext.free_load_f(snapshotLoadId, granuleContext.userContext);
+			for (int i = 0; i < chunk.deltaFiles.size(); i++) {
+				granuleContext.free_load_f(deltaLoadIds[i], granuleContext.userContext);
+			}
+		}
+		return ErrorOr<RangeResult>(results);
+	} catch (Error& e) {
+		return ErrorOr<RangeResult>(e);
+	}
+}
+
+// FIXME: re-enable test!
+TEST_CASE(":/blobgranule/files/applyDelta") {
+	printf("Testing blob granule delta applying\n");
+	Arena a;
+
+	// do this 2 phase arena creation of string refs instead of LiteralStringRef because there is no char* StringRef
+	// constructor, and valgrind might complain if the stringref data isn't in the arena
+	std::string sk_a = "A";
+	std::string sk_ab = "AB";
+	std::string sk_b = "B";
+	std::string sk_c = "C";
+	std::string sk_z = "Z";
+	std::string sval1 = "1";
+	std::string sval2 = "2";
+
+	StringRef k_a = StringRef(a, sk_a);
+	StringRef k_ab = StringRef(a, sk_ab);
+	StringRef k_b = StringRef(a, sk_b);
+	StringRef k_c = StringRef(a, sk_c);
+	StringRef k_z = StringRef(a, sk_z);
+	StringRef val1 = StringRef(a, sval1);
+	StringRef val2 = StringRef(a, sval2);
+
+	std::map<KeyRef, ValueRef> data;
+	data.insert({ k_a, val1 });
+	data.insert({ k_ab, val1 });
+	data.insert({ k_b, val1 });
+
+	std::map<KeyRef, ValueRef> correctData = data;
+	std::map<KeyRef, ValueRef> originalData = data;
+
+	ASSERT(data == correctData);
+
+	// test all clear permutations
+
+	MutationRef mClearEverything(MutationRef::ClearRange, allKeys.begin, allKeys.end);
+	data = originalData;
+	correctData = originalData;
+	applyDelta(allKeys, mClearEverything, data);
+	correctData.clear();
+	ASSERT(data == correctData);
+
+	MutationRef mClearEverything2(MutationRef::ClearRange, allKeys.begin, k_c);
+	data = originalData;
+	correctData = originalData;
+	applyDelta(allKeys, mClearEverything2, data);
+	correctData.clear();
+	ASSERT(data == correctData);
+
+	MutationRef mClearEverything3(MutationRef::ClearRange, k_a, allKeys.end);
+	data = originalData;
+	correctData = originalData;
+	applyDelta(allKeys, mClearEverything3, data);
+	correctData.clear();
+	ASSERT(data == correctData);
+
+	MutationRef mClearEverything4(MutationRef::ClearRange, k_a, k_c);
+	data = originalData;
+	correctData = originalData;
+	applyDelta(allKeys, mClearEverything, data);
+	correctData.clear();
+	ASSERT(data == correctData);
+
+	MutationRef mClearFirst(MutationRef::ClearRange, k_a, k_ab);
+	data = originalData;
+	correctData = originalData;
+	applyDelta(allKeys, mClearFirst, data);
+	correctData.erase(k_a);
+	ASSERT(data == correctData);
+
+	MutationRef mClearSecond(MutationRef::ClearRange, k_ab, k_b);
+	data = originalData;
+	correctData = originalData;
+	applyDelta(allKeys, mClearSecond, data);
+	correctData.erase(k_ab);
+	ASSERT(data == correctData);
+
+	MutationRef mClearThird(MutationRef::ClearRange, k_b, k_c);
+	data = originalData;
+	correctData = originalData;
+	applyDelta(allKeys, mClearThird, data);
+	correctData.erase(k_b);
+	ASSERT(data == correctData);
+
+	MutationRef mClearFirst2(MutationRef::ClearRange, k_a, k_b);
+	data = originalData;
+	correctData = originalData;
+	applyDelta(allKeys, mClearFirst2, data);
+	correctData.erase(k_a);
+	correctData.erase(k_ab);
+	ASSERT(data == correctData);
+
+	MutationRef mClearLast2(MutationRef::ClearRange, k_ab, k_c);
+	data = originalData;
+	correctData = originalData;
+	applyDelta(allKeys, mClearLast2, data);
+	correctData.erase(k_ab);
+	correctData.erase(k_b);
+	ASSERT(data == correctData);
+
+	// test set data
+	MutationRef mSetA(MutationRef::SetValue, k_a, val2);
+	data = originalData;
+	correctData = originalData;
+	applyDelta(allKeys, mSetA, data);
+	correctData[k_a] = val2;
+	ASSERT(data == correctData);
+
+	MutationRef mSetAB(MutationRef::SetValue, k_ab, val2);
+	data = originalData;
+	correctData = originalData;
+	applyDelta(allKeys, mSetAB, data);
+	correctData[k_ab] = val2;
+	ASSERT(data == correctData);
+
+	MutationRef mSetB(MutationRef::SetValue, k_b, val2);
+	data = originalData;
+	correctData = originalData;
+	applyDelta(allKeys, mSetB, data);
+	correctData[k_b] = val2;
+	ASSERT(data == correctData);
+
+	MutationRef mSetC(MutationRef::SetValue, k_c, val2);
+	data = originalData;
+	correctData = originalData;
+	applyDelta(allKeys, mSetC, data);
+	correctData[k_c] = val2;
+	ASSERT(data == correctData);
+
+	// test pruning deltas that are outside of the key range
+
+	MutationRef mSetZ(MutationRef::SetValue, k_z, val2);
+	data = originalData;
+	applyDelta(KeyRangeRef(k_a, k_c), mSetZ, data);
+	ASSERT(data == originalData);
+
+	applyDelta(KeyRangeRef(k_ab, k_c), mSetA, data);
+	ASSERT(data == originalData);
+
+	applyDelta(KeyRangeRef(k_ab, k_c), mClearFirst, data);
+	ASSERT(data == originalData);
+
+	applyDelta(KeyRangeRef(k_a, k_ab), mClearThird, data);
+	ASSERT(data == originalData);
+
+	return Void();
+}

fdbclient/BlobGranuleFiles.h

@@ -0,0 +1,40 @@
+/*
+ * BlobGranuleFiles.h
+ *
+ * This source file is part of the FoundationDB open source project
+ *
+ * Copyright 2013-2021 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 FDBCLIENT_BLOBGRANULEFILES_H
+#define FDBCLIENT_BLOBGRANULEFILES_H
+
+// This file contains functions for readers who want to materialize blob granules from the underlying files
+
+#include "fdbclient/BlobGranuleCommon.h"
+
+ErrorOr<RangeResult> loadAndMaterializeBlobGranules(const Standalone<VectorRef<BlobGranuleChunkRef>>& files,
+                                                    const KeyRangeRef& keyRange,
+                                                    Version beginVersion,
+                                                    Version readVersion,
+                                                    ReadBlobGranuleContext granuleContext);
+
+RangeResult materializeBlobGranule(const BlobGranuleChunkRef& chunk,
+                                   KeyRangeRef keyRange,
+                                   Version readVersion,
+                                   Optional<StringRef> snapshotData,
+                                   StringRef deltaFileData[]);
+
+#endif