Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

JDK-8266431: Dual-Pivot Quicksort improvements (Radix sort) #3938

Closed
wants to merge 21 commits into from
+7,007 −6,532
Closed

JDK-8266431: Dual-Pivot Quicksort improvements (Radix sort) #3938

Changes from 1 commit
Commits
Show all changes
21 commits
Select commit Hold shift + click to select a range
087b1ea
JDK-8266431: Dual-Pivot Quicksort improvements (Radix sort)
iaroslavski May 8, 2021
6afd60a
JDK-8266431: Dual-Pivot Quicksort improvements (Radix sort)
iaroslavski May 17, 2021
2d97288
JDK-8266431: Dual-Pivot Quicksort improvements (Radix sort)
iaroslavski May 18, 2021
189f547
JDK-8266431: Dual-Pivot Quicksort improvements (Radix sort)
iaroslavski Sep 14, 2021
6003fb6
Merge remote-tracking branch 'upstream/master' into JDK-8266431-Dual-…
iaroslavski Sep 16, 2021
adcc694
JDK-8266431: Dual-Pivot Quicksort improvements (Radix sort)
iaroslavski Sep 27, 2021
90c08ae
JDK-8266431: Dual-Pivot Quicksort improvements (Radix sort)
iaroslavski Oct 5, 2021
9989de5
JDK-8266431: Dual-Pivot Quicksort improvements (Radix sort)
iaroslavski Oct 6, 2021
ee7f6e8
JDK-8266431: Dual-Pivot Quicksort improvements (Radix sort)
Oct 29, 2021
e1b01cf
JDK-8266431: Dual-Pivot Quicksort improvements (Radix sort)
iaroslavski Nov 12, 2021
4baa9a3
JDK-8266431: Dual-Pivot Quicksort improvements (Radix sort)
Nov 15, 2021
41b92f6
JDK-8266431: Dual-Pivot Quicksort improvements (Radix sort)
iaroslavski Nov 29, 2021
95f1538
JDK-8266431: Dual-Pivot Quicksort improvements (Radix sort)
iaroslavski Jan 12, 2022
8a37374
JDK-8266431: Dual-Pivot Quicksort improvements (Radix sort)
iaroslavski Mar 14, 2022
6acc0bd
JDK-8266431: Dual-Pivot Quicksort improvements (Radix sort)
iaroslavski Jun 30, 2022
1cb6fd7
JDK-8266431: Dual-Pivot Quicksort improvements (Radix sort)
iaroslavski Jun 30, 2022
618bdb5
JDK-8266431: Dual-Pivot Quicksort improvements (Radix sort)
iaroslavski Jul 7, 2022
fcda2aa
JDK-8266431: Dual-Pivot Quicksort improvements (Radix sort)
iaroslavski Aug 2, 2022
4772617
JDK-8266431: Dual-Pivot Quicksort improvements (Radix sort)
VladimirIaroslavski Oct 31, 2022
203610a
JDK-8266431: Dual-Pivot Quicksort improvements (Radix sort)
VladimirIaroslavski Nov 9, 2022
4f6ece0
JDK-8266431: Dual-Pivot Quicksort improvements (Radix sort)
VladimirIaroslavski Mar 12, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
260 changes: 108 additions & 152 deletions src/java.base/share/classes/java/util/DualPivotQuicksort.java
View file
Original file line number Diff line number Diff line change
@@ -260,16 +260,6 @@ && tryMergeRuns(sorter, a, low, size)) {
if (a[e2] < a[e1]) { int t = a[e2]; a[e2] = a[e1]; a[e1] = t; }
if (a[e4] < a[e2]) { int t = a[e4]; a[e4] = a[e2]; a[e2] = t; }

/*
* Tries radix sort on large random data.
*/
if (size > MIN_RADIX_SORT_SIZE
&& (sorter == null || bits > MIN_RADIX_SORT_DEPTH)
&& a[e1] < a[e2] && a[e2] < a[e4] && a[e4] < a[e5]
&& tryRadixSort(sorter, a, low, high)) {
return;
}

/*
* Insert the last element.
*/
@@ -287,6 +277,16 @@ && tryRadixSort(sorter, a, low, high)) {
}
}

