Add RegExp cache, optimize CHAR_CLASS

JerryScript-DCO-1.0-Signed-off-by: László Langó [email protected]

Author: LaszloLango

jerry-core/ecma/operations/ecma-regexp-object.c

@@ -618,8 +618,8 @@ re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
 
         while (num_of_ranges)
         {
-          ecma_char_t ch1 = re_canonicalize ((ecma_char_t) re_get_value (&bc_p), is_ignorecase);
-          ecma_char_t ch2 = re_canonicalize ((ecma_char_t) re_get_value (&bc_p), is_ignorecase);
+          ecma_char_t ch1 = re_canonicalize (re_get_char (&bc_p), is_ignorecase);
+          ecma_char_t ch2 = re_canonicalize (re_get_char (&bc_p), is_ignorecase);
           JERRY_DDLOG ("num_of_ranges=%d, ch1=%d, ch2=%d, curr_ch=%d; ",
                        num_of_ranges, ch1, ch2, curr_ch);
 

jerry-core/parser/regexp/re-bytecode.c

@@ -420,8 +420,8 @@ re_dump_bytecode (re_bytecode_ctx_t *bc_ctx_p) /**< RegExp bytecode context */
         JERRY_DLOG ("%d", num_of_class);
         while (num_of_class)
         {
-          JERRY_DLOG (" %d", re_get_value (&bytecode_p));
-          JERRY_DLOG ("-%d", re_get_value (&bytecode_p));
+          JERRY_DLOG (" %d", re_get_char (&bytecode_p));
+          JERRY_DLOG ("-%d", re_get_char (&bytecode_p));
           num_of_class--;
         }
         JERRY_DLOG (", ");

jerry-core/parser/regexp/re-bytecode.h

@@ -31,6 +31,11 @@
  * @{
  */
 
+/**
+  * Size of the RegExp bytecode cache
+  */
+#define RE_CHACHE_SIZE 10u
+
 /**
  * RegExp opcodes
  */
@@ -116,4 +121,4 @@ void re_dump_bytecode (re_bytecode_ctx_t *bc_ctx);
  */
 
 #endif /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_REGEXP_BUILTIN */
-#endif RE_BYTECODE_H /* !RE_BYTECODE_H */
+#endif /* !RE_BYTECODE_H */

jerry-core/parser/regexp/re-compiler.c

@@ -41,12 +41,12 @@
  */
 static void
 re_append_char_class (void *re_ctx_p, /**< RegExp compiler context */
-                      uint32_t start, /**< character class range from */
-                      uint32_t end) /**< character class range to */
+                      ecma_char_t start, /**< character class range from */
+                      ecma_char_t end) /**< character class range to */
 {
   re_compiler_ctx_t *ctx_p = (re_compiler_ctx_t *) re_ctx_p;
-  re_append_u32 (ctx_p->bytecode_ctx_p, start);
-  re_append_u32 (ctx_p->bytecode_ctx_p, end);
+  re_append_char (ctx_p->bytecode_ctx_p, start);
+  re_append_char (ctx_p->bytecode_ctx_p, end);
   ctx_p->parser_ctx_p->num_of_classes++;
 } /* re_append_char_class */
 
@@ -202,7 +202,7 @@ re_insert_into_group_with_jump (re_compiler_ctx_t *re_ctx_p, /**< RegExp compile
 /**
  * Parse alternatives
  *
- * @return completion value
+ * @return ecma value
  *         Returned value must be freed with ecma_free_value
  */
 static ecma_value_t
@@ -438,14 +438,54 @@ re_parse_alternative (re_compiler_ctx_t *re_ctx_p, /**< RegExp compiler context
   return ret_value;
 } /* re_parse_alternative */
 
+static const re_compiled_code_t *re_cache[RE_CHACHE_SIZE];
+
+/**
+ * Search for the given pattern in the RegExp cache
+ *
+ * @return compiled bytecode - if found
+ *         NULL - otherwise
+ */
+static re_compiled_code_t *
+re_find_bytecode_in_cache (ecma_string_t *pattern_str_p, /**< pattern string */
+                           uint32_t *idx) /**< [out] index */
+{
+  uint32_t free_idx = RE_CHACHE_SIZE;
+
+  for (*idx = 0u; *idx < RE_CHACHE_SIZE && re_cache[*idx] != NULL; (*idx)++)
+  {
+    re_compiled_code_t *cached_bytecode_p = re_cache[*idx];
+
+    if ((cached_bytecode_p->flags >> ECMA_BYTECODE_REF_SHIFT) > 0)
+    {
+      ecma_string_t *cached_pattern_str_p;
+      cached_pattern_str_p = ECMA_GET_NON_NULL_POINTER (ecma_string_t, cached_bytecode_p->pattern_cp);
+
+      if (ecma_compare_ecma_strings (cached_pattern_str_p, pattern_str_p))
+      {
+        return re_cache[*idx];
+      }
+    }
+    else
+    {
+      /* mark as free, so it can be overridden if the cache is full */
+      free_idx = *idx;
+    }
+  }
+
+  *idx = free_idx;
+
+  return NULL;
+} /* re_find_bytecode_in_cache */
+
 /**
  * Compilation of RegExp bytecode
  *
- * @return completion value
+ * @return ecma value
  *         Returned value must be freed with ecma_free_value
  */
 ecma_value_t
-re_compile_bytecode (re_compiled_code_t **out_bytecode_p, /**< out:pointer to bytecode */
+re_compile_bytecode (re_compiled_code_t **out_bytecode_p, /**< [out] pointer to bytecode */
                      ecma_string_t *pattern_str_p, /**< pattern */
                      uint16_t flags) /**< flags */
 {
@@ -462,64 +502,83 @@ re_compile_bytecode (re_compiled_code_t **out_bytecode_p, /**< out:pointer to by
 
   re_ctx.bytecode_ctx_p = &bc_ctx;
 
-  lit_utf8_size_t pattern_str_size = ecma_string_get_size (pattern_str_p);
-  MEM_DEFINE_LOCAL_ARRAY (pattern_start_p, pattern_str_size, lit_utf8_byte_t);
+  uint32_t cache_idx;
+  *out_bytecode_p = re_find_bytecode_in_cache (pattern_str_p, &cache_idx);
 
-  ssize_t sz = ecma_string_to_utf8_string (pattern_str_p, pattern_start_p, (ssize_t) pattern_str_size);
-  JERRY_ASSERT (sz >= 0);
+  if (*out_bytecode_p != NULL)
+  {
+    ecma_bytecode_ref ((ecma_compiled_code_t *) *out_bytecode_p);
+  }
+  else
+  { /* not in the RegExp cache, so compile it */
+    lit_utf8_size_t pattern_str_size = ecma_string_get_size (pattern_str_p);
+    MEM_DEFINE_LOCAL_ARRAY (pattern_start_p, pattern_str_size, lit_utf8_byte_t);
 
-  re_parser_ctx_t parser_ctx;
-  parser_ctx.input_start_p = pattern_start_p;
-  parser_ctx.input_curr_p = pattern_start_p;
-  parser_ctx.input_end_p = pattern_start_p + pattern_str_size;
-  parser_ctx.num_of_groups = -1;
-  re_ctx.parser_ctx_p = &parser_ctx;
+    ssize_t sz = ecma_string_to_utf8_string (pattern_str_p, pattern_start_p, (ssize_t) pattern_str_size);
+    JERRY_ASSERT (sz >= 0);
 
-  /* 1. Parse RegExp pattern */
-  re_ctx.num_of_captures = 1;
-  re_append_opcode (&bc_ctx, RE_OP_SAVE_AT_START);
+    re_parser_ctx_t parser_ctx;
+    parser_ctx.input_start_p = pattern_start_p;
+    parser_ctx.input_curr_p = pattern_start_p;
+    parser_ctx.input_end_p = pattern_start_p + pattern_str_size;
+    parser_ctx.num_of_groups = -1;
+    re_ctx.parser_ctx_p = &parser_ctx;
 
-  ECMA_TRY_CATCH (empty, re_parse_alternative (&re_ctx, true), ret_value);
+    /* 1. Parse RegExp pattern */
+    re_ctx.num_of_captures = 1;
+    re_append_opcode (&bc_ctx, RE_OP_SAVE_AT_START);
 
-  /* 2. Check for invalid backreference */
-  if (re_ctx.highest_backref >= re_ctx.num_of_captures)
-  {
-    ret_value = ecma_raise_syntax_error ("Invalid backreference.\n");
-  }
-  else
-  {
-    re_append_opcode (&bc_ctx, RE_OP_SAVE_AND_MATCH);
-    re_append_opcode (&bc_ctx, RE_OP_EOF);
-
-    /* 3. Insert extra informations for bytecode header */
-    re_compiled_code_t re_compiled_code;
-
-    re_compiled_code.flags = re_ctx.flags | (1u << ECMA_BYTECODE_REF_SHIFT);
-    ECMA_SET_NON_NULL_POINTER (re_compiled_code.pattern_cp,
-                               ecma_copy_or_ref_ecma_string (pattern_str_p));
-    re_compiled_code.num_of_captures = re_ctx.num_of_captures * 2;
-    re_compiled_code.num_of_non_captures = re_ctx.num_of_non_captures;
-
-    re_bytecode_list_insert (&bc_ctx,
-                             0,
-                             (uint8_t *) &re_compiled_code,
-                             sizeof (re_compiled_code_t));
-  }
-  ECMA_FINALIZE (empty);
+    ECMA_TRY_CATCH (empty, re_parse_alternative (&re_ctx, true), ret_value);
 
-  MEM_FINALIZE_LOCAL_ARRAY (pattern_start_p);
+    /* 2. Check for invalid backreference */
+    if (re_ctx.highest_backref >= re_ctx.num_of_captures)
+    {
+      ret_value = ecma_raise_syntax_error ("Invalid backreference.\n");
+    }
+    else
+    {
+      re_append_opcode (&bc_ctx, RE_OP_SAVE_AND_MATCH);
+      re_append_opcode (&bc_ctx, RE_OP_EOF);
+
+      /* 3. Insert extra informations for bytecode header */
+      re_compiled_code_t re_compiled_code;
+
+      re_compiled_code.flags = re_ctx.flags | (1u << ECMA_BYTECODE_REF_SHIFT);
+      ECMA_SET_NON_NULL_POINTER (re_compiled_code.pattern_cp,
+                                 ecma_copy_or_ref_ecma_string (pattern_str_p));
+      re_compiled_code.num_of_captures = re_ctx.num_of_captures * 2;
+      re_compiled_code.num_of_non_captures = re_ctx.num_of_non_captures;
+
+      re_bytecode_list_insert (&bc_ctx,
+                               0,
+                               (uint8_t *) &re_compiled_code,
+                               sizeof (re_compiled_code_t));
+    }
+    ECMA_FINALIZE (empty);
 
-  if (!ecma_is_value_empty (ret_value))
-  {
-    /* Compilation failed, free bytecode. */
-    mem_heap_free_block (bc_ctx.block_start_p);
-    *out_bytecode_p = NULL;
-  }
-  else
-  {
-    /* The RegExp bytecode contains at least a RE_OP_SAVE_AT_START opdoce, so it cannot be NULL. */
-    JERRY_ASSERT (bc_ctx.block_start_p != NULL);
-    *out_bytecode_p = (re_compiled_code_t *) bc_ctx.block_start_p;
+    MEM_FINALIZE_LOCAL_ARRAY (pattern_start_p);
+
+    if (!ecma_is_value_empty (ret_value))
+    {
+      /* Compilation failed, free bytecode. */
+      mem_heap_free_block (bc_ctx.block_start_p);
+      *out_bytecode_p = NULL;
+    }
+    else
+    {
+      /* The RegExp bytecode contains at least a RE_OP_SAVE_AT_START opdoce, so it cannot be NULL. */
+      JERRY_ASSERT (bc_ctx.block_start_p != NULL);
+      *out_bytecode_p = (re_compiled_code_t *) bc_ctx.block_start_p;
+
+      if (cache_idx < RE_CHACHE_SIZE)
+      {
+        re_cache[cache_idx] = *out_bytecode_p;
+      }
+      else
+      {
+        JERRY_DDLOG ("RegExp cache is full! Cannot add new bytecode to it.");
+      }
+    }
   }
 
 #ifdef JERRY_ENABLE_LOG