From 563fbde8b9ae1d849829be3c114bbfd8ddc4eb45 Mon Sep 17 00:00:00 2001 From: Faye Gao Date: Wed, 24 Nov 2021 11:00:50 +0000 Subject: [PATCH 1/4] 8276673: Optimize abs operations in C2 compiler The patch aims to help optimize Math.abs() mainly from these three parts: 1) Remove redundant instructions for abs with constant values 2) Remove redundant instructions for abs with char type 3) Convert some common abs operations to ideal forms 1. Remove redundant instructions for abs with constant values If we can decide the value of the input node for function Math.abs() at compile-time, we can substitute the Abs node with the absolute value of the constant and don't have to calculate it at runtime. For example, int[] a for (int i = 0; i < SIZE; i++) { a[i] = Math.abs(-38); } Before the patch, the generated code for the testcase above is: ... mov w10, #0xffffffda cmp w10, wzr cneg w17, w10, lt dup v16.8h, w17 ... After the patch, the generated code for the testcase above is : ... movi v16.4s, #0x26 ... 2. Remove redundant instructions for abs with char type In Java semantics, as the char type is always non-negative, we could actually remove the absI node in the C2 middle end. As for vectorization part, in current SLP, the vectorization of Math.abs() with char type is intentionally disabled after JDK-8261022 because it generates incorrect result before. After removing the AbsI node in the middle end, Math.abs(char) can be vectorized naturally. For example, char[] a; char[] b; for (int i = 0; i < SIZE; i++) { b[i] = (char) Math.abs(a[i]); } Before the patch, the generated assembly code for the testcase above is: B15: add x13, x21, w20, sxtw #1 ldrh w11, [x13, #16] cmp w11, wzr cneg w10, w11, lt strh w10, [x13, #16] ldrh w10, [x13, #18] cmp w10, wzr cneg w10, w10, lt strh w10, [x13, #18] ... add w20, w20, #0x1 cmp w20, w17 b.lt B15 After the patch, the generated assembly code is: B15: sbfiz x18, x19, #1, #32 add x0, x14, x18 ldr q16, [x0, #16] add x18, x21, x18 str q16, [x18, #16] ldr q16, [x0, #32] str q16, [x18, #32] ... add w19, w19, #0x40 cmp w19, w17 b.lt B15 3. Convert some common abs operations to ideal forms The patch overrides some virtual support functions for AbsNode so that optimization of gvn can work on it. Here are the optimizable forms: a) abs(0 - x) => abs(x) Before the patch: ... ldr w13, [x13, #16] neg w13, w13 cmp w13, wzr cneg w14, w13, lt ... After the patch: ... ldr w13, [x13, #16] cmp w13, wzr cneg w13, w13, lt ... b) abs(abs(x)) => abs(x) Before the patch: ... ldr w12, [x12, #16] cmp w12, wzr cneg w12, w12, lt cmp w12, wzr cneg w12, w12, lt ... After the patch: ... ldr w13, [x13, #16] cmp w13, wzr cneg w13, w13, lt ... Change-Id: I5434c01a225796caaf07ffbb19983f4fe2e206bd --- src/hotspot/share/opto/subnode.cpp | 66 +++++++++ src/hotspot/share/opto/subnode.hpp | 5 +- src/hotspot/share/opto/type.hpp | 4 +- test/hotspot/jtreg/compiler/c2/TestAbs.java | 155 +++++++++++++++++++- 4 files changed, 223 insertions(+), 7 deletions(-) diff --git a/src/hotspot/share/opto/subnode.cpp b/src/hotspot/share/opto/subnode.cpp index 5956b1738f1ee..0a35573d93e38 100644 --- a/src/hotspot/share/opto/subnode.cpp +++ b/src/hotspot/share/opto/subnode.cpp @@ -1825,6 +1825,72 @@ bool BoolNode::is_counted_loop_exit_test() { return false; } +//============================================================================= +//------------------------------Value------------------------------------------ +const Type* AbsNode::Value(PhaseGVN* phase) const { + const Type* t1 = phase->type(in(1)); + if (t1 == Type::TOP) return Type::TOP; + + switch (t1->base()) { + case Type::Int: { + const TypeInt* ti = t1->is_int(); + if (ti->is_con()) { + // Special case for min_jint: Math.abs(min_jint) = min_jint. + // Do not use C++ abs() for min_jint to avoid undefined behavior. + return (ti->is_con(min_jint)) ? TypeInt::MIN : TypeInt::make(abs(ti->get_con())); + } + break; + } + case Type::Long: { + const TypeLong* tl = t1->is_long(); + if (tl->is_con()) { + // Special case for min_jlong: Math.abs(min_jlong) = min_jlong. + // Do not use C++ abs() for min_jlong to avoid undefined behavior. + return (tl->is_con(min_jlong)) ? TypeLong::MIN : TypeLong::make(abs(tl->get_con())); + } + break; + } + case Type::FloatCon: + return TypeF::make(abs(t1->getf())); + case Type::DoubleCon: + return TypeD::make(abs(t1->getd())); + default: + break; + } + + return bottom_type(); +} + +//------------------------------Identity---------------------------------------- +Node* AbsNode::Identity(PhaseGVN* phase) { + Node* in1 = in(1); + // No need to do abs for non-negative values + if (phase->type(in1)->higher_equal(TypeInt::POS) || + phase->type(in1)->higher_equal(TypeLong::POS)) { + return in1; + } + // Convert "abs(abs(x))" into "abs(x)" + if (in1->Opcode() == Opcode()) { + return in1; + } + return this; +} + +//------------------------------Ideal------------------------------------------ +Node* AbsNode::Ideal(PhaseGVN* phase, bool can_reshape) { + Node* in1 = in(1); + // Convert "abs(0-x)" into "abs(x)" + if (in1->is_Sub() && phase->type(in1->in(1))->is_zero_type()) { + set_req(1, in1->in(2)); + PhaseIterGVN* igvn = phase->is_IterGVN(); + if (igvn) { + igvn->_worklist.push(in1); + } + return this; + } + return NULL; +} + //============================================================================= //------------------------------Value------------------------------------------ // Compute sqrt diff --git a/src/hotspot/share/opto/subnode.hpp b/src/hotspot/share/opto/subnode.hpp index 281b28237c85c..23087f164aeab 100644 --- a/src/hotspot/share/opto/subnode.hpp +++ b/src/hotspot/share/opto/subnode.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2019, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 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 @@ -379,6 +379,9 @@ class BoolNode : public Node { class AbsNode : public Node { public: AbsNode( Node *value ) : Node(0,value) {} + virtual Node* Identity(PhaseGVN* phase); + virtual Node* Ideal(PhaseGVN* phase, bool can_reshape); + virtual const Type* Value(PhaseGVN* phase) const; }; //------------------------------AbsINode--------------------------------------- diff --git a/src/hotspot/share/opto/type.hpp b/src/hotspot/share/opto/type.hpp index 6a927ee49a784..83ff37c9a30e5 100644 --- a/src/hotspot/share/opto/type.hpp +++ b/src/hotspot/share/opto/type.hpp @@ -589,7 +589,7 @@ class TypeInt : public TypeInteger { // Check for single integer int is_con() const { return _lo==_hi; } - bool is_con(int i) const { return is_con() && _lo == i; } + bool is_con(jint i) const { return is_con() && _lo == i; } jint get_con() const { assert( is_con(), "" ); return _lo; } virtual bool is_finite() const; // Has a finite value @@ -657,7 +657,7 @@ class TypeLong : public TypeInteger { // Check for single integer int is_con() const { return _lo==_hi; } - bool is_con(int i) const { return is_con() && _lo == i; } + bool is_con(jlong i) const { return is_con() && _lo == i; } jlong get_con() const { assert( is_con(), "" ); return _lo; } // Check for positive 32-bit value. diff --git a/test/hotspot/jtreg/compiler/c2/TestAbs.java b/test/hotspot/jtreg/compiler/c2/TestAbs.java index 6dfbbbfd5b638..c98804718d370 100644 --- a/test/hotspot/jtreg/compiler/c2/TestAbs.java +++ b/test/hotspot/jtreg/compiler/c2/TestAbs.java @@ -21,17 +21,151 @@ * questions. */ -package compiler.c2; - /* * @test - * @bug 8248445 - * @summary Use of AbsI / AbsL nodes should be limited to supported platforms + * @bug 8248445 8276673 + * @summary Abs nodes detection and optimization in C2 + * @library /test/lib * @requires vm.debug == true * * @run main/othervm -XX:-TieredCompilation -Xbatch -XX:CompileOnly=java.lang.Math::abs compiler.c2.TestAbs + * @run main/othervm -XX:-TieredCompilation compiler.c2.TestAbs */ + +package compiler.c2; +import jdk.test.lib.Asserts; + public class TestAbs { + private static int SIZE = 500; + + public static char [] cspecial = { + 0, 42, 128, 256, 1024, 4096, 65535 + }; + + public static int [] ispecial = { + 0, Integer.MAX_VALUE, Integer.MIN_VALUE, -42, 42, -1, 1 + }; + + public static long [] lspecial = { + 0, Long.MAX_VALUE, Long.MIN_VALUE, -42, 42, -1, 1 + }; + + public static float [] fspecial = { + 0.0f, + -0.0f, + Float.MAX_VALUE, + Float.MIN_VALUE, + -Float.MAX_VALUE, + -Float.MIN_VALUE, + Float.NaN, + Float.POSITIVE_INFINITY, + Float.NEGATIVE_INFINITY, + Integer.MAX_VALUE, + Integer.MIN_VALUE, + Long.MAX_VALUE, + Long.MIN_VALUE, + -1.0f, + 1.0f, + -42.0f, + 42.0f + }; + + public static double [] dspecial = { + 0.0, + -0.0, + Double.MAX_VALUE, + Double.MIN_VALUE, + -Double.MAX_VALUE, + -Double.MIN_VALUE, + Double.NaN, + Double.POSITIVE_INFINITY, + Double.NEGATIVE_INFINITY, + Integer.MAX_VALUE, + Integer.MIN_VALUE, + Long.MIN_VALUE, + Long.MAX_VALUE, + -1, + 1, + 42, + -42, + Math.PI, + Math.E, + Float.MAX_VALUE, + Float.MIN_VALUE, + -Float.MAX_VALUE, + -Float.MIN_VALUE, + Float.NaN, + Float.POSITIVE_INFINITY, + Float.NEGATIVE_INFINITY + }; + + public static void testAbsConstant() { + // Test abs(constant) optimization for int + Asserts.assertEquals(Integer.MAX_VALUE, Math.abs(Integer.MAX_VALUE)); + Asserts.assertEquals(Integer.MIN_VALUE, Math.abs(Integer.MIN_VALUE)); + Asserts.assertEquals(Integer.MAX_VALUE, Math.abs(-Integer.MAX_VALUE)); + + // Test abs(constant) optimization for long + Asserts.assertEquals(Long.MAX_VALUE, Math.abs(Long.MAX_VALUE)); + Asserts.assertEquals(Long.MIN_VALUE, Math.abs(Long.MIN_VALUE)); + Asserts.assertEquals(Long.MAX_VALUE, Math.abs(-Long.MAX_VALUE)); + + // Test abs(constant) optimization for float + Asserts.assertEquals(Float.NaN, Math.abs(Float.NaN)); + Asserts.assertEquals(Float.POSITIVE_INFINITY, Math.abs(Float.NEGATIVE_INFINITY)); + Asserts.assertEquals(Float.POSITIVE_INFINITY, Math.abs(Float.POSITIVE_INFINITY)); + Asserts.assertEquals(0.0f, Math.abs(0.0f)); + Asserts.assertEquals(0.0f, Math.abs(-0.0f)); + Asserts.assertEquals(Float.MAX_VALUE, Math.abs(Float.MAX_VALUE)); + Asserts.assertEquals(Float.MIN_VALUE, Math.abs(Float.MIN_VALUE)); + Asserts.assertEquals(Float.MAX_VALUE, Math.abs(-Float.MAX_VALUE)); + Asserts.assertEquals(Float.MIN_VALUE, Math.abs(-Float.MIN_VALUE)); + + // Test abs(constant) optimization for double + Asserts.assertEquals(Double.NaN, Math.abs(Double.NaN)); + Asserts.assertEquals(Double.POSITIVE_INFINITY, Math.abs(Double.NEGATIVE_INFINITY)); + Asserts.assertEquals(Double.POSITIVE_INFINITY, Math.abs(Double.POSITIVE_INFINITY)); + Asserts.assertEquals(0.0, Math.abs(0.0)); + Asserts.assertEquals(0.0, Math.abs(-0.0)); + Asserts.assertEquals(Double.MAX_VALUE, Math.abs(Double.MAX_VALUE)); + Asserts.assertEquals(Double.MIN_VALUE, Math.abs(Double.MIN_VALUE)); + Asserts.assertEquals(Double.MAX_VALUE, Math.abs(-Double.MAX_VALUE)); + Asserts.assertEquals(Double.MIN_VALUE, Math.abs(-Double.MIN_VALUE)); + } + + private static void testAbsTransformInt(int[] a) { + for (int i = 0; i < a.length; i++) { + Asserts.assertEquals(Math.abs(Math.abs(a[i])), Math.abs(a[i])); + Asserts.assertEquals(Math.abs(0 - a[i]), Math.abs(a[i])); + } + } + + private static void testAbsTransformLong(long[] a) { + for (int i = 0; i < a.length; i++) { + Asserts.assertEquals(Math.abs(Math.abs(a[i])), Math.abs(a[i])); + Asserts.assertEquals(Math.abs(0 - a[i]), Math.abs(a[i])); + } + } + + private static void testAbsTransformFloat(float[] a) { + for (int i = 0; i < a.length; i++) { + Asserts.assertEquals(Math.abs(Math.abs(a[i])), Math.abs(a[i])); + Asserts.assertEquals(Math.abs(0 - a[i]), Math.abs(a[i])); + } + } + + private static void testAbsTransformDouble(double[] a) { + for (int i = 0; i < a.length; i++) { + Asserts.assertEquals(Math.abs(Math.abs(a[i])), Math.abs(a[i])); + Asserts.assertEquals(Math.abs(0 - a[i]), Math.abs(a[i])); + } + } + + private static void testAbsOptChar(char[] a) { + for (int i = 0; i < a.length; i++) { + Asserts.assertEquals(a[i], (char) Math.abs(a[i])); + } + } public static void test() { // java.lang.Math.abs() collapses into AbsI/AbsL nodes on platforms that support the correspondent nodes @@ -45,7 +179,20 @@ public static void test() { public static void main(String args[]) { for (int i = 0; i < 20_000; i++) { test(); + + testAbsConstant(); + + // Verify abs(abs(x)) = abs(x) for all types + // Verify abs(0-x) = abs(x) for all types + testAbsTransformInt(ispecial); + testAbsTransformLong(lspecial); + testAbsTransformFloat(fspecial); + testAbsTransformDouble(dspecial); + + // Verify abs(non-negative_value) = non-negative_value + testAbsOptChar(cspecial); } + } } From 2d122a2d096530962719541966f06821929b01d1 Mon Sep 17 00:00:00 2001 From: Fei Gao Date: Wed, 15 Dec 2021 14:58:34 +0000 Subject: [PATCH 2/4] Add a jmh benchmark case Change-Id: I64938d543126c2e3f9fad8ffc4a50e25e4473d8f --- test/micro/org/openjdk/bench/java/lang/MathBench.java | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/test/micro/org/openjdk/bench/java/lang/MathBench.java b/test/micro/org/openjdk/bench/java/lang/MathBench.java index 6cd1353907e97..2c7b7ca27d612 100644 --- a/test/micro/org/openjdk/bench/java/lang/MathBench.java +++ b/test/micro/org/openjdk/bench/java/lang/MathBench.java @@ -101,6 +101,11 @@ public long absLong() { return Math.abs(long13); } + @Benchmark + public int absConstantInt() { + return Math.abs(-3); + } + @Benchmark public double acosDouble() { return Math.acos(double1); From e254d9f7ebf5b4b10669a5969077091bca8aeb2d Mon Sep 17 00:00:00 2001 From: Fei Gao Date: Fri, 17 Dec 2021 11:20:17 +0000 Subject: [PATCH 3/4] Use uabs() to calculate the absolute value of constant Change-Id: Ie6f37ab159fb7092e1443b9af8d620562a45ae47 --- src/hotspot/share/opto/subnode.cpp | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/src/hotspot/share/opto/subnode.cpp b/src/hotspot/share/opto/subnode.cpp index 524de14435048..a04c87f22e7b6 100644 --- a/src/hotspot/share/opto/subnode.cpp +++ b/src/hotspot/share/opto/subnode.cpp @@ -1849,18 +1849,14 @@ const Type* AbsNode::Value(PhaseGVN* phase) const { case Type::Int: { const TypeInt* ti = t1->is_int(); if (ti->is_con()) { - // Special case for min_jint: Math.abs(min_jint) = min_jint. - // Do not use C++ abs() for min_jint to avoid undefined behavior. - return (ti->is_con(min_jint)) ? TypeInt::MIN : TypeInt::make(abs(ti->get_con())); + return TypeInt::make(uabs(ti->get_con())); } break; } case Type::Long: { const TypeLong* tl = t1->is_long(); if (tl->is_con()) { - // Special case for min_jlong: Math.abs(min_jlong) = min_jlong. - // Do not use C++ abs() for min_jlong to avoid undefined behavior. - return (tl->is_con(min_jlong)) ? TypeLong::MIN : TypeLong::make(abs(tl->get_con())); + return TypeLong::make(uabs(tl->get_con())); } break; } From 845d43a1aa71aa6e1230d68c28ae9adcdc1228df Mon Sep 17 00:00:00 2001 From: Fei Gao Date: Fri, 14 Jan 2022 06:34:02 +0000 Subject: [PATCH 4/4] Add a case in the C2 IR test framework Change-Id: Ia2372ed06fcc7c88285461a1b013898d9327c18e --- src/hotspot/share/opto/subnode.cpp | 8 +- src/hotspot/share/opto/subnode.hpp | 2 +- src/hotspot/share/opto/type.hpp | 2 +- test/hotspot/jtreg/compiler/c2/TestAbs.java | 155 +----------- .../jtreg/compiler/c2/irTests/TestIRAbs.java | 231 ++++++++++++++++++ .../compiler/lib/ir_framework/IRNode.java | 6 + .../openjdk/bench/java/lang/MathBench.java | 5 - 7 files changed, 245 insertions(+), 164 deletions(-) create mode 100644 test/hotspot/jtreg/compiler/c2/irTests/TestIRAbs.java diff --git a/src/hotspot/share/opto/subnode.cpp b/src/hotspot/share/opto/subnode.cpp index a095eda9870d1..67b60f74c6098 100644 --- a/src/hotspot/share/opto/subnode.cpp +++ b/src/hotspot/share/opto/subnode.cpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2022, 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 @@ -1899,11 +1899,7 @@ Node* AbsNode::Ideal(PhaseGVN* phase, bool can_reshape) { Node* in1 = in(1); // Convert "abs(0-x)" into "abs(x)" if (in1->is_Sub() && phase->type(in1->in(1))->is_zero_type()) { - set_req(1, in1->in(2)); - PhaseIterGVN* igvn = phase->is_IterGVN(); - if (igvn) { - igvn->_worklist.push(in1); - } + set_req_X(1, in1->in(2), phase); return this; } return NULL; diff --git a/src/hotspot/share/opto/subnode.hpp b/src/hotspot/share/opto/subnode.hpp index a52df9b1034e2..55b0e90a3875e 100644 --- a/src/hotspot/share/opto/subnode.hpp +++ b/src/hotspot/share/opto/subnode.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2022, 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 diff --git a/src/hotspot/share/opto/type.hpp b/src/hotspot/share/opto/type.hpp index 874ba5462f811..0007ed0c5e004 100644 --- a/src/hotspot/share/opto/type.hpp +++ b/src/hotspot/share/opto/type.hpp @@ -1,5 +1,5 @@ /* - * Copyright (c) 1997, 2021, Oracle and/or its affiliates. All rights reserved. + * Copyright (c) 1997, 2022, 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 diff --git a/test/hotspot/jtreg/compiler/c2/TestAbs.java b/test/hotspot/jtreg/compiler/c2/TestAbs.java index c98804718d370..6dfbbbfd5b638 100644 --- a/test/hotspot/jtreg/compiler/c2/TestAbs.java +++ b/test/hotspot/jtreg/compiler/c2/TestAbs.java @@ -21,151 +21,17 @@ * questions. */ +package compiler.c2; + /* * @test - * @bug 8248445 8276673 - * @summary Abs nodes detection and optimization in C2 - * @library /test/lib + * @bug 8248445 + * @summary Use of AbsI / AbsL nodes should be limited to supported platforms * @requires vm.debug == true * * @run main/othervm -XX:-TieredCompilation -Xbatch -XX:CompileOnly=java.lang.Math::abs compiler.c2.TestAbs - * @run main/othervm -XX:-TieredCompilation compiler.c2.TestAbs */ - -package compiler.c2; -import jdk.test.lib.Asserts; - public class TestAbs { - private static int SIZE = 500; - - public static char [] cspecial = { - 0, 42, 128, 256, 1024, 4096, 65535 - }; - - public static int [] ispecial = { - 0, Integer.MAX_VALUE, Integer.MIN_VALUE, -42, 42, -1, 1 - }; - - public static long [] lspecial = { - 0, Long.MAX_VALUE, Long.MIN_VALUE, -42, 42, -1, 1 - }; - - public static float [] fspecial = { - 0.0f, - -0.0f, - Float.MAX_VALUE, - Float.MIN_VALUE, - -Float.MAX_VALUE, - -Float.MIN_VALUE, - Float.NaN, - Float.POSITIVE_INFINITY, - Float.NEGATIVE_INFINITY, - Integer.MAX_VALUE, - Integer.MIN_VALUE, - Long.MAX_VALUE, - Long.MIN_VALUE, - -1.0f, - 1.0f, - -42.0f, - 42.0f - }; - - public static double [] dspecial = { - 0.0, - -0.0, - Double.MAX_VALUE, - Double.MIN_VALUE, - -Double.MAX_VALUE, - -Double.MIN_VALUE, - Double.NaN, - Double.POSITIVE_INFINITY, - Double.NEGATIVE_INFINITY, - Integer.MAX_VALUE, - Integer.MIN_VALUE, - Long.MIN_VALUE, - Long.MAX_VALUE, - -1, - 1, - 42, - -42, - Math.PI, - Math.E, - Float.MAX_VALUE, - Float.MIN_VALUE, - -Float.MAX_VALUE, - -Float.MIN_VALUE, - Float.NaN, - Float.POSITIVE_INFINITY, - Float.NEGATIVE_INFINITY - }; - - public static void testAbsConstant() { - // Test abs(constant) optimization for int - Asserts.assertEquals(Integer.MAX_VALUE, Math.abs(Integer.MAX_VALUE)); - Asserts.assertEquals(Integer.MIN_VALUE, Math.abs(Integer.MIN_VALUE)); - Asserts.assertEquals(Integer.MAX_VALUE, Math.abs(-Integer.MAX_VALUE)); - - // Test abs(constant) optimization for long - Asserts.assertEquals(Long.MAX_VALUE, Math.abs(Long.MAX_VALUE)); - Asserts.assertEquals(Long.MIN_VALUE, Math.abs(Long.MIN_VALUE)); - Asserts.assertEquals(Long.MAX_VALUE, Math.abs(-Long.MAX_VALUE)); - - // Test abs(constant) optimization for float - Asserts.assertEquals(Float.NaN, Math.abs(Float.NaN)); - Asserts.assertEquals(Float.POSITIVE_INFINITY, Math.abs(Float.NEGATIVE_INFINITY)); - Asserts.assertEquals(Float.POSITIVE_INFINITY, Math.abs(Float.POSITIVE_INFINITY)); - Asserts.assertEquals(0.0f, Math.abs(0.0f)); - Asserts.assertEquals(0.0f, Math.abs(-0.0f)); - Asserts.assertEquals(Float.MAX_VALUE, Math.abs(Float.MAX_VALUE)); - Asserts.assertEquals(Float.MIN_VALUE, Math.abs(Float.MIN_VALUE)); - Asserts.assertEquals(Float.MAX_VALUE, Math.abs(-Float.MAX_VALUE)); - Asserts.assertEquals(Float.MIN_VALUE, Math.abs(-Float.MIN_VALUE)); - - // Test abs(constant) optimization for double - Asserts.assertEquals(Double.NaN, Math.abs(Double.NaN)); - Asserts.assertEquals(Double.POSITIVE_INFINITY, Math.abs(Double.NEGATIVE_INFINITY)); - Asserts.assertEquals(Double.POSITIVE_INFINITY, Math.abs(Double.POSITIVE_INFINITY)); - Asserts.assertEquals(0.0, Math.abs(0.0)); - Asserts.assertEquals(0.0, Math.abs(-0.0)); - Asserts.assertEquals(Double.MAX_VALUE, Math.abs(Double.MAX_VALUE)); - Asserts.assertEquals(Double.MIN_VALUE, Math.abs(Double.MIN_VALUE)); - Asserts.assertEquals(Double.MAX_VALUE, Math.abs(-Double.MAX_VALUE)); - Asserts.assertEquals(Double.MIN_VALUE, Math.abs(-Double.MIN_VALUE)); - } - - private static void testAbsTransformInt(int[] a) { - for (int i = 0; i < a.length; i++) { - Asserts.assertEquals(Math.abs(Math.abs(a[i])), Math.abs(a[i])); - Asserts.assertEquals(Math.abs(0 - a[i]), Math.abs(a[i])); - } - } - - private static void testAbsTransformLong(long[] a) { - for (int i = 0; i < a.length; i++) { - Asserts.assertEquals(Math.abs(Math.abs(a[i])), Math.abs(a[i])); - Asserts.assertEquals(Math.abs(0 - a[i]), Math.abs(a[i])); - } - } - - private static void testAbsTransformFloat(float[] a) { - for (int i = 0; i < a.length; i++) { - Asserts.assertEquals(Math.abs(Math.abs(a[i])), Math.abs(a[i])); - Asserts.assertEquals(Math.abs(0 - a[i]), Math.abs(a[i])); - } - } - - private static void testAbsTransformDouble(double[] a) { - for (int i = 0; i < a.length; i++) { - Asserts.assertEquals(Math.abs(Math.abs(a[i])), Math.abs(a[i])); - Asserts.assertEquals(Math.abs(0 - a[i]), Math.abs(a[i])); - } - } - - private static void testAbsOptChar(char[] a) { - for (int i = 0; i < a.length; i++) { - Asserts.assertEquals(a[i], (char) Math.abs(a[i])); - } - } public static void test() { // java.lang.Math.abs() collapses into AbsI/AbsL nodes on platforms that support the correspondent nodes @@ -179,20 +45,7 @@ public static void test() { public static void main(String args[]) { for (int i = 0; i < 20_000; i++) { test(); - - testAbsConstant(); - - // Verify abs(abs(x)) = abs(x) for all types - // Verify abs(0-x) = abs(x) for all types - testAbsTransformInt(ispecial); - testAbsTransformLong(lspecial); - testAbsTransformFloat(fspecial); - testAbsTransformDouble(dspecial); - - // Verify abs(non-negative_value) = non-negative_value - testAbsOptChar(cspecial); } - } } diff --git a/test/hotspot/jtreg/compiler/c2/irTests/TestIRAbs.java b/test/hotspot/jtreg/compiler/c2/irTests/TestIRAbs.java new file mode 100644 index 0000000000000..fc8362b1e1f06 --- /dev/null +++ b/test/hotspot/jtreg/compiler/c2/irTests/TestIRAbs.java @@ -0,0 +1,231 @@ +/* + * Copyright (c) 2022, Arm Limited. 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.c2.irTests; + +import jdk.test.lib.Asserts; +import compiler.lib.ir_framework.*; + +/* + * @test + * @bug 8276673 + * @summary Test abs nodes optimization in C2. + * @library /test/lib / + * @run driver compiler.c2.irTests.TestIRAbs + */ + +public class TestIRAbs { + + public static char [] cspecial = { + 0, 42, 128, 256, 1024, 4096, 65535 + }; + + public static int [] ispecial = { + 0, Integer.MAX_VALUE, Integer.MIN_VALUE, -42, 42, -1, 1 + }; + + public static long [] lspecial = { + 0, Long.MAX_VALUE, Long.MIN_VALUE, -42, 42, -1, 1 + }; + + public static float [] fspecial = { + 0.0f, + -0.0f, + Float.MAX_VALUE, + Float.MIN_VALUE, + -Float.MAX_VALUE, + -Float.MIN_VALUE, + Float.NaN, + Float.POSITIVE_INFINITY, + Float.NEGATIVE_INFINITY, + Integer.MAX_VALUE, + Integer.MIN_VALUE, + Long.MAX_VALUE, + Long.MIN_VALUE, + -1.0f, + 1.0f, + -42.0f, + 42.0f + }; + + public static double [] dspecial = { + 0.0, + -0.0, + Double.MAX_VALUE, + Double.MIN_VALUE, + -Double.MAX_VALUE, + -Double.MIN_VALUE, + Double.NaN, + Double.POSITIVE_INFINITY, + Double.NEGATIVE_INFINITY, + Integer.MAX_VALUE, + Integer.MIN_VALUE, + Long.MIN_VALUE, + Long.MAX_VALUE, + -1, + 1, + 42, + -42, + Math.PI, + Math.E, + Float.MAX_VALUE, + Float.MIN_VALUE, + -Float.MAX_VALUE, + -Float.MIN_VALUE, + Float.NaN, + Float.POSITIVE_INFINITY, + Float.NEGATIVE_INFINITY + }; + + public static void main(String[] args) { + TestFramework.run(); + } + + @Test + @IR(failOn = {IRNode.ABS_I, IRNode.ABS_L, IRNode.ABS_F, IRNode.ABS_D}) + public void testAbsConstant() { + // Test abs(constant) optimization for int + Asserts.assertEquals(Integer.MAX_VALUE, Math.abs(Integer.MAX_VALUE)); + Asserts.assertEquals(Integer.MIN_VALUE, Math.abs(Integer.MIN_VALUE)); + Asserts.assertEquals(Integer.MAX_VALUE, Math.abs(-Integer.MAX_VALUE)); + + // Test abs(constant) optimization for long + Asserts.assertEquals(Long.MAX_VALUE, Math.abs(Long.MAX_VALUE)); + Asserts.assertEquals(Long.MIN_VALUE, Math.abs(Long.MIN_VALUE)); + Asserts.assertEquals(Long.MAX_VALUE, Math.abs(-Long.MAX_VALUE)); + + // Test abs(constant) optimization for float + Asserts.assertTrue(Float.isNaN(Math.abs(Float.NaN))); + Asserts.assertEquals(Float.POSITIVE_INFINITY, Math.abs(Float.NEGATIVE_INFINITY)); + Asserts.assertEquals(Float.POSITIVE_INFINITY, Math.abs(Float.POSITIVE_INFINITY)); + Asserts.assertEquals(0.0f, Math.abs(0.0f)); + Asserts.assertEquals(0.0f, Math.abs(-0.0f)); + Asserts.assertEquals(Float.MAX_VALUE, Math.abs(Float.MAX_VALUE)); + Asserts.assertEquals(Float.MIN_VALUE, Math.abs(Float.MIN_VALUE)); + Asserts.assertEquals(Float.MAX_VALUE, Math.abs(-Float.MAX_VALUE)); + Asserts.assertEquals(Float.MIN_VALUE, Math.abs(-Float.MIN_VALUE)); + + // Test abs(constant) optimization for double + Asserts.assertTrue(Double.isNaN(Math.abs(Double.NaN))); + Asserts.assertEquals(Double.POSITIVE_INFINITY, Math.abs(Double.NEGATIVE_INFINITY)); + Asserts.assertEquals(Double.POSITIVE_INFINITY, Math.abs(Double.POSITIVE_INFINITY)); + Asserts.assertEquals(0.0, Math.abs(0.0)); + Asserts.assertEquals(0.0, Math.abs(-0.0)); + Asserts.assertEquals(Double.MAX_VALUE, Math.abs(Double.MAX_VALUE)); + Asserts.assertEquals(Double.MIN_VALUE, Math.abs(Double.MIN_VALUE)); + Asserts.assertEquals(Double.MAX_VALUE, Math.abs(-Double.MAX_VALUE)); + Asserts.assertEquals(Double.MIN_VALUE, Math.abs(-Double.MIN_VALUE)); + } + + @Test + @IR(counts = {IRNode.ABS_I, "1"}) + public int testInt0(int x) { + return Math.abs(Math.abs(x)); // transformed to Math.abs(x) + } + + @Test + @IR(failOn = {IRNode.SUB_I}) + @IR(counts = {IRNode.ABS_I, "1"}) + public int testInt1(int x) { + return Math.abs(0 - x); // transformed to Math.abs(x) + } + + @Run(test = {"testInt0", "testInt1"}) + public void checkTestInt(RunInfo info) { + for (int i = 0; i < ispecial.length; i++) { + Asserts.assertEquals(Math.abs(ispecial[i]), testInt0(ispecial[i])); + Asserts.assertEquals(Math.abs(ispecial[i]), testInt1(ispecial[i])); + } + } + + @Test + @IR(counts = {IRNode.ABS_L, "1"}) + public long testLong0(long x) { + return Math.abs(Math.abs(x)); // transformed to Math.abs(x) + } + + @Test + @IR(failOn = {IRNode.SUB_L}) + @IR(counts = {IRNode.ABS_L, "1"}) + public long testLong1(long x) { + return Math.abs(0 - x); // transformed to Math.abs(x) + } + + @Run(test = {"testLong0", "testLong1"}) + public void checkTestLong(RunInfo info) { + for (int i = 0; i < lspecial.length; i++) { + Asserts.assertEquals(Math.abs(lspecial[i]), testLong0(lspecial[i])); + Asserts.assertEquals(Math.abs(lspecial[i]), testLong1(lspecial[i])); + } + } + + @Test + @IR(counts = {IRNode.ABS_F, "1"}) + public float testFloat0(float x) { + return Math.abs(Math.abs(x)); // transformed to Math.abs(x) + } + + @Test + @IR(failOn = {IRNode.SUB_F}) + @IR(counts = {IRNode.ABS_F, "1"}) + public float testFloat1(float x) { + return Math.abs(0 - x); // transformed to Math.abs(x) + } + + @Run(test = {"testFloat0", "testFloat1"}) + public void checkTestFloat(RunInfo info) { + for (int i = 0; i < fspecial.length; i++) { + Asserts.assertEquals(Math.abs(fspecial[i]), testFloat0(fspecial[i])); + Asserts.assertEquals(Math.abs(fspecial[i]), testFloat1(fspecial[i])); + } + } + + @Test + @IR(counts = {IRNode.ABS_D, "1"}) + public double testDouble0(double x) { + return Math.abs(Math.abs(x)); // transformed to Math.abs(x) + } + + @Test + @IR(failOn = {IRNode.SUB_D}) + @IR(counts = {IRNode.ABS_D, "1"}) + public double testDouble1(double x) { + return Math.abs(0 - x); // transformed to Math.abs(x) + } + + @Run(test = {"testDouble0", "testDouble1"}) + public void checkTestDouble(RunInfo info) { + for (int i = 0; i < dspecial.length; i++) { + Asserts.assertEquals(Math.abs(dspecial[i]), testDouble0(dspecial[i])); + Asserts.assertEquals(Math.abs(dspecial[i]), testDouble1(dspecial[i])); + } + } + + @Test + @IR(failOn = {IRNode.ABS_I}) + public void testChar() { + for (int i = 0; i < cspecial.length; i++) { + Asserts.assertEquals(cspecial[i], (char) Math.abs(cspecial[i])); + } + } + } diff --git a/test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java b/test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java index 46428c2a05f69..315dfa350b79a 100644 --- a/test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java +++ b/test/hotspot/jtreg/compiler/lib/ir_framework/IRNode.java @@ -136,6 +136,10 @@ public class IRNode { public static final String SCOPE_OBJECT = "(.*# ScObj.*" + END; public static final String MEMBAR = START + "MemBar" + MID + END; + public static final String ABS_I = START + "AbsI" + MID + END; + public static final String ABS_L = START + "AbsL" + MID + END; + public static final String ABS_F = START + "AbsF" + MID + END; + public static final String ABS_D = START + "AbsD" + MID + END; public static final String AND_I = START + "AndI" + MID + END; public static final String AND_L = START + "AndL" + MID + END; public static final String LSHIFT_I = START + "LShiftI" + MID + END; @@ -145,6 +149,8 @@ public class IRNode { public static final String ADD_VD = START + "AddVD" + MID + END; public static final String SUB_I = START + "SubI" + MID + END; public static final String SUB_L = START + "SubL" + MID + END; + public static final String SUB_F = START + "SubF" + MID + END; + public static final String SUB_D = START + "SubD" + MID + END; public static final String MUL_I = START + "MulI" + MID + END; public static final String MUL_L = START + "MulL" + MID + END; public static final String CONV_I2L = START + "ConvI2L" + MID + END; diff --git a/test/micro/org/openjdk/bench/java/lang/MathBench.java b/test/micro/org/openjdk/bench/java/lang/MathBench.java index 2c7b7ca27d612..6cd1353907e97 100644 --- a/test/micro/org/openjdk/bench/java/lang/MathBench.java +++ b/test/micro/org/openjdk/bench/java/lang/MathBench.java @@ -101,11 +101,6 @@ public long absLong() { return Math.abs(long13); } - @Benchmark - public int absConstantInt() { - return Math.abs(-3); - } - @Benchmark public double acosDouble() { return Math.acos(double1);