Add a simple thrift_latency_test.cpp to verify oss thrift slowness issue

Summary:
This diff just added the experimental thrift_latency_test.cpp from facebook/folly#2559

With the oss build, this simple thrift call can take 6418ms
```
[root@0eb3f90dd235 fboss]# ./thrift_latency_test
Creating Thrift server...
I0116 22:30:33.090906 42865 ThriftServer.cpp:2060] Using randomly generated TLS ticket keys.
I0116 22:30:33.091259 42865 ThriftServer.cpp:988] Using resource pools on address/port [::1]:0: thrift flag: true, enable gflag: false, disable gflag: false, runtime actions:
I0116 22:30:33.091567 42865 ThriftServer.cpp:1538] Resource pools configured: 2
I0116 22:30:33.092444 42865 ThriftServer.cpp:746] ThriftServer listening on address/port: [::1]:37999
Server listening on port 37999
Making RPC call...
RPC call completed in 6418 ms
Result: lastAppliedInMs = 12345
ERROR: RPC took too long! Expected < 100ms
```

While in our internal build, the same test without using any FBOSS internal logic only take 16ms
```
❯❯❯ buck2 run fbcode//fboss/cli/fboss2/test:thrift_latency_test
Buck UI: https://www.internalfb.com/buck2/fc447728-e42e-45da-8e9b-a29ae80abeb5
Network: Up: 0B  Down: 0B
Command: run.
Time elapsed: 0.0s
BUILD SUCCEEDED - starting your binary
Creating Thrift server...
I0116 14:35:48.140404 328824 ThriftServer.cpp:2060] Using randomly generated TLS ticket keys.
I0116 14:35:48.142755 328824 ThriftServer.cpp:988] Using resource pools on address/port [::1]:0: thrift flag: true, enable gflag: false, disable gflag: false, runtime actions:
I0116 14:35:48.145723 328824 ThriftServer.cpp:1538] Resource pools configured: 2
I0116 14:35:48.281738 328824 ThriftServer.cpp:746] ThriftServer listening on address/port: [::1]:40581
Server listening on port 40581
Making RPC call...
RPC call completed in 16 ms
Result: lastAppliedInMs = 12345
OK: RPC latency is acceptable
```

This is a huge difference b.w OSS build and internal build: **6418ms vs 16ms**
As you can see in thrift_latency_test.cpp, we used `ScopedServerInterfaceThread` to spawn a simple fboss agent thrift server, then use `FbossCtrlAsyncClient` with `RocketClientChannel` to call a thrift function.
No FBOSS internal logic is used here.

I am suspecting there's performance discrepancy b/w our internal build and OSS build for fbthrift.

Based on the new comments from https://fb.workplace.com/groups/560979627394613/permalink/3541014286057784/
I asked Metamate to generate a similar test but use EpollBackend and IoUring to create a thrift server

Reviewed By: kevin645

Differential Revision: D90894498

fbshipit-source-id: c8d04d6434c7aca326bc33133d40f514ea8252bb

Author: joseph5wu

cmake/CliFboss2Test.cmake

@@ -86,3 +86,18 @@ target_link_libraries(fboss2_cmd_test
 )
 
 gtest_discover_tests(fboss2_cmd_test)
+
+# thrift_latency_test - Comprehensive backend comparison test
+#
+# This test demonstrates the performance difference between various EventBase
+# backends for Thrift RPC calls. It runs all three backends (LibEvent, Epoll,
+# IoUring) sequentially and reports average/max latency for each.
+add_executable(thrift_latency_test
+  fboss/cli/fboss2/test/thrift_latency_test.cpp
+)
+
+target_link_libraries(thrift_latency_test
+  ctrl_cpp2
+  Folly::folly
+  FBThrift::thriftcpp2
+)

fboss/cli/fboss2/test/BUCK

@@ -1,3 +1,4 @@
+load("@fbcode_macros//build_defs:cpp_binary.bzl", "cpp_binary")
 load("@fbcode_macros//build_defs:cpp_library.bzl", "cpp_library")
 load("@fbcode_macros//build_defs:cpp_unittest.bzl", "cpp_unittest")
 
@@ -154,3 +155,29 @@ cpp_unittest(
         ("boost", None, "boost_filesystem"),
     ],
 )
