Juanlu Herrero

This commit introduces a **defensive check** within the **`IoUringBufferPoolSharing`** component, specifically in the `setupIoUringBufferPoolSharingImpl` function located in `folly/io/async/IoUringBufferPoolSharing.cpp`. This **bug fix** ensures that at least one hardware queue (`numHwQueues`) is provided during setup. By adding this early validation, the change prevents potential runtime errors, such as a divide-by-zero or modulo-by-zero crash that could occur later during the `ownerIdx` calculation if `numHwQueues` were zero. This improves the **robustness** of the buffer pool sharing mechanism by failing loudly and early with a clear error message, rather than encountering a cryptic crash.

This commit provides a **bug fix** for the **`folly::io::async::IoUringBufferPoolSharing`** component, specifically addressing incorrect calculations involving `startQueueId` that could result in negative queue counts. It **removes the `startQueueId` parameter** from the `setupIoUringBufferPoolSharing` and `setupIoUringBufferPoolSharingImpl` functions, along with its corresponding declarations in `folly/io/async/IoUringBufferPoolSharing.h`. This **refactoring** and **bug fix** ensures accurate buffer pool owner assignment and sharing within the `io_uring` subsystem, enhancing its reliability and preventing potential runtime errors.

This commit **fixes bugs** within the **`io_uring` buffer pool sharing** logic, specifically addressing an incorrect calculation that could yield negative queue counts. The **bug fix** corrects the call to `setupIoUringBufferPoolSharing` in `thrift/conformance/stresstest/client/ClientRunner.cpp` by removing an erroneous `startQueueId` argument. This ensures the robust and accurate setup of `io_uring` buffer pools, particularly impacting the **Thrift conformance stress test client**.

This commit **refactors** the **`IoUringBackend`** module by **removing the redundant `struct` keyword** from C type declarations. It updates both `IoUringBackend.cpp` and `IoUringBackend.h` to omit `struct` when referring to C struct types in function parameters, return types, local variables, and member variables. This change is purely **stylistic**, leveraging C++'s allowance to refer to struct types without the `struct` elaboration, thereby improving **code readability and consistency** within the I/O Uring backend implementation. There is no functional impact on the backend's behavior or performance.

This commit **refactors** the **`folly::io::async::IoUringBackend`** implementation to utilize modern C++ container idioms and patterns. It updates various methods, including those in `SignalRegistry` and `SQGroupInfoRegistry` within `IoUringBackend.cpp`, and `hasBufferProvider` in `IoUringBackend.h`. The changes involve replacing older C++ patterns like `(*map_).find()` with `map_->find()`, `CHECK(x.find(k) == x.end())` with `CHECK(!x.count(k))`, and `insert(make_pair(...))` with `emplace()` or `try_emplace()`, as well as `size() > 0` with `!empty()`. This is a **code quality refactoring** that improves the readability, maintainability, and adherence to contemporary C++ best practices within the **`IoUringBackend`** subsystem.

This commit **refactors** the **`folly::io::async::IoUringBackend`** by systematically replacing C-style casts with modern C++ casts, specifically `static_cast` for safe conversions and `reinterpret_cast` for pointer manipulations. This **type safety and code style improvement** impacts various functions across `IoUringBackend.cpp` and `IoUringBackend.h`, including I/O submission, timer management, and signal processing. The change enhances code clarity and reduces the risk of subtle runtime errors associated with less strict C-style casts. Ultimately, this makes the **asynchronous I/O backend** more robust and maintainable.

This commit **refactors** the `FDCreateFunc` lambda within the **`IoUringBackend`** constructor in `folly/io/async/IoUringBackend.cpp`. The change simplifies the control flow by introducing an early return when `io_uring` initialization is successful, reducing the lambda's cyclomatic complexity. This **maintenance** effort improves the readability and maintainability of the **Folly asynchronous I/O backend** initialization logic.

This commit introduces a **new capability** to support **source port binding** for **Fizz clients**, enabling the calculation and application of bind options before the socket connection is established. This functionality is crucial for the **`zcrx` system**, which requires Fizz clients to bind to specific source ports. The change primarily affects the **client creation logic** within `thrift/conformance/stresstest/client/ClientFactory.cpp`, specifically by passing bind options to the `AsyncFizzClient` constructor, impacting functions like `createIOUringFizz`. This ensures that Fizz clients can meet specific network configuration requirements.

