string.c: take the single-byte path for a string of nothing but ASCII - #7209

A character index into a string is already a byte index when every byte of it
stands for a character of its own, and RSTR_SINGLE_BYTE_P() is where that is
written down:

#define RSTR_SINGLE_BYTE_P(s) \
  (RSTR_CODERANGE(s) == MRB_STR_CODERANGE_7BIT || RSTR_BINARY_P(s))

Two sides arrive at it. A string read as bytes indexes by byte because that is
what it is, and a string of nothing but ASCII indexes by byte because ASCII
spells one character per byte. Three places in src/string.c read only the
first of the two, so a string already known to hold nothing but ASCII was sent
down the path written for a string that can spell a character in several bytes.

The answers do not move. What moves is how many bytes are read to produce them.

mrb_str_char_len()

The two early returns are the macro written out, so this commit is a fold and
nothing else. The comment above them named the halves separately; now it names
the one thing they are.

str_escape()

String#inspect passes a whole character through unescaped so it stays
readable, which is why it reads the character at every byte to learn where the
next one starts. String#dump does not, and a byte-read string was already
sent down dump's path because it holds no characters to keep readable.

A string of nothing but ASCII holds none spelled in more than one byte either.
The read finds a character of one byte and nothing else, and the escaping
writes each of those bytes out the way dump already does, so the read is
work with no reader. Asking RSTR_SINGLE_BYTE_P() drops it, and
("a" * 100000).inspect comes to cost exactly what .dump of the same string costs.

Only a string whose bytes have been looked at already takes the shorter path.
One that nothing has read yet still reads a character per byte, and records
what it finds as it goes, so the next question about it is answered off the
flag.

mrb_str_chop_bang()

String#chop! cuts the last byte outright for a byte-read string and walks
back from the end with mrb_utf8_char_head() for every other one, which is how
it finds the head of a character spelled in more than one byte. A string of
nothing but ASCII spells none of those, so the walk finds the last byte and
nothing else.

Cutting the last byte is what the two builds already have in common, so it is
what the local starts at and the walk is what overrides it. That is the shape
the byte-indexed build was compiled to all along, and writing it that way is
what takes the #else arm away.

Instruction counts

Wall clock on this machine carries a few percent of noise, which is wider than
most of the rows below, so the counts come from callgrind as Ir(2N) - Ir(N)
so that interpreter start-up cancels.

n = ARGV[0].to_i
s = "a" * 100000
s.length          # settle the coderange, as any earlier question would
n.times { s.inspect }

The one row that moves is the escaping of an ASCII string, and it lands on the
count dump of the same string already had. chop! loses 12 instructions per
call and length 4, which is the shape of the change rather than a saving
worth claiming: neither was reading the string, only testing it.

Wall clock agrees where the difference is wide enough to see. Best of five
inside the process, with master and this branch alternated five times and the
minimum taken, -O3, default gembox plus mruby-encoding:

def bench(name, n)
  best = nil
  5.times do
    t = Time.now
    n.times { yield }
    d = Time.now - t
    best = d if best.nil? || d < best
  end
  puts "#{name}\t#{'%.4f' % best}"
end

ascii = "a" * 100000
ascii.length
bench("inspect ascii", 100) { ascii.inspect }

Size

.text summed over every .o, each side built from an empty build directory:

byte-string is unchanged to the byte, which is what a build indexing strings
by byte should show: RSTR_CODERANGE() is the constant MRB_STR_CODERANGE_7BIT
there, so RSTR_SINGLE_BYTE_P() folds away and the two touched functions are
compiled from the arms they already were.

By commit, on bintest:

The -16 is the arm that goes away: with the cut of the last byte as the
local's initial value, the byte-read case is no longer a branch of its own.

Testing

ci/gcc-clang and build_config/asan.rb, run per build so the counts are
attributable:

bintest (the binary tests) passes 117 of 117 under ci/gcc-clang and 79 of
79 under asan.

Since every claim here is that an answer does not move, the two binaries were
also asked the same questions and compared:

• a hand written corpus of 38 strings, each in 5 states (plain, b, and with
  the coderange settled beforehand by length or by valid_encoding?), each
  asked 25 questions covering length, inspect, dump, chop, chop!,
  chomp, chomp!, valid_encoding?, ascii_only?, succ, reverse,
  chars, codepoints, ljust, rjust, center, [], index, rindex,
  and what the string stands at afterwards: 4750 answers, identical.
• 20000 random byte strings of up to 8 bytes over an alphabet of ASCII, UTF-8
  lead and continuation bytes, overlong and surrogate sequences, and 0xff,
  a third of them byte-read and half of them measured first: identical.

No new tests come with this. The existing suite already asks each of the three
functions about a string of nothing but ASCII, which is the case that changes
paths, and the answers are what it already asserts.

Environment

# 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_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 src/string.c

# 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 -DHAVE_MRUBY_REGEXP_GEM -DMRB_USE_SET -DMRB_USE_TASK_SCHEDULER -DMRB_USE_DEBUG_HOOK src/string.c

# 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 -DHAVE_MRUBY_REGEXP_GEM -DMRB_USE_SET -DMRB_USE_TASK_SCHEDULER src/string.c

# 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 -DHAVE_MRUBY_REGEXP_GEM -DMRB_USE_SET -DMRB_USE_TASK_SCHEDULER src/string.c

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

# 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 -DHAVE_MRUBY_REGEXP_GEM -DMRB_USE_SET -DMRB_USE_TASK_SCHEDULER src/string.c

# the build the timings were taken on: default gembox plus mruby-encoding
gcc -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -DHAVE_MRUBY_REGEXP_GEM -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 src/string.c

Summary by CodeRabbit

• Bug Fixes
  • Improved character-length handling for single-byte strings.
  • String inspection now consistently handles single-byte content without unnecessary character-preserving behavior.
  • Fixed String#chop! behavior for single-byte strings, while preserving correct UTF-8 boundary handling for multi-byte strings.
  • These updates provide more consistent results when working with ASCII, binary, and multi-byte string data.