Ankit Kumar

This commit **fixes** an issue where the **Thrift package declarations** were missing or incorrect within the **`thrift/example`** module's interface definition files. It updates the `package` statement in both `MetadataExample.thrift` and `chatroom.thrift` to the correct `facebook.com/thrift/example` identifier. This **maintenance fix** also removes legacy include statements and annotations from these example Thrift files. The change ensures that the example Thrift definitions are properly structured and resolvable, preventing potential compilation or integration problems for consumers of these examples.

This commit **fixes noisy logging** within the **RPC Benchmarking** tool by preventing redundant log messages. Previously, the same information was logged once per thread, leading to excessive output that cluttered logs and hindered readability, especially on development servers and during multi-iteration benchmark runs. This **maintenance improvement** enhances the developer experience by making important logs easier to follow and reducing disk space usage for log files. The change specifically targets the **benchmarking subsystem** to streamline its output.

This commit **refactors** the **RPC Bench** `PoissonLoadGenerator` by **removing the load ramp-up functionality**. Specifically, it deletes the `stepUpLoad` method and its scheduling from `thrift/conformance/stresstest/client/PoissonLoadGenerator.cpp`, and removes related member variables and declarations from `thrift/conformance/stresstest/client/PoissonLoadGenerator.h`. This change simplifies the load generator to use a fixed mean for its Poisson distribution, as the ramp-up logic will now be handled externally. This **maintenance** update enables a single `target_qps` per test run, aligning with how test statistics are reported within the **Thrift conformance stresstest client**.

This commit introduces a **new performance metric**, `totalCpuCycles`, to the **Thrift conformance stress test client** to enhance performance analysis. It modifies the **`ClientRunnerStats`** to track and aggregate CPU cycles within `ClientRpcStats`, and integrates this data into the stress test reports for logging average CPU cycles per request. A key aspect of this **feature enhancement** is the automatic reset of `totalCpuCycles` in `WarmupDoneTimeout` after the warmup phase, ensuring that reported CPU usage accurately reflects steady-state performance. This provides more granular insights into the resource consumption of the system under test.

This commit provides a **bug fix** for the **Thrift conformance stress test client**. Previously, the `co_sinkTm` function in `thrift/conformance/stresstest/client/StressTestClient.cpp` failed to `co_await` its sink task, leading to payloads not being sent and the task prematurely canceling. This change ensures the sink task is correctly awaited, allowing the **stress test client** to properly send all its payloads. This improves the reliability of the **stress testing infrastructure** by ensuring tests accurately reflect payload transmission.

This commit introduces a **load ramp-up mechanism** to the **`PoissonLoadGenerator`** within the `StressTest` framework. This **new capability** allows the load generator to gradually increase the request rate at a custom pace, rather than applying a sudden, constant load. Specifically, it adds a `stepUpLoad` function and modifies `generateRequestSignal` and `start` in `PoissonLoadGenerator.cpp` to incorporate this behavior. The `PoissonLoadGenerator` class in `PoissonLoadGenerator.h` is updated with new constructors and member variables to configure the ramp-up parameters, significantly enhancing the realism and control of stress tests.

This commit performs a **significant refactoring** of the **Thrift conformance stress test framework**. It **extracts common statistics and timeout callback logic** from the `ClientRunner` and `TestRunner` components, moving definitions like `ClientRpcStats`, `ClientThreadMemoryStats`, `StressTestStats`, `TestDoneTimeout`, and `WarmupDoneTimeout` into dedicated, newly created header and source files (`ClientRunnerStats.h/.cpp`, `StressTestStats.h/.cpp`, `TimeoutCallbacks.h/.cpp`). This **improves modularity** and **reduces coupling** within the stress test infrastructure by centralizing shared functionalities. This **preparatory work** is essential for enabling the integration of new client runner types, particularly for **RPC comparison stress testing**.

