Summary

Enumerable#count reaches an element through a call to each, a block call and a __svalue send, then compares it with == where an argument was given, and counts every element the same way where none was. An Array reads its length off itself, and an argument is counted by a walk made in C where the pair is compared with mrb_equal(), as Array#index and #delete already compare one. This is the move Array#minmax made in 7c0c643, applied to the other Enumerable method this gem lends an Array.

Changes

The three forms

def count(v = Enumerable::NONE, &block)
  if Enumerable::NONE.equal?(v)
    block ? super : size
  else
    __count(v)
  end
end

With no argument the answer is the length, which an Array already knows. With an argument it is a walk in C. The block form is left where it is written and reached through super, as Array#minmax leaves its own.

mrb_equal() takes two values for equal where they are the same object and asks == only after, which is the test OP_EQ makes for a == b before it dispatches anything, and the one Enumerable#count reached == through. The answers are the ones the array gave before.

The walk reads the length and the pointer afresh each turn, because == may run Ruby that grows or shrinks the array under it, and it restores the GC arena at the end of each turn. What a call leaves in the arena is its return value, and a count goes past a true answer rather than returning at it, so an == answering with a fresh object every time would pile up one per element; a fixed arena fills at a few hundred. Array#include? needs no such restore, returning at the first true answer, and Array#index has none for the same reason.

Behaviour

a and b are two NaNs built at run time as z / z from z = [0.0][0], so that nothing folds them into a single literal. Bold marks a row that differs from CRuby.

An argument decides even where a block came with it, which is what CRuby does, warning that the block goes unused; Enumerable#count took the block and dropped the argument. This is Array#count only: Enumerable#count is unchanged, and every other receiver still takes the block.

The last three rows are one answer. A NaN is equal to no value, its own operand included, so == can never find one and only the object is left to go by; #index looked for the object and found the NaN an array holds, and #count counts it now too. That is right about the NaN an array holds and wrong about a second one, because a boxing that keeps a Float in the value normalizes every NaN to one representation, which is what the last row shows #index saying on master and saying still. Making a NaN an object of its own is a change to what a Float is rather than to how an array counts, and it is not in this PR.

Speed

a = (1..200).to_a
i = 0
while i < 20000 do a.count(200); i += 1 end

Best of 11 interleaved runs against master, with a master-vs-master control to read the noise by, and the instruction counts callgrind reads beside them:

Size

bin/mruby .text for every build in build_config/ci/gcc-clang.rb:

The whole of it is mrbgems/mruby-enum-ext/src/enum.o, which grows by exactly 208 for the one function and the arena save and restore around its loop; the Ruby that picks between the three forms is bytecode and lands in .rodata, not here.

Testing

rake test passes for the default build, for build_config/host-nofloat.rb, for every build in build_config/ci/gcc-clang.rb including the C++ ABI one, and for a MRB_NO_BOXING build of the full-core gembox, with no compiler warnings beyond the one -Wmaybe-uninitialized about eq in hash.c that master already emits in a MRB_NO_BOXING build. The last of those is there because the rows about a NaN in the table above are ones a boxing decides.

The Enumerable#count assertions this gem already carries are written with an Array receiver, so they now reach the C walk. They are kept as they are and the new ones are asked beside them; Enumerable#count itself is reached by the block form through super.

Environment

The wall clock and instruction counts were taken with the default build:

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

The ## Size table was taken with build_config/ci/gcc-clang.rb:

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
ascii-ctype  gcc -std=gnu99 -g -O3 -Wall -Wundef -Werror-implicit-function-declaration -Wwrite-strings -DMRB_USE_ASCII_CTYPE -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
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
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
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

cxx_abi compiles mruby as C++ with gcc -x c++ -std=gnu++03; g++ only links. full-debug is the one build at -O0, enable_debug putting -g3 -O0 after the toolchain default of -g -O3.

Summary by CodeRabbit

• New Features

  • Added Array#count for counting all elements, matching values, or elements meeting a block condition.
  • Supports Ruby-compatible behavior when both an argument and block are provided.

• Bug Fixes

  • Improved counting behavior for arrays modified during element comparison.

• Tests

  • Added coverage for empty arrays, value matching, block behavior, self-equality, and mutations during counting.