| /* |
| * Copyright (C) 2017 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| /** |
| * Tests for MIN/MAX vectorization. |
| */ |
| public class ByteSimdMinMax { |
| |
| /// CHECK-START: void ByteSimdMinMax.doitMin(byte[], byte[], byte[]) loop_optimization (before) |
| /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Get1:b\d+>> ArrayGet loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Get2:b\d+>> ArrayGet loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Min:i\d+>> Min [<<Get1>>,<<Get2>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Cnv:b\d+>> TypeConversion [<<Min>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none |
| // |
| /// CHECK-START-{ARM,ARM64,MIPS64}: void ByteSimdMinMax.doitMin(byte[], byte[], byte[]) loop_optimization (after) |
| /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Min:d\d+>> VecMin [<<Get1>>,<<Get2>>] packed_type:Int8 loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<Min>>] loop:<<Loop>> outer_loop:none |
| private static void doitMin(byte[] x, byte[] y, byte[] z) { |
| int min = Math.min(x.length, Math.min(y.length, z.length)); |
| for (int i = 0; i < min; i++) { |
| x[i] = (byte) Math.min(y[i], z[i]); |
| } |
| } |
| |
| /// CHECK-START: void ByteSimdMinMax.doitMinUnsigned(byte[], byte[], byte[]) instruction_simplifier (before) |
| /// CHECK-DAG: <<I255:i\d+>> IntConstant 255 loop:none |
| /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Get1:b\d+>> ArrayGet loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Get2:b\d+>> ArrayGet loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<And1:i\d+>> And [<<Get1>>,<<I255>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<And2:i\d+>> And [<<Get2>>,<<I255>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Min:i\d+>> InvokeStaticOrDirect [<<And1>>,<<And2>>] intrinsic:MathMinIntInt loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Cnv:b\d+>> TypeConversion [<<Min>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: ArraySet [{{l\d+}},{{i\d+}},<<Cnv>>] loop:<<Loop>> outer_loop:none |
| // |
| /// CHECK-START: void ByteSimdMinMax.doitMinUnsigned(byte[], byte[], byte[]) loop_optimization (before) |
| /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Get1:a\d+>> ArrayGet loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Get2:a\d+>> ArrayGet loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Min:i\d+>> Min [<<Get1>>,<<Get2>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Cnv:b\d+>> TypeConversion [<<Min>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none |
| // |
| /// CHECK-START-{ARM,ARM64,MIPS64}: void ByteSimdMinMax.doitMinUnsigned(byte[], byte[], byte[]) loop_optimization (after) |
| /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Min:d\d+>> VecMin [<<Get1>>,<<Get2>>] packed_type:Uint8 loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<Min>>] loop:<<Loop>> outer_loop:none |
| private static void doitMinUnsigned(byte[] x, byte[] y, byte[] z) { |
| int min = Math.min(x.length, Math.min(y.length, z.length)); |
| for (int i = 0; i < min; i++) { |
| x[i] = (byte) Math.min(y[i] & 0xff, z[i] & 0xff); |
| } |
| } |
| |
| /// CHECK-START: void ByteSimdMinMax.doitMax(byte[], byte[], byte[]) loop_optimization (before) |
| /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Get1:b\d+>> ArrayGet loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Get2:b\d+>> ArrayGet loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Max:i\d+>> Max [<<Get1>>,<<Get2>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Cnv:b\d+>> TypeConversion [<<Max>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none |
| // |
| /// CHECK-START-{ARM,ARM64,MIPS64}: void ByteSimdMinMax.doitMax(byte[], byte[], byte[]) loop_optimization (after) |
| /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Max:d\d+>> VecMax [<<Get1>>,<<Get2>>] packed_type:Int8 loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<Max>>] loop:<<Loop>> outer_loop:none |
| private static void doitMax(byte[] x, byte[] y, byte[] z) { |
| int min = Math.min(x.length, Math.min(y.length, z.length)); |
| for (int i = 0; i < min; i++) { |
| x[i] = (byte) Math.max(y[i], z[i]); |
| } |
| } |
| |
| /// CHECK-START: void ByteSimdMinMax.doitMaxUnsigned(byte[], byte[], byte[]) instruction_simplifier (before) |
| /// CHECK-DAG: <<I255:i\d+>> IntConstant 255 loop:none |
| /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Get1:b\d+>> ArrayGet loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Get2:b\d+>> ArrayGet loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<And1:i\d+>> And [<<Get1>>,<<I255>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<And2:i\d+>> And [<<Get2>>,<<I255>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Max:i\d+>> InvokeStaticOrDirect [<<And1>>,<<And2>>] intrinsic:MathMaxIntInt loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Cnv:b\d+>> TypeConversion [<<Max>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: ArraySet [{{l\d+}},{{i\d+}},<<Cnv>>] loop:<<Loop>> outer_loop:none |
| // |
| /// CHECK-START: void ByteSimdMinMax.doitMaxUnsigned(byte[], byte[], byte[]) loop_optimization (before) |
| /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Get1:a\d+>> ArrayGet loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Get2:a\d+>> ArrayGet loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Max:i\d+>> Max [<<Get1>>,<<Get2>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Cnv:b\d+>> TypeConversion [<<Max>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none |
| // |
| /// CHECK-START-{ARM,ARM64,MIPS64}: void ByteSimdMinMax.doitMaxUnsigned(byte[], byte[], byte[]) loop_optimization (after) |
| /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Max:d\d+>> VecMax [<<Get1>>,<<Get2>>] packed_type:Uint8 loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<Max>>] loop:<<Loop>> outer_loop:none |
| private static void doitMaxUnsigned(byte[] x, byte[] y, byte[] z) { |
| int min = Math.min(x.length, Math.min(y.length, z.length)); |
| for (int i = 0; i < min; i++) { |
| x[i] = (byte) Math.max(y[i] & 0xff, z[i] & 0xff); |
| } |
| } |
| |
| /// CHECK-START: void ByteSimdMinMax.doitMin100(byte[], byte[]) loop_optimization (before) |
| /// CHECK-DAG: <<I100:i\d+>> IntConstant 100 loop:none |
| /// CHECK-DAG: <<Phi:i\d+>> Phi loop:<<Loop:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Get:b\d+>> ArrayGet loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Min:i\d+>> Min [<<Get>>,<<I100>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Cnv:b\d+>> TypeConversion [<<Min>>] loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: ArraySet [{{l\d+}},<<Phi>>,<<Cnv>>] loop:<<Loop>> outer_loop:none |
| // |
| /// CHECK-START-{ARM,ARM64,MIPS64}: void ByteSimdMinMax.doitMin100(byte[], byte[]) loop_optimization (after) |
| /// CHECK-DAG: <<I100:i\d+>> IntConstant 100 loop:none |
| /// CHECK-DAG: <<Repl:d\d+>> VecReplicateScalar [<<I100>>] loop:none |
| /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Min:d\d+>> VecMin [<<Get>>,<<Repl>>] packed_type:Int8 loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<Min>>] loop:<<Loop>> outer_loop:none |
| private static void doitMin100(byte[] x, byte[] y) { |
| int min = Math.min(x.length, y.length); |
| for (int i = 0; i < min; i++) { |
| x[i] = (byte) Math.min(y[i], 100); |
| } |
| } |
| |
| /// CHECK-START-{ARM,ARM64,MIPS64}: void ByteSimdMinMax.doitMinMax(byte[], byte[]) loop_optimization (after) |
| /// CHECK-DAG: <<I11:i\d+>> IntConstant -11 loop:none |
| /// CHECK-DAG: <<I23:i\d+>> IntConstant 23 loop:none |
| /// CHECK-DAG: <<Rpl1:d\d+>> VecReplicateScalar [<<I23>>] loop:none |
| /// CHECK-DAG: <<Rpl2:d\d+>> VecReplicateScalar [<<I11>>] loop:none |
| /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Min:d\d+>> VecMin [<<Get>>,<<Rpl1>>] packed_type:Int8 loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Max:d\d+>> VecMax [<<Min>>,<<Rpl2>>] packed_type:Int8 loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<Max>>] loop:<<Loop>> outer_loop:none |
| private static void doitMinMax(byte[] x, byte[] y) { |
| int n = Math.min(x.length, y.length); |
| for (int i = 0; i < n; i++) { |
| x[i] = (byte) Math.max(-11, Math.min(y[i], 23)); |
| } |
| } |
| |
| /// CHECK-START-{ARM,ARM64,MIPS64}: void ByteSimdMinMax.doitMinMaxUnsigned(byte[], byte[]) loop_optimization (after) |
| /// CHECK-DAG: <<I11:i\d+>> IntConstant 11 loop:none |
| /// CHECK-DAG: <<I23:i\d+>> IntConstant 23 loop:none |
| /// CHECK-DAG: <<Rpl1:d\d+>> VecReplicateScalar [<<I23>>] loop:none |
| /// CHECK-DAG: <<Rpl2:d\d+>> VecReplicateScalar [<<I11>>] loop:none |
| /// CHECK-DAG: <<Get:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Min:d\d+>> VecMin [<<Get>>,<<Rpl1>>] packed_type:Uint8 loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Max:d\d+>> VecMax [<<Min>>,<<Rpl2>>] packed_type:Uint8 loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<Max>>] loop:<<Loop>> outer_loop:none |
| private static void doitMinMaxUnsigned(byte[] x, byte[] y) { |
| int n = Math.min(x.length, y.length); |
| for (int i = 0; i < n; i++) { |
| x[i] = (byte) Math.max(11, Math.min(y[i] & 0xff, 23)); |
| } |
| } |
| |
| /// CHECK-START-{ARM,ARM64}: void ByteSimdMinMax.doitMinAlt(byte[], byte[], byte[]) loop_optimization (after) |
| /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Min:d\d+>> VecMin [<<Get1>>,<<Get2>>] packed_type:Int8 loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<Min>>] loop:<<Loop>> outer_loop:none |
| private static void doitMinAlt(byte[] x, byte[] y, byte[] z) { |
| int n = Math.min(x.length, Math.min(y.length, z.length)); |
| for (int i = 0; i < n; ++i) { |
| x[i] = y[i] < z[i] ? y[i] : z[i]; |
| } |
| } |
| |
| /// CHECK-START-{ARM,ARM64,MIPS64}: void ByteSimdMinMax.doitMaxAlt(byte[], byte[], byte[]) loop_optimization (after) |
| /// CHECK-DAG: <<Get1:d\d+>> VecLoad loop:<<Loop:B\d+>> outer_loop:none |
| /// CHECK-DAG: <<Get2:d\d+>> VecLoad loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: <<Max:d\d+>> VecMax [<<Get1>>,<<Get2>>] packed_type:Int8 loop:<<Loop>> outer_loop:none |
| /// CHECK-DAG: VecStore [{{l\d+}},{{i\d+}},<<Max>>] loop:<<Loop>> outer_loop:none |
| private static void doitMaxAlt(byte[] x, byte[] y, byte[] z) { |
| int n = Math.min(x.length, Math.min(y.length, z.length)); |
| for (int i = 0; i < n; ++i) { |
| x[i] = y[i] > z[i] ? y[i] : z[i]; |
| } |
| } |
| |
| public static void main() { |
| // Initialize cross-values for all possible values. |
| int total = 256 * 256; |
| byte[] x = new byte[total]; |
| byte[] y = new byte[total]; |
| byte[] z = new byte[total]; |
| int k = 0; |
| for (int i = 0; i < 256; i++) { |
| for (int j = 0; j < 256; j++) { |
| x[k] = 0; |
| y[k] = (byte) i; |
| z[k] = (byte) j; |
| k++; |
| } |
| } |
| |
| // And test. |
| doitMin(x, y, z); |
| for (int i = 0; i < total; i++) { |
| byte expected = (byte) Math.min(y[i], z[i]); |
| expectEquals(expected, x[i]); |
| } |
| doitMinUnsigned(x, y, z); |
| for (int i = 0; i < total; i++) { |
| byte expected = (byte) Math.min(y[i] & 0xff, z[i] & 0xff); |
| expectEquals(expected, x[i]); |
| } |
| doitMax(x, y, z); |
| for (int i = 0; i < total; i++) { |
| byte expected = (byte) Math.max(y[i], z[i]); |
| expectEquals(expected, x[i]); |
| } |
| doitMaxUnsigned(x, y, z); |
| for (int i = 0; i < total; i++) { |
| byte expected = (byte) Math.max(y[i] & 0xff, z[i] & 0xff); |
| expectEquals(expected, x[i]); |
| } |
| doitMin100(x, y); |
| for (int i = 0; i < total; i++) { |
| byte expected = (byte) Math.min(y[i], 100); |
| expectEquals(expected, x[i]); |
| } |
| doitMinMax(x, y); |
| for (int i = 0; i < total; i++) { |
| int s = y[i]; |
| byte expected = (byte) (s < -11 ? -11 : (s > 23 ? 23 : s)); |
| expectEquals(expected, x[i]); |
| } |
| doitMinMaxUnsigned(x, y); |
| for (int i = 0; i < total; i++) { |
| int u = y[i] & 0xff; |
| byte expected = (byte) (u < 11 ? 11 : (u > 23 ? 23 : u)); |
| expectEquals(expected, x[i]); |
| } |
| doitMinAlt(x, y, z); |
| for (int i = 0; i < total; i++) { |
| byte expected = (byte) Math.min(y[i], z[i]); |
| expectEquals(expected, x[i]); |
| } |
| doitMaxAlt(x, y, z); |
| for (int i = 0; i < total; i++) { |
| byte expected = (byte) Math.max(y[i], z[i]); |
| expectEquals(expected, x[i]); |
| } |
| System.out.println("ByteSimdMinMax passed"); |
| } |
| |
| private static void expectEquals(byte expected, byte result) { |
| if (expected != result) { |
| throw new Error("Expected: " + expected + ", found: " + result); |
| } |
| } |
| } |