8173585: Intrinsify StringLatin1.indexOf(char)

Rewrite of unit test and newlines added to end of files

Changes to unit test:
- main test adjusted such that Strings gennerated are much longer (up to
2048 characters) and of the form: azaza, aazaazaa, aaazaaazaaa, etc with
'z' being the search character searched for. Multiple instances of the
search character are included in the String in order to validate that
the starting offset is correctly handleded. Results are compared to non
intrinsified version of the code. Longer strings means that the looping
functionality of the various paths is entered into.
- Run configurations introduced such that it checks behaviour where use
of SSE and AVX instructions are restricted.
- Tier4InvocationThreshold adjusted so as to ensure C2 code iis invoked.

Other changes:
- newlines added at end of files

Author: Jason Tatton (AWS)

src/hotspot/cpu/x86/c2_MacroAssembler_x86.cpp

@@ -1886,7 +1886,7 @@ void C2_MacroAssembler::stringL_indexof_char(Register str1, Register cnt1, Regis
 
     bind(SCAN_TO_32_CHAR_LOOP);
     vmovdqu(vec3, Address(result, 0));
-    vpcmpeqb(vec3, vec3, vec1, 1);
+    vpcmpeqb(vec3, vec3, vec1, Assembler::AVX_256bit);
     vptest(vec2, vec3);
     jcc(Assembler::carryClear, FOUND_CHAR);
     addptr(result, 32);

test/hotspot/jtreg/compiler/intrinsics/string/TestStringLatin1IndexOfChar.java

@@ -4,24 +4,29 @@
  * @summary Test intrinsification of StringLatin1.indexOf(char). Note that
  * differing code paths are taken contingent upon the length of the input String.
  * Hence we must test against differing string lengths in order to validate
- * correct functionality
+ * correct functionality. We also ensure the strings are long enough to trigger
+ * the looping conditions of the individual code paths.
+ *
+ * Run with varing levels of AVX and SSE support, also without the intrinsic at all
  *
  * @library /compiler/patches /test/lib
- * @run main/othervm -Xbatch -XX:CompileThreshold=100 -XX:+UnlockDiagnosticVMOptions -XX:DisableIntrinsic=_indexOfL_char compiler.intrinsics.string.TestStringLatin1IndexOfChar
- * @run main/othervm -Xbatch -XX:CompileThreshold=100 compiler.intrinsics.string.TestStringLatin1IndexOfChar
+ * @run main/othervm -Xbatch -XX:Tier4InvocationThreshold=200 -XX:CompileThreshold=100 compiler.intrinsics.string.TestStringLatin1IndexOfChar
+ * @run main/othervm -Xbatch -XX:Tier4InvocationThreshold=200 -XX:CompileThreshold=100 -XX:+UnlockDiagnosticVMOptions -XX:DisableIntrinsic=_indexOfL_char compiler.intrinsics.string.TestStringLatin1IndexOfChar
+ * @run main/othervm -Xbatch -XX:Tier4InvocationThreshold=200 -XX:CompileThreshold=100 -XX:UseSSE=0 compiler.intrinsics.string.TestStringLatin1IndexOfChar
+ * @run main/othervm -Xbatch -XX:Tier4InvocationThreshold=200 -XX:CompileThreshold=100 -XX:UseAVX=1 compiler.intrinsics.string.TestStringLatin1IndexOfChar
+ * @run main/othervm -Xbatch -XX:Tier4InvocationThreshold=200 -XX:CompileThreshold=100 -XX:UseAVX=2 compiler.intrinsics.string.TestStringLatin1IndexOfChar
+ * @run main/othervm -Xbatch -XX:Tier4InvocationThreshold=200 -XX:CompileThreshold=100 -XX:UseAVX=3 compiler.intrinsics.string.TestStringLatin1IndexOfChar
  */
 
 package compiler.intrinsics.string;
 
 import jdk.test.lib.Asserts;
-import java.util.HashMap;
-import java.util.Map;
 
 public class TestStringLatin1IndexOfChar{
-    private final static int MAX_LENGTH = 513;//future proof for AVX-512 instructions
+    private final static int MAX_LENGTH = 2048;//future proof for AVX-512 instructions
 
     public static void main(String[] args) throws Exception {
-        for (int i = 0; i < 100_0; ++i) {//repeat such that we enter into C2 code...
+        for (int i = 0; i < 1_000; ++i) {//repeat such that we enter into C2 code...
             maintest();
             testEmpty();
         }
@@ -31,46 +36,62 @@ private static void testEmpty(){
         Asserts.assertEQ("".indexOf('a'), -1);
     }
 
-    private static final char[] alphabet = new char[]{'a', 'b', 'c'};//Latin1 are made of these
+    private final static char SEARCH_CHAR = 'z';
+    private final static char INVERLEAVING_CHAR = 'a';
+    private final static char MISSING_CHAR = 'd';
 
     private static void maintest(){
         //progressivly move through string checking indexes and starting offset correctly processed
-        for(int strLength = alphabet.length; strLength < MAX_LENGTH; strLength++){
-            String totest = makeCandidateStringLatin1(strLength);
+        //string is of form azaza, aazaazaa, aaazaaazaaa, etc
+        //we find n s.t. maxlength = (n*3) + 2
+        int maxaInstances = (MAX_LENGTH-2)/3;
 
-            //track starting offset here
-            Map<Character, Integer> lastIndexOf = new HashMap<Character, Integer>();
-            for(Character c : alphabet){
-                lastIndexOf.put(c, 0);
-            }
+        for(int aInstances = 5; aInstances < MAX_LENGTH; aInstances++){
+            String totest = makeCandidateStringLatin1(aInstances);
+
+            int startoffset;
+            {
+                int intri = totest.indexOf(SEARCH_CHAR);
+                int nonintri = indexOfCharNonIntrinsic(totest, SEARCH_CHAR, 0);
 
-            for(int alphaidx = 0; ; alphaidx++){
-                char wanted = alphabet[alphaidx % alphabet.length];
-                int lastInst = lastIndexOf.get(wanted);
+                Asserts.assertEQ(intri, nonintri);
+                startoffset = intri+1;
+            }
 
-                int intri = totest.indexOf(wanted, lastInst);
-                int nonintri = indexOfChar(totest, wanted, lastInst);
+            {
+                int intri = totest.indexOf(SEARCH_CHAR, startoffset);
+                int nonintri = indexOfCharNonIntrinsic(totest, SEARCH_CHAR, startoffset);
 
                 Asserts.assertEQ(intri, nonintri);
-                if(intri == -1 || intri == strLength-1){
-                    break;
-                }
-                lastIndexOf.put(wanted, intri+1);
+                startoffset = intri+1;
             }
 
-            Asserts.assertEQ(totest.indexOf('d'), -1);
+            Asserts.assertEQ(totest.indexOf(SEARCH_CHAR, startoffset), -1);//only two SEARCH_CHAR per string
+            Asserts.assertEQ(totest.indexOf(MISSING_CHAR), -1);
         }
     }
 
-    private static String makeCandidateStringLatin1(int strLength){
-        StringBuilder sb = new StringBuilder(strLength);
-        for(int n =0; n < strLength; n++){//only 1 byte elements...
-            sb.append(alphabet[n % alphabet.length]);
+    private static String makeCandidateStringLatin1(int aInstances){
+        StringBuilder sb = new StringBuilder((aInstances*3) + 2);
+        for(int n =0; n < aInstances; n++){
+            sb.append(INVERLEAVING_CHAR);
+        }
+
+        sb.append(SEARCH_CHAR);
+
+        for(int n =0; n < aInstances; n++){
+            sb.append(INVERLEAVING_CHAR);
+        }
+
+        sb.append(SEARCH_CHAR);
+
+        for(int n =0; n < aInstances; n++){
+            sb.append(INVERLEAVING_CHAR);
         }
         return sb.toString();
     }
 
-    private static int indexOfChar(String value, int ch, int fromIndex) {
+    private static int indexOfCharNonIntrinsic(String value, int ch, int fromIndex) {
         //non intrinsic version of indexOfChar
         byte c = (byte)ch;
         for (int i = fromIndex; i < value.length(); i++) {
@@ -80,5 +101,4 @@ private static int indexOfChar(String value, int ch, int fromIndex) {
         }
         return -1;
     }
-
- }
+}

test/micro/org/openjdk/bench/java/lang/StringIndexOfChar.java

@@ -196,4 +196,4 @@ public static int utf16_AVX2_String() {
         }
         return ret;
     }
-}
+}