This commit **cleans up the I/O subsystem** by **removing experimental shims and forwarding headers** that are no longer needed. It eliminates numerous shim targets related to **asynchronous I/O**, `liburing` integration, `epoll` backends, `mux_io_thread_pool_executor`, `fs_util`, and `huge_pages`, along with associated test shims and `bad_targets` entries. This **refactoring** effort streamlines the build configuration and reduces indirection within the **I/O stack**, as evidenced by the update in `folly/io/async/test/BUCK` to use `async_base` directly. The change improves the **maintainability and clarity of the core I/O infrastructure**.

This commit **refactors** the codebase by performing an **include path migration** for `AsyncIoUringSocket`, `AsyncIoUringSocketFactory`, and `IoTestTempFileUtil` to their **canonical locations**. Specifically, `AsyncIoUringSocket` and `AsyncIoUringSocketFactory` are now referenced from `folly/io/async` instead of `folly/experimental/io`, while `IoTestTempFileUtil` moves from `folly/experimental/io/test` to `folly/io/async/test`. This **maintenance** task ensures **consistent referencing** of `iouring`-related components within the **`folly/io/async` library**. The change primarily impacts the **Thrift conformance stresstest client** and various **Hypernode components** that utilize these utilities.

This commit introduces **overloads** for the `setupIoUringBufferPoolSharing` function within the **`folly::io::async`** library, significantly enhancing its flexibility. This **feature enhancement** allows the function to accept `std::vector`s of either raw `folly::EventBase*` pointers or `std::unique_ptr<folly::EventBase>` instances, accommodating diverse usage patterns found in components like `ThriftDptExecutor` and thrift stresstests. To achieve this, the common setup logic has been **refactored** into a new private helper function, `setupIoUringBufferPoolSharingImpl`, improving code organization and maintainability. This change simplifies the integration of `IoUring` buffer sharing across different `EventBase` management strategies, reducing friction for downstream consumers.

This commit introduces a **new capability** to the **Thrift conformance stress test client** by integrating **IoUring buffer pool sharing**. It enables **zero-copy receive buffer pool sharing** within the `ClientRunner` constructor, controlled by the new `--io_zcrx_buffer_pool_sharing` flag. To facilitate this, the `setupIoUringBufferPoolSharing` utility in `IoUringUtil` was **refactored** to accept `vector<EventBase*>` in addition to `unique_ptr`s, delegating to a shared template helper for improved flexibility. Additionally, a new flag `--io_zcrx_hw_queues` was added to `IoUringUtil` to conditionally configure zero-copy receive based on hardware queue availability and thread ownership. This enhancement allows the stress test client to leverage advanced IoUring features for potentially **improved performance and resource utilization**.

This commit introduces a **new capability** within the **`folly/io/async`** module by adding a helper for **`IoUring` zero-copy buffer pool sharing**. It implements the `setupIoUringBufferPoolSharing` function, declared in `folly/io/async/IoUringBufferPoolSharing.h` and defined in `folly/io/async/IoUringBufferPoolSharing.cpp`, to manage the import and export of buffer pool handles. This mechanism is crucial for scenarios where there are more I/O threads or EventBases than hardware queues, enabling efficient resource sharing and improved performance for `IoUring` operations. The change allows multiple threads to share `IoUring` buffer pools, optimizing resource utilization.

This commit introduces a **new capability** to the **`folly::io::async::IoUringBackend`** by providing flexible mechanisms for managing zero-copy buffer pool handles. It adds public methods such as `createZcBufferPool`, `importZcBufferPool`, and `exportZcBufferPool` to allow for the dynamic construction, sharing, and ownership transfer of buffer pools *after* backend initialization. This **refactoring** improves the ergonomics of resource management, making it easier to share buffer pools between different `IoUringBackend` instances without requiring ownership decisions at creation time. This enhancement is crucial for upcoming changes in the stack, enabling more adaptable and efficient resource sharing.

