string.c: compare the first byte before memcmp() searching backward - #7186

A backward search tries the needle at every position from pos down to the head, and hands each one to memcmp():

for (mrb_int i = pos; 0 <= i; i--) {
  if (memcmp(sbeg+i, t, len) == 0) {
    return i;
  }
}

Where the needle is not there, that is a call per byte of the string, and the call is what the search spends nearly all of its time on: memcmp() has to be entered, has its own head to run before it looks at anything, and then almost always disagrees on the first byte it reads.

The needle's first byte has to match wherever the rest of it does. Reading it inline settles every position but the ones that carry that byte, and only those reach memcmp():

const char head = t[0];
for (mrb_int i = pos; 0 <= i; i--) {
  if (sbeg[i] == head && memcmp(sbeg+i, t, len) == 0) {
    return i;
  }
}

str_char_rindex() searches the same way over character boundaries, and gets the same guard. There the byte is read at that position anyway, since stepping back to the previous character starts by looking at it.

Both functions have already returned by then for an empty needle, so t[0] is a byte of the needle in both. In str_char_rindex() the clamp above the loop puts s at the last byte the needle fits at, and the walk back only lowers it, so *s is inside the string at every turn.

Measurements

The bench-utf8 build under Environment at the end, whose compile line is gcc -O3, best of 5 runs of best of 5:

a = "a" * 100000
200.times { a.rindex("zzz") }
200.times { a.byterindex("zzz") }

u = "あ" * 50000
200.times { u.rindex("zzz") }

The multi-byte receiver gains least because there the positions tried are characters rather than bytes, a third as many here, and stepping between them is work of its own that stays.

A search that finds its needle at the first position tried pays one byte comparison it did not pay before. A search that has to look for it is the case this is about.

Generated code

.text over every .o, against the same objects built from master, for each of the four builds ci/gcc-clang makes. Their compile lines are under Environment at the end: full-debug is -O0, the other three are -O3.

byte-string is the build without mruby-encoding. str_byterindex() is what a string answers with there, so it gains the guard too, and str_char_rindex() is not compiled.

Testing

rake -m test over ci/gcc-clang, all four 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, tests and bintests. The reordered read is the reason to run it: the guard reads *s before the length check that used to come first.

Against master over 6720 cases of String#index and String#rindex, spanning ASCII, multi-byte, broken and binary receivers and needles with offsets on both sides of every edge, the answers are identical byte for byte, under the sanitizers as well.

No test accompanies the change. Both searches answer what they answered, so there is nothing new to pin.

Environment

MRuby::Build.new('bench-utf8') do |conf|
  toolchain :gcc
  conf.cc.flags << '-O3'

  conf.gembox 'default'
  conf.gem :core => 'mruby-encoding'
end

# bench-utf8, the build every timing was taken on
gcc -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -O3 -DMRB_USE_SET -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -DMRB_USE_COMPLEX -DMRB_USE_BIGINT -DMRB_USE_DEBUG_HOOK -DHAVE_MRUBY_ENCODING_GEM -DMRB_UTF8_STRING

# 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 -DMRB_UNICODE_CASE -DMRB_DEBUG -DMRB_USE_BIGINT -DMRB_USE_COMPLEX -DHAVE_MRUBY_ENCODING_GEM -DMRB_UTF8_STRING -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -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 -DMRB_USE_BIGINT -DMRB_USE_COMPLEX -DHAVE_MRUBY_ENCODING_GEM -DMRB_UTF8_STRING -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -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 -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 -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 -DMRB_USE_BIGINT -DMRB_USE_COMPLEX -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -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 -DMRB_DEBUG -DMRB_USE_BIGINT -DMRB_USE_COMPLEX -DHAVE_MRUBY_ENCODING_GEM -DMRB_UTF8_STRING -DHAVE_MRUBY_IO_GEM -DMRB_USE_RATIONAL -DMRB_USE_SET -DMRB_USE_TASK_SCHEDULER