Alexey Spiridonov

This commit **finalizes the transition to unconditionally thread-safe `ServiceFrameworkLight` and `ServiceFramework`** by removing the deprecated `threadSafe` constructor parameter. It **refactors the internal concurrency management** within these core **service frameworks**, replacing an optional, heap-allocated `boost::scoped_ptr<std::mutex>` with a direct `std::mutex` member for guaranteed availability and simpler lifecycle. Furthermore, the commit **modernizes the locking mechanism** by replacing manual `lock()`/`unlock()` calls with `std::lock_guard` at all call sites, improving safety and readability. A minor **dependency cleanup** in `ProcModule.h` updates `boost::scoped_ptr` to `std::unique_ptr`, and a `stop()` doc comment is adjusted for consistency. This **refactoring and maintenance** effort simplifies the API, reduces code complexity, and enhances the robustness of the service framework's threading model.

This commit **fixes** the build configuration for the **`folly/result/detail`** module, ensuring proper cross-platform compilation. It updates the `folly/result/detail/BUCK` file to utilize `folly_xplat_cxx_library` and includes `use_raw_headers` and `xplat_impl` attributes. This **build system maintenance** preserves **static linkage** for these internal targets, aligning their build pattern with the parent `folly/result/BUCK` file. The change prevents potential linkage issues and guarantees consistent compilation across diverse environments.

This commit **refactors** the **build system** for components within the **Folly library's `result` module**. It **migrates** various C++ library and binary targets in `folly/result/demo` and `folly/result/detail` to use the new `fb_dirsync_cpp_binary` and `fb_dirsync_cpp_library` **BUCK macros**. This change completes the "dirsync-ifying" process, standardizing how these Folly components are built. The primary impact is on the internal build infrastructure, ensuring consistency and leveraging updated build system capabilities for these specific Folly sub-modules.

This commit **refactors** the **Folly epitaph error reporting mechanism** to ensure stack traces are always captured, even when symbolization is unavailable. It modifies `folly/result/epitaph.h` to unconditionally call `getStackTrace`, decoupling stack capture from the `FOLLY_EPITAPH_USE_SYMBOLIZER` flag which now only gates symbolization. This **bug fix** significantly improves **debuggability** for platforms like Android, which previously received zero stack frames, by providing raw hexadecimal addresses as a fallback. A new test in `folly/result/test/stack_epitaph_test.cpp` verifies this behavior, and `folly/result/BUCK` is updated for dependency management.

This commit implements a **packaging workaround** to resolve an `UnsatisfiedLinkError` crash on **Android** caused by an unconditional dependency on `folly/debugging/symbolizer` within `folly/result/epitaph`. It **platform-gates** the symbolizer dependency using `select()` and a new `FOLLY_EPITAPH_USE_SYMBOLIZER` macro, preventing its inclusion in Android builds. The change involves **refactoring** `folly/result/epitaph.h` to use a forward declaration for `getStackTrace` and updating `folly/result/epitaph.cpp` for conditional symbolizer usage, ensuring proper module boundaries and preventing runtime crashes in the Messenger APK. Additionally, `generate_cmake.py` is updated to correctly handle hidden dependencies, and `ssize_t` is fixed for Windows MSVC.

This commit introduces a **new capability** to the **`folly/result` library** by implementing `stack_epitaph()`, which captures and attaches call stacks to `error_or_stopped` objects. This significantly enhances **error reporting for `result` coroutines**, as `unhandled_exception()` will now automatically include a stack trace, showing the origin of exceptions. The underlying `epitaph` system was **refactored** to generalize location storage, supporting both source locations and stack traces efficiently via `epitaph_impl`. This provides developers with much richer diagnostic information, making it easier to debug issues within `result`-based asynchronous workflows with minimal performance overhead.

