Fix perf testing mode in katran_tester

Summary:
katran tester has perf tesing mode to meause time took for running xdp program for input packet. This flow was broken and needed some fixes:
1. Updates to the script, selected gue mode
2. Fix calls to bpf_prog_test_run with repeat argument. Repeat isn't useful if we xdp prog modifies packet inline, the next runs sees updated packet and skips it
3. Skip LRU for test vips. This way we run same bpf instructions on every repeat run
4. Added printing results in a neat table, sorted by duration. This way we can check the most expensive input packet, in terms of processing time in XDP

Reviewed By: tagrawal03

Differential Revision: D81096115

fbshipit-source-id: a3ee4977a59c90f44496831baae3c3269c500d91

Author: nikhildl12

katran/lib/testing/framework/BpfTester.cpp

@@ -100,6 +100,7 @@ void BpfTester::testPcktsFromPcap() {
       VLOG(2) << "we have read all the packets from pcap file";
       break;
     }
+
     auto res = adapter_.testXdpProg(
         config_.bpfProgFd,
         kTestRepeatCount,
@@ -413,50 +414,79 @@ void BpfTester::resetTestFixtures(const std::vector<PacketAttributes>& data) {
   config_.testData = data;
 }
 
-void BpfTester::testPerfFromFixture(uint32_t repeat, const int position) {
+std::vector<TestResult> BpfTester::testPerfFromFixture(
+    uint32_t repeat,
+    const int position) {
   // for inputData format is <pckt_base64, test description>
   int first_index{0}, last_index{0};
-  uint32_t duration{0};
-  uint64_t pckt_num{1};
-  std::string ret_val_str;
-  std::string test_result;
   if (position < 0 || position >= config_.testData.size()) {
     first_index = 0;
     last_index = config_.testData.size();
   } else {
     first_index = position;
     last_index = first_index + 1;
   }
+
+  std::vector<TestResult> results;
+
+  // Run all tests and collect results
   for (int i = first_index; i < last_index; i++) {
-    auto buf = folly::IOBuf::create(kMaxXdpPcktSize);
-    auto input_pckt =
-        parser_.getPacketFromBase64(config_.testData[i].inputPacket);
+    auto single_results = runXdpProgPerf(
+        config_.testData[i].inputPacket,
+        config_.testData[i].description,
+        repeat);
+    results.insert(results.end(), single_results.begin(), single_results.end());
+  }
+  return results;
+}
+
+std::vector<TestResult> BpfTester::runXdpProgPerf(
+    const std::string& input_packet,
+    const std::string& description,
+    uint32_t repeat) {
+  std::vector<TestResult> results;
+  results.reserve(repeat); // Pre-allocate capacity
+
+  auto buf = folly::IOBuf::create(kMaxXdpPcktSize);
+  uint32_t output_pckt_size{0};
+
+  auto input_pckt = parser_.getPacketFromBase64(input_packet);
+
+  // Passing repeat directly to testXdpProg() will cause the input_pckt to be
+  // modified with the first run and the subsequent runs will see the encaped
+  // packet. For more acurate perf runs, we call testXdpProg() repeatedly with
+  // repeat = 1
+
+  uint32_t total_duration = 0;
+  for (uint32_t run = 0; run < repeat; ++run) {
+    uint32_t duration{0};
     auto res = adapter_.testXdpProg(
         config_.bpfProgFd,
-        repeat,
+        1, // repeat = 1
         input_pckt->writableData(),
         input_pckt->length(),
         buf->writableData(),
-        nullptr, // output pckt size
+        &output_pckt_size,
         nullptr, // retval
         &duration);
+
     if (res < 0) {
-      LOG(INFO) << "failed to run bpf test on pckt #" << pckt_num;
-      ++pckt_num;
-      continue;
+      LOG(ERROR) << "failed to run bpf test on run #" << run;
+      break;
     }
-    VLOG(2) << "pckt #" << pckt_num;
+    total_duration += duration;
+
     if (duration == 0) {
       duration = 1;
     }
-    auto pps = kNanosecInSec / duration;
-    LOG(INFO) << fmt::format(
-        "Test: {:60} duration: {:10} ns/pckt or {} pps",
-        config_.testData[i].description,
-        duration,
-        pps);
-    ++pckt_num;
   }
+  if (repeat > 0) {
+    auto avgDuration = total_duration / repeat;
+    auto pps = kNanosecInSec / avgDuration;
+    auto pps_millions = static_cast<double>(pps) / 1000000.0;
+    results.push_back({description, avgDuration, pps_millions});
+  }
+  return results;
 }
 
 uint64_t BpfTester::getGlobalLruRoutedPackets() {

katran/lib/testing/framework/BpfTester.h

@@ -28,6 +28,13 @@
 
 namespace katran {
 
+// Structure to hold test results for perf testing runs
+struct TestResult {
+  std::string description;
+  uint32_t duration;
+  double pps_millions;
+};
+
 /**
  * structure with config params for BpfTester.
  */
@@ -151,8 +158,11 @@ class BpfTester {
    * @param int position    of the packet if fixtures vector.
    * helper function to run perf test on specified packet from test fixtures
    * if position is negative - run perf tests on every packet in fixtures
+   * @return std::vector<TestResult> results from the performance tests
    */
-  void testPerfFromFixture(uint32_t repeat, const int position = -1);
+  std::vector<TestResult> testPerfFromFixture(
+      uint32_t repeat,
+      const int position = -1);
 
   /**
    * @param IOBuf with packet data to write.
@@ -184,6 +194,18 @@ class BpfTester {
       const std::string& actualPacket,
       const std::string& expectedPacket);
 
+  /**
+   * @param const std::string& input_packet base64 encoded input packet
+   * @param const std::string& description test description for the results
+   * @param uint32_t repeat how many times to repeat the test
+   * helper function to run performance tests in a loop with repeat=1 and return
+   * results
+   */
+  std::vector<struct TestResult> runXdpProgPerf(
+      const std::string& input_packet,
+      const std::string& description,
+      uint32_t repeat);
+
   TesterConfig config_;
   PcapParser parser_;
   BpfAdapter adapter_;

katran/lib/testing/framework/katran_tester.cpp

@@ -248,6 +248,78 @@ KatranTestParam getTestParam() {
   }
 }
 
+// Function to print performance test results in a formatted table
+// sorted by duration in descending order
+void printPerfResults(std::vector<katran::TestResult>& results) {
+  if (results.empty()) {
+    std::cout << "No performance test results to display." << std::endl;
+    return;
+  }
+  // Sort results by duration in descending order (largest on top)
+  std::sort(
+      results.begin(),
+      results.end(),
+      [](const katran::TestResult& a, const katran::TestResult& b) {
+        return a.duration > b.duration;
+      });
+
+  // Calculate dynamic column widths
+  constexpr int duration_width = 12;
+  constexpr int pps_width = 12;
+  constexpr int min_desc_width = 40;
+  constexpr int max_desc_width = 80;
+
+  // Find the longest description to determine optimal width
+  int max_desc_len = 0;
+  for (const auto& result : results) {
+    max_desc_len =
+        std::max(max_desc_len, static_cast<int>(result.description.length()));
+  }
+
+  int desc_width =
+      std::max(min_desc_width, std::min(max_desc_width, max_desc_len));
+
+  // Print table header
+  std::cout << "+" << std::string(desc_width + 2, '-') << "+"
+            << std::string(duration_width + 2, '-') << "+"
+            << std::string(pps_width + 2, '-') << "+" << std::endl;
+  std::cout << fmt::format(
+                   "| {:<{}} | {:>{}} | {:>{}} |",
+                   "Test Description",
+                   desc_width,
+                   "Duration",
+                   duration_width,
+                   "PPS",
+                   pps_width)
+            << std::endl;
+  std::cout << "+" << std::string(desc_width + 2, '-') << "+"
+            << std::string(duration_width + 2, '-') << "+"
+            << std::string(pps_width + 2, '-') << "+" << std::endl;
+
+  // Print sorted results
+  for (const auto& result : results) {
+    // Truncate description if it's too long
+    std::string desc = result.description;
+    if (desc.length() > desc_width) {
+      desc = desc.substr(0, desc_width - 3) + "...";
+    }
+
+    std::cout << fmt::format(
+                     "| {:<{}} | {:>{}} ns | {:>8.2f} Mpps |",
+                     desc,
+                     desc_width,
+                     result.duration,
+                     duration_width - 3,
+                     result.pps_millions)
+              << std::endl;
+  }
+
+  // Print table footer
+  std::cout << "+" << std::string(desc_width + 2, '-') << "+"
+            << std::string(duration_width + 2, '-') << "+"
+            << std::string(pps_width + 2, '-') << "+" << std::endl;
+}
+
 int main(int argc, char** argv) {
   gflags::ParseCommandLineFlags(&argc, &argv, true);
   google::InitGoogleLogging(argv[0]);
@@ -321,14 +393,15 @@ int main(int argc, char** argv) {
     }
     return 0;
   }
-  prepareLbData(*lb);
+  prepareLbData(*lb, FLAGS_perf_testing);
   if (!FLAGS_pcap_input.empty()) {
     tester.testPcktsFromPcap();
     return 0;
   } else if (FLAGS_perf_testing) {
     // for perf tests to work katran must be compiled w -DINLINE_DECAP
     preparePerfTestingLbData(*lb);
-    tester.testPerfFromFixture(FLAGS_repeat, FLAGS_position);
+    auto results = tester.testPerfFromFixture(FLAGS_repeat, FLAGS_position);
+    printPerfResults(results);
   }
   return 0;
 }

katran/lib/testing/utils/KatranTestProvision.cpp

@@ -105,32 +105,45 @@ void addQuicMappings(katran::KatranLb& lb) {
   lb.modifyQuicRealsMapping(action, qreals);
 }
 
-void prepareLbData(katran::KatranLb& lb) {
+void prepareLbData(katran::KatranLb& lb, bool skipLru) {
   lb.restartKatranMonitor(kMonitorLimit);
   katran::VipKey vip;
   // adding udp vip for tests
   vip.address = "10.200.1.1";
   vip.port = kVipPort;
   vip.proto = kUdp;
   lb.addVip(vip);
+  if (skipLru) {
+    LOG(INFO) << "Skipping LRU lookup for vip " << vip.address;
+    lb.modifyVip(vip, kBypassLruLookup);
+  }
   // adding few reals to test
   std::vector<std::string> reals = {"10.0.0.1", "10.0.0.2", "10.0.0.3"};
   std::vector<std::string> reals6 = {"fc00::1", "fc00::2", "fc00::3"};
   addReals(lb, vip, reals);
   // adding tcp vip for tests
   vip.proto = kTcp;
   lb.addVip(vip);
+  if (skipLru) {
+    lb.modifyVip(vip, kBypassLruLookup);
+  }
   // adding few reals to test
   addReals(lb, vip, reals);
   // vip which ignores dst_port (testing for TURN-like services)
   vip.address = "10.200.1.2";
   vip.port = 0;
   lb.addVip(vip);
+  if (skipLru) {
+    lb.modifyVip(vip, kBypassLruLookup);
+  }
   // adding few reals to test
   addReals(lb, vip, reals);
   // vip which is using only dst port to pick up real
   vip.address = "10.200.1.4";
   lb.addVip(vip);
+  if (skipLru) {
+    lb.modifyVip(vip, kBypassLruLookup);
+  }
   // adding few reals to test
   addReals(lb, vip, reals);
   lb.modifyVip(vip, kDportHash);
@@ -143,6 +156,9 @@ void prepareLbData(katran::KatranLb& lb) {
   // v6inv6 vip. tcp
   vip.address = "fc00:1::1";
   lb.addVip(vip);
+  if (skipLru) {
+    lb.modifyVip(vip, kBypassLruLookup);
+  }
   // adding few reals to test
   addReals(lb, vip, reals6);
   // adding mappings for quic.
@@ -152,18 +168,27 @@ void prepareLbData(katran::KatranLb& lb) {
   vip.port = 443;
   vip.address = "10.200.1.5";
   lb.addVip(vip);
+  if (skipLru) {
+    lb.modifyVip(vip, kBypassLruLookup);
+  }
   lb.modifyVip(vip, kQuicVip);
   addReals(lb, vip, reals);
   // adding quic v6 vip.
   vip.address = "fc00:1::2";
   lb.addVip(vip);
+  if (skipLru) {
+    lb.modifyVip(vip, kBypassLruLookup);
+  }
   lb.modifyVip(vip, kQuicVip);
   addReals(lb, vip, reals6);
   // adding udp with flow migration vip for tests
   vip.address = "10.200.1.6";
   vip.port = kVipPort;
   vip.proto = kUdp;
   lb.addVip(vip);
+  if (skipLru) {
+    lb.modifyVip(vip, kBypassLruLookup);
+  }
   lb.modifyVip(vip, kUdpFlowMigration);
   addReals(lb, vip, reals);
   // setting a real to be down

katran/lib/testing/utils/KatranTestProvision.h

@@ -44,6 +44,9 @@ constexpr uint32_t kDefaultWeight = 1;
 // Flags from katran/lib/bpf/balancer_consts.h
 // real is specified as local (1 << 1)
 constexpr uint8_t kLocalReal = 2;
+
+// F_LRU_BYPASS
+constexpr uint32_t kBypassLruLookup = 2; // (1 << 1)
 // use quic's connection id for the hash calculation (1 << 2)
 constexpr uint32_t kQuicVip = 4;
 // use only dst port for the hash calculation (1 << 3)
@@ -166,7 +169,7 @@ void deleteReals(
 
 void addQuicMappings(katran::KatranLb& lb);
 
-void prepareLbData(katran::KatranLb& lb);
+void prepareLbData(katran::KatranLb& lb, bool skipLru = false);
 
 void prepareOptionalLbData(katran::KatranLb& lb);