Use Truffle utility methods, which intrinsify to vector instructions, when searching for single-byte characters in a String.

Author: nirvdrum

CHANGELOG.md

@@ -9,6 +9,32 @@ Bug fixes:
 * Fixed `Addrinfo.new(String)` to reliably find the address family (#1702).
 * Fixed argument checks in `BasicSocket#setsockopt` (#1460).
 * Fixed `ObjectSpace.trace_object_allocations` (#1456).
+
+Compatibility:
+
+* Exceptions from `coerce` are no longer rescued, like MRI.
+* Implemented `Integer#{allbits?,anybits?,nobits?}`.
+* `Integer#{ceil,floor,truncate}` now accept a precision and `Integer#round` accepts a rounding mode.
+* Added missing `Enumerable#filter` and `Enumerator::Lazy#filter` aliases to the respective `select` method (#1610).
+* Implemented more `Ripper` methods as no-ops (#1694).
+* Implemented `rb_enc_sprintf` (#1702).
+* Implemented `ENV#{filter,filter!}` aliases for `select` and `select!`.
+* Non-blocking `StringIO` and `Socket` APIs now support `exception: false` like MRI (#1702).
+
+Changes:
+
+* Interactive sources (like the GraalVM polyglot shell) now all share the same binding (#1695).
+
+Performance:
+
+* `eval(code, binding)` for a fixed `code` containing blocks is now much faster. This improves the performance of rendering `ERB` templates containing loops.
+* Several `String` methods have been made faster by the usage of vector instructions
+  when searching for a single-byte character in a String.
+
+# 20.0.0 beta 1
+
+Bug fixes:
+
 * Fixed `BigDecimal#{clone,dup}` so it now just returns the receiver, per Ruby 2.5+ semantics (#1680).
 * Fixed creating `BigDecimal` instances from non-finite `Float` values (#1685).
 * Fixed `BigDecimal#inspect` output for non-finite values (e.g, NaN or -Infinity) (#1683).

src/main/java/org/truffleruby/core/string/StringNodes.java

@@ -3627,26 +3627,24 @@ public Object stringIndexEmptyPattern(DynamicObject string, DynamicObject patter
         })
         public Object stringIndexSingleBytePattern(DynamicObject string, DynamicObject pattern, int byteOffset,
                 @Cached("create()") RopeNodes.BytesNode bytesNode,
-                @Cached("create()") BranchProfile matchFoundProfile,
-                @Cached("create()") BranchProfile noMatchProfile) {
+                @Cached("createBinaryProfile()") ConditionProfile offsetTooLargeProfile) {
             assert byteOffset >= 0;
 
             checkEncoding(string, pattern);
 
             final Rope sourceRope = rope(string);
             final int end = sourceRope.byteLength();
+
+            if (offsetTooLargeProfile.profile(byteOffset >= end)) {
+                return nil();
+            }
+
             final byte[] sourceBytes = bytesNode.execute(sourceRope);
             final byte searchByte = bytesNode.execute(rope(pattern))[0];
 
-            for (int i = byteOffset; i < end; i++) {
-                if (sourceBytes[i] == searchByte) {
-                    matchFoundProfile.enter();
-                    return i;
-                }
-            }
+            final int index = com.oracle.truffle.api.ArrayUtils.indexOf(sourceBytes, byteOffset, end, searchByte);
 
-            noMatchProfile.enter();
-            return nil();
+            return index == -1 ? nil() : index;
         }
 
         @Specialization(guards = {

src/main/java/org/truffleruby/core/support/ByteArrayNodes.java

@@ -9,6 +9,7 @@
  */
 package org.truffleruby.core.support;
 
+import com.oracle.truffle.api.ArrayUtils;
 import com.oracle.truffle.api.dsl.Cached;
 import com.oracle.truffle.api.dsl.Specialization;
 import com.oracle.truffle.api.object.DynamicObject;
@@ -195,15 +196,9 @@ public Object getByteSingleByte(DynamicObject bytes, DynamicObject pattern, int
                 start = 0;
             }
 
-            for (int i = start; i < length; i++) {
-                if (in.get(i) == searchByte) {
-                    matchFoundProfile.enter();
-                    return i + 1;
-                }
-            }
+            final int index = ArrayUtils.indexOf(in.getUnsafeBytes(), start, length, searchByte);
 
-            noMatchProfile.enter();
-            return nil();
+            return index == -1 ? nil() : index + 1;
         }
 
         @Specialization(guards = { "isRubyString(pattern)", "!isSingleBytePattern(pattern)" })