perf(*): cache regex predicates with rc using router attribute

KAG-3182

Author: nowNick

.github/workflows/tests.yml

@@ -14,7 +14,7 @@ concurrency:
 jobs:
   tests:
     name: Tests
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-24.04
 
     strategy:
       matrix:

src/ast.rs

@@ -1,7 +1,7 @@
 use crate::schema::Schema;
 use cidr::IpCidr;
 use regex::Regex;
-use std::net::IpAddr;
+use std::{net::IpAddr, rc::Rc};
 
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
@@ -53,7 +53,7 @@ pub enum Value {
     IpAddr(IpAddr),
     Int(i64),
     #[cfg_attr(feature = "serde", serde(with = "serde_regex"))]
-    Regex(Regex),
+    Regex(Rc<Regex>),
 }
 
 impl PartialEq for Value {
@@ -137,7 +137,7 @@ pub struct Predicate {
 mod tests {
     use super::*;
     use crate::parser::parse;
-    use std::fmt;
+    use std::{collections::HashMap, fmt};
 
     impl fmt::Display for Expression {
         fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
@@ -240,6 +240,7 @@ mod tests {
 
     #[test]
     fn expr_op_and_prec() {
+        let mut regex_cache = HashMap::new();
         let tests = vec![
             ("a > 0", "(a > 0)"),
             ("a in \"abc\"", "(a in \"abc\")"),
@@ -271,13 +272,14 @@ mod tests {
             ),
         ];
         for (input, expected) in tests {
-            let result = parse(input).unwrap();
+            let result = parse(input, &mut regex_cache).unwrap();
             assert_eq!(result.to_string(), expected);
         }
     }
 
     #[test]
     fn expr_var_name_and_ip() {
+        let mut regex_cache = HashMap::new();
         let tests = vec![
             // ipv4_literal
             ("kong.foo in 1.1.1.1", "(kong.foo in 1.1.1.1)"),
@@ -298,13 +300,14 @@ mod tests {
             ),
         ];
         for (input, expected) in tests {
-            let result = parse(input).unwrap();
+            let result = parse(input, &mut regex_cache).unwrap();
             assert_eq!(result.to_string(), expected);
         }
     }
 
     #[test]
     fn expr_regex() {
+        let mut regex_cache = HashMap::new();
         let tests = vec![
             // regex_literal
             (
@@ -318,13 +321,14 @@ mod tests {
             ),
         ];
         for (input, expected) in tests {
-            let result = parse(input).unwrap();
+            let result = parse(input, &mut regex_cache).unwrap();
             assert_eq!(result.to_string(), expected);
         }
     }
 
     #[test]
     fn expr_digits() {
+        let mut regex_cache = HashMap::new();
         let tests = vec![
             // dec literal
             ("kong.foo.foo7 == 123", "(kong.foo.foo7 == 123)"),
@@ -340,13 +344,14 @@ mod tests {
             ("kong.foo.foo12 == -0123", "(kong.foo.foo12 == -83)"),
         ];
         for (input, expected) in tests {
-            let result = parse(input).unwrap();
+            let result = parse(input, &mut regex_cache).unwrap();
             assert_eq!(result.to_string(), expected);
         }
     }
 
     #[test]
     fn expr_transformations() {
+        let mut regex_cache = HashMap::new();
         let tests = vec![
             // lower
             (
@@ -360,13 +365,14 @@ mod tests {
             ),
         ];
         for (input, expected) in tests {
-            let result = parse(input).unwrap();
+            let result = parse(input, &mut regex_cache).unwrap();
             assert_eq!(result.to_string(), expected);
         }
     }
 
     #[test]
     fn expr_transformations_nested() {
+        let mut regex_cache = HashMap::new();
         let tests = vec![
             // lower + lower
             (
@@ -390,35 +396,37 @@ mod tests {
             ),
         ];
         for (input, expected) in tests {
-            let result = parse(input).unwrap();
+            let result = parse(input, &mut regex_cache).unwrap();
             assert_eq!(result.to_string(), expected);
         }
     }
 
     #[test]
     fn str_unicode_test() {
+        let mut regex_cache = HashMap::new();
         let tests = vec![
             // cjk chars
             ("t_msg in \"你好\"", "(t_msg in \"你好\")"),
             // 0xXXX unicode
             ("t_msg in \"\u{4f60}\u{597d}\"", "(t_msg in \"你好\")"),
         ];
         for (input, expected) in tests {
-            let result = parse(input).unwrap();
+            let result = parse(input, &mut regex_cache).unwrap();
             assert_eq!(result.to_string(), expected);
         }
     }
 
     #[test]
     fn rawstr_test() {
+        let mut regex_cache = HashMap::new();
         let tests = vec![
             // invalid escape sequence
             (r##"a == r#"/path/to/\d+"#"##, r#"(a == "/path/to/\d+")"#),
             // valid escape sequence
             (r##"a == r#"/path/to/\n+"#"##, r#"(a == "/path/to/\n+")"#),
         ];
         for (input, expected) in tests {
-            let result = parse(input).unwrap();
+            let result = parse(input, &mut regex_cache).unwrap();
             assert_eq!(result.to_string(), expected);
         }
     }

src/ffi/context.rs

@@ -158,8 +158,8 @@ pub unsafe extern "C" fn context_reset(context: &mut Context) {
 /// Violating any of the following constraints will result in undefined behavior:
 ///
 /// - `context` must be a valid pointer returned by [`context_new`],
-///    must be passed to [`router_execute`] before calling this function,
-///    and must not be reset by [`context_reset`] before calling this function.
+///   must be passed to [`router_execute`] before calling this function,
+///   and must not be reset by [`context_reset`] before calling this function.
 /// - If `uuid_hex` is not `NULL`, `uuid_hex` must be valid to read and write for
 ///   `16 * size_of::<u8>()` bytes, and it must be properly aligned.
 /// - If `matched_field` is not `NULL`,

src/ffi/expression.rs

@@ -3,6 +3,7 @@ use crate::ffi::ERR_BUF_MAX_LEN;
 use crate::schema::Schema;
 use bitflags::bitflags;
 use std::cmp::min;
+use std::collections::HashMap;
 use std::ffi;
 use std::os::raw::c_char;
 use std::slice::from_raw_parts_mut;
@@ -163,7 +164,7 @@ pub unsafe extern "C" fn expression_validate(
     let errbuf = from_raw_parts_mut(errbuf, ERR_BUF_MAX_LEN);
 
     // Parse the expression
-    let result = parse(atc).map_err(|e| e.to_string());
+    let result = parse(atc, &mut HashMap::new()).map_err(|e| e.to_string());
     if let Err(e) = result {
         let errlen = min(e.len(), *errbuf_len);
         errbuf[..errlen].copy_from_slice(&e.as_bytes()[..errlen]);

src/ffi/router.rs

@@ -80,13 +80,13 @@ pub unsafe extern "C" fn router_free(router: *mut Router) {
 ///
 /// - `router` must be a valid pointer returned by [`router_new`].
 /// - `uuid` must be a valid pointer to a C-style string, must be properly aligned,
-///    and must not have '\0' in the middle.
+///   and must not have '\0' in the middle.
 /// - `atc` must be a valid pointer to a C-style string, must be properly aligned,
-///    and must not have '\0' in the middle.
+///   and must not have '\0' in the middle.
 /// - `errbuf` must be valid to read and write for `errbuf_len * size_of::<u8>()` bytes,
-///    and it must be properly aligned.
+///   and it must be properly aligned.
 /// - `errbuf_len` must be valid to read and write for `size_of::<usize>()` bytes,
-///    and it must be properly aligned.
+///   and it must be properly aligned.
 #[no_mangle]
 pub unsafe extern "C" fn router_add_matcher(
     router: &mut Router,
@@ -135,7 +135,7 @@ pub unsafe extern "C" fn router_add_matcher(
 ///
 /// - `router` must be a valid pointer returned by [`router_new`].
 /// - `uuid` must be a valid pointer to a C-style string, must be properly aligned,
-///    and must not have '\0' in the middle.
+///   and must not have '\0' in the middle.
 #[no_mangle]
 pub unsafe extern "C" fn router_remove_matcher(
     router: &mut Router,
@@ -165,8 +165,8 @@ pub unsafe extern "C" fn router_remove_matcher(
 ///
 /// - `router` must be a valid pointer returned by [`router_new`].
 /// - `context` must be a valid pointer returned by [`context_new`],
-///    and must be reset by [`context_reset`] before calling this function
-///    if you want to reuse the same context for multiple matches.
+///   and must be reset by [`context_reset`] before calling this function
+///   if you want to reuse the same context for multiple matches.
 #[no_mangle]
 pub unsafe extern "C" fn router_execute(router: &Router, context: &mut Context) -> bool {
     router.execute(context)
@@ -180,9 +180,9 @@ pub unsafe extern "C" fn router_execute(router: &Router, context: &mut Context)
 ///
 /// - `router`: a pointer to the [`Router`] object returned by [`router_new`].
 /// - `fields`: a pointer to an array of pointers to the field names
-///    (NOT C-style strings) that are actually used in the router, which will be filled in.
-///    if `fields` is `NULL`, this function will only return the number of fields used
-///    in the router.
+///   (NOT C-style strings) that are actually used in the router, which will be filled in.
+///   if `fields` is `NULL`, this function will only return the number of fields used
+///   in the router.
 /// - `fields_len`: a pointer to an array of the length of each field name.
 ///
 /// # Lifetimes