mruby-regexp: speed up String#sub and #gsub - #7274

Three costs stood between a substitution and the bytes it moves, and none of them was the search.

A String pattern was compiled on every call

"hello world".gsub("o", "0") spent most of its time in Regexp.escape and the compiler, and the rest of it in a compiled pattern the engine walked one character at a time. A literal now reaches Regexp.__sub_lit / Regexp.__gsub_lit, which search for its bytes with memchr and compile nothing.

What a compiled pattern is still needed for is the Regexp the match names in $~. MatchData#regexp quotes and compiles that one the first time something asks for it and keeps the last one compiled, which is what CRuby does for a match against a String pattern (match_regexp in re.c compiles on demand, and rb_reg_regcomp keeps one entry). A call that never looks at $~.regexp compiles nothing. The one entry hangs off the Regexp class under names instance_variables does not report, keyed by a frozen copy of the literal, so a caller that goes on to modify the pattern it passed cannot turn the entry into a hit for something else.

The block form drove its walk from mrblib

It paid, per match, for a __byte_search frame, two byteslice frames and their strings, a __byte_begin/__byte_end pair and an array entry, then a join to spend the pieces. Regexp.__gsub_block does the walk in C around one mrb_yield. The block still reads the globals of the match it was handed, so a MatchData is built per turn as before, and the last one is republished when the walk ends, as the mrblib loop did. What the mrblib loop did with a block that changes the receiver under it, the C loop does too: the bound is the length the walk started with and the bytes are read afresh each turn, so nothing observable moves here. Following CRuby there (str_mod_check, and the closing search behind $~) is #7267, which is stacked on this loop.

Everything else was per-call overhead

sub! and gsub! searched the subject once to decide whether to answer nil and again to substitute; the literal path answers both from the one search __sub_lit / __gsub_lit already makes. The argument counts are compared rather than asked of a Range built per call.

__gsub_str, __sub_str and __byte_search lose their checked argument along with the last caller that set it.

Behaviour

One observable change, the identity of $~.regexp after a String pattern, which moves onto CRuby's answer:

"abc".gsub("b", "X"); a = $~.regexp
"zbz".gsub("b", "Y"); a.equal?($~.regexp)   # was false, now true, as in CRuby

