VectorizedMismatchTest.java

/*
 * Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

package compiler.intrinsics;

/*
 * @test
 * @requires vm.opt.final.UseVectorizedMismatchIntrinsic == true
 * @modules java.base/jdk.internal.misc
 *          java.base/jdk.internal.util
 *
 *  @run main/othervm -XX:CompileCommand=quiet -XX:CompileCommand=compileonly,*::test*
 *                    -Xbatch -XX:-TieredCompilation
 *                    -XX:UseAVX=3
 *                     compiler.intrinsics.VectorizedMismatchTest
 *
 *  @run main/othervm -XX:CompileCommand=quiet -XX:CompileCommand=compileonly,*::test*
 *                    -Xbatch -XX:-TieredCompilation
 *                    -XX:+UnlockDiagnosticVMOptions -XX:UseAVX=3 -XX:AVX3Threshold=0
 *                     compiler.intrinsics.VectorizedMismatchTest
 */

import jdk.internal.misc.Unsafe;
import jdk.internal.util.ArraysSupport;

public class VectorizedMismatchTest {
    private boolean[] boolean_a = new boolean[128];
    private boolean[] boolean_b = new boolean[128];

    int testBooleanConstantLength(int length) {
        boolean[] obja = boolean_a;
        boolean[] objb = boolean_b;
        long offset = Unsafe.ARRAY_BOOLEAN_BASE_OFFSET;
        int scale = ArraysSupport.LOG2_ARRAY_BOOLEAN_INDEX_SCALE;
        return ArraysSupport.vectorizedMismatch(obja, offset, objb, offset, length, scale);
    }

    int testBooleanConstantLength0()   { return testBooleanConstantLength(0);   }
    int testBooleanConstantLength1()   { return testBooleanConstantLength(1);   }
    int testBooleanConstantLength64()  { return testBooleanConstantLength(64);  }
    int testBooleanConstantLength128() { return testBooleanConstantLength(128); }

    /* ==================================================================================== */

    private byte[] byte_a = new byte[128];
    private byte[] byte_b = new byte[128];

    int testByteConstantLength(int length) {
        byte[] obja = byte_a;
        byte[] objb = byte_b;
        long offset = Unsafe.ARRAY_BYTE_BASE_OFFSET;
        int scale = ArraysSupport.LOG2_ARRAY_BYTE_INDEX_SCALE;
        return ArraysSupport.vectorizedMismatch(obja, offset, objb, offset, length, scale);
    }

    int testByteConstantLength0()   { return testByteConstantLength(0);   }
    int testByteConstantLength1()   { return testByteConstantLength(1);   }
    int testByteConstantLength64()  { return testByteConstantLength(64);  }
    int testByteConstantLength128() { return testByteConstantLength(128); }

    /* ==================================================================================== */

    private short[] short_a = new short[64];
    private short[] short_b = new short[64];

    int testShortConstantLength(int length) {
        short[] obja = short_a;
        short[] objb = short_b;
        long offset = Unsafe.ARRAY_SHORT_BASE_OFFSET;
        int scale = ArraysSupport.LOG2_ARRAY_SHORT_INDEX_SCALE;
        return ArraysSupport.vectorizedMismatch(obja, offset, objb, offset, length, scale);
    }

    int testShortConstantLength0()  { return testShortConstantLength(0);  }
    int testShortConstantLength1()  { return testShortConstantLength(1);  }
    int testShortConstantLength32() { return testShortConstantLength(32); }
    int testShortConstantLength64() { return testShortConstantLength(64); }

    /* ==================================================================================== */

    private char[] char_a = new char[64];
    private char[] char_b = new char[64];

    int testCharConstantLength(int length) {
        char[] obja = char_a;
        char[] objb = char_b;
        long offset = Unsafe.ARRAY_CHAR_BASE_OFFSET;
        int scale = ArraysSupport.LOG2_ARRAY_CHAR_INDEX_SCALE;
        return ArraysSupport.vectorizedMismatch(obja, offset, objb, offset, length, scale);
    }

    int testCharConstantLength0()  { return testCharConstantLength(0);  }
    int testCharConstantLength1()  { return testCharConstantLength(1);  }
    int testCharConstantLength32() { return testCharConstantLength(32); }
    int testCharConstantLength64() { return testCharConstantLength(64); }

    /* ==================================================================================== */

    private int[] int_a = new int[32];
    private int[] int_b = new int[32];

    int testIntConstantLength(int length) {
        int[] obja = int_a;
        int[] objb = int_b;
        long offset = Unsafe.ARRAY_INT_BASE_OFFSET;
        int scale = ArraysSupport.LOG2_ARRAY_INT_INDEX_SCALE;
        return ArraysSupport.vectorizedMismatch(obja, offset, objb, offset, length, scale);
    }

    int testIntConstantLength0()  { return testIntConstantLength(0);  }
    int testIntConstantLength1()  { return testIntConstantLength(1);  }
    int testIntConstantLength16() { return testIntConstantLength(16); }
    int testIntConstantLength32() { return testIntConstantLength(32); }

    /* ==================================================================================== */

    private float[] float_a = new float[32];
    private float[] float_b = new float[32];

    int testFloatConstantLength(int length) {
        float[] obja = float_a;
        float[] objb = float_b;
        long offset = Unsafe.ARRAY_FLOAT_BASE_OFFSET;
        int scale = ArraysSupport.LOG2_ARRAY_FLOAT_INDEX_SCALE;
        return ArraysSupport.vectorizedMismatch(obja, offset, objb, offset, length, scale);
    }

