UT[bmqt::UriParser]: add multi-threading benchmark (#1013)

Signed-off-by: Evgeny Malygin <[email protected]>

Author: 678098

src/groups/bmq/bmqt/bmqt_uri.t.cpp

@@ -22,17 +22,23 @@
 // BDE
 #include <ball_log.h>
 #include <bdlf_bind.h>
+#include <bdlma_localsequentialallocator.h>
 #include <bsl_string.h>
 #include <bsl_utility.h>
 #include <bsl_vector.h>
 #include <bslh_defaulthashalgorithm.h>
 #include <bslh_hash.h>
 #include <bslmt_barrier.h>
+#include <bslmt_latch.h>
 #include <bslmt_threadgroup.h>
 
 // TEST DRIVER
 #include <bmqtst_testhelper.h>
-#include <bsl_functional.h>
+
+// BENCHMARKING LIBRARY
+#ifdef BMQTST_BENCHMARK_ENABLED
+#include <benchmark/benchmark.h>
+#endif
 
 // CONVENIENCE
 using namespace BloombergLP;
@@ -647,6 +653,123 @@ static void test7_testLongUri()
     bmqt::UriParser::shutdown();
 }
 
+#ifdef BMQTST_BENCHMARK_ENABLED
+
+struct UriParserBenchmark {
+    static void bench(bslmt::Latch*   initLatch_p,
+                      bslmt::Barrier* startBarrier_p,
+                      bslmt::Latch*   finishLatch_p)
+    {
+        // PRECONDITIONS
+        BSLS_ASSERT_OPT(initLatch_p);
+        BSLS_ASSERT_OPT(startBarrier_p);
+        BSLS_ASSERT_OPT(finishLatch_p);
+
+        const size_t      k_NUM_ITERATIONS = 100000;
+        const bsl::string k_SAMPLE_URI(
+            "bmq://my.sample.domain.~dev/my-queue-name?id=consumer123",
+            bmqtst::TestHelperUtil::allocator());
+
+        bmqt::Uri   uri(bmqtst::TestHelperUtil::allocator());
+        bsl::string error(bmqtst::TestHelperUtil::allocator());
+
+        initLatch_p->arrive();
+        startBarrier_p->wait();
+
+        for (size_t i = 0; i < k_NUM_ITERATIONS; ++i) {
+            bmqt::UriParser::parse(&uri, &error, k_SAMPLE_URI);
+        }
+
+        finishLatch_p->arrive();
+    }
+};
+
+struct UriConstructorBenchmark {
+    static void bench(bslmt::Latch*   initLatch_p,
+                      bslmt::Barrier* startBarrier_p,
+                      bslmt::Latch*   finishLatch_p)
+    {
+        // PRECONDITIONS
+        BSLS_ASSERT_OPT(initLatch_p);
+        BSLS_ASSERT_OPT(startBarrier_p);
+        BSLS_ASSERT_OPT(finishLatch_p);
+
+        const size_t      k_NUM_ITERATIONS = 100000;
+        const bsl::string k_SAMPLE_URI(
+            "bmq://my.sample.domain.~dev/my-queue-name?id=consumer123",
+            bmqtst::TestHelperUtil::allocator());
+
+        // Test allocator is slow and might skew the benchmarks
+        bdlma::LocalSequentialAllocator<256> lsa(
+            bmqtst::TestHelperUtil::allocator());
+
+        initLatch_p->arrive();
+        startBarrier_p->wait();
+
+        for (size_t i = 0; i < k_NUM_ITERATIONS; ++i) {
+            bmqt::Uri uri(k_SAMPLE_URI, &lsa);
+            (void)uri;
+        }
+
+        finishLatch_p->arrive();
+    }
+};
+
+template <size_t NUM_THREADS, typename BENCHMARK>
+static void testN1_benchmark(benchmark::State& state)
+// ------------------------------------------------------------------------
+// URI PERFORMANCE TEST
+//
+// Plan: spawn NUM_THREADS and measure the time taken for BENCHMARK::bench
+//
+// Testing:
+//  Performance
+// ------------------------------------------------------------------------
+{
+    bmqtst::TestHelper::printTestName("URI PERFORMANCE TEST");
+
+    bmqt::UriParser::initialize(bmqtst::TestHelperUtil::allocator());
+
+    bslmt::Latch   initThreadLatch(NUM_THREADS);
+    bslmt::Barrier startBenchmarkBarrier(NUM_THREADS + 1);
+    bslmt::Latch   finishBenchmarkLatch(NUM_THREADS);
+
+    bslmt::ThreadGroup threadGroup(bmqtst::TestHelperUtil::allocator());
+    for (size_t i = 0; i < NUM_THREADS; ++i) {
+        const int rc = threadGroup.addThread(
+            bdlf::BindUtil::bindS(bmqtst::TestHelperUtil::allocator(),
+                                  &(BENCHMARK::bench),
+                                  &initThreadLatch,
+                                  &startBenchmarkBarrier,
+                                  &finishBenchmarkLatch));
+        BMQTST_ASSERT_EQ_D(i, rc, 0);
+    }
+
+    initThreadLatch.wait();
+
+    size_t iter = 0;
+    for (auto _ : state) {
+        // Benchmark time start
+
+        // We don't support running multi-iteration benchmarks because we
+        // prepare and start complex tasks in separate threads.
+        // Once these tasks are finished, we cannot simply re-run them without
+        // reinitialization, and it goes against benchmark library design.
+        // Make sure we run this only once.
+        BSLS_ASSERT_OPT(0 == iter++ && "Must be run only once");
+
+        startBenchmarkBarrier.wait();
+        finishBenchmarkLatch.wait();
+
+        // Benchmark time end
+    }
+
+    threadGroup.joinAll();
+    bmqt::UriParser::shutdown();
+}
+
+#endif  // BMQTST_BENCHMARK_ENABLED
+
 // ============================================================================
 //                                 MAIN PROGRAM
 // ----------------------------------------------------------------------------