Otherwise nothing: a matrix of 13 subjects × 12 patterns × 11 replacements across sub, gsub, sub!, gsub! and both block forms, comparing the result, the receiver afterwards, $~[0], $~.begin(0), $`, $', $~.string and $~.regexp.source, answers byte for byte on master and on this branch, in the byte-indexed default build and in a UTF-8 build (14,976 lines each, no diff).

Cost

Wall clock, the cases of the review on #7267 and the same shapes with a String pattern, minimum of 5 alternating runs, -O3, default configuration:

s480 = "hello world foo bar " * 24
30000.times { s480.gsub(/o/) { } }        # gsub480_blk
100000.times { "abc".gsub(/b/) { } }      # gsub_abc_blk
100000.times { "abc".scan(/b/) { } }      # scan_abc_blk
100000.times { "abc".sub!(/b/) { } }      # sub!_abc_blk
30000.times { s480.gsub(/o/, "0") }       # gsub480_str
100000.times { "abc".scan(/b/) }          # scan_abc
100000.times { "abc".sub!(/b/, "0") }     # sub!_abc_str
30000.times { s480.gsub(/z/) { } }        # gsub480_none
30000.times { s480.gsub("o") { } }        # lit_gsub480_blk
100000.times { "abc".gsub("b") { } }      # lit_gsub_abc_blk
100000.times { "abc".sub!("b") { } }      # lit_sub!_abc_blk
30000.times { s480.gsub("o", "0") }       # lit_gsub480_str
100000.times { "abc".gsub("b", "0") }     # lit_gsub_abc_str
100000.times { "abc".sub("b", "0") }      # lit_sub_abc_str
100000.times { "abc".sub!("b", "0") }     # lit_sub!_abc_str
100000.times { "abc".gsub!("b", "0") }    # lit_gsub!_abc_str
30000.times { s480.gsub("z", "0") }       # lit_gsub480_none

The block rows are the walk moving into C, Regexp and String pattern alike. The String pattern rows without a block are the quoting and the compile coming out, and the two bang rows fall furthest because they also lose the second walk of the subject. scan and the blockless gsub(/o/, "0") were already in C and are unchanged; sub!(/b/) moves on the Range alone. lit_sub!_abc_blk still quotes and compiles the literal for __search and sub, which is why it moves the least of the String rows.

Size

.text of bin/mruby, build_config/ci/gcc-clang.rb, each side from a clean
build directory. regexp.o is the object that changes, and it accounts for the
whole delta in every build (to within 2 bytes of alignment in full-debug):
the three C entry points, __sub_lit, __gsub_lit and __gsub_block. The
mrblib loop that left was bytecode in mruby-regexp/gem_init.o's .rodata,
which shrinks by 192 (224 in full-debug).

On the default configuration, the one the wall clock was measured on, .text is
1,197,614 on master and 1,203,502 here (+5,888).

Testing

Full suite green: rake -m test on the default configuration in a fresh build directory, MRUBY_CONFIG=build_config/ci/gcc-clang.rb rake -m test and MRUBY_CONFIG=build_config/gcc-asan.rb rake -m test, no sanitizer report.

New assertions cover the literal search and the match it publishes, a literal against a subject whose bytes spell no character, the empty-pattern step, replacement expansion under a literal, the one search the bang methods make, MatchData#regexp compiling on demand and keeping one entry, a block that replaces the subject under the walk, and a String pattern carrying its own __sub_lit / __gsub_lit / __gsub_block singletons.

Environment

# full-debug
gcc -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -g3 -O0 -DMRB_GC_STRESS -DMRB_USE_DEBUG_HOOK -DMRBGEM_MRUBY_REGEXP_VERSION=0.0.0 -DMRB_DEBUG -DMRB_USE_BIGINT -DMRB_USE_COMPLEX -DHAVE_MRUBY_ENCODING_GEM -DMRB_UTF8_STRING -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -DHAVE_MRUBY_REGEXP_GEM -DMRB_USE_SET -DMRB_USE_TASK_SCHEDULER mrbgems/mruby-regexp/src/regexp.c
# bintest
gcc -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -DMRB_GC_FIXED_ARENA -DMRBGEM_MRUBY_REGEXP_VERSION=0.0.0 -DMRB_USE_BIGINT -DMRB_USE_COMPLEX -DHAVE_MRUBY_ENCODING_GEM -DMRB_UTF8_STRING -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -DHAVE_MRUBY_REGEXP_GEM -DMRB_USE_SET -DMRB_USE_TASK_SCHEDULER -DMRB_USE_DEBUG_HOOK mrbgems/mruby-regexp/src/regexp.c
# cxx_abi
gcc -g -O3 -Wall -Wundef -Wwrite-strings -x c++ -std=gnu++03 -DMRB_GC_FIXED_ARENA -DMRBGEM_MRUBY_REGEXP_VERSION=0.0.0 -DMRB_USE_CXX_EXCEPTION -DMRB_USE_CXX_ABI -DMRB_USE_BIGINT -DMRB_USE_COMPLEX -DHAVE_MRUBY_ENCODING_GEM -DMRB_UTF8_STRING -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -DHAVE_MRUBY_REGEXP_GEM -DMRB_USE_SET -DMRB_USE_TASK_SCHEDULER mrbgems/mruby-regexp/src/regexp.c
# byte-string
gcc -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -DMRBGEM_MRUBY_REGEXP_VERSION=0.0.0 -DMRB_USE_BIGINT -DMRB_USE_COMPLEX -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -DHAVE_MRUBY_REGEXP_GEM -DMRB_USE_SET -DMRB_USE_TASK_SCHEDULER mrbgems/mruby-regexp/src/regexp.c
# ascii-ctype
gcc -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -DMRB_USE_ASCII_CTYPE -DMRBGEM_MRUBY_REGEXP_VERSION=0.0.0 -DMRB_USE_BIGINT -DMRB_USE_COMPLEX -DHAVE_MRUBY_ENCODING_GEM -DMRB_UTF8_STRING -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -DHAVE_MRUBY_REGEXP_GEM -DMRB_USE_SET -DMRB_USE_TASK_SCHEDULER mrbgems/mruby-regexp/src/regexp.c
# gcc-asan
gcc -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -fsanitize=address,undefined -g3 -O0 -DMRBGEM_MRUBY_REGEXP_VERSION=0.0.0 -DMRB_DEBUG -DMRB_USE_BIGINT -DMRB_USE_COMPLEX -DHAVE_MRUBY_ENCODING_GEM -DMRB_UTF8_STRING -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -DHAVE_MRUBY_REGEXP_GEM -DMRB_USE_SET -DMRB_USE_TASK_SCHEDULER mrbgems/mruby-regexp/src/regexp.c
# default (no MRUBY_CONFIG), the build every figure above was measured on
gcc -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -DMRBGEM_MRUBY_REGEXP_VERSION=0.0.0 -DHAVE_MRUBY_REGEXP_GEM -DMRB_USE_SET -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -DMRB_USE_COMPLEX -DMRB_USE_BIGINT -DMRB_USE_DEBUG_HOOK mrbgems/mruby-regexp/src/regexp.c