Report degraded multi region status

.clang-tidy

@@ -1,6 +1,7 @@
 ---
 Checks: >
   -*,
+  bugprone-assignment-in-if-condition,
   bugprone-dangling-handle,
   bugprone-implicit-widening-of-multiplication-result,
   bugprone-inaccurate-erase,
@@ -13,6 +14,7 @@ Checks: >
   bugprone-sizeof-expression,
   bugprone-string-constructor,
   bugprone-string-integer-assignment,
+  bugprone-string-literal-with-embedded-nul,
   bugprone-stringview-nullptr,
   bugprone-suspicious-memory-comparison,
   bugprone-suspicious-memset-usage,
@@ -32,6 +34,7 @@ Checks: >
   modernize-use-using,
   performance-for-range-copy,
   performance-implicit-conversion-in-loop,
+  performance-inefficient-vector-operation,
   performance-move-const-arg,
   performance-move-constructor-init,
   readability-braces-around-statements,

.github/workflows/tidy.yml

@@ -48,12 +48,6 @@ jobs:
             fdb_c_generated             \
             fdb-java
 
-          # all flow actors, for generated headers
-          ACTORS=$(
-            ninja -t targets all | grep -v /build_output/ | grep '_actors:' | cut -d: -f1
-          )
-          ninja -v $ACTORS
-
           # all protobuf headers
           PB_HEADERS=$(
             ninja -t targets all | grep -v /build_output/ | grep '\.pb\.h:' | cut -d: -f1
@@ -73,9 +67,6 @@ jobs:
             if [[ $FILE == contrib/* ]]; then
               continue  # skip contrib sources
             fi
-            if [[ $FILE == *.actor.* ]]; then
-              continue  # actor syntax is not plain c++
-            fi
             if [[ $FILE == flow/include/flow/CoroutinesImpl.h ]]; then
               continue  # internal implementation header, included only from Coroutines.h
             fi

.gitignore

@@ -87,7 +87,6 @@ foundationdb.VC.db
 foundationdb.VC.VC.opendb
 ipch/
 compile_commands.json
-flow/actorcompiler/obj
 flow/coveragetool/obj
 *.code-workspace
 

AGENTS.md

@@ -62,28 +62,25 @@ Enable simulation tests in cmake: `-DENABLE_SIMULATION_TESTS=ON`
 
 FoundationDB is a distributed ordered key-value store with strict serializability. The codebase is organized into ~12 subsystems. For background on subsystems before diving into code, the `design/` directory holds human-authored design docs and `design/AI-generated/` holds subsystem maps and per-subsystem diagrams (start with `design/AI-generated/foundationdb_subsystem_map.md`).
 
-### Concurrency Model: Flow Actors and C++ Coroutines
+### Concurrency Model: C++ Coroutines
 
-FDB uses cooperative single-threaded concurrency. Code is written using either:
-
-- **Flow actors** (`.actor.cpp` / `.actor.h` files): A custom preprocessor (`actorcompiler`) translates `ACTOR`, `state`, `wait()`, `choose/when` syntax into generated C++ state machines. The `#include "flow/actorcompiler.h"` must be the **last** include in actor files.
-- **C++ coroutines**: Newer code uses `co_await` and `co_return` instead of `wait()` and actor-style `return`. Coroutines can appear in regular `.cpp` files and in `.actor.cpp` files that still contain actorcompiler input; actors and coroutines can be mixed. New code should use coroutines; see `design/coroutines.md`.
+FDB uses cooperative single-threaded concurrency. Asynchronous functions use
+standard C++ coroutines with `co_await` and `co_return` in ordinary `.cpp` and
+`.h` files. See `design/coroutines.md` for coroutine and cancellation semantics.
 
 Key types: `Future<T>`, `Promise<T>`, `PromiseStream<T>`, `Reference<T>` (ref-counted pointer), `Optional<T>`, `ErrorOr<T>`, `Arena` (region-based allocation).
 
 #### Common pitfalls
 
-- `wait()` / `waitNext()` cannot appear inside ternary expressions, function arguments, or other sub-expressions. Assign to a `state` variable first, or use a small gating actor.
 - C++ coroutines: `co_await` is not allowed inside a `catch` handler. Capture the error, exit the catch, then `co_await` outside.
-- `ACTOR` functions declared in headers must not be defined inside an anonymous namespace, or call sites get ambiguous-overload errors.
 - Errors are integer codes (`flow/include/flow/error_definitions.h`), not exceptions with messages. When you `catch (Error& e)`, re-throw `actor_cancelled` (and never silently swallow `broken_promise`) — eating cancellation causes hangs and leaks. Transaction retry goes through `tr.onError(e)`, not a bare loop.
 - `StringRef`/`KeyRef`/`ValueRef` are non-owning views into an `Arena`. Returning or storing one past its arena's lifetime is a dangling-reference bug; use `Standalone<>` (or `Key`/`Value`) when you need to own the bytes.
 
 ### Core Subsystems
 
 - **`flow/`** — Async runtime, event loop, tracing, deterministic random, arenas
 - **`fdbrpc/`** — Endpoint-addressed RPC, peer management, failure monitor, Sim2 (deterministic simulation network)
-- **`fdbclient/`** — Transaction API (`NativeAPI.actor.cpp`), read-your-writes (`ReadYourWrites.actor.cpp`), location cache, multi-version client
+- **`fdbclient/`** — Transaction API (`NativeAPI.cpp`), read-your-writes (`ReadYourWrites.cpp`), location cache, multi-version client
 - **`fdbserver/`** — All server roles, organized by subdirectory:
   - `clustercontroller/` — Leader election, role recruitment, ServerDBInfo broadcasting
   - `coordinator/` — Paxos-based coordination state (generation registers)
@@ -134,11 +131,11 @@ Before changing a serialized type that persists on disk, inspect its `serializer
 
 `clang-format` is used. Python code uses `black` and `flake8` (pre-commit hooks: `pip install pre-commit && pre-commit install`).
 
-Edit `.actor.cpp` and `.actor.h` sources, not actorcompiler-generated output under the build directory.
+Edit tracked `.cpp` and `.h` sources, not generated output under the build directory.
 
 ## Source File Headers
 
-Every new `.cpp` / `.h` / `.actor.cpp` / `.actor.h` file starts with the standard Apache 2.0 license block, with the filename on line 2 and the current year on the copyright line. Copy from any existing file in the tree (e.g. `flow/Knobs.cpp`). Add file-purpose comments *after* the license block, not in place of it.
+Every new `.cpp` / `.h` file starts with the standard Apache 2.0 license block, with the filename on line 2 and the current year on the copyright line. Copy from any existing file in the tree (e.g. `flow/Knobs.cpp`). Add file-purpose comments *after* the license block, not in place of it.
 
 ## Code Comments
 

CMakeLists.txt

@@ -179,10 +179,9 @@ endif()
 
 include(utils)
 
-# First thing we need is the actor compiler
 option(
   WITH_CSHARP
-  "Prefer C# build tools (actor compiler, coverage tool, vexillographer) when a toolchain is available"
+  "Prefer C# build tools (coverage tool, vexillographer) when a toolchain is available"
   ON)
 
 set(FDB_USE_CSHARP_TOOLS_EXPLICIT FALSE)
@@ -227,8 +226,6 @@ if(FDB_USE_CSHARP_TOOLS_EXPLICIT AND FDB_USE_CSHARP_TOOLS
     "FDB_USE_CSHARP_TOOLS is enabled, but CSHARP_TOOLCHAIN_FOUND is FALSE. Install .NET (dotnet) or Mono, or set WITH_CSHARP=OFF.")
 endif()
 
-include(CompileActorCompiler)
-
 if(FDB_USE_CSHARP_TOOLS AND CSHARP_TOOLCHAIN_FOUND)
   include(CompileCoverageTool)
   set(COVERAGETOOL_AVAILABLE TRUE)
@@ -238,7 +235,6 @@ endif()
 # Vexilographer generation is configured inside fdbclient
 include(CompileVexillographer)
 
-# with the actor compiler, we can now make the flow commands available
 include(FlowCommands)
 
 ###############################################################################
@@ -346,7 +342,7 @@ if(CMAKE_EXPORT_COMPILE_COMMANDS AND WITH_PYTHON)
     COMMAND
       $<TARGET_FILE:Python3::Interpreter>
       ${CMAKE_CURRENT_SOURCE_DIR}/contrib/gen_compile_db.py ARGS -b
-      ${CMAKE_CURRENT_BINARY_DIR} -s ${CMAKE_CURRENT_SOURCE_DIR} -o
+      ${CMAKE_CURRENT_BINARY_DIR} -o
       ${CMAKE_CURRENT_SOURCE_DIR}/compile_commands.json -ninjatool
       ${CMAKE_MAKE_PROGRAM} ${CMAKE_CURRENT_BINARY_DIR}/compile_commands.json
     DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/contrib/gen_compile_db.py
@@ -357,8 +353,7 @@ if(CMAKE_EXPORT_COMPILE_COMMANDS AND WITH_PYTHON)
     DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/compile_commands.json
             ${CMAKE_CURRENT_BINARY_DIR}/compile_commands.json)
 
-  # A prebuild target ensures that all actors, Swift-generated headers, and
-  # Swift modules are built.
+  # A prebuild target ensures that Swift-generated headers and modules are built.
   if(WITH_SWIFT)
     add_custom_target(prebuild_for_ide ALL DEPENDS fdbserver_swift
                                                    processed_compile_commands)

README.md

@@ -2,7 +2,7 @@
 
 ![Build Status](https://codebuild.us-west-2.amazonaws.com/badges?uuid=eyJlbmNyeXB0ZWREYXRhIjoiVjVzb1RQNUZTaGxGNm9iUnk4OUZ1d09GdTMzZnVOT1YzaUU1RU1xR2o2TENRWFZjb3ZrTHJEcngrZVdnNE40bXJJVDErOGVwendIL3lFWFY3Y3oxQmdjPSIsIml2UGFyYW1ldGVyU3BlYyI6IlJUbWhnaUlJVXRORUNJTjQiLCJtYXRlcmlhbFNldFNlcmlhbCI6MX0%3D&branch=main)
 
-FoundationDB is a distributed database designed to handle large volumes of structured data across clusters of commodity servers. It organizes data as an ordered key-value store and employs ACID transactions for all operations. It is especially well-suited for read/write workloads, but also has excellent performance for write-intensive workloads. Users interact with the database using API language binding.
+FoundationDB is a distributed database designed to handle large volumes of structured data across clusters of commodity servers. It organizes data as an ordered key-value store and employs ACID transactions for all operations. It is especially well-suited for read/write workloads, but also has excellent performance for write-intensive workloads. Users interact with the database using API language bindings.
 
 To learn more about FoundationDB, visit [foundationdb.org](https://www.foundationdb.org/)
 
@@ -12,17 +12,17 @@ Documentation can be found online at <https://apple.github.io/foundationdb/>. Th
 
 ## Forums
 
-[The FoundationDB Forums](https://forums.foundationdb.org/) are the home for most of the discussion and communication about the FoundationDB project. We welcome your participation!  We want FoundationDB to be a great project to be a part of, and as part of that, we have established a [Code of Conduct](CODE_OF_CONDUCT.md) to define what constitutes permissible modes of interaction.
+[The FoundationDB Forums](https://forums.foundationdb.org/) are the home for most of the discussion and communication about the FoundationDB project. We welcome your participation! We want FoundationDB to be a great project to be a part of, and as part of that, we have established a [Code of Conduct](CODE_OF_CONDUCT.md) to define what constitutes permissible modes of interaction.
 
 ## Contributing
 
-Contributing to FoundationDB can be in contributions to the codebase, sharing your experience and insights in the community on the Forums, or contributing to projects that make use of FoundationDB. Please see the [contributing guide](CONTRIBUTING.md) for more specifics.
+Contributions to FoundationDB can include contributions to the codebase, sharing your experience and insights with the community on the Forums, or contributing to projects that make use of FoundationDB. Please see the [contributing guide](CONTRIBUTING.md) for more specifics.
 
 ## Getting Started
 
 ### Latest Stable Releases
 
-The latest stable releases are (were) versions that are recommended for production use, which have been extensively validated via simulation and real cluster tests and used in our production environment.
+The latest stable releases are versions that are recommended for production use, which have been extensively validated via simulation and real cluster tests and used in our production environment.
 
 | Branch   |     Latest Production Release      |  Notes |
 |:--------:|:-------------:|------:|
@@ -84,7 +84,7 @@ defined in `/root/.bashrc` in the container image.
 
 To build outside of the official Docker image, you'll need at least these dependencies:
 
-1. [CMake](https://cmake.org/) version 3.24.2 or higher 
+1. [CMake](https://cmake.org/) version 3.24.2 or higher
 1. [Mono](https://www.mono-project.com/download/stable/)
 1. [ninja](https://ninja-build.org/)
 
@@ -140,7 +140,7 @@ Building FoundationDB requires at least 8GB of memory. More memory is needed whe
 
 ### macOS
 
-The build under macOS will work the same way as on Linux. [Homebrew](https://brew.sh/) can be used to install the `boost` library and the `ninja` build tool. Be careful, current main branch uses boost 1.86, do install this version or just let cmake download one. Also, if the Swift binding is not of interest, use -DBUILD_SWIFT_BINDING=OFF.
+The build under macOS will work the same way as on Linux. [Homebrew](https://brew.sh/) can be used to install the `boost` library and the `ninja` build tool. Be careful: the current main branch uses Boost 1.86; install this version or let CMake download it. Also, if the Swift binding is not of interest, use `-DBUILD_SWIFT_BINDING=OFF`.
 
 ```sh
 cmake -G Ninja <FDB_SOURCE_DIR> -B <BUILD_DIR>
@@ -156,10 +156,10 @@ To generate an installable package,
 
 ### Windows
 
-Under Windows, only Visual Studio with ClangCl is supported
+Under Windows, only Visual Studio with ClangCl is supported.
 
 1. Install Visual Studio 2019 (IDE or Build Tools), and enable LLVM support
-1. Install  [CMake 3.24.2](https://cmake.org/download/) or higher
+1. Install [CMake 3.24.2](https://cmake.org/download/) or higher
 1. Download [Boost 1.86.0](https://archives.boost.io/release/1.86.0/source/boost_1_86_0.tar.bz2)
 1. Unpack boost to C:\boost, or use `-DBOOST_ROOT=<PATH_TO_BOOST>` with `cmake` if unpacked elsewhere
 1. Install [Python](https://www.python.org/downloads/) if it is not already installed by Visual Studio
@@ -169,7 +169,7 @@ Under Windows, only Visual Studio with ClangCl is supported
 1. `mkdir build && cd build`
 1. `cmake -G "Visual Studio 16 2019" -A x64 -T ClangCl <FDB_SOURCE_DIR>`
 1. `msbuild /p:Configuration=Release foundationdb.sln`
-1. To increase build performance, use `/p:UseMultiToolTask=true` and `/p:CL_MPCount=<NUMBER_OF_PARALLEL_JOBS>` 
+1. To increase build performance, use `/p:UseMultiToolTask=true` and `/p:CL_MPCount=<NUMBER_OF_PARALLEL_JOBS>`
 
 ### Language Bindings
 
@@ -180,21 +180,21 @@ Generally, CMake will build all language bindings for which it can find all nece
 
 ### Generating `compile_commands.json`
 
-CMake can build a compilation database for you. However, the default generated one is not too useful as it operates on the generated files. When running `ninja`, the build system creates another `compile_commands.json` file in the source directory. This can then be used for tools such as  [CCLS](https://github.com/MaskRay/ccls) and [CQuery](https://github.com/cquery-project/cquery), among others. This way, you can get code completion and code navigation in flow. It is not yet perfect (it will show a few errors), but we are continually working to improve the development experience.
+CMake can generate a compilation database for code completion, navigation, and static analysis of the C++20 coroutine sources. Pass `-DCMAKE_EXPORT_COMPILE_COMMANDS=ON` when configuring a Ninja or Makefile build, then point your tooling at `compile_commands.json` in the build directory.
 
-CMake will not produce a `compile_commands.json` by default; you must pass `-DCMAKE_EXPORT_COMPILE_COMMANDS=ON`.  This also enables the target `processed_compile_commands`, which rewrites `compile_commands.json` to describe the actor compiler source file, not the post-processed output files, and places the output file in the source directory.  This file should then be picked up automatically by any tooling.
+When Python support is enabled, this option also enables the `processed_compile_commands` target, which writes a database to the source directory. With Ninja, it includes Swift compilation commands as well.
 
-Note that if the building is done inside the `foundationdb/build` Docker image, the resulting paths will still be incorrect and require manual fixing. One will wish to re-run `cmake` with `-DCMAKE_EXPORT_COMPILE_COMMANDS=OFF` to prevent it from reverting the manual changes.
+If the build runs inside a container, the database contains container paths. Run the tooling in the same environment or map those paths to the host checkout.
 
 ### Code Formatting and Static Analysis
 
 `clang-format` and `clang-tidy` run as part of CI on every pull request. See the [clang-format](https://apple.github.io/foundationdb/clang-format.html) and [clang-tidy](https://apple.github.io/foundationdb/clang-tidy.html) guides for how to run them locally before pushing.
 
 ### Using IDEs
 
-CMake provides built-in support for several popular IDEs. However, most FoundationDB files are written in the `flow` language, which is an extension of the C++ programming language,  for coroutine support (Note that when FoundationDB was being developed, C++20 was not available). The `flow` language will be transpiled into C++ code using `actorcompiler`, while preventing most IDEs from recognizing `flow`-specific syntax.
+CMake provides built-in support for several popular IDEs. FoundationDB's asynchronous code uses standard C++20 coroutines with the Flow runtime, so use an IDE or language server with C++20 support. See the [coroutine guide](design/coroutines.md) for the programming model.
 
-It is possible to generate project files for editing `flow` with a supported IDE. There is a CMake option called `OPEN_FOR_IDE`, which creates a project that can be opened in an IDE for editing. This project cannot be built, but you will be able to edit the files and utilize most of the editing and navigation features that your IDE supports.
+The CMake option `OPEN_FOR_IDE` creates an editing-only project for a supported IDE. This project cannot be built, but supports editing and navigation.
 
 For example, if you want to use Xcode to make changes to FoundationDB, you can create an Xcode project with the following command:
 

SWIFT_GUIDE.md

@@ -52,8 +52,6 @@ Then, you can then include the generated module in C++:
 ```cpp
 // ... 
 #include "SwiftModules/FDBServer"
-
-#include "flow/actorcompiler.h" // This must be the last #include.
 ```
 
 ## Swift Basics

SWIFT_IDE_SETUP.md

@@ -45,7 +45,7 @@ export FOUNDATIONDB_LLVM_TOOLCHAIN_ROOT=~/Downloads/clang+llvm-15.0.7-arm64-appl
 ```
 
 
-For actor compiler: Download and install mono:  [https://www.mono-project.com](https://www.mono-project.com/), e.g.
+For the C# build tools, including option generation, install [Mono](https://www.mono-project.com/), e.g.
 
 ```bash
 brew install mono
@@ -147,7 +147,5 @@ Setup:
 
 ## Known issues
 
-* jump-to-definition fails to open actor header files.
 * jump-to-definition from C++ to Swift does not work.
 * Code completion for semantic responses in Swift can be slow sometimes especially in files that import both FDBServer and FDBClient
-

bindings/c/test/apitester/TesterTransactionExecutor.cpp

@@ -295,6 +295,7 @@ class TransactionContextBase : public ITransactionContext {
 
 	std::vector<fdb::Error::CodeType> retriedErrorCodes() {
 		std::vector<fdb::Error::CodeType> retriedErrorCodes;
+		retriedErrorCodes.reserve(retriedErrors.size());
 		for (auto e : retriedErrors) {
 			retriedErrorCodes.push_back(e.code());
 		}

bindings/c/test/apitester/TesterWorkload.cpp

@@ -305,6 +305,7 @@ void WorkloadManager::schedulePrintStatistics(int timeIntervalMs) {
 std::vector<std::shared_ptr<IWorkload>> WorkloadManager::getActiveWorkloads() {
 	std::unique_lock<std::mutex> lock(mutex);
 	std::vector<std::shared_ptr<IWorkload>> res;
+	res.reserve(workloads.size());
 	for (const auto& iter : workloads) {
 		res.push_back(iter.second.ref);
 	}

bindings/c/test/client_memory_test.cpp

@@ -64,6 +64,7 @@ int main(int argc, char** argv) {
 	};
 	std::vector<std::thread> threads;
 	constexpr auto kThreadCount = 64;
+	threads.reserve(kThreadCount);
 	for (int i = 0; i < kThreadCount; ++i) {
 		threads.emplace_back(thread_func);
 	}

bindings/flow/fdb_flow.cpp

@@ -53,6 +53,7 @@ Future<Void> _test() {
 	// for (int i = 0; i < 100000; i++) {
 	// 	Version v = wait( tr->getReadVersion() );
 	// }
+	versions.reserve(100000);
 	for (int i = 0; i < 100000; i++) {
 		versions.push_back(tr->getReadVersion());
 	}