Add Glushkov regex fast-path to libcudf

cpp/CMakeLists.txt

@@ -772,6 +772,7 @@ add_library(
   src/strings/merge/merge.cu
   src/strings/padding.cu
   src/strings/positions.cu
+  src/strings/regex/glushkov_regcomp.cpp
   src/strings/regex/regcomp.cpp
   src/strings/regex/regexec.cpp
   src/strings/regex/regex_program.cpp

cpp/benchmarks/string/contains.cpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2021-2025, NVIDIA CORPORATION.
+ * SPDX-FileCopyrightText: Copyright (c) 2021-2026, NVIDIA CORPORATION.
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -12,21 +12,49 @@
 
 #include <nvbench/nvbench.cuh>
 
+#include <utility>
+#include <vector>
+
+// create_string_column generates data from 10 hardcoded strings where only row 0
+// ("123 abc 4567890 DEFGHI 0987 5W43") is scattered at exactly hit_rate%.
+// All patterns below match ONLY row 0 (via the unique "5W" substring), so
+// the hit_rate parameter correctly controls the match frequency for every pattern.
 // longer pattern lengths demand more working memory per string
-std::string patterns[] = {"^\\d+ [a-z]+", "[A-Z ]+\\d+ +\\d+[A-Z]+\\d+$", "5W43"};
+// patterns 0 and 1 contain anchors (^ $) so Glushkov falls back to Thompson for those
+static std::vector<std::string> const patterns = {
+  "^\\d+ [a-z]+",                  // 0: anchor pattern (anchors ^ $)
+  "[A-Z ]+\\d+ +\\d+[A-Z]+\\d+$",  // 1: anchor pattern (anchors ^ $)
+  "5W43",                          // 2: simple literal (baseline)
+  "5[A-Z]\\d+",                    // 3: char class + quantifier (3 positions)
+  "5W43|X9Z8",                     // 4: alternation (8 positions; only "5W43" branch matches)
+  "5W4{1,3}",                      // 5: bounded repetition (5 positions)
+  "(?:5W){1,2}",                   // 6: non-capturing group + bounded rep (4 positions)
+  "5.4.",                          // 7: dot wildcard (4 positions)
+  ".+5W",                          // 8: late-failure stress (dot prefix):
+           //    '.' matches everything → phase 1 state never dies until "5W" found;
+           //    only row 0 has "5W" → hit_rate controls match frequency correctly
+};
 
 static void bench_contains(nvbench::state& state)
 {
   auto const num_rows      = static_cast<cudf::size_type>(state.get_int64("num_rows"));
   auto const row_width     = static_cast<cudf::size_type>(state.get_int64("row_width"));
   auto const pattern_index = static_cast<cudf::size_type>(state.get_int64("pattern"));
   auto const hit_rate      = static_cast<cudf::size_type>(state.get_int64("hit_rate"));
+  auto const engine        = state.get_string("engine");
+
+  // Patterns 0-1 contain anchors (^ $) which Glushkov doesn't support
+  if (engine == "glushkov" && pattern_index <= 1) {
+    state.skip("anchor pattern — Glushkov falls back to Thompson");
+    return;
+  }
 
   auto col   = create_string_column(num_rows, row_width, hit_rate);
   auto input = cudf::strings_column_view(col->view());
 
-  auto pattern = patterns[pattern_index];
-  auto program = cudf::strings::regex_program::create(pattern);
+  auto flags   = (engine == "glushkov") ? cudf::strings::regex_flags::GLUSHKOV
+                                        : cudf::strings::regex_flags::DEFAULT;
+  auto program = cudf::strings::regex_program::create(patterns[pattern_index], flags);
 
   state.add_global_memory_reads<nvbench::int8_t>(col->alloc_size());
   state.add_global_memory_writes<nvbench::int32_t>(input.size());
@@ -40,4 +68,5 @@ NVBENCH_BENCH(bench_contains)
   .add_int64_axis("row_width", {32, 64, 128, 256})
   .add_int64_axis("num_rows", {32768, 262144, 2097152})
   .add_int64_axis("hit_rate", {50, 100})  // percentage
-  .add_int64_axis("pattern", {0, 1, 2});
+  .add_int64_axis("pattern", {0, 1, 2, 3, 4, 5, 6, 7, 8})
+  .add_string_axis("engine", {"thompson", "glushkov"});

cpp/benchmarks/string/count.cpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2021-2025, NVIDIA CORPORATION.
+ * SPDX-FileCopyrightText: Copyright (c) 2021-2026, NVIDIA CORPORATION.
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -14,14 +14,36 @@
 
 #include <nvbench/nvbench.cuh>
 
-static std::string patterns[] = {"\\d+", "a"};
+#include <utility>
+#include <vector>
+
+// All patterns are Glushkov-compatible (no anchors ^ $ \b \B, all < 64 NFA positions).
+// Match-rate estimates for 32-char random ASCII strings (chars 32-126, ~90% ASCII):
+//   \d+              : ~97% of strings contain ≥1 digit run  (~3 matches/string)
+//   [a-z]+[A-Z]+     : ~92% of strings contain ≥1 lower→upper transition (~2 matches)
+//   [a-f]+|[0-5]+    : similar density to \d+ (~2 matches/string) -- exercises alternation
+//   [a-z][0-9]{0,3}[A-Z]: ~92% via the zero-digit case alone -- exercises gap transitions
+static std::vector<std::string> const patterns = {
+  "\\d+",                  // 0: char class + quantifier (baseline)
+  "a",                     // 1: simple literal
+  "[a-z]+[A-Z]+",          // 2: multi char-class sequence
+  "[a-f]+|[0-5]+",         // 3: alternation (comparable density to \d+)
+  "[a-z][0-9]{0,3}[A-Z]",  // 4: bounded repetition / gap transitions (7 positions)
+  ".+[0-9]",               // 5: late-failure stress (~97% hit rate, ~1 match/string):
+                           //    '.' matches all ASCII → phase 1 state never dies until digit
+                           //    found; O(n) two-phase search for both engines
+  "[a-z]+Z",               // 6: late-failure + low hit rate (~23% on 32-char strings,
+                           //    ~79% on 256-char strings); Glushkov skips ~73% of start
+                           //    positions via reach filter
+};
 
 static void bench_count(nvbench::state& state)
 {
   auto const num_rows      = static_cast<cudf::size_type>(state.get_int64("num_rows"));
   auto const min_width     = static_cast<cudf::size_type>(state.get_int64("min_width"));
   auto const max_width     = static_cast<cudf::size_type>(state.get_int64("max_width"));
   auto const pattern_index = static_cast<cudf::size_type>(state.get_int64("pattern"));
+  auto const engine        = state.get_string("engine");
 
   data_profile const table_profile = data_profile_builder().distribution(
     cudf::type_id::STRING, distribution_id::NORMAL, min_width, max_width);
@@ -30,8 +52,9 @@ static void bench_count(nvbench::state& state)
   cudf::strings_column_view input(table->view().column(0));
 
   auto const pattern = patterns[pattern_index];
-
-  auto prog = cudf::strings::regex_program::create(pattern);
+  auto const flags   = (engine == "glushkov") ? cudf::strings::regex_flags::GLUSHKOV
+                                              : cudf::strings::regex_flags::DEFAULT;
+  auto prog          = cudf::strings::regex_program::create(pattern, flags);
 
   state.set_cuda_stream(nvbench::make_cuda_stream_view(cudf::get_default_stream().value()));
   // gather some throughput statistics as well
@@ -48,4 +71,5 @@ NVBENCH_BENCH(bench_count)
   .add_int64_axis("min_width", {0})
   .add_int64_axis("max_width", {32, 64, 128, 256})
   .add_int64_axis("num_rows", {32768, 262144, 2097152})
-  .add_int64_axis("pattern", {0, 1});
+  .add_int64_axis("pattern", {0, 1, 2, 3, 4, 5, 6})
+  .add_string_axis("engine", {"thompson", "glushkov"});

cpp/benchmarks/string/replace_re.cpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2021-2025, NVIDIA CORPORATION.
+ * SPDX-FileCopyrightText: Copyright (c) 2021-2026, NVIDIA CORPORATION.
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -12,19 +12,53 @@
 
 #include <nvbench/nvbench.cuh>
 
+#include <utility>
+#include <vector>
+
+// All patterns are Glushkov-compatible (no anchors ^ $ \b \B, all < 64 NFA positions).
+// No capture groups in the patterns — for replace_with_backrefs the benchmark wraps
+// each pattern in a capture group at runtime so \1 references the whole match.
+// Match-rate estimates for 32-char random ASCII strings (chars 32-126, ~90% ASCII):
+//   \d+              : ~97% of strings contain ≥1 digit run  (~3 matches/string)
+//   [a-z]+[A-Z]+     : ~92% of strings contain ≥1 lower→upper transition (~2 matches)
+//   [a-f]+|[0-5]+    : similar density to \d+ (~2 matches/string) -- exercises alternation
+//   [a-z][0-9]{0,3}[A-Z]: ~92% via the zero-digit case alone -- exercises gap transitions
+static std::vector<std::string> const patterns = {
+  "\\d+",                  // 0: char class + quantifier (baseline)
+  "[a-z]+[A-Z]+",          // 1: multi char-class sequence
+  "[a-f]+|[0-5]+",         // 2: alternation (comparable density to \d+)
+  "[a-z][0-9]{0,3}[A-Z]",  // 3: bounded repetition / gap transitions (7 positions)
+  ".+[0-9]",               // 4: late-failure stress (~97% hit rate — quadratic for Glushkov):
+              //    '.' matches all ASCII → inner loop runs full string from every start
+  "[a-z]+Z",  // 5: late-failure + low hit rate (~23% on 32-char, ~79% on 256-char)
+};
+
 static void bench_replace(nvbench::state& state)
 {
-  auto const num_rows  = static_cast<cudf::size_type>(state.get_int64("num_rows"));
-  auto const min_width = static_cast<cudf::size_type>(state.get_int64("min_width"));
-  auto const max_width = static_cast<cudf::size_type>(state.get_int64("max_width"));
-  auto const rtype     = state.get_string("type");
+  auto const num_rows      = static_cast<cudf::size_type>(state.get_int64("num_rows"));
+  auto const min_width     = static_cast<cudf::size_type>(state.get_int64("min_width"));
+  auto const max_width     = static_cast<cudf::size_type>(state.get_int64("max_width"));
+  auto const pattern_index = static_cast<cudf::size_type>(state.get_int64("pattern"));
+  auto const rtype         = state.get_string("type");
+  auto const engine        = state.get_string("engine");
+
+  // replace_with_backrefs requires capture groups; Glushkov doesn't support extract/backrefs
+  if (engine == "glushkov" && rtype == "backref") {
+    state.skip("backref replace — Glushkov doesn't support capture groups");
+    return;
+  }
 
   data_profile const profile = data_profile_builder().distribution(
     cudf::type_id::STRING, distribution_id::NORMAL, min_width, max_width);
   auto const column = create_random_column(cudf::type_id::STRING, row_count{num_rows}, profile);
   cudf::strings_column_view input(column->view());
 
-  auto program = cudf::strings::regex_program::create("(\\d+)");
+  auto flags = (engine == "glushkov") ? cudf::strings::regex_flags::GLUSHKOV
+                                      : cudf::strings::regex_flags::DEFAULT;
+  // Wrap in a capture group for backref replace so \1 references the whole match
+  auto const pat =
+    (rtype == "backref") ? "(" + patterns[pattern_index] + ")" : patterns[pattern_index];
+  auto program = cudf::strings::regex_program::create(pat, flags);
 
   auto const data_size = column->alloc_size();
   state.add_global_memory_reads<nvbench::int8_t>(data_size);
@@ -48,4 +82,6 @@ NVBENCH_BENCH(bench_replace)
   .add_int64_axis("min_width", {0})
   .add_int64_axis("max_width", {32, 64, 128, 256})
   .add_int64_axis("num_rows", {32768, 262144, 2097152})
-  .add_string_axis("type", {"replace", "backref"});
+  .add_int64_axis("pattern", {0, 1, 2, 3, 4, 5})
+  .add_string_axis("type", {"replace", "backref"})
+  .add_string_axis("engine", {"thompson", "glushkov"});

cpp/benchmarks/string/split_re.cpp

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2023-2025, NVIDIA CORPORATION.
+ * SPDX-FileCopyrightText: Copyright (c) 2023-2026, NVIDIA CORPORATION.
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -14,13 +14,36 @@
 
 #include <nvbench/nvbench.cuh>
 
+#include <utility>
+#include <vector>
+
+// All patterns are Glushkov-compatible (no anchors ^ $ \b \B, all < 64 NFA positions).
+// Match-rate estimates for 32-char random ASCII strings (chars 32-126, ~90% ASCII):
+//   \d+              : ~97% of strings contain ≥1 digit run  (~3 matches/string)
+//   [a-z]+[A-Z]+     : ~92% of strings contain ≥1 lower→upper transition (~2 matches)
+//   [a-f]+|[0-5]+    : similar density to \d+ (~2 matches/string) -- exercises alternation
+//   [a-z][0-9]{0,3}[A-Z]: ~92% via the zero-digit case alone -- exercises gap transitions
+static std::vector<std::string> const patterns = {
+  "\\d+",                  // 0: char class + quantifier (baseline)
+  "[a-z]+[A-Z]+",          // 1: multi char-class sequence
+  "[a-f]+|[0-5]+",         // 2: alternation (comparable density to \d+)
+  "[a-z][0-9]{0,3}[A-Z]",  // 3: bounded repetition / gap transitions (7 positions)
+  ".+[0-9]",               // 4: late-failure stress (~97% hit rate — quadratic for Glushkov):
+              //    '.' matches all ASCII → inner loop runs full string from every start
+  "[a-z]+Z",  // 5: late-failure + low hit rate (~23% on 32-char, ~79% on 256-char)
+};
+
 static void bench_split(nvbench::state& state)
 {
-  auto const num_rows  = static_cast<cudf::size_type>(state.get_int64("num_rows"));
-  auto const min_width = static_cast<cudf::size_type>(state.get_int64("min_width"));
-  auto const max_width = static_cast<cudf::size_type>(state.get_int64("max_width"));
+  auto const num_rows      = static_cast<cudf::size_type>(state.get_int64("num_rows"));
+  auto const min_width     = static_cast<cudf::size_type>(state.get_int64("min_width"));
+  auto const max_width     = static_cast<cudf::size_type>(state.get_int64("max_width"));
+  auto const pattern_index = static_cast<cudf::size_type>(state.get_int64("pattern"));
+  auto const engine        = state.get_string("engine");
 
-  auto prog = cudf::strings::regex_program::create("\\d+");
+  auto flags = (engine == "glushkov") ? cudf::strings::regex_flags::GLUSHKOV
+                                      : cudf::strings::regex_flags::DEFAULT;
+  auto prog  = cudf::strings::regex_program::create(patterns[pattern_index], flags);
 
   data_profile const profile = data_profile_builder().distribution(
     cudf::type_id::STRING, distribution_id::NORMAL, min_width, max_width);
@@ -42,4 +65,6 @@ NVBENCH_BENCH(bench_split)
   .set_name("split_re")
   .add_int64_axis("min_width", {0})
   .add_int64_axis("max_width", {32, 64, 128, 256})
-  .add_int64_axis("num_rows", {32768, 262144, 2097152});
+  .add_int64_axis("num_rows", {32768, 262144, 2097152})
+  .add_int64_axis("pattern", {0, 1, 2, 3, 4, 5})
+  .add_string_axis("engine", {"thompson", "glushkov"});

cpp/include/cudf/strings/regex/flags.hpp

@@ -24,12 +24,15 @@ namespace strings {
  * and to match the Python flag values.
  */
 enum regex_flags : uint32_t {
-  DEFAULT     = 0,    ///< default
-  IGNORECASE  = 2,    ///< ignore case on matching all literal characters
-  MULTILINE   = 8,    ///< the '^' and '$' honor new-line characters
-  DOTALL      = 16,   ///< the '.' matching includes new-line characters
-  ASCII       = 256,  ///< use only ASCII when matching built-in character classes
-  EXT_NEWLINE = 512   ///< new-line matches extended characters
+  DEFAULT     = 0,     ///< default
+  IGNORECASE  = 2,     ///< ignore case on matching all literal characters
+  MULTILINE   = 8,     ///< the '^' and '$' honor new-line characters
+  DOTALL      = 16,    ///< the '.' matching includes new-line characters
+  ASCII       = 256,   ///< use only ASCII when matching built-in character classes
+  EXT_NEWLINE = 512,   ///< new-line matches extended characters
+  GLUSHKOV    = 1024,  ///< prefer Glushkov NFA (bit-parallel, no working memory);
+                       ///< automatically falls back to Thompson NFA when the pattern
+                       ///< contains assertions (^ $ \\b \\B) or has >64 positions
 };
 
 /**
@@ -87,6 +90,17 @@ constexpr bool is_ext_newline(regex_flags const f)
   return (f & regex_flags::EXT_NEWLINE) == regex_flags::EXT_NEWLINE;
 }
 
+/**
+ * @brief Returns true if the given flags request the Glushkov NFA engine.
+ *
+ * @param f Regex flags to check
+ * @return true if `f` includes GLUSHKOV
+ */
+constexpr bool is_glushkov(regex_flags const f)
+{
+  return (f & regex_flags::GLUSHKOV) == regex_flags::GLUSHKOV;
+}
+
 /**
  * @brief Capture groups setting
  *

cpp/src/strings/extract/extract.cu

@@ -79,8 +79,8 @@ std::unique_ptr<table> extract(strings_column_view const& input,
                                rmm::cuda_stream_view stream,
                                rmm::device_async_resource_ref mr)
 {
-  // create device object from regex_program
-  auto d_prog = regex_device_builder::create_prog_device(prog, stream);
+  // create device object from regex_program — extract() needs Thompson (Glushkov has no groups)
+  auto d_prog = regex_device_builder::create_prog_device(prog, stream, /*use_glushkov=*/false);
 
   auto const groups = d_prog->group_counts();
   CUDF_EXPECTS(groups > 0, "Group indicators not found in regex pattern");
@@ -151,8 +151,8 @@ std::unique_ptr<column> extract_single(strings_column_view const& input,
 {
   if (input.is_empty()) { return make_empty_column(type_id::STRING); }
 
-  // create device object from regex_program
-  auto d_prog = regex_device_builder::create_prog_device(prog, stream);
+  // create device object from regex_program — extract() needs Thompson (Glushkov has no groups)
+  auto d_prog = regex_device_builder::create_prog_device(prog, stream, /*use_glushkov=*/false);
 
   auto const groups = d_prog->group_counts();
   CUDF_EXPECTS(groups > 0, "capture groups not found in regex pattern", std::invalid_argument);

cpp/src/strings/extract/extract_all.cu

@@ -99,8 +99,8 @@ std::unique_ptr<column> extract_all_record(strings_column_view const& input,
   auto const strings_count = input.size();
   auto const d_strings     = column_device_view::create(input.parent(), stream);
 
-  // create device object from regex_program
-  auto d_prog = regex_device_builder::create_prog_device(prog, stream);
+  // create device object from regex_program — extract() needs Thompson (Glushkov has no groups)
+  auto d_prog = regex_device_builder::create_prog_device(prog, stream, /*use_glushkov=*/false);
 
   // The extract pattern should always include groups.
   auto const groups = d_prog->group_counts();