Introduce BOP_CMP for optimized comparison

Prior to this commit the `OPTIMIZED_CMP` macro relied on a method lookup
to determine whether `<=>` was overridden. The result of the lookup was
cached, but only for the duration of the specific method that
initialized the cmp_opt_data cache structure.

With this method lookup, `[x,y].max` is slower than doing `x > y ?
x : y` even though there's an optimized instruction for "new array max".
(John noticed somebody a proposed micro-optimization based on this fact
in https://github.com/mastodon/mastodon/pull/19903.)

```rb
a, b = 1, 2
Benchmark.ips do |bm|
  bm.report('conditional') { a > b ? a : b }
  bm.report('method') { [a, b].max }
  bm.compare!
end
```

Before:

```
Comparison:
         conditional: 22603733.2 i/s
              method: 19820412.7 i/s - 1.14x  (± 0.00) slower
```

This commit replaces the method lookup with a new CMP basic op, which
gives the examples above equivalent performance.

After:

```
Comparison:
              method: 24022466.5 i/s
         conditional: 23851094.2 i/s - same-ish: difference falls within
error
```

Relevant benchmarks show an improvement to Array#max and Array#min when
not using the optimized newarray_max instruction as well. They are
noticeably faster for small arrays with the relevant types, and the same
or maybe a touch faster on larger arrays.

```
$ make benchmark COMPARE_RUBY=<master@5958c305> ITEM=array_min
$ make benchmark COMPARE_RUBY=<master@5958c305> ITEM=array_max
```

The benchmarks added in this commit also look generally improved.

Co-authored-by: John Hawthorn <[email protected]>

1 files changed, 2 insertions, 4 deletions

diff --git a/range.c b/range.c
index 94b6e5a560..5ce9678652 100644
--- a/range.c
+++ b/range.c
@@ -1297,10 +1297,9 @@ range_min(int argc, VALUE *argv, VALUE range)
         return range_first(argc, argv, range);
     }
     else {
-        struct cmp_opt_data cmp_opt = { 0, 0 };
         VALUE b = RANGE_BEG(range);
         VALUE e = RANGE_END(range);
-        int c = NIL_P(e) ? -1 : OPTIMIZED_CMP(b, e, cmp_opt);
+        int c = NIL_P(e) ? -1 : OPTIMIZED_CMP(b, e);
 
         if (c > 0 || (c == 0 && EXCL(range)))
             return Qnil;
@@ -1408,8 +1407,7 @@ range_max(int argc, VALUE *argv, VALUE range)
         return rb_call_super(argc, argv);
     }
     else {
-        struct cmp_opt_data cmp_opt = { 0, 0 };
-        int c = NIL_P(b) ? -1 : OPTIMIZED_CMP(b, e, cmp_opt);
+        int c = NIL_P(b) ? -1 : OPTIMIZED_CMP(b, e);
 
         if (c > 0)
             return Qnil;