@@ -664,6 +787,50 @@ int main(int argc, char* argv[])
     case 3: test3_URIBuilderMultiThreaded(); break;
     case 2: test2_URIBuilder(); break;
     case 1: test1_breathingTest(); break;
+    case -1: {
+#ifdef BMQTST_BENCHMARK_ENABLED
+        BENCHMARK(testN1_benchmark<1, UriParserBenchmark>)
+            ->Name("bmqt::UriParser::parse threads=1")
+            ->Iterations(1)
+            ->Unit(benchmark::kMillisecond);
+        BENCHMARK(testN1_benchmark<2, UriParserBenchmark>)
+            ->Name("bmqt::UriParser::parse threads=2")
+            ->Iterations(1)
+            ->Unit(benchmark::kMillisecond);
+        BENCHMARK(testN1_benchmark<4, UriParserBenchmark>)
+            ->Name("bmqt::UriParser::parse threads=4")
+            ->Iterations(1)
+            ->Unit(benchmark::kMillisecond);
+        BENCHMARK(testN1_benchmark<8, UriParserBenchmark>)
+            ->Name("bmqt::UriParser::parse threads=8")
+            ->Iterations(1)
+            ->Unit(benchmark::kMillisecond);
+
+        BENCHMARK(testN1_benchmark<1, UriConstructorBenchmark>)
+            ->Name("bmqt::Uri::Uri         threads=1")
+            ->Iterations(1)
+            ->Unit(benchmark::kMillisecond);
+        BENCHMARK(testN1_benchmark<2, UriConstructorBenchmark>)
+            ->Name("bmqt::Uri::Uri         threads=2")
+            ->Iterations(1)
+            ->Unit(benchmark::kMillisecond);
+        BENCHMARK(testN1_benchmark<4, UriConstructorBenchmark>)
+            ->Name("bmqt::Uri::Uri         threads=4")
+            ->Iterations(1)
+            ->Unit(benchmark::kMillisecond);
+        BENCHMARK(testN1_benchmark<8, UriConstructorBenchmark>)
+            ->Name("bmqt::Uri::Uri         threads=8")
+            ->Iterations(1)
+            ->Unit(benchmark::kMillisecond);
+
+        benchmark::Initialize(&argc, argv);
+        benchmark::RunSpecifiedBenchmarks();
+#else
+        cerr << "WARNING: BENCHMARK '" << _testCase
+             << "' IS NOT SUPPORTED ON THIS PLATFORM." << endl;
+        bmqtst::TestHelperUtil::testStatus() = -1;
+#endif  // BMQTST_BENCHMARK_ENABLED
+    } break;
     default: {
         cerr << "WARNING: CASE '" << _testCase << "' NOT FOUND." << endl;
         bmqtst::TestHelperUtil::testStatus() = -1;