This commit significantly **enhances the `folly` adaptive benchmarking system** by optimizing its convergence and execution methodology. It **accelerates benchmark stability detection** in `folly/detail/BenchmarkAdaptive.cpp` by dynamically adjusting the instability criterion, leading to faster results without compromising precision. Furthermore, the system now utilizes **random interleaving** for benchmark execution to better account for machine dynamic-state variance, and the intermediate results reporting is refined for improved readability. These updates collectively provide a more efficient, robust, and user-friendly benchmarking experience within the `folly` library.

This commit introduces **enhanced intermediate reporting** for **adaptive benchmarks** (`-bm_mode=adaptive`), providing periodic updates on their progress. It now prints "final-like" tables every 5 seconds of runtime, annotating incomplete results with `[unstable]` or `[imprecise]` to give users real-time insight into long-running tests. This **new capability** significantly improves the user experience by allowing early termination if desired, and the new verbose output can be suppressed with the `-bm_quiet` flag. The changes primarily affect the **`folly::Benchmark` output subsystem**, specifically `folly/detail/BenchmarkAdaptive.cpp`, by refactoring output logic into `BenchmarkResultsPrinter` and adding `formatIntermediateReport` for these progress updates.

This commit introduces a **new `adaptive` benchmarking mode** (`--bm_mode=adaptive`) to the **`folly::Benchmark` subsystem**, designed to provide statistically sound and consistent performance measurements by automatically mitigating system noise and oscillations. Concurrently, it **changes the default `--bm_min_usec` from 100μs to 1000μs**, which will make default benchmark runs slower but significantly more accurate by reducing measurement artifacts like cache interference. This **enhancement** improves the reliability and trustworthiness of benchmark results across the project, especially on noisy multi-tenant systems, and is thoroughly documented in `docs/BenchmarkAdaptive.md`. These changes provide users with more robust tools for performance analysis and ensure more reliable default benchmark behavior.

This commit performs a **refactoring** of **folly**'s **benchmarking infrastructure** by renaming the `bm_min_usec` command-line flag to `bm_slice_usec`. The original flag name was misleading and has been deprecated to improve **clarity** and prevent confusion with other benchmark parameters. This **maintenance** change updates various benchmark test files across `folly/compression`, `folly/concurrency`, `folly/coro`, `folly/fibers`, `folly/hash`, `folly/lang`, `folly/system`, and `folly/test`. The updates include modifying default command-line options and comments to consistently use the new `bm_slice_usec` flag, ensuring better understanding of benchmark configuration.

This commit performs a **refactoring** of the **benchmarking utility** within `folly/Benchmark.cpp`. It **reorders gflag definitions** and **improves their associated docstrings** to enhance clarity and categorization of configuration options. The primary goal is to make it easier for users to understand which options apply to "best-of" versus "adaptive" benchmarking modes. This change is purely for **documentation and code readability**, introducing **no functional changes** to the benchmark execution or its behavior.

This commit **enhances the `folly::Benchmark` utility** by introducing **robust input validation** for command-line options. It adds a **new feature** to `folly/Benchmark.cpp` that specifically checks for and prevents incompatible flag combinations, such as the use of `bm_estimate_time` alongside `adaptive` or `best-of` benchmark modes. This **maintenance improvement** provides users with immediate feedback and warnings, guiding them away from potentially misleading or inefficient benchmark configurations. Ultimately, this ensures more reliable and consistent benchmark results by preventing common misconfigurations within the **benchmarking subsystem**.

This commit implements a **critical safety enhancement** for **`folly::result` coroutines**, preventing a severe stack-use-after-free vulnerability. It introduces a compile-time restriction in `result_promise_base`'s `await_transform` that disallows `co_await` on suspending awaitables that are not explicitly marked as `or_unwind_awaitable`. This **bug fix** transforms a potential runtime crash into a **compile-time error**, significantly improving the **robustness and predictability** of `folly::result`-returning coroutines. Developers attempting this unsafe pattern will now receive a clear compilation failure, guided by new documentation in `detail/result_or_unwind.h` and verified by new unit tests.