This commit introduces a **new runner framework** within the **Thrift conformance stress test client** to facilitate robust **RPC comparison testing**, specifically for benchmarking Thrift against gRPC. This **new feature** establishes a dedicated test environment, separate from the existing conformance setup, to accommodate gRPC's unique implementation requirements. It initializes the `runtimeSeconds` field in the `StressTestStats` structure within `TestRunner.cpp` using the `FLAGS_runtime_s` value, ensuring accurate duration tracking for these new stress tests. This framework will enable comprehensive performance evaluations and **comparison of Thrift against gRPC** and potentially other RPC technologies under stress conditions.

This commit performs **code cleanup** by **removing the unused `StressTest.proto` file** and its corresponding `StressTest_grpc` gRPC library target from the **build system**. This action streamlines the project by eliminating dead code and unnecessary build configurations, specifically within the gRPC definitions. The change primarily affects the **build process** and **repository size**, contributing to improved maintainability and reduced clutter.

This commit performs a **refactoring** of the **gRPC stress test client factory** within the `thrift/conformance/stresstest` module. It **removes the dedicated `createGrpcClient` function** and extracts all gRPC client creation logic from the general `createClients` pluggable function in `ClientFactory.cpp`. This change improves the internal code organization and maintainability of the client instantiation process for gRPC stress tests, with **no functional impact** on the stress test's behavior or capabilities.

This commit introduces **new microbenchmarks** within the `thrift/lib/cpp2/protocol/benchmark` module to quantitatively compare the serialization and deserialization performance of various protocols. Specifically, it adds tests for **Thrift (Binary and Compact), Carbon, and Protobuf**, using newly defined small, medium, and large test data structures across `CarbonTestData.idl`, `ProtobufTestData.proto`, and `ThriftTestData.thrift`. This **new capability** provides essential infrastructure for performance analysis, allowing developers to evaluate and optimize the efficiency of different data interchange formats within the **Thrift ecosystem**. The work includes comprehensive helper functions in `ThriftProtocolBenchmarkHelper.cpp` and `ThriftProtocolBenchmarkHelper.h` to facilitate data generation and protocol operations for these benchmarks. This enables informed decision-making regarding protocol choice based on performance characteristics.

This commit introduces **gRPC support** to the `thrift/conformance/stresstest` framework, adding a **new capability** for comprehensive performance evaluation. It implements both an asynchronous gRPC client and server, integrating new configuration options in `ClientConfig` and client factory logic in `ClientFactory`. The change enables stress testing of gRPC services with initial support for `Ping` and `Echo` operations, running on the completion queue worker. This significantly expands the scope of the `thrift/conformance/stresstest` module to include gRPC alongside existing Thrift services.

This commit implements a **bug fix** to address a critical object lifetime issue within the **Thrift C++2 asynchronous server-side BiDi sink bridge**. It modifies the `ServerBiDiSinkBridge` constructor to acquire an `EventBase` keep-alive token and updates the `cancel` method to capture the bridge by value in the cancellation callback. This ensures that both the `EventBase` and the BiDi bridge remain alive long enough for the cancellation message to be reliably dispatched to the client. The change enhances the stability and reliability of **Thrift BiDi cancellation mechanisms**, preventing potential crashes or silent failures during asynchronous client operation cancellations.

This commit **fixes a bug** in the **Thrift C++2 protocol library** by removing an erroneous `DCHECK` within the `decode` method of `PaddedBinaryAdapter.h`. Previously, this assertion would incorrectly trigger when the padding value was zero, despite zero padding being a valid case that should result in a no-op. This change ensures that the `PaddedBinaryAdapter` now correctly handles zero padding, allowing data to be returned as-is without assertion failures, and resolves issues encountered in unit tests. The safety of the adapter remains unaffected, as it simply treats zero padding as a non-padded scenario.

