Add: NW benchmarks on GPU

Author: ashvardanian

scripts/bench_similarity.cpp

@@ -64,6 +64,7 @@ int main(int argc, char const **argv) {
 
         std::printf("Starting string similarity benchmarks...\n");
         bench_levenshtein(env);
+        bench_needleman_wunsch(env);
     }
     catch (std::exception const &e) {
         std::fprintf(stderr, "Failed with: %s\n", e.what());

scripts/bench_similarity.cu

@@ -64,6 +64,7 @@ int main(int argc, char const **argv) {
 
         std::printf("Starting string similarity benchmarks...\n");
         bench_levenshtein(env);
+        bench_needleman_wunsch(env);
     }
     catch (std::exception const &e) {
         std::fprintf(stderr, "Failed with: %s\n", e.what());

scripts/bench_similarity.cuh

@@ -40,7 +40,7 @@ struct similarities_callable {
         if (env.tokens.size() <= batch_size) throw std::runtime_error("Batch size is too large.");
     }
 
-    inline call_result_t operator()(std::size_t batch_index) noexcept(false) {
+    call_result_t operator()(std::size_t batch_index) noexcept(false) {
         std::size_t const batch_size = results.size();
         std::size_t const forward_token_index = (batch_index * batch_size) % (env.tokens.size() - batch_size);
         std::size_t const backward_token_index = env.tokens.size() - forward_token_index - batch_size;
@@ -49,10 +49,11 @@ struct similarities_callable {
                           {env.tokens.data() + backward_token_index, batch_size});
     }
 
-    inline call_result_t operator()(std::span<token_view_t const> a, std::span<token_view_t const> b) noexcept(false) {
+    call_result_t operator()(std::span<token_view_t const> a, std::span<token_view_t const> b) noexcept(false) {
         // Unpack the extra arguments from `std::tuple` into the engine call using `std::apply`
         sz::status_t status =
             std::apply([&](auto &&...rest) { return engine(a, b, results.data(), rest...); }, extra_args);
+        do_not_optimize(status);
 
         if (status != sz::status_t::success_k) throw std::runtime_error("Failed to compute Levenshtein distance.");
         do_not_optimize(results);
@@ -71,7 +72,7 @@ struct similarities_callable {
 };
 
 struct similarities_equality_t {
-    bool operator()(check_value_t const &a, check_value_t const &b) const {
+    bool operator()(check_value_t const &a, check_value_t const &b) const noexcept {
         similarities_t const &a_ = *reinterpret_cast<similarities_t const *>(a);
         similarities_t const &b_ = *reinterpret_cast<similarities_t const *>(b);
         if (a_.size() != b_.size()) return false;
@@ -133,10 +134,56 @@ void bench_levenshtein(environment_t const &env) {
         bench_result_t utf8_baseline = bench_unary(env, name_utf8_baseline, call_utf8_baseline).log();
 
 #if SZ_USE_ICE
-        bench_unary(env, "levenshtein_utf8_ice:batch"s + std::to_string(batch_size), call_baseline,
+        bench_unary(env, "levenshtein_utf8_ice:batch"s + std::to_string(batch_size), call_utf8_baseline,
                     similarities_callable<levenshtein_utf8_ice_t>(env, results_accelerated, batch_size),
                     callable_no_op_t {},        // preprocessing
                     similarities_equality_t {}) // equality check
+            .log(utf8_baseline);
+        scramble_accelerated_results();
+#endif
+    }
+}
+
+void bench_needleman_wunsch(environment_t const &env) {
+
+    using namespace std::string_literals; // for "s" suffix
+
+#if SZ_USE_CUDA
+    sz::gpu_specs_t specs = *sz::gpu_specs();
+#endif
+    std::vector<std::size_t> batch_sizes = {1024 / 32, 1024, 1024 * 32};
+#if SZ_DEBUG
+    batch_sizes = {1, 2, 32};
+#endif
+    similarities_t results_baseline, results_accelerated;
+
+    auto scramble_accelerated_results = [&] {
+        std::shuffle(results_accelerated.begin(), results_accelerated.end(), global_random_generator());
+    };
+
+    for (std::size_t batch_size : batch_sizes) {
+        results_baseline.resize(batch_size);
+        results_accelerated.resize(batch_size);
+
+        auto call_baseline = similarities_callable<needleman_wunsch_serial_t>(env, results_baseline, batch_size);
+        auto name_baseline = "needleman_wunsch_serial:batch"s + std::to_string(batch_size);
+        bench_result_t baseline = bench_unary(env, name_baseline, call_baseline).log();
+
+#if SZ_USE_ICE
+        bench_unary(env, "needleman_wunsch_ice:batch"s + std::to_string(batch_size), call_baseline,
+                    similarities_callable<needleman_wunsch_ice_t>(env, results_accelerated, batch_size),
+                    callable_no_op_t {},        // preprocessing
+                    similarities_equality_t {}) // equality check
+            .log(baseline);
+        scramble_accelerated_results();
+#endif
+
+#if SZ_USE_CUDA
+        bench_unary(env, "needleman_wunsch_cuda:batch"s + std::to_string(batch_size), call_baseline,
+                    similarities_callable<needleman_wunsch_cuda_t, sz::gpu_specs_t>(env, results_accelerated,
+                                                                                    batch_size, specs),
+                    callable_no_op_t {},        // preprocessing
+                    similarities_equality_t {}) // equality check
             .log(baseline);
         scramble_accelerated_results();
 #endif