Speed up GTG Simulator by reducing slices/matches

At a high level, the while loop in `#memos` breaks up the string into
parts where each part is one of the three "special characters" or a
group of consecutive characters that aren't one of those "special
characters". However, the current implementation does a lot of duplicate
or unnecessary work.

The StringScanner allocates the scanned string, but then only uses its
length. The string is then re-allocated with `#slice` inside `#move`.
Additionally, because the StringScanner scans for both the "special
characters" and non-"special characters" cases, `#move` has to `#match?` to
figure out which of the two cases was scanned.

This commit improves the performance of routing by 25-35% in simple
cases by removing the duplication and preventing excess string
allocations. The improvement is larger for routes with more children or
deeper in the tree.

The StringScanner is replaced with manually iterating through the string
to look for the three "special characters". This prevents string
allocations from scanning and also prevents Regexp matching (since there
is no more StringScanner), which is slower than the lookup table. The
only time a string is allocated is now the non "special character" case.
Additionally, the `#match?` inside `#move` is replaced with a boolean
parameter because the two match cases are now distinct, and that
information can be passed on instead of checking a second time.

Benchmark:

```ruby
require "action_dispatch"
require "benchmark/ips"

routes = ActionDispatch::Routing::RouteSet.new
routes.draw do
  get "/products", to: ->(e) { [200, {}, ["p"]] }
  get "/products/:id", to: ->(e) { [200, {}, ["pid"]] }
  get "/collections", to: ->(e) { [200, {}, ["c"]] }
  get "/collections/:id/products", to: ->(e) { [200, {}, ["cidp"]] }
end

stage = ENV.fetch("STAGE", "before")

requests = {
  index: {
    "REQUEST_METHOD" => "GET",
    "PATH_INFO" => "/products",
    "SCRIPT_NAME" => "",
    "rack.input" => File.open("/dev/null"),
  }.freeze,

  show: {
    "REQUEST_METHOD" => "GET",
    "PATH_INFO" => "/products/1",
    "SCRIPT_NAME" => "",
    "rack.input" => File.open("/dev/null"),
  }.freeze,

  show_nested: {
    "REQUEST_METHOD" => "GET",
    "PATH_INFO" => "/collections/1/products",
    "SCRIPT_NAME" => "",
    "rack.input" => File.open("/dev/null"),
  }.freeze,
}.each do |name, env|
  puts "== #{name} =="
  Benchmark.ips do |x|
    x.report(stage) { routes.call(env.dup) }
    x.save!("/tmp/action_dispatch_#{name}")
    x.compare!(order: :baseline)
  end
end
```

```
== index ==
ruby 3.4.1 (2024-12-25 revision 48d4efcb85) +YJIT +PRISM [arm64-darwin23]
Warming up --------------------------------------
               after    33.759k i/100ms
Calculating -------------------------------------
               after    338.664k (± 0.4%) i/s    (2.95 μs/i) -      1.722M in   5.083918s

Comparison:
              before:   269469.3 i/s
               after:   338664.4 i/s - 1.26x  faster

== show ==
ruby 3.4.1 (2024-12-25 revision 48d4efcb85) +YJIT +PRISM [arm64-darwin23]
Warming up --------------------------------------
               after    25.635k i/100ms
Calculating -------------------------------------
               after    257.573k (± 0.3%) i/s    (3.88 μs/i) -      1.307M in   5.075826s

Comparison:
              before:   194468.2 i/s
               after:   257572.6 i/s - 1.32x  faster

== show_nested ==
ruby 3.4.1 (2024-12-25 revision 48d4efcb85) +YJIT +PRISM [arm64-darwin23]
Warming up --------------------------------------
               after    22.175k i/100ms
Calculating -------------------------------------
               after    222.257k (± 2.4%) i/s    (4.50 μs/i) -      1.131M in   5.091618s

Comparison:
              before:   165457.3 i/s
               after:   222256.8 i/s - 1.34x  faster
```

Co-authored-by: Jean Boussier <[email protected]>

Author: skipkayhil

actionpack/lib/action_dispatch/journey/gtg/simulator.rb

@@ -2,8 +2,6 @@
 
 # :markup: markdown
 