/*
* Try radix sort on large random data.
*/
if (size > MIN_RADIX_SORT_SIZE
&& (sorter == null || bits > MIN_RADIX_SORT_DEPTH)
&& a[e1] < a[e2] && a[e2] < a[e4] && a[e4] < a[e5]
&& tryRadixSort(sorter, a, low, high)) {
return;
}

// Pointers
int lower = low; // The index of the last element of the left part
int upper = end; // The index of the first element of the right part
@@ -477,65 +477,54 @@ private static void mixedInsertionSort(int[] a, int low, int end, int high) {
/*
* Invoke simple insertion sort on tiny array.
*/
for (int i; ++low < end; ) {
for (int i; ++low < high; ) {
int ai = a[i = low];

while (ai < a[--i]) {
a[i + 1] = a[i];
}
a[i + 1] = ai;
}

} else {

/*
* Start with pin insertion sort on small part.
*
* Pin insertion sort is extended simple insertion sort.
* The main idea of this sort is to put elements larger
* than an element called pin to the end of array (the
* proper area for such elements). It avoids expensive
* movements of these elements through the whole array.
*/
int pin = a[end];

for (int i, p = high; ++low < end; ) {
int ai = a[i = low];

if (ai < a[i - 1]) { // Element smaller than pin

/*
* Insert this element into sorted part.
*/
a[i] = a[--i];

while (ai < a[--i]) {
a[i + 1] = a[i];
}
a[i + 1] = ai;

} else if (p > i && ai > pin) { // Element larger than pin
/*
* Put elements larger than an element called pin
* to the end of array (the proper area for them).
* It avoids expensive movements of these elements
* through the whole array.
*/
if (p > i && ai > pin) { // Element larger than pin

/*
* Find element smaller than pin.
*/
while (a[--p] > pin);

/*
* Swap it with large element.
* Swap it with larger element.
*/
if (p > i) {
ai = a[p];
a[p] = a[i];
}
}

/*
* Insert smaller element into sorted part.
*/
while (ai < a[--i]) {
a[i + 1] = a[i];
}
a[i + 1] = ai;
/*
* Insert element into sorted part.
*/
while (ai < a[--i]) {
a[i + 1] = a[i];
}
a[i + 1] = ai;
}

/*
@@ -1154,16 +1143,6 @@ && tryMergeRuns(sorter, a, low, size)) {
if (a[e2] < a[e1]) { long t = a[e2]; a[e2] = a[e1]; a[e1] = t; }
if (a[e4] < a[e2]) { long t = a[e4]; a[e4] = a[e2]; a[e2] = t; }

/*
* Tries radix sort on large random data.
*/
if (size > MIN_RADIX_SORT_SIZE
&& (sorter == null || bits > MIN_RADIX_SORT_DEPTH)
&& a[e1] < a[e2] && a[e2] < a[e4] && a[e4] < a[e5]
&& tryRadixSort(sorter, a, low, high)) {
return;
}

/*
* Insert the last element.
*/
@@ -1181,6 +1160,16 @@ && tryRadixSort(sorter, a, low, high)) {
}
}

/*
* Try radix sort on large random data.
*/
if (size > MIN_RADIX_SORT_SIZE
&& (sorter == null || bits > MIN_RADIX_SORT_DEPTH)
&& a[e1] < a[e2] && a[e2] < a[e4] && a[e4] < a[e5]
&& tryRadixSort(sorter, a, low, high)) {
return;
}

// Pointers
int lower = low; // The index of the last element of the left part
int upper = end; // The index of the first element of the right part
@@ -1371,65 +1360,54 @@ private static void mixedInsertionSort(long[] a, int low, int end, int high) {
/*
* Invoke simple insertion sort on tiny array.
*/
for (int i; ++low < end; ) {
for (int i; ++low < high; ) {
long ai = a[i = low];

while (ai < a[--i]) {
a[i + 1] = a[i];
}
a[i + 1] = ai;
}

} else {

/*
* Start with pin insertion sort on small part.
*
* Pin insertion sort is extended simple insertion sort.
* The main idea of this sort is to put elements larger
* than an element called pin to the end of array (the
* proper area for such elements). It avoids expensive
* movements of these elements through the whole array.
*/
long pin = a[end];

for (int i, p = high; ++low < end; ) {
long ai = a[i = low];

if (ai < a[i - 1]) { // Element smaller than pin

/*
* Insert this element into sorted part.
*/
a[i] = a[--i];

while (ai < a[--i]) {
a[i + 1] = a[i];
}
a[i + 1] = ai;

} else if (p > i && ai > pin) { // Element larger than pin
/*
* Put elements larger than an element called pin
* to the end of array (the proper area for them).
* It avoids expensive movements of these elements
* through the whole array.
*/
if (p > i && ai > pin) { // Element larger than pin

/*
* Find element smaller than pin.
*/
while (a[--p] > pin);

/*
* Swap it with large element.
* Swap it with larger element.
*/
if (p > i) {
ai = a[p];
a[p] = a[i];
}
}

/*
* Insert smaller element into sorted part.
*/
while (ai < a[--i]) {
a[i + 1] = a[i];
}
a[i + 1] = ai;
/*
* Insert element into sorted part.
*/
while (ai < a[--i]) {
a[i + 1] = a[i];
}
a[i + 1] = ai;
}

/*
@@ -2834,16 +2812,6 @@ && tryMergeRuns(sorter, a, low, size)) {
if (a[e2] < a[e1]) { float t = a[e2]; a[e2] = a[e1]; a[e1] = t; }
if (a[e4] < a[e2]) { float t = a[e4]; a[e4] = a[e2]; a[e2] = t; }

/*
* Tries radix sort on large random data.
*/
if (size > MIN_RADIX_SORT_SIZE
&& (sorter == null || bits > MIN_RADIX_SORT_DEPTH)
&& a[e1] < a[e2] && a[e2] < a[e4] && a[e4] < a[e5]
&& tryRadixSort(sorter, a, low, high)) {
return;
}

/*
* Insert the last element.
*/
@@ -2861,6 +2829,16 @@ && tryRadixSort(sorter, a, low, high)) {
}
}

/*
* Try radix sort on large random data.
*/
if (size > MIN_RADIX_SORT_SIZE
&& (sorter == null || bits > MIN_RADIX_SORT_DEPTH)
&& a[e1] < a[e2] && a[e2] < a[e4] && a[e4] < a[e5]
&& tryRadixSort(sorter, a, low, high)) {
return;
}

// Pointers
int lower = low; // The index of the last element of the left part
int upper = end; // The index of the first element of the right part
@@ -3051,65 +3029,54 @@ private static void mixedInsertionSort(float[] a, int low, int end, int high) {
/*
* Invoke simple insertion sort on tiny array.
*/
for (int i; ++low < end; ) {
for (int i; ++low < high; ) {
float ai = a[i = low];

while (ai < a[--i]) {
a[i + 1] = a[i];
}
a[i + 1] = ai;
}

} else {

/*
* Start with pin insertion sort on small part.
*
* Pin insertion sort is extended simple insertion sort.
* The main idea of this sort is to put elements larger
* than an element called pin to the end of array (the
* proper area for such elements). It avoids expensive
* movements of these elements through the whole array.
*/
float pin = a[end];

for (int i, p = high; ++low < end; ) {
float ai = a[i = low];

if (ai < a[i - 1]) { // Element smaller than pin

/*
* Insert this element into sorted part.
*/
a[i] = a[--i];

while (ai < a[--i]) {
a[i + 1] = a[i];
}
a[i + 1] = ai;

} else if (p > i && ai > pin) { // Element larger than pin
/*
* Put elements larger than an element called pin
* to the end of array (the proper area for them).
* It avoids expensive movements of these elements
* through the whole array.
*/
if (p > i && ai > pin) { // Element larger than pin

/*
* Find element smaller than pin.
*/
while (a[--p] > pin);

/*
* Swap it with large element.
* Swap it with larger element.
*/
if (p > i) {
ai = a[p];
a[p] = a[i];
}
}

/*
* Insert smaller element into sorted part.
*/
while (ai < a[--i]) {
a[i + 1] = a[i];
}
a[i + 1] = ai;
/*
* Insert element into sorted part.
*/
while (ai < a[--i]) {
a[i + 1] = a[i];
}
a[i + 1] = ai;
}

/*
@@ -3760,16 +3727,6 @@ && tryMergeRuns(sorter, a, low, size)) {
if (a[e2] < a[e1]) { double t = a[e2]; a[e2] = a[e1]; a[e1] = t; }
if (a[e4] < a[e2]) { double t = a[e4]; a[e4] = a[e2]; a[e2] = t; }

/*
* Tries radix sort on large random data.
*/
if (size > MIN_RADIX_SORT_SIZE
&& (sorter == null || bits > MIN_RADIX_SORT_DEPTH)
&& a[e1] < a[e2] && a[e2] < a[e4] && a[e4] < a[e5]
&& tryRadixSort(sorter, a, low, high)) {
return;
}

/*
* Insert the last element.
*/
@@ -3787,6 +3744,16 @@ && tryRadixSort(sorter, a, low, high)) {
}
}

/*
* Try radix sort on large random data.
*/
if (size > MIN_RADIX_SORT_SIZE
&& (sorter == null || bits > MIN_RADIX_SORT_DEPTH)
&& a[e1] < a[e2] && a[e2] < a[e4] && a[e4] < a[e5]
&& tryRadixSort(sorter, a, low, high)) {
return;
}

// Pointers
int lower = low; // The index of the last element of the left part
int upper = end; // The index of the first element of the right part
@@ -3977,65 +3944,54 @@ private static void mixedInsertionSort(double[] a, int low, int end, int high) {
/*
* Invoke simple insertion sort on tiny array.
*/
for (int i; ++low < end; ) {
for (int i; ++low < high; ) {
double ai = a[i = low];

while (ai < a[--i]) {
a[i + 1] = a[i];
}
a[i + 1] = ai;
}

} else {

/*
* Start with pin insertion sort on small part.
*
* Pin insertion sort is extended simple insertion sort.
* The main idea of this sort is to put elements larger
* than an element called pin to the end of array (the
* proper area for such elements). It avoids expensive
* movements of these elements through the whole array.
*/
double pin = a[end];

for (int i, p = high; ++low < end; ) {
double ai = a[i = low];

if (ai < a[i - 1]) { // Element smaller than pin

/*
* Insert this element into sorted part.
*/
a[i] = a[--i];

while (ai < a[--i]) {
a[i + 1] = a[i];
}
a[i + 1] = ai;

} else if (p > i && ai > pin) { // Element larger than pin
/*
* Put elements larger than an element called pin
* to the end of array (the proper area for them).
* It avoids expensive movements of these elements
* through the whole array.
*/
if (p > i && ai > pin) { // Element larger than pin

/*
* Find element smaller than pin.
*/
while (a[--p] > pin);

/*
* Swap it with large element.
* Swap it with larger element.
*/
if (p > i) {
ai = a[p];
a[p] = a[i];
}
}

/*
* Insert smaller element into sorted part.
*/
while (ai < a[--i]) {
a[i + 1] = a[i];
}
a[i + 1] = ai;
/*
* Insert element into sorted part.
*/
while (ai < a[--i]) {
a[i + 1] = a[i];
}
a[i + 1] = ai;
}

/*