This commit introduces a **new capability** for **Folly's `AsyncIoUring` backend** to support **multi-threaded client applications** utilizing **Zero-Copy Receive/Transmit (ZC-RX)**. It **refactors** the socket binding mechanism within `folly::io::async::AsyncIoUringSocketFactory` by replacing an older method with `createBoundSocketForZcRx`, which now dynamically allocates ports. This new approach iteratively attempts to bind sockets within a specified port range (1024-32768), starting from a random point, to gracefully handle `EADDRINUSE` errors and ensure successful binding for concurrent threads. The changes also involve updating the `computeSrcPortForQueueId` function in `folly::io::async::IoUringBackend` to accept parameters for this new port range strategy, enhancing the robustness of ZC-RX socket operations.

This commit **enhances the Zero-Copy RX (ZC-RX) socket binding mechanism** within the **Thrift conformance stresstest client** to properly support **multiple client threads**. It introduces a **new capability** for `io_zcrx_socket_bind` to dynamically select source ports within the 1024-32768 range, starting at a random point and retrying upon `EADDRINUSE` errors to find an available port. This involves **refactoring** the `createIOUring` and `createIOUringTLS` methods in `thrift/conformance/stresstest/client/ClientFactory.cpp` to use pre-bound file descriptors. Additionally, the `src_port_callback` signature in `thrift/conformance/stresstest/util/IoUringUtil.cpp` and `thrift/conformance/stresstest/StressTest.cpp` is updated to accept port range parameters. This change ensures the **stresstest client** can effectively simulate **multi-threaded scenarios** with ZC-RX, improving its robustness and testing capabilities.

This commit **fixes a critical bug** in the **`folly::io::async` `IoUringBackend`** that prevented `io_uring` zero-copy receive (ZC-RX) from correctly resolving source ports. Previously, the `computeSrcPortForQueueId` function was erroneously using `napiId_` instead of the intended `options_.zcRxQueueId` when calculating the source port, leading to a "No matching source port found" error. The change ensures the correct `queueId` is passed, resolving this specific issue and allowing the ZC-RX functionality to proceed. Additionally, a **refactoring** was performed in `IoUringOptions.h` to rename `targetNapiId` to `targetQueueId` for improved clarity.

This commit performs a **refactoring migration** to update **Thrift C++2 components** and their associated tests to utilize canonical include paths and BUCK dependencies for Folly I/O utilities. Specifically, references to headers like `AsyncIoUringSocketFactory.h` and `MuxIOThreadPoolExecutor.h` are updated from `folly/experimental/io` to their stable locations under `folly/io/async` or `folly/io`. This **maintenance** effort ensures that Thrift consumers, including fbcode and xplat projects, rely on the official Folly I/O paths. The change improves build system consistency and removes dependencies on deprecated experimental shims, streamlining future development.

This commit **refactors** the `folly` codebase by **migrating** all remaining internal uses of `folly/experimental/io` to their **canonical paths** within `folly/io` and `folly/io/async`. This **maintenance** effort involves updating both include directives in source files and build dependencies in BUCK files. Specifically, it affects **I/O-related components** such as `AsyncBase`, `AsyncIO`, `SimpleAsyncIO`, `Epoll`, `EpollBackend`, `EventBasePoller`, `MuxIOThreadPoolExecutor`, `FsUtil`, and `HugePages`, along with various `folly/cli`, `folly/ext`, `folly/system`, and `folly/test` modules. The change ensures consistency in internal `folly` code, simplifying future maintenance and removing reliance on an outdated directory structure across a broad internal scope.

This commit **removes deprecated experimental `io_uring` shims** from the `folly/experimental/io/` module. Specifically, it deletes forwarding headers and BUCK targets for `IoUring.h`, `IoUringProvidedBufferRing.h`, `IoUringEvent.h`, and `IoUringEventBaseLocal.h`. This **cleanup** completes the migration of all consumers to the direct `folly/io/async/` implementations, simplifying the codebase without affecting functionality. The **maintenance** work ensures that the `folly` library no longer carries these obsolete experimental components, streamlining the `folly/io` subsystem.