-require "strscan"
-
 module ActionDispatch
   module Journey # :nodoc:
     module GTG # :nodoc:
@@ -16,6 +14,12 @@ def initialize(memos)
       end
 
       class Simulator # :nodoc:
+        STATIC_TOKENS = Array.new(64)
+        STATIC_TOKENS[".".ord] = "."
+        STATIC_TOKENS["/".ord] = "/"
+        STATIC_TOKENS["?".ord] = "?"
+        STATIC_TOKENS.freeze
+
         INITIAL_STATE = [ [0, nil] ].freeze
 
         attr_reader :tt
@@ -25,16 +29,25 @@ def initialize(transition_table)
         end
 
         def memos(string)
-          input = StringScanner.new(string)
           state = INITIAL_STATE
-          start_index = 0
 
-          while sym = input.scan(%r([/.?]|[^/.?]+))
-            end_index = start_index + sym.length
+          pos = 0
+          eos = string.bytesize
+
+          while pos < eos
+            start_index = pos
+            pos += 1
 
-            state = tt.move(state, string, start_index, end_index)
+            if (token = STATIC_TOKENS[string.getbyte(start_index)])
+              state = tt.move(state, string, token, start_index, false)
+            else
+              while pos < eos && STATIC_TOKENS[string.getbyte(pos)].nil?
+                pos += 1
+              end
 
-            start_index = end_index
+              token = string.byteslice(start_index, pos - start_index)
+              state = tt.move(state, string, token, start_index, true)
+            end
           end
 
           acceptance_states = state.each_with_object([]) do |s_d, memos|

actionpack/lib/action_dispatch/journey/gtg/transition_table.rb

@@ -47,25 +47,22 @@ def eclosure(t)
           Array(t)
         end
 
-        def move(t, full_string, start_index, end_index)
+        def move(t, full_string, token, start_index, token_matches_default)
           return [] if t.empty?
 
           next_states = []
 
-          tok = full_string.slice(start_index, end_index - start_index)
-          token_matches_default_component = DEFAULT_EXP_ANCHORED.match?(tok)
-
           t.each { |s, previous_start|
             if previous_start.nil?
               # In the simple case of a "default" param regex do this fast-path and add all
               # next states.
-              if token_matches_default_component && std_state = @stdparam_states[s]
+              if token_matches_default && std_state = @stdparam_states[s]
                 next_states << [std_state, nil].freeze
               end
 
               # When we have a literal string, we can just pull the next state
               if states = @string_states[s]
-                next_states << [states[tok], nil].freeze unless states[tok].nil?
+                next_states << [states[token], nil].freeze unless states[token].nil?
               end
             end
 
@@ -80,7 +77,7 @@ def move(t, full_string, start_index, end_index)
                 previous_start
               end
 
-              slice_length = end_index - slice_start
+              slice_length = start_index + token.length - slice_start
               curr_slice = full_string.slice(slice_start, slice_length)
 
               states.each { |re, v|

actionpack/test/journey/gtg/builder_test.rb

@@ -8,13 +8,13 @@ module GTG
       class TestBuilder < ActiveSupport::TestCase
         def test_following_states_multi
           table = tt ["a|a"]
-          assert_equal 1, table.move([[0, nil]], "a", 0, 1).length
+          assert_equal 1, table.move([[0, nil]], "a", "a", 0, true).length
         end
 
         def test_following_states_multi_regexp
           table = tt [":a|b"]
-          assert_equal 1, table.move([[0, nil]], "fooo", 0, 4).length
-          assert_equal 2, table.move([[0, nil]], "b", 0, 1).length
+          assert_equal 1, table.move([[0, nil]], "fooo", "fooo", 0, true).length
+          assert_equal 2, table.move([[0, nil]], "b", "b", 0, true).length
         end
 
         def test_multi_path
@@ -26,7 +26,7 @@ def test_multi_path
             [2, "/"],
             [1, "c"],
           ].inject([[0, nil]]) { |state, (exp, sym)|
-            new = table.move(state, sym, 0, sym.length)
+            new = table.move(state, sym, sym, 0, sym != "/")
             assert_equal exp, new.length
             new
           }