Implement SIMD-based search function

Author: jkurdek

include/simd_search.h

@@ -0,0 +1,62 @@
+// NOLINTBEGIN(*)
+
+#ifndef SIMD_SEARCH_H_
+#define SIMD_SEARCH_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <string_view>
+
+#ifdef __ARM_NEON
+#include <arm_neon.h>
+#endif
+
+#ifdef __ARM_NEON
+inline bool simd_search4(std::string_view haystack, std::string_view needle) {
+    if (haystack.size() < 4) {
+        return false;
+    }
+    // Prepare the needle value and replicate it into a SIMD register.
+    const uint32_t needle_val = *reinterpret_cast<const uint32_t*>(needle.data());
+    const uint32x4_t needle_vec = vdupq_n_u32(needle_val);
+    // Set up pointers.
+    const char* data = haystack.data();
+    const size_t haystack_len = haystack.size();
+    const auto* curr = reinterpret_cast<const uint8_t*>(data);
+    const uint8_t* end = curr + haystack_len - 3;
+    while (curr + 16 <= end) {
+        uint8x16_t data0 = vld1q_u8(curr + 0);
+        uint8x16_t data1 = vld1q_u8(curr + 1);
+        uint8x16_t data2 = vld1q_u8(curr + 2);
+        uint8x16_t data3 = vld1q_u8(curr + 3);
+        uint32x4_t seq0 = vreinterpretq_u32_u8(data0);
+        uint32x4_t seq1 = vreinterpretq_u32_u8(data1);
+        uint32x4_t seq2 = vreinterpretq_u32_u8(data2);
+        uint32x4_t seq3 = vreinterpretq_u32_u8(data3);
+        uint32x4_t eq0 = vceqq_u32(seq0, needle_vec);
+        uint32x4_t eq1 = vceqq_u32(seq1, needle_vec);
+        uint32x4_t eq2 = vceqq_u32(seq2, needle_vec);
+        uint32x4_t eq3 = vceqq_u32(seq3, needle_vec);
+        uint32x4_t combined = vorrq_u32(vorrq_u32(eq0, eq1), vorrq_u32(eq2, eq3));
+        if (vmaxvq_u32(combined)) return true;
+        curr += 13;
+    }
+    while (curr <= end) {
+        if (*reinterpret_cast<const uint32_t*>(curr) == needle_val) {
+            return true;
+        }
+        ++curr;
+    }
+    return false;
+}
+#else
+#include <string>
+inline bool simd_search4(std::string_view haystack, std::string_view needle) {
+    // Fallback: use std::string_view::find.
+    return haystack.find(needle) != std::string_view::npos;
+}
+#endif
+
+#endif  // SIMD_SEARCH_H_
+
+// NOLINTEND(*)

src/sparser/sparser.cpp

@@ -22,6 +22,7 @@
 #include "node.h"
 #include "raw_filter.h"
 #include "rdtsc.h"
+#include "simd_search.h"
 
 EstimationResult Sparser::Calibrate(const std::vector<std::string_view>& input, const JsonQuery& json_query,
                                     const RawFilterData& rf_data) {
@@ -46,14 +47,14 @@ EstimationResult Sparser::Calibrate(const std::vector<std::string_view>& input,
                     auto idx = GetFlatIdx(conj_idx, pred_idx, rf_idx);
 
                     auto grepStart = rdtsc();
-                    auto find_result = json_row.find(rf);
+                    auto find_result = simd_search4(json_row, rf);
                     auto grepEnd = rdtsc();
 
                     const auto rf_runtime = static_cast<double>(grepEnd - grepStart);
                     total_rf_time += rf_runtime;
                     rf_count++;
 
-                    if (find_result != std::string_view::npos) {
+                    if (find_result) {
 #ifndef NDEBUG
                         std::cout << "Found: " << rf << "\n";
 #endif
@@ -91,10 +92,15 @@ void Sparser::Run(const std::string& input_path, const JsonQuery& json_query) {
 
     const auto& disjunction = json_query.GetDisjunction();
     auto rf_data = RawFilterQueryGenerator::GenerateRawFilters(disjunction);
+
+    auto calibrate_time_start = benchmark_start();
     auto estimation_result = Calibrate(sparser_input, json_query, rf_data);
+    auto calibrate_time = benchmark_stop(calibrate_time_start);
+    std::cout << "Calibration time: " << calibrate_time << '\n';
 
     auto cascade_builder = CascadeBuilder(disjunction, rf_data);
     auto valid_cascades = cascade_builder.GenerateValidCascades();
+    std::cout << "Generated " << valid_cascades.size() << " valid cascades\n";
 
     auto cascade_evaluator = CascadeEvaluator(estimation_result);
     double min_cost = std::numeric_limits<double>::max();
@@ -141,8 +147,8 @@ SparserSearchStats Sparser::SearchCascade(const std::vector<std::string_view>& i
         while (root->type == NodeType::INTER) {
             auto rf = rf_data.data.at(root->conjunction_idx).at(root->predicate_idx).at(root->raw_filter_idx);
 
-            auto find_result = record.find(rf);
-            if (find_result != std::string_view::npos) {
+            auto find_result = simd_search4(record, rf);
+            if (find_result) {
                 root = root->right;
             } else {
                 root = root->left;