mruby-regexp: hold a character class's ranges sorted and free of overlaps - #7207

Closing a character class under case folding for /i builds the ranges it then reads, and it read them the slowest way there is.

What it costs

class_add_range() merged a new range only with the entry appended last, so what collapsed depended on the order the entries arrived in. A written class arrives in scan order and collapses well. The closure has no order at all: the folds of a range land back inside it and outside it by turns, and once one of them is appended above the range, every fold that follows lands below the entry standing last and is appended as a second entry naming what the first already accepts.

/[\^@-\u2FFF]/i is one written range. It left 527 entries after the round that adds the folds, and 1545 after the round that adds their sources. Both rounds walk the two case tables once per entry, so the entries the closure made are what the closure then reads.

The second commit is a smaller version of the same thing. An ASCII member can have a source outside ASCII, U+212A folding to k and U+017F to s, and the bitmap holds no ranges for the range walk to find those through, so the closure asked about every set bit on its own. A question costs a walk of both tables whatever it spans, and a class of 38 ASCII members paid 38 walks to learn about two characters.

What changes

The range list is held sorted by lo, with no two entries that overlap or touch. A range the class already covers is then found and dropped rather than appended, and /[\^@-\u2FFF]/i closes to 10 entries. The entry standing highest is still checked before the search, since within one walk the ranges arrive ascending and that is the entry they join.

The two rounds then walk by codepoint rather than by index, an index no longer naming the same entry once an insertion moved it. A walk that resumes above the range it just handed over reaches every entry the round began with. What it may skip is an entry inserted behind it, and neither round has anything to say about one: folding is idempotent, so the fold of a fold the first round added is that fold, and nothing folds to a character that folds elsewhere, so a source the second round adds has no source of its own.

The ASCII bitmap is asked about a run of set bits at a time. The tables hold no ASCII source, ASCII being what they are the rest of, so nothing that walk finds lands in the bitmap and no run of it grows while it is being read.

Nothing here changes which characters a class holds.

Speed

Instructions to compile one pattern under /i, callgrind on bin/mruby, as Ir(2N) - Ir(N) so the startup cancels. Every build below is a clean one. perf is not available on this machine and its wall clock moves by up to 80% between runs of the same binary, so the instruction count is the measurement rather than a check on one.

The last two classes grow by under 2%. Their folds all land inside what was written, so the merge with the last entry already collapsed them to a single range, and what they pay is the search that finds it.

The shorter list is also what class_match() reads, once per character the bitmap cannot answer for:

Generated code

.text over every .o, each side built from an empty build directory, for the five builds ci/gcc-clang makes. Their compile lines are under Environment at the end: full-debug is -O0, the other four are -O3.

class_add_range() grows into a search and an insertion, and the two builds that fold /i by Unicode get that back from the per-bit loop going away. byte-string and ascii-case fold /i without the tables and have no such loop to lose, so they carry the search alone.

Testing

rake -m test over ci/gcc-clang from an empty build directory, all five builds green, 0 KO, 0 crash, no new warnings:

rake -m test over build_config/asan.rb is green too, address and undefined sanitizers both: 2313 tests, 2310 OK, 3 skip, plus 79 bintests. The insertion and the memmove behind it are what to run it for.

The new test pins the class rather than the list, since holding the ranges another way has to come to the same members:

[/[Ā-Ȁ]/, /[ƀ-ȀĀ-Ɛ]/,
 /[Ā-Őő-Ȁ]/, /[Ā-ȀĠ-İ]/,
 /[ȀĀ-ȀĀ]/].each do |re|
  assert_equal 0, ("Ā" =~ re)
  assert_equal 0, ("Ő" =~ re)
  assert_equal 0, ("Ȁ" =~ re)
  assert_nil ("ÿ" =~ re)
  assert_nil ("ȁ" =~ re)
end

Against master over 3,000 randomly built /i classes, each asked about the same 300 subjects, the answers are identical: 900,000 comparisons spanning Latin, Greek, Cyrillic, Armenian, Georgian, Cherokee, Deseret, Osage and the fullwidth forms, the characters that fold across the ASCII boundary, the ones whose fold spells several characters, negated classes and classes written out of order. Identical under the sanitizers as well.

Environment

MRuby::Build.new('perf-utf8') do |conf|
  conf.toolchain :gcc
  conf.gembox 'full-core'
  conf.cc.flags = %w(-O3 -g -std=gnu99 -Wall -Wundef)
  conf.enable_test
end

# perf-utf8, the build every number above was taken on
gcc -O3 -g -std=gnu99 -Wall -Wundef -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

# ci/gcc-clang, 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

# ci/gcc-clang, 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

# ci/gcc-clang, 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

# ci/gcc-clang, 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

# ci/gcc-clang, ascii-case
gcc -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -DMRB_USE_ASCII_CASE -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

# build_config/asan.rb
clang -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -Wzero-length-array -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