diff --git a/src/hotspot/share/opto/library_call.cpp b/src/hotspot/share/opto/library_call.cpp index 4a9d7fb1616..62d78580953 100644 --- a/src/hotspot/share/opto/library_call.cpp +++ b/src/hotspot/share/opto/library_call.cpp @@ -5367,8 +5367,6 @@ void LibraryCallKit::create_new_uncommon_trap(CallStaticJavaNode* uncommon_trap_ //------------------------------inline_array_partition----------------------- bool LibraryCallKit::inline_array_partition() { - const char *stubName = "array_partition_stub"; - Node* elementType = null_check(argument(0)); Node* obj = argument(1); Node* offset = argument(2); @@ -5377,38 +5375,48 @@ bool LibraryCallKit::inline_array_partition() { Node* indexPivot1 = argument(6); Node* indexPivot2 = argument(7); - const TypeInstPtr* elem_klass = gvn().type(elementType)->isa_instptr(); - ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type(); - BasicType bt = elem_type->basic_type(); - address stubAddr = nullptr; - stubAddr = StubRoutines::select_array_partition_function(); - // stub not loaded - if (stubAddr == nullptr) { - return false; - } - // get the address of the array - const TypeAryPtr* obj_t = _gvn.type(obj)->isa_aryptr(); - if (obj_t == nullptr || obj_t->elem() == Type::BOTTOM ) { - return false; // failed input validation - } - Node* obj_adr = make_unsafe_address(obj, offset); + Node* pivotIndices = nullptr; - // create the pivotIndices array of type int and size = 2 - Node* size = intcon(2); - Node* klass_node = makecon(TypeKlassPtr::make(ciTypeArrayKlass::make(T_INT))); - Node* pivotIndices = new_array(klass_node, size, 0); // no arguments to push - AllocateArrayNode* alloc = tightly_coupled_allocation(pivotIndices); - guarantee(alloc != nullptr, "created above"); - Node* pivotIndices_adr = basic_plus_adr(pivotIndices, arrayOopDesc::base_offset_in_bytes(T_INT)); + // Set the original stack and the reexecute bit for the interpreter to reexecute + // the bytecode that invokes DualPivotQuicksort.partition() if deoptimization happens. + { PreserveReexecuteState preexecs(this); + jvms()->set_should_reexecute(true); - // pass the basic type enum to the stub - Node* elemType = intcon(bt); + const TypeInstPtr* elem_klass = gvn().type(elementType)->isa_instptr(); + ciType* elem_type = elem_klass->const_oop()->as_instance()->java_mirror_type(); + BasicType bt = elem_type->basic_type(); + address stubAddr = nullptr; + stubAddr = StubRoutines::select_array_partition_function(); + // stub not loaded + if (stubAddr == nullptr) { + return false; + } + // get the address of the array + const TypeAryPtr* obj_t = _gvn.type(obj)->isa_aryptr(); + if (obj_t == nullptr || obj_t->elem() == Type::BOTTOM ) { + return false; // failed input validation + } + Node* obj_adr = make_unsafe_address(obj, offset); - // Call the stub - make_runtime_call(RC_LEAF|RC_NO_FP, OptoRuntime::array_partition_Type(), - stubAddr, stubName, TypePtr::BOTTOM, - obj_adr, elemType, fromIndex, toIndex, pivotIndices_adr, - indexPivot1, indexPivot2); + // create the pivotIndices array of type int and size = 2 + Node* size = intcon(2); + Node* klass_node = makecon(TypeKlassPtr::make(ciTypeArrayKlass::make(T_INT))); + pivotIndices = new_array(klass_node, size, 0); // no arguments to push + AllocateArrayNode* alloc = tightly_coupled_allocation(pivotIndices); + guarantee(alloc != nullptr, "created above"); + Node* pivotIndices_adr = basic_plus_adr(pivotIndices, arrayOopDesc::base_offset_in_bytes(T_INT)); + + // pass the basic type enum to the stub + Node* elemType = intcon(bt); + + // Call the stub + const char *stubName = "array_partition_stub"; + make_runtime_call(RC_LEAF|RC_NO_FP, OptoRuntime::array_partition_Type(), + stubAddr, stubName, TypePtr::BOTTOM, + obj_adr, elemType, fromIndex, toIndex, pivotIndices_adr, + indexPivot1, indexPivot2); + + } // original reexecute is set back here if (!stopped()) { set_result(pivotIndices); @@ -5421,9 +5429,6 @@ bool LibraryCallKit::inline_array_partition() { //------------------------------inline_array_sort----------------------- bool LibraryCallKit::inline_array_sort() { - const char *stubName; - stubName = "arraysort_stub"; - Node* elementType = null_check(argument(0)); Node* obj = argument(1); Node* offset = argument(2); @@ -5451,6 +5456,7 @@ bool LibraryCallKit::inline_array_sort() { Node* elemType = intcon(bt); // Call the stub. + const char *stubName = "arraysort_stub"; make_runtime_call(RC_LEAF|RC_NO_FP, OptoRuntime::array_sort_Type(), stubAddr, stubName, TypePtr::BOTTOM, obj_adr, elemType, fromIndex, toIndex); diff --git a/test/hotspot/jtreg/compiler/intrinsics/SortingDeoptimizationTest.java b/test/hotspot/jtreg/compiler/intrinsics/SortingDeoptimizationTest.java new file mode 100644 index 00000000000..f9fbcfefb99 --- /dev/null +++ b/test/hotspot/jtreg/compiler/intrinsics/SortingDeoptimizationTest.java @@ -0,0 +1,72 @@ +/* + * Copyright (c) 2023, 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. + */ + +/* + * @test + * @bug 8318306 + * @run main/othervm/timeout=200 -XX:+IgnoreUnrecognizedVMOptions -Xcomp -ea -esa -XX:CompileThreshold=100 -XX:+UnlockExperimentalVMOptions -server -XX:-TieredCompilation -XX:+DeoptimizeALot SortingDeoptimizationTest 1e-2 100 50 + * @summary Exercise Arrays.parallelSort when -XX:+DeoptimizeALot is enabled + * + */ + +import java.io.PrintStream; +import java.util.Arrays; +import java.util.Random; + +public class SortingDeoptimizationTest { + + private static final PrintStream err = System.err; + private static final PrintStream out = System.out; + + public static void main(String[] args) { + int MAX = 2147483647; // 2^32 - 1 + float fraction = Float.parseFloat(args[0]); + int size = (int) (fraction * MAX); // size is a fraction of the MAX size + int iters = Integer.parseInt(args[1]); // number of iterations + int max = args.length > 2 ? Integer.parseInt(args[2]) : -1 ; // max value for the array elements + long seed = 0xC0FFEE; + Random rand = new Random(seed); + + for (int i = 0; i < iters; i++) { + boolean isSorted = runSort(size, max, rand); + out.println("Iteration " + i + ": is sorted? -> "+ isSorted); + if (!isSorted) fail("Array is not correctly sorted."); + } + } + + private static void fail(String message) { + err.format("\n*** TEST FAILED ***\n\n%s\n\n", message); + throw new RuntimeException("Test failed"); + } + + private static boolean runSort(int size, int max, Random rand) { + int[] a = new int[size]; + for (int i = 0; i < a.length; i++) a[i] = max > 0 ? rand.nextInt(max) : rand.nextInt(); + // call parallel sort + Arrays.parallelSort(a); + // check if sorted + boolean isSorted = true; + for (int i = 0; i < (a.length -1); i++) isSorted = isSorted && (a[i] <= a[i+1]); + return isSorted; + } +}