    int testFloatConstantLength0()  { return testFloatConstantLength(0);  }
    int testFloatConstantLength1()  { return testFloatConstantLength(1);  }
    int testFloatConstantLength16() { return testFloatConstantLength(16); }
    int testFloatConstantLength32() { return testFloatConstantLength(32); }

    /* ==================================================================================== */

    private long[] long_a = new long[16];
    private long[] long_b = new long[16];

    int testLongConstantLength(int length) {
        long[] obja = long_a;
        long[] objb = long_b;
        long offset = Unsafe.ARRAY_LONG_BASE_OFFSET;
        int scale = ArraysSupport.LOG2_ARRAY_LONG_INDEX_SCALE;
        return ArraysSupport.vectorizedMismatch(obja, offset, objb, offset, length, scale);
    }

    int testLongConstantLength0()  { return testLongConstantLength(0);  }
    int testLongConstantLength1()  { return testLongConstantLength(1);  }
    int testLongConstantLength8()  { return testLongConstantLength(8);  }
    int testLongConstantLength16() { return testLongConstantLength(16); }

    /* ==================================================================================== */

    private double[] double_a = new double[16];
    private double[] double_b = new double[16];

    int testDoubleConstantLength(int length) {
        double[] obja = double_a;
        double[] objb = double_b;
        long offset = Unsafe.ARRAY_DOUBLE_BASE_OFFSET;
        int  scale  = ArraysSupport.LOG2_ARRAY_DOUBLE_INDEX_SCALE;
        return ArraysSupport.vectorizedMismatch(obja, offset, objb, offset, length, scale);
    }

    int testDoubleConstantLength0()  { return testDoubleConstantLength(0);  }
    int testDoubleConstantLength1()  { return testDoubleConstantLength(1);  }
    int testDoubleConstantLength8()  { return testDoubleConstantLength(8);  }
    int testDoubleConstantLength16() { return testDoubleConstantLength(16); }

    /* ==================================================================================== */

    static class ClassInitTest {
        static final int LENGTH = 64;
        static final int RESULT;
        static {
            byte[] arr1 = new byte[LENGTH];
            byte[] arr2 = new byte[LENGTH];
            for (int i = 0; i < 20_000; i++) {
                test(arr1, arr2);
            }
            RESULT = test(arr1, arr2);
        }

        static int test(byte[] obja, byte[] objb) {
            long offset = Unsafe.ARRAY_BYTE_BASE_OFFSET;
            int  scale  = ArraysSupport.LOG2_ARRAY_BYTE_INDEX_SCALE;
            return ArraysSupport.vectorizedMismatch(obja, offset, objb, offset, LENGTH, scale); // LENGTH is not considered a constant
        }
    }

    int testConstantBeingInitialized() {
        return ClassInitTest.RESULT; // trigger class initialization
    }

    /* ==================================================================================== */

    int testLoopUnswitch(int length) {
        long offset = Unsafe.ARRAY_BYTE_BASE_OFFSET;
        int  scale  = ArraysSupport.LOG2_ARRAY_BYTE_INDEX_SCALE;

        int acc = 0;
        for (int i = 0; i < 32; i++) {
            acc += ArraysSupport.vectorizedMismatch(byte_a, offset, byte_b, offset, length, scale);
        }
        return acc;
    }

    int testLoopHoist(int length, int stride) {
        long offset = Unsafe.ARRAY_BYTE_BASE_OFFSET;
        int  scale  = ArraysSupport.LOG2_ARRAY_BYTE_INDEX_SCALE;

        int acc = 0;

        for (int i = 0; i < 32; i += stride) {
            acc += ArraysSupport.vectorizedMismatch(byte_a, offset, byte_b, offset, length, scale);
        }
        return acc;
    }

    /* ==================================================================================== */

    public static void main(String[] args) {
        VectorizedMismatchTest t = new VectorizedMismatchTest();
        for (int i = 0; i < 20_000; i++) {
            t.testBooleanConstantLength0();
            t.testBooleanConstantLength1();
            t.testBooleanConstantLength64();
            t.testBooleanConstantLength128();

            t.testByteConstantLength0();
            t.testByteConstantLength1();
            t.testByteConstantLength64();
            t.testByteConstantLength128();

            t.testShortConstantLength0();
            t.testShortConstantLength1();
            t.testShortConstantLength32();
            t.testShortConstantLength64();

            t.testCharConstantLength0();
            t.testCharConstantLength1();
            t.testCharConstantLength32();
            t.testCharConstantLength64();

            t.testIntConstantLength0();
            t.testIntConstantLength1();
            t.testIntConstantLength16();
            t.testIntConstantLength32();

            t.testFloatConstantLength0();
            t.testFloatConstantLength1();
            t.testFloatConstantLength16();
            t.testFloatConstantLength32();

            t.testLongConstantLength0();
            t.testLongConstantLength1();
            t.testLongConstantLength8();
            t.testLongConstantLength16();

            t.testDoubleConstantLength0();
            t.testDoubleConstantLength1();
            t.testDoubleConstantLength8();
            t.testDoubleConstantLength16();

            t.testLoopUnswitch(32);
            t.testLoopHoist(128, 2);
        }
    }
}