This commit introduces **new stress tests** for **aligned data** using the `RequestResponseFrame` within the **Thrift conformance suite**. It adds a new client configuration option for **Rocket frame relative alignment** and updates the `StressTest.thrift` interface to include `PaddedBinaryData` and new `alignedRequestResponseTm` and `alignedRequestResponseEb` service methods. The client (`StressTestClient`) and server (`StressTestHandler`) implementations are updated to support these new aligned request-response operations, replacing previous `co_aligned` methods and adding comparison logic to `PaddedBinaryAdapter.h`. This **feature addition** significantly enhances the testing infrastructure, allowing for robust validation of Thrift's handling of aligned data structures, particularly with the Rocket protocol.

This commit introduces a **new capability** to **Thrift RPC** by adding an `RpcOption` allowing users to request **frame-relative data alignment**. This feature enables clients to specify memory alignment for the first binary field of the first parameter in a Thrift RPC call, which can improve data access efficiency for performance-critical applications. The change primarily impacts **Thrift's client-side serialization** within `RocketClientChannel` and the **Rocket transport framing layer**, where validation ensures alignment is only applied under specific conditions like binary protocol usage and non-fragmented `REQUEST_RESPONSE` frames. This **new feature** is exposed via `RpcOptions::setFrameRelativeDataAlignment` and includes comprehensive integration tests to verify its behavior and constraints.

This commit introduces a **new capability** to the **Thrift Rocket transport** that allows users to request alignment of the first data field within a request struct relative to the start of the frame. This feature, implemented primarily by the new `FrameDataFirstFieldAligner` class, enables precise control over data layout for **Thrift RPC calls** using `RequestResponseFrame`s. It affects the `thrift/lib/cpp2/transport/rocket/framing` subsystem by modifying serialization logic in `Frames.cpp` and adding new types in `Types.h` to support alignment metadata. This enhancement provides a specialized optimization for scenarios requiring strict data alignment, subject to several specific serialization and data type conditions like using `PaddedBinaryAdapter` and `BinaryProtocol`.

This commit **enhances** the **Thrift `PaddedBinaryAdapter`** to write padded buffers as unpacked, chained `IOBuf`s, which is crucial for enabling **Frame relative alignment**. It introduces a new `pack` parameter to the `BinaryProtocol`'s `writeBinary` and `serializedSizeBinary` functions (in `BinaryProtocol.h` and `BinaryProtocol-inl.h`), allowing explicit control over whether `IOBuf` data is packed or written unpacked. The `PaddedBinaryAdapter` (in `PaddedBinaryAdapter.h`) now leverages this by passing `pack=false` during serialization, and its `serializedSize` and `fromThrift` methods were updated to correctly handle the resulting chained buffers. This **refactoring** ensures proper serialization for advanced alignment scenarios and includes a new test case to verify `serializedSize` calculations.

This commit introduces a **new capability** to the **`folly::io::QueueAppender`** by modifying its `insert` methods. An optional `pack` parameter has been added, allowing callers to explicitly control whether a newly inserted `IOBuf` should be packed (merged) with the current `IOBuf` in the underlying `IOBufQueue` or kept as a separate buffer. This enhancement is critical for enabling **zero-copy alignment in Thrift** and generally benefits users who need to maintain distinct `IOBuf`s within a queue, bringing `QueueAppender`'s functionality in line with `IOBufQueue`'s existing non-packing insertion support.

This commit introduces a **new capability** to the **Thrift C++ protocol layer** by adding the `PaddedBinaryAdapter`. This adapter facilitates the **serialization and deserialization of binary fields with explicit padding**, addressing requirements for data alignment or specific data structures. It defines a new `PaddedBinaryData` type that encapsulates user data with prepended magic bytes, padding size, and the padding itself, which is then handled transparently by the adapter. This feature enhances Thrift's binary data handling, providing a robust mechanism for padded fields, but requires a server-side upgrade before client-side adoption to ensure correct interpretation of the new `PaddedBinaryData` format.