This commit **enhances the `folly::result` library** by making the `value_only_result` type **copyable**, enabling direct duplication of these objects. It introduces **copy construction and assignment operators** for `value_only_result` in `folly/result/value_only_result.h`, deprecating the explicit `copy()` method for a more idiomatic C++ approach. This **new capability** provides consistent behavior with the general `result` type and simplifies handling of `value_only_result` instances. Comprehensive **unit tests** and static assertions have been added in `folly/result/test/value_only_result_test.cpp` to validate the new copy and move semantics, ensuring robust behavior.

This commit **fixes** an interaction issue by **enabling the static variant** for the `now_task` and `safe_task` `fb_dirsync_cpp_library` rules within the **`folly/coro/safe`** module. This **configuration change** in the `BUCK` file addresses a specific problem related to the combination of `dirsync` and these asynchronous primitives. By ensuring these components are statically linked, it improves the reliability and correctness of builds that utilize `dirsync` with `folly::coro::safe` functionalities. This is a **maintenance fix** to enhance build system robustness.

This commit **reverts** the `Expected(EmptyTag)` constructors in `folly/Expected.h` back to private access. This **refactoring** is performed because the `result` type no longer utilizes `Expected`, eliminating the need for `EmptyTag` to be publicly exposed for coroutine promises. The change simplifies the **`folly::Expected`** utility by removing unnecessary API surface and associated comments. This **maintenance** task improves the internal consistency of the `Expected` class by removing code that is no longer required.

This commit introduces **new test cases** within `folly/result/test/result_test.cpp` to **validate** the recently added support for `co_return lvalue` semantics. These tests specifically verify the correct behavior of `co_return` when used with lvalues and ensure proper `const`-correctness for `result<T&>`. This **testing enhancement** is crucial for confirming the stability of `folly::result`'s coroutine integration. The work ensures the robustness of the `folly::result` library's handling of advanced C++ coroutine features, particularly in anticipation of future changes that will make `result<T>` copyable based on `T`'s copyability.

This commit **refactors** the internal implementation of the **`folly::result`** type, removing its dependency on `folly::Expected` to manage its state. This significant **internal rewrite** introduces a direct `eos_` member and a union for value storage, which **improves robustness** by eliminating the valueless-by-exception state for types with throwing move constructors. The change also **reduces memory footprint** for `result<>` (now 8 bytes) and delivers **performance optimizations**, particularly benefiting **`folly::coro`** tasks where `result` replaces `Try<T>`. This comprehensive **refactoring** ensures a more efficient, predictable, and feature-rich error-handling mechanism within the `folly` library.

This commit **enhances the `folly::result` library** by making the `result<T>` type implicitly copyable, aligning it with standard value-type expectations and simplifying generic programming. Previously move-only with an explicit `.copy()` method, `result<T>` now supports implicit copy construction and assignment based on `T`'s copyability. This includes specific deep-const semantics for `result<V&>` (copyable only from mutable `result<V&>&`) and always-copyable `result<const V&>` and `result<void>`. The explicit `.copy()` method has been **deprecated**, and all internal call sites within `folly/result/` have been migrated to use implicit copying or `folly::copy()`. This **API change** improves usability and consistency for consumers of `folly::result` by reducing boilerplate and enabling more natural generic code.

This commit performs **maintenance** and **build system refactoring** for the **`folly/coro/safe` module**. It updates the BUCK build rules across `folly/coro/safe`, `folly/coro/safe/detail`, and their respective test directories to utilize `fb_dirsync_cpp_library` and `fb_dirsync_cpp_unittest` for better integration with the `dirsync` build system. Concurrently, it **improves test reliability** by adding `folly::Init` initialization to the `main` functions of `folly/coro/safe/test/AsyncClosureTest.cpp` and `folly/coro/safe/test/SafeTaskTest.cpp`. This ensures proper setup for these unit tests, preventing potential runtime issues. The changes streamline the build process and enhance the robustness of the `folly/coro/safe` test suite.