+
+# Thrift RPC Latency Test - Comprehensive Backend Comparison
+#
+# This test demonstrates the performance difference between various EventBase
+# backends for Thrift RPC calls. It runs all three backends (LibEvent, Epoll,
+# IoUring) sequentially and reports average/max latency for each.
+#
+# Run with: buck2 run fbcode//fboss/cli/fboss2/test:thrift_latency_test
+cpp_binary(
+    name = "thrift_latency_test",
+    srcs = [
+        "thrift_latency_test.cpp",
+    ],
+    deps = [
+        "//fboss/agent/if:ctrl-cpp2-services",
+        "//folly/executors:io_thread_pool_executor",
+        "//folly/init:init",
+        "//folly/io/async:async_base",
+        "//folly/io/async:async_socket",
+        "//folly/io/async:epoll_backend",
+        "//folly/io/async:event_base_manager",
+        "//thrift/lib/cpp2:server",
+        "//thrift/lib/cpp2/async:rocket_client_channel",
+        "//thrift/lib/cpp2/util:util",
+    ],
+)

fboss/cli/fboss2/test/thrift_latency_test.cpp

@@ -0,0 +1,308 @@
+/*
+ * Thrift RPC Latency Test - Comprehensive Backend Comparison
+ *
+ * This test demonstrates the performance difference between various EventBase
+ * backends for Thrift RPC calls. It reproduces the multi-second latency issue
+ * seen in OSS builds with libevent 2.x and validates the fixes.
+ *
+ * Usage:
+ *   # Internal build (Buck2):
+ *   buck2 run fbcode//fboss/cli/fboss2/test:thrift_latency_test
+ *
+ *   # OSS build (CMake):
+ *   ./thrift_latency_test
+ */
+
+#include <algorithm>
+#include <chrono>
+#include <iomanip>
+#include <iostream>
+#include <memory>
+#include <numeric>
+#include <thread>
+#include <vector>
+
+#include <folly/executors/IOThreadPoolExecutor.h>
+#include <folly/init/Init.h>
+#include <folly/io/async/AsyncSocket.h>
+#include <folly/io/async/EventBase.h>
+#include <folly/io/async/EventBaseManager.h>
+#include <thrift/lib/cpp2/async/RocketClientChannel.h>
+#include <thrift/lib/cpp2/server/ThriftServer.h>
+#include <thrift/lib/cpp2/util/ScopedServerInterfaceThread.h>
+
+// Conditionally include EpollBackend if available
+#if __has_include(<folly/io/async/EpollBackend.h>)
+#include <folly/io/async/EpollBackend.h>
+#define HAS_EPOLL_BACKEND 1
+#else
+#define HAS_EPOLL_BACKEND 0
+#endif
+
+#include "fboss/agent/if/gen-cpp2/FbossCtrl.h"
+
+using namespace facebook::fboss;
+using namespace apache::thrift;
+
+constexpr int kNumIterations = 10;
+constexpr int64_t kLatencyThresholdMs = 100;
+
+#if HAS_EPOLL_BACKEND
+// Get EventBase::Options configured to use EpollBackend
+folly::EventBase::Options getEpollEventBaseOptions() {
+  return folly::EventBase::Options{}.setBackendFactory(
+      []() -> std::unique_ptr<folly::EventBaseBackendBase> {
+        return std::make_unique<folly::EpollBackend>(
+            folly::EpollBackend::Options{});
+      });
+}
+
+// EventBaseManager that creates EventBases with EpollBackend
+folly::EventBaseManager& getEpollEventBaseManager() {
+  static folly::EventBaseManager manager(getEpollEventBaseOptions());
+  return manager;
+}
+#endif
+
+// Simple handler that returns a fixed timestamp
+class SimpleHandler : public apache::thrift::ServiceHandler<FbossCtrl> {
+ public:
+  void getConfigAppliedInfo(ConfigAppliedInfo& info) override {
+    info.lastAppliedInMs() = 12345;
+    info.lastColdbootAppliedInMs() = 0;
+  }
+};
+
+// Result of running a backend test
+struct BackendResult {
+  std::string name;
+  bool success;
+  std::vector<double> latenciesMs;
+  double avgLatencyMs;
+  double maxLatencyMs;
+  std::string errorMsg;
+};
+
+// Run latency test for a specific backend configuration
+BackendResult runBackendTest(
+    const std::string& backendName,
+    std::function<void(ThriftServer&)> configureServer) {
+  BackendResult result;
+  result.name = backendName;
+  result.success = true;
+
+  try {
+    auto handler = std::make_shared<SimpleHandler>();
+
+    // Keep executor alive for the lifetime of the server
+    std::shared_ptr<folly::IOThreadPoolExecutor> executor;
+
+    ScopedServerInterfaceThread::ServerConfigCb serverConfigCb =
+        [&configureServer, &executor](ThriftServer& server) {
+          configureServer(server);
+        };
+
+    ScopedServerInterfaceThread server(
+        handler, "::1", 0, std::move(serverConfigCb));
+
+    auto port = server.getAddress().getPort();
+    std::cout << "  Server started on port " << port << std::endl;
+
+    // Create client
+    auto client = server.newClient<apache::thrift::Client<FbossCtrl>>(
+        nullptr, RocketClientChannel::newChannel);
+
+    // Run multiple iterations
+    for (int i = 0; i < kNumIterations; ++i) {
+      auto start = std::chrono::steady_clock::now();
+
+      ConfigAppliedInfo info;
+      client->sync_getConfigAppliedInfo(info);
+
+      auto end = std::chrono::steady_clock::now();
+      // Use microseconds for sub-millisecond precision, convert to double ms
+      auto durationUs =
+          std::chrono::duration_cast<std::chrono::microseconds>(end - start)
+              .count();
+      double durationMs = durationUs / 1000.0;
+
+      result.latenciesMs.push_back(durationMs);
+      std::cout << std::fixed << std::setprecision(3);
+      std::cout << "    Iteration " << (i + 1) << ": " << durationMs << " ms"
+                << std::endl;
+    }
+
+    // Calculate statistics
+    double sum = std::accumulate(
+        result.latenciesMs.begin(), result.latenciesMs.end(), 0.0);
+    result.avgLatencyMs = sum / result.latenciesMs.size();
+    result.maxLatencyMs =
+        *std::max_element(result.latenciesMs.begin(), result.latenciesMs.end());
+
+  } catch (const std::exception& e) {
+    result.success = false;
+    result.errorMsg = e.what();
+    result.avgLatencyMs = 0;
+    result.maxLatencyMs = 0;
+  }
+
+  return result;
+}
+
+void printSeparator() {
+  std::cout << std::string(60, '-') << std::endl;
+}
+
+void printResult(const BackendResult& result) {
+  std::cout << std::endl;
+  std::cout << "  Results:" << std::endl;
+  if (result.success) {
+    std::cout << std::fixed << std::setprecision(2);
+    std::cout << "    Average latency: " << result.avgLatencyMs << " ms"
+              << std::endl;
+    std::cout << "    Max latency:     " << result.maxLatencyMs << " ms"
+              << std::endl;
+
+    if (result.avgLatencyMs > kLatencyThresholdMs) {
+      std::cout << "    Status: SLOW (avg > " << kLatencyThresholdMs << " ms)"
+                << std::endl;
+    } else {
+      std::cout << "    Status: OK (avg < " << kLatencyThresholdMs << " ms)"
+                << std::endl;
+    }
+  } else {
+    std::cout << "    Status: FAILED - " << result.errorMsg << std::endl;
+  }
+}
+
+int main(int argc, char** argv) {
+  folly::Init init(&argc, &argv);
+
+  std::cout << "========================================" << std::endl;
+  std::cout << "  Thrift RPC Latency Test" << std::endl;
+  std::cout << "  Iterations per backend: " << kNumIterations << std::endl;
+  std::cout << "========================================" << std::endl;
+  std::cout << std::endl;
+
+#if HAS_EPOLL_BACKEND
+  std::cout << "EpollBackend: available" << std::endl;
+#else
+  std::cout << "EpollBackend: NOT available" << std::endl;
+#endif
+  std::cout << std::endl;
+
+  std::vector<BackendResult> results;
+
+  // Test 1: LibEvent (default) backend
+  printSeparator();
+  std::cout << "[1/3] Testing LibEvent backend (default)..." << std::endl;
+  auto libeventResult =
+      runBackendTest("LibEvent", [](ThriftServer& /* server */) {
+        // No configuration needed - uses default libevent backend
+      });
+  printResult(libeventResult);
+  results.push_back(libeventResult);
+
+  // Test 2: Epoll backend
+  printSeparator();
+  std::cout << "[2/3] Testing Epoll backend..." << std::endl;
+#if HAS_EPOLL_BACKEND
+  auto epollResult = runBackendTest("Epoll", [](ThriftServer& server) {
+    auto& epollManager = getEpollEventBaseManager();
+    auto executor = std::make_shared<folly::IOThreadPoolExecutor>(
+        std::thread::hardware_concurrency(),
+        std::make_shared<folly::NamedThreadFactory>("ThriftIO"),
+        &epollManager,
+        folly::IOThreadPoolExecutor::Options().setEnableThreadIdCollection(
+            true));
+    server.setIOThreadPool(executor);
+  });
+  printResult(epollResult);
+  results.push_back(epollResult);
+#else
+  std::cout << "  SKIPPED - EpollBackend not available" << std::endl;
+  BackendResult epollSkipped;
+  epollSkipped.name = "Epoll";
+  epollSkipped.success = false;
+  epollSkipped.errorMsg = "EpollBackend not available";
+  results.push_back(epollSkipped);
+#endif
+
+  // Test 3: IoUring backend
+  printSeparator();
+  std::cout << "[3/3] Testing IoUring backend..." << std::endl;
+  auto iouringResult = runBackendTest("IoUring", [](ThriftServer& server) {
+    server.setPreferIoUring(true);
+    server.setUseDefaultIoUringExecutor(true);
+  });
+  printResult(iouringResult);
+  results.push_back(iouringResult);
+
+  // Print summary
+  printSeparator();
+  std::cout << std::endl;
+  std::cout << "========================================" << std::endl;
+  std::cout << "  Summary" << std::endl;
+  std::cout << "========================================" << std::endl;
+  std::cout << std::endl;
+
+  std::cout << std::left << std::setw(12) << "Backend" << std::right
+            << std::setw(12) << "Avg (ms)" << std::setw(12) << "Max (ms)"
+            << std::setw(12) << "Status" << std::endl;
+  std::cout << std::string(48, '-') << std::endl;
+
+  bool hasFailure = false;
+  for (const auto& r : results) {
+    std::cout << std::left << std::setw(12) << r.name;
+    if (r.success) {
+      std::cout << std::right << std::fixed << std::setprecision(2)
+                << std::setw(12) << r.avgLatencyMs << std::setw(12)
+                << r.maxLatencyMs;
+      if (r.avgLatencyMs > kLatencyThresholdMs) {
+        std::cout << std::setw(12) << "SLOW";
+        // LibEvent being slow is expected in OSS builds
+        if (r.name != "LibEvent") {
+          hasFailure = true;
+        }
+      } else {
+        std::cout << std::setw(12) << "OK";
+      }
+    } else {
+      std::cout << std::right << std::setw(12) << "N/A" << std::setw(12)
+                << "N/A" << std::setw(12) << "SKIP/FAIL";
+    }
+    std::cout << std::endl;
+  }
+
+  std::cout << std::endl;
+
+  if (hasFailure) {
+    std::cout << "ERROR: Non-libevent backend(s) showed high latency!"
+              << std::endl;
+    return 1;
+  }
+
+  // Check if libevent is slow but alternatives are fast
+  bool libeventSlow = libeventResult.success &&
+      libeventResult.avgLatencyMs > kLatencyThresholdMs;
+  bool hasWorkingAlternative = false;
+  for (const auto& r : results) {
+    if (r.name != "LibEvent" && r.success &&
+        r.avgLatencyMs <= kLatencyThresholdMs) {
+      hasWorkingAlternative = true;
+      break;
+    }
+  }
+
+  if (libeventSlow && hasWorkingAlternative) {
+    std::cout
+        << "Note: LibEvent backend is slow (expected in OSS builds with libevent 2.x)"
+        << std::endl;
+    std::cout
+        << "      Alternative backends (Epoll/IoUring) are working correctly."
+        << std::endl;
+  }
+
+  std::cout << "Test completed successfully." << std::endl;
+  return 0;
+}