From dbf26421d9f3df60b9d9b9415a844d7c313f9cb1 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 17 Dec 2024 14:13:20 +0000
Subject: [PATCH 01/70] FinnSort: Disable printouts
---
.../main/java/de/uni_marburg/powersort/FinnSort/FinnSort.java | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/app/src/main/java/de/uni_marburg/powersort/FinnSort/FinnSort.java b/app/src/main/java/de/uni_marburg/powersort/FinnSort/FinnSort.java
index 341603f..ae5f1c5 100644
--- a/app/src/main/java/de/uni_marburg/powersort/FinnSort/FinnSort.java
+++ b/app/src/main/java/de/uni_marburg/powersort/FinnSort/FinnSort.java
@@ -15,7 +15,7 @@ public class FinnSort {
int i = 0;
int j = extendRunRight(a, i, c);
- printList(a, c);
+// printList(a, c);
runs.add(new Run(i, j, 0));
@@ -63,7 +63,7 @@ public class FinnSort {
System.arraycopy(merge.toArray(), 0, a, min(r1.start, r2.start), merge.size());
Run r = new Run(min(r1.start, r2.start), max(r1.end, r2.end), min(r1.power, r2.power));
runs.add(r);
- printList(a, c);
+// printList(a, c);
}
private static <T> int extendRunRight(T[] a, int i, Comparator<? super T> c) {
From b730c34ddd1ee1185ea9377a8ea6892c512abadc Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 17 Dec 2024 16:28:01 +0000
Subject: [PATCH 02/70] benchmark: numbers
---
.../powersort/benchmark/MainJmh.java | 6 ++---
.../uni_marburg/powersort/benchmark/Main.java | 2 ++
.../uni_marburg/powersort/data/DataEnum.java | 25 +++++++++++--------
3 files changed, 19 insertions(+), 14 deletions(-)
diff --git a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/MainJmh.java b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/MainJmh.java
index 31cb83e..6c194c1 100644
--- a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/MainJmh.java
+++ b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/MainJmh.java
@@ -22,9 +22,9 @@ import java.util.concurrent.TimeUnit;
/*
* Benchmark parameters
*/
-@Fork(0)
-@Warmup(iterations = 0)
-@Measurement(iterations = 1)
+@Fork(1)
+@Warmup(iterations = 1)
+@Measurement(iterations = 6)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
/*
diff --git a/app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java b/app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java
index 917446f..90431f0 100644
--- a/app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java
+++ b/app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java
@@ -15,6 +15,7 @@ public class Main {
final EnumSet<SortEnum> sortImplementations = getSortImplementations();
final EnumSet<DataEnum> dataEnums = getSortInputSuppliers();
+ System.out.println();
for (DataEnum dataEnum : dataEnums) {
ObjectSupplier objectSupplier = dataEnum.getObjectSupplier();
System.out.println(dataEnum);
@@ -32,6 +33,7 @@ public class Main {
final String durFormatted = LongFormatter.formatUnderscore(durMillis);
System.out.println(durFormatted + "," + sortImplementation);
}
+ System.out.println();
}
}
diff --git a/app/src/main/java/de/uni_marburg/powersort/data/DataEnum.java b/app/src/main/java/de/uni_marburg/powersort/data/DataEnum.java
index 243f838..d375b5e 100644
--- a/app/src/main/java/de/uni_marburg/powersort/data/DataEnum.java
+++ b/app/src/main/java/de/uni_marburg/powersort/data/DataEnum.java
@@ -1,26 +1,29 @@
package de.uni_marburg.powersort.data;
public enum DataEnum {
- RANDOM_INTEGERS,
- ASCENDING_INTEGERS,
- DESCENDING_INTEGERS,
- ASCENDING_RUNS,
- ASCENDING_RUNS_WITH_OVERLAP;
+ RANDOM_INTEGERS_300M,
+ ASCENDING_INTEGERS_300M,
+ DESCENDING_INTEGERS_250M,
+ ASCENDING_RUNS_1M,
+ ASCENDING_RUNS_WITH_OVERLAP_1M;
public ObjectSupplier getObjectSupplier() {
// We use a seed to get the same random list every time -> Repeatable benchmarks on same input data!
// final long seed = 3651660232967549736L; // System.nanoTime() ++ Math.random()
final long seed = 140506881906827520L; // (long) 'P' * (long) 'O' *(long) 'W' * (long) 'E' * (long) 'R' * (long) 'S' * (long) 'O' * (long) 'R' * (long) 'T';
- int longListSize = 50_000_000;
+ int longListSize = 300_000_000; // Any larger: Out of Heap Space. TODO GRADLE config
+ int middleListSize = 250_000_000;
+ int runs = 1000;
+ int runLength = 1000;
return switch (this) {
- case RANDOM_INTEGERS -> new RandomIntegers(longListSize, seed);
- case ASCENDING_INTEGERS -> new AscendingIntegers(longListSize);
- case DESCENDING_INTEGERS -> new DescendingIntegers(longListSize);
+ case RANDOM_INTEGERS_300M -> new RandomIntegers(longListSize, seed);
+ case ASCENDING_INTEGERS_300M -> new AscendingIntegers(longListSize);
+ case DESCENDING_INTEGERS_250M -> new DescendingIntegers(middleListSize);
- case ASCENDING_RUNS -> AscendingRuns.newAscendingRuns(10_000, 10_000, -10_000);
- case ASCENDING_RUNS_WITH_OVERLAP -> AscendingRuns.newAscendingRuns(10_000, 10_000, -5_000);
+ case ASCENDING_RUNS_1M -> AscendingRuns.newAscendingRuns(runs, runLength, -runLength);
+ case ASCENDING_RUNS_WITH_OVERLAP_1M -> AscendingRuns.newAscendingRuns(runs, runLength, (int) (-0.5 * runLength));
};
}
}
From a7a6f9e2461f11aea49bbc1c3938b3dda92c046a Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 17 Dec 2024 16:38:41 +0000
Subject: [PATCH 03/70] benchmark: exclude merge sort
---
app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java b/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
index 976bfd8..8053d53 100644
--- a/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
+++ b/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
@@ -5,7 +5,7 @@ import de.uni_marburg.powersort.benchmark.NaturalOrder;
public enum SortEnum {
// BUBBLE_SORT,
- MERGE_SORT,
+// MERGE_SORT,
TIM_SORT,
FINN_SORT,
ASORT;
@@ -13,7 +13,7 @@ public enum SortEnum {
public SortImpl getSortImpl() {
return switch (this) {
// case BUBBLE_SORT -> array -> BubbleSort.sort(array, NaturalOrder.INSTANCE);
- case MERGE_SORT -> array -> MergeSort.legacyMergeSort(array, NaturalOrder.INSTANCE);
+// case MERGE_SORT -> array -> MergeSort.legacyMergeSort(array, NaturalOrder.INSTANCE);
case TIM_SORT -> array -> TimSort.sort(array, 0, array.length, NaturalOrder.INSTANCE, null, 0, 0);
case FINN_SORT -> array -> FinnSort.sort(array, NaturalOrder.INSTANCE);
case ASORT -> array -> ASort.sort(array, NaturalOrder.INSTANCE);
From 526d69e95bd4813ac0cfac4ab530bbc1890f80e3 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 17 Dec 2024 16:52:59 +0000
Subject: [PATCH 04/70] benchmark: include merge and bubble again ^^
---
.../main/java/de/uni_marburg/powersort/data/DataEnum.java | 4 ++--
.../main/java/de/uni_marburg/powersort/sort/SortEnum.java | 8 ++++----
.../de/uni_marburg/powersort/sort/BubbleSortTest.java | 7 +++++++
3 files changed, 13 insertions(+), 6 deletions(-)
create mode 100644 app/src/test/java/de/uni_marburg/powersort/sort/BubbleSortTest.java
diff --git a/app/src/main/java/de/uni_marburg/powersort/data/DataEnum.java b/app/src/main/java/de/uni_marburg/powersort/data/DataEnum.java
index d375b5e..7c8a783 100644
--- a/app/src/main/java/de/uni_marburg/powersort/data/DataEnum.java
+++ b/app/src/main/java/de/uni_marburg/powersort/data/DataEnum.java
@@ -14,8 +14,8 @@ public enum DataEnum {
int longListSize = 300_000_000; // Any larger: Out of Heap Space. TODO GRADLE config
int middleListSize = 250_000_000;
- int runs = 1000;
- int runLength = 1000;
+ int runs = 1_000;
+ int runLength = 1_000;
return switch (this) {
case RANDOM_INTEGERS_300M -> new RandomIntegers(longListSize, seed);
diff --git a/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java b/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
index 8053d53..0ceb21a 100644
--- a/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
+++ b/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
@@ -4,16 +4,16 @@ import de.uni_marburg.powersort.FinnSort.FinnSort;
import de.uni_marburg.powersort.benchmark.NaturalOrder;
public enum SortEnum {
-// BUBBLE_SORT,
-// MERGE_SORT,
+ BUBBLE_SORT,
+ MERGE_SORT,
TIM_SORT,
FINN_SORT,
ASORT;
public SortImpl getSortImpl() {
return switch (this) {
-// case BUBBLE_SORT -> array -> BubbleSort.sort(array, NaturalOrder.INSTANCE);
-// case MERGE_SORT -> array -> MergeSort.legacyMergeSort(array, NaturalOrder.INSTANCE);
+ case BUBBLE_SORT -> array -> BubbleSort.sort(array, NaturalOrder.INSTANCE);
+ case MERGE_SORT -> array -> MergeSort.legacyMergeSort(array, NaturalOrder.INSTANCE);
case TIM_SORT -> array -> TimSort.sort(array, 0, array.length, NaturalOrder.INSTANCE, null, 0, 0);
case FINN_SORT -> array -> FinnSort.sort(array, NaturalOrder.INSTANCE);
case ASORT -> array -> ASort.sort(array, NaturalOrder.INSTANCE);
diff --git a/app/src/test/java/de/uni_marburg/powersort/sort/BubbleSortTest.java b/app/src/test/java/de/uni_marburg/powersort/sort/BubbleSortTest.java
new file mode 100644
index 0000000..65d5fbc
--- /dev/null
+++ b/app/src/test/java/de/uni_marburg/powersort/sort/BubbleSortTest.java
@@ -0,0 +1,7 @@
+package de.uni_marburg.powersort.sort;
+
+public class BubbleSortTest extends AbstractSortTest {
+ BubbleSortTest() {
+ sortAlg = SortEnum.BUBBLE_SORT;
+ }
+}
From 9bb9096c9279bf6eaafced28f01e8723ca6b0685 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 17 Dec 2024 17:53:54 +0100
Subject: [PATCH 05/70] rm conflicting IDE settings
---
.idea/gradle.xml | 17 -----------------
.idea/misc.xml | 7 -------
2 files changed, 24 deletions(-)
delete mode 100644 .idea/gradle.xml
delete mode 100644 .idea/misc.xml
diff --git a/.idea/gradle.xml b/.idea/gradle.xml
deleted file mode 100644
index 4979975..0000000
--- a/.idea/gradle.xml
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
- <component name="GradleMigrationSettings" migrationVersion="1" />
- <component name="GradleSettings">
- <option name="linkedExternalProjectsSettings">
- <GradleProjectSettings>
- <option name="externalProjectPath" value="$PROJECT_DIR$" />
- <option name="modules">
- <set>
- <option value="$PROJECT_DIR$" />
- <option value="$PROJECT_DIR$/app" />
- </set>
- </option>
- </GradleProjectSettings>
- </option>
- </component>
-</project>
\ No newline at end of file
diff --git a/.idea/misc.xml b/.idea/misc.xml
deleted file mode 100644
index 5a6579d..0000000
--- a/.idea/misc.xml
+++ /dev/null
@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
- <component name="FrameworkDetectionExcludesConfiguration">
- <file type="web" url="file://$PROJECT_DIR$" />
- </component>
- <component name="ProjectRootManager" version="2" languageLevel="JDK_21" project-jdk-name="23" project-jdk-type="JavaSDK" />
-</project>
\ No newline at end of file
From 68d86d6e6b3d4c3c7c3a095f20e6d6479c17606f Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 17 Dec 2024 18:56:55 +0000
Subject: [PATCH 06/70] benchmark: filter out some of the "data x algorithm"
combinations
---
.../powersort/benchmark/MainJmh.java | 14 ++++++-
.../powersort/benchmark/Filter.java | 40 +++++++++++++++++++
.../uni_marburg/powersort/benchmark/Main.java | 34 ++++++++++------
.../powersort/data/ObjectSupplier.java | 2 +
4 files changed, 76 insertions(+), 14 deletions(-)
create mode 100644 app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java
diff --git a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/MainJmh.java b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/MainJmh.java
index 6c194c1..c806c34 100644
--- a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/MainJmh.java
+++ b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/MainJmh.java
@@ -18,6 +18,8 @@ import org.openjdk.jmh.annotations.Warmup;
import java.util.concurrent.TimeUnit;
+import static de.uni_marburg.powersort.data.ObjectSupplier.EMPTY_ARRAY;
+
// TODO: The parameters are way too low. Use for debugging only!
/*
* Benchmark parameters
@@ -40,15 +42,23 @@ public class MainJmh {
@Param()
private SortEnum sortEnum;
- private ObjectSupplier data;
+ private ObjectSupplier data = EMPTY_ARRAY;
/* package-protected */ Object[] workingCopy;
// TODO: This is inaccurate. How to create and use separate arrays for each warmup x iteration x sortAlgorithm ?
@Setup(Level.Invocation)
public void setup() {
+ if(Filter.isFiltered(dataEnum, sortEnum)) {
+ // This combination of DataEnum and SortEnum should be skipped.
+ // We can't tell JMH to not run the benchmark at all,
+ // so we'll let it sort an empty list instead ;)
+ data = EMPTY_ARRAY;
+ return;
+ }
+
// A new MainJmh object is created for each @Param variation.
// Then, `data` is `null` again.
- if (data == null) {
+ if (data == EMPTY_ARRAY) {
data = dataEnum.getObjectSupplier();
}
// For all warmup and measurement iterations of one @Param variation, the MainJmh object is reused.
diff --git a/app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java b/app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java
new file mode 100644
index 0000000..023403c
--- /dev/null
+++ b/app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java
@@ -0,0 +1,40 @@
+package de.uni_marburg.powersort.benchmark;
+
+import de.uni_marburg.powersort.data.DataEnum;
+import de.uni_marburg.powersort.sort.SortEnum;
+
+import java.util.List;
+
+public class Filter {
+ /* Utility Class */
+ private Filter() {
+ }
+
+ public static boolean isFiltered(DataEnum d, SortEnum s) {
+
+ if (s == SortEnum.MERGE_SORT) {
+ return List.of(
+ DataEnum.RANDOM_INTEGERS_300M,
+ DataEnum.ASCENDING_INTEGERS_300M,
+ DataEnum.DESCENDING_INTEGERS_250M
+ ).contains(d);
+ }
+
+ if (s == SortEnum.BUBBLE_SORT) {
+ return List.of(
+ DataEnum.DESCENDING_INTEGERS_250M,
+ DataEnum.ASCENDING_RUNS_1M,
+ DataEnum.ASCENDING_RUNS_WITH_OVERLAP_1M
+ ).contains(d);
+ }
+
+ // TODO: Remove this once performance of FinnSort improved
+ if (s == SortEnum.FINN_SORT) {
+ return List.of(
+ DataEnum.DESCENDING_INTEGERS_250M
+ ).contains(d);
+ }
+
+ return false;
+ }
+}
diff --git a/app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java b/app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java
index 90431f0..29a88b0 100644
--- a/app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java
+++ b/app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java
@@ -17,26 +17,36 @@ public class Main {
System.out.println();
for (DataEnum dataEnum : dataEnums) {
+ System.out.println("⏳ Creating object supplier " + dataEnum + " ⏳");
ObjectSupplier objectSupplier = dataEnum.getObjectSupplier();
- System.out.println(dataEnum);
for (SortEnum sortImplementation : sortImplementations) {
- Object[] sortInput = objectSupplier.getCopy();
-
- // TODO: JVM warmup!
- final long startNanos = System.nanoTime();
- sortImplementation.getSortImpl().sort(sortInput);
- final long stopNanos = System.nanoTime();
-
- final long durNanos = stopNanos - startNanos;
- final long durMillis = TimeUnit.NANOSECONDS.toMillis(durNanos);
- final String durFormatted = LongFormatter.formatUnderscore(durMillis);
- System.out.println(durFormatted + "," + sortImplementation);
+ if(!Filter.isFiltered(dataEnum, sortImplementation)) {
+ benchmark(objectSupplier, sortImplementation);
+ }
}
+
System.out.println();
}
}
+ static void benchmark(ObjectSupplier objectSupplier, SortEnum sortImplementation){
+ System.out.print(sortImplementation);
+ System.out.flush();
+ Object[] sortInput = objectSupplier.getCopy();
+
+ // TODO: JVM warmup!
+ final long startNanos = System.nanoTime();
+ sortImplementation.getSortImpl().sort(sortInput);
+ final long stopNanos = System.nanoTime();
+
+ final long durNanos = stopNanos - startNanos;
+ final long durMillis = TimeUnit.NANOSECONDS.toMillis(durNanos);
+ final String durFormatted = LongFormatter.formatUnderscore(durMillis);
+
+ System.out.println("," + durFormatted);
+ }
+
static EnumSet<SortEnum> getSortImplementations() {
return EnumSet.allOf(SortEnum.class);
}
diff --git a/app/src/main/java/de/uni_marburg/powersort/data/ObjectSupplier.java b/app/src/main/java/de/uni_marburg/powersort/data/ObjectSupplier.java
index f4c1fa8..5805157 100644
--- a/app/src/main/java/de/uni_marburg/powersort/data/ObjectSupplier.java
+++ b/app/src/main/java/de/uni_marburg/powersort/data/ObjectSupplier.java
@@ -3,6 +3,8 @@ package de.uni_marburg.powersort.data;
import java.util.Arrays;
public abstract class ObjectSupplier {
+ public static final ObjectSupplier EMPTY_ARRAY = new ObjectSupplier(new Object[0]) {};
+
/* package-protected */ final Object[] readOnly;
ObjectSupplier(Object[] readOnly) {
From 6d25796bac30c946da7055e9033f34ea6f815f83 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 17 Dec 2024 19:14:30 +0000
Subject: [PATCH 07/70] import QuickSort
---
.../uni_marburg/powersort/sort/QuickSort.java | 40 +++++++++++++++++++
.../uni_marburg/powersort/sort/SortEnum.java | 2 +
.../powersort/sort/QuickSortTest.java | 7 ++++
3 files changed, 49 insertions(+)
create mode 100644 app/src/main/java/de/uni_marburg/powersort/sort/QuickSort.java
create mode 100644 app/src/test/java/de/uni_marburg/powersort/sort/QuickSortTest.java
diff --git a/app/src/main/java/de/uni_marburg/powersort/sort/QuickSort.java b/app/src/main/java/de/uni_marburg/powersort/sort/QuickSort.java
new file mode 100644
index 0000000..815b8b7
--- /dev/null
+++ b/app/src/main/java/de/uni_marburg/powersort/sort/QuickSort.java
@@ -0,0 +1,40 @@
+package de.uni_marburg.powersort.sort;
+
+public class QuickSort {
+ /**
+ * Based on https://www.baeldung.com/java-quicksort
+ */
+ public static void sort(Integer[] arr) {
+ quickSort(arr, 0, arr.length-1);
+ }
+
+ private static void quickSort(Integer[] arr, int begin, int end) {
+ if (begin < end) {
+ int partitionIndex = partition(arr, begin, end);
+
+ quickSort(arr, begin, partitionIndex-1);
+ quickSort(arr, partitionIndex+1, end);
+ }
+ }
+
+ private static int partition(Integer[] arr, int begin, int end) {
+ int pivot = arr[end];
+ int i = (begin-1);
+
+ for (int j = begin; j < end; j++) {
+ if (arr[j] <= pivot) {
+ i++;
+
+ int swapTemp = arr[i];
+ arr[i] = arr[j];
+ arr[j] = swapTemp;
+ }
+ }
+
+ int swapTemp = arr[i+1];
+ arr[i+1] = arr[end];
+ arr[end] = swapTemp;
+
+ return i+1;
+ }
+}
diff --git a/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java b/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
index 0ceb21a..06e346b 100644
--- a/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
+++ b/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
@@ -5,6 +5,7 @@ import de.uni_marburg.powersort.benchmark.NaturalOrder;
public enum SortEnum {
BUBBLE_SORT,
+ QUICK_SORT,
MERGE_SORT,
TIM_SORT,
FINN_SORT,
@@ -13,6 +14,7 @@ public enum SortEnum {
public SortImpl getSortImpl() {
return switch (this) {
case BUBBLE_SORT -> array -> BubbleSort.sort(array, NaturalOrder.INSTANCE);
+ case QUICK_SORT -> array -> QuickSort.sort((Integer[]) array); // TODO rm cast
case MERGE_SORT -> array -> MergeSort.legacyMergeSort(array, NaturalOrder.INSTANCE);
case TIM_SORT -> array -> TimSort.sort(array, 0, array.length, NaturalOrder.INSTANCE, null, 0, 0);
case FINN_SORT -> array -> FinnSort.sort(array, NaturalOrder.INSTANCE);
diff --git a/app/src/test/java/de/uni_marburg/powersort/sort/QuickSortTest.java b/app/src/test/java/de/uni_marburg/powersort/sort/QuickSortTest.java
new file mode 100644
index 0000000..033fb04
--- /dev/null
+++ b/app/src/test/java/de/uni_marburg/powersort/sort/QuickSortTest.java
@@ -0,0 +1,7 @@
+package de.uni_marburg.powersort.sort;
+
+public class QuickSortTest extends AbstractSortTest {
+ QuickSortTest() {
+ sortAlg = SortEnum.ASORT;
+ }
+}
From 0b483c32f34c4990b683b11babd19c2d2e29de92 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 17 Dec 2024 19:18:16 +0000
Subject: [PATCH 08/70] improve QuickSort
---
.../uni_marburg/powersort/sort/QuickSort.java | 30 ++++++++++---------
.../uni_marburg/powersort/sort/SortEnum.java | 2 +-
2 files changed, 17 insertions(+), 15 deletions(-)
diff --git a/app/src/main/java/de/uni_marburg/powersort/sort/QuickSort.java b/app/src/main/java/de/uni_marburg/powersort/sort/QuickSort.java
index 815b8b7..8d3f3dd 100644
--- a/app/src/main/java/de/uni_marburg/powersort/sort/QuickSort.java
+++ b/app/src/main/java/de/uni_marburg/powersort/sort/QuickSort.java
@@ -1,40 +1,42 @@
package de.uni_marburg.powersort.sort;
+import java.util.Comparator;
+
public class QuickSort {
/**
* Based on https://www.baeldung.com/java-quicksort
*/
- public static void sort(Integer[] arr) {
- quickSort(arr, 0, arr.length-1);
+ public static <T> void sort(final T[] arr, Comparator<T> c) {
+ quickSort(arr, c, 0, arr.length - 1);
}
- private static void quickSort(Integer[] arr, int begin, int end) {
+ private static <T> void quickSort(T[] arr, Comparator<T> c, int begin, int end) {
if (begin < end) {
- int partitionIndex = partition(arr, begin, end);
+ int partitionIndex = partition(arr, c, begin, end);
- quickSort(arr, begin, partitionIndex-1);
- quickSort(arr, partitionIndex+1, end);
+ quickSort(arr, c, begin, partitionIndex - 1);
+ quickSort(arr, c, partitionIndex + 1, end);
}
}
- private static int partition(Integer[] arr, int begin, int end) {
- int pivot = arr[end];
- int i = (begin-1);
+ private static <T> int partition(T[] arr, Comparator<T> c, int begin, int end) {
+ T pivot = arr[end];
+ int i = (begin - 1);
for (int j = begin; j < end; j++) {
- if (arr[j] <= pivot) {
+ if (c.compare(arr[j], pivot) <= 0) {
i++;
- int swapTemp = arr[i];
+ T swapTemp = arr[i];
arr[i] = arr[j];
arr[j] = swapTemp;
}
}
- int swapTemp = arr[i+1];
- arr[i+1] = arr[end];
+ T swapTemp = arr[i + 1];
+ arr[i + 1] = arr[end];
arr[end] = swapTemp;
- return i+1;
+ return i + 1;
}
}
diff --git a/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java b/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
index 06e346b..8ae042a 100644
--- a/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
+++ b/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
@@ -14,7 +14,7 @@ public enum SortEnum {
public SortImpl getSortImpl() {
return switch (this) {
case BUBBLE_SORT -> array -> BubbleSort.sort(array, NaturalOrder.INSTANCE);
- case QUICK_SORT -> array -> QuickSort.sort((Integer[]) array); // TODO rm cast
+ case QUICK_SORT -> array -> QuickSort.sort(array, NaturalOrder.INSTANCE);
case MERGE_SORT -> array -> MergeSort.legacyMergeSort(array, NaturalOrder.INSTANCE);
case TIM_SORT -> array -> TimSort.sort(array, 0, array.length, NaturalOrder.INSTANCE, null, 0, 0);
case FINN_SORT -> array -> FinnSort.sort(array, NaturalOrder.INSTANCE);
From 438d0099daff126a16678afce31f24c821d23df6 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 17 Dec 2024 20:06:58 +0000
Subject: [PATCH 09/70] adjust QuickSort
---
.../sort/dpqs/DualPivotQuicksort.java | 892 ++++++++++++++++++
.../powersort/sort/dpqs/Unsafe.java | 8 +
2 files changed, 900 insertions(+)
create mode 100644 app/src/main/java/de/uni_marburg/powersort/sort/dpqs/DualPivotQuicksort.java
create mode 100644 app/src/main/java/de/uni_marburg/powersort/sort/dpqs/Unsafe.java
diff --git a/app/src/main/java/de/uni_marburg/powersort/sort/dpqs/DualPivotQuicksort.java b/app/src/main/java/de/uni_marburg/powersort/sort/dpqs/DualPivotQuicksort.java
new file mode 100644
index 0000000..d98bf5b
--- /dev/null
+++ b/app/src/main/java/de/uni_marburg/powersort/sort/dpqs/DualPivotQuicksort.java
@@ -0,0 +1,892 @@
+// Imported from JDK23 DualPivotQuicksort.java
+
+package de.uni_marburg.powersort.sort.dpqs;
+
+/*
+ * Copyright (c) 2009, 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.
+ */
+
+import java.util.Arrays;
+import java.util.concurrent.CountedCompleter;
+import java.util.concurrent.RecursiveTask;
+
+/**
+ * This class implements powerful and fully optimized versions, both
+ * sequential and parallel, of the Dual-Pivot Quicksort algorithm by
+ * Vladimir Yaroslavskiy, Jon Bentley and Josh Bloch. This algorithm
+ * offers O(n log(n)) performance on all data sets, and is typically
+ * faster than traditional (one-pivot) Quicksort implementations.
+ *
+ * There are also additional algorithms, invoked from the Dual-Pivot
+ * Quicksort, such as mixed insertion sort, merging of runs and heap
+ * sort, counting sort and parallel merge sort.
+ *
+ * @author Vladimir Yaroslavskiy
+ * @author Jon Bentley
+ * @author Josh Bloch
+ * @author Doug Lea
+ *
+ * @version 2018.08.18
+ *
+ * @since 1.7 * 14
+ */
+public final class DualPivotQuicksort {
+
+ /**
+ * Prevents instantiation.
+ */
+ private DualPivotQuicksort() {}
+
+ /**
+ * Max array size to use mixed insertion sort.
+ */
+ private static final int MAX_MIXED_INSERTION_SORT_SIZE = 65;
+
+ /**
+ * Max array size to use insertion sort.
+ */
+ private static final int MAX_INSERTION_SORT_SIZE = 44;
+
+ /**
+ * Min array size to try merging of runs.
+ */
+ private static final int MIN_TRY_MERGE_SIZE = 4 << 10;
+
+ /**
+ * Min size of the first run to continue with scanning.
+ */
+ private static final int MIN_FIRST_RUN_SIZE = 16;
+
+ /**
+ * Min factor for the first runs to continue scanning.
+ */
+ private static final int MIN_FIRST_RUNS_FACTOR = 7;
+
+ /**
+ * Max capacity of the index array for tracking runs.
+ */
+ private static final int MAX_RUN_CAPACITY = 5 << 10;
+
+ /**
+ * Threshold of mixed insertion sort is incremented by this value.
+ */
+ private static final int DELTA = 3 << 1;
+
+ /**
+ * Max recursive partitioning depth before using heap sort.
+ */
+ private static final int MAX_RECURSION_DEPTH = 64 * DELTA;
+
+ /**
+ * Represents a function that accepts the array and sorts the specified range
+ * of the array into ascending order.
+ */
+ @FunctionalInterface
+ private static interface SortOperation<A> {
+ /**
+ * Sorts the specified range of the array.
+ *
+ * @param a the array to be sorted
+ * @param low the index of the first element, inclusive, to be sorted
+ * @param high the index of the last element, exclusive, to be sorted
+ */
+ void sort(A a, int low, int high);
+ }
+
+ /**
+ * Sorts the specified range of the array into ascending numerical order.
+ *
+ * @param elemType the class of the elements of the array to be sorted
+ * @param array the array to be sorted
+ * @param offset the relative offset, in bytes, from the base address of
+ * the array to sort, otherwise if the array is {@code null},an absolute
+ * address pointing to the first element to sort from.
+ * @param low the index of the first element, inclusive, to be sorted
+ * @param high the index of the last element, exclusive, to be sorted
+ * @param so the method reference for the fallback implementation
+ */
+ private static <A> void sort(Class<?> elemType, A array, long offset, int low, int high, SortOperation<A> so) {
+ so.sort(array, low, high);
+ }
+
+ /**
+ * Represents a function that accepts the array and partitions the specified range
+ * of the array using the pivots provided.
+ */
+ @FunctionalInterface
+ interface PartitionOperation<A> {
+ /**
+ * Partitions the specified range of the array using the given pivots.
+ *
+ * @param a the array to be partitioned
+ * @param low the index of the first element, inclusive, to be partitioned
+ * @param high the index of the last element, exclusive, to be partitioned
+ * @param pivotIndex1 the index of pivot1, the first pivot
+ * @param pivotIndex2 the index of pivot2, the second pivot
+ */
+ int[] partition(A a, int low, int high, int pivotIndex1, int pivotIndex2);
+ }
+
+ /**
+ * Partitions the specified range of the array using the two pivots provided.
+ *
+ * @param elemType the class of the array to be partitioned
+ * @param array the array to be partitioned
+ * @param offset the relative offset, in bytes, from the base address of
+ * the array to partition, otherwise if the array is {@code null},an absolute
+ * address pointing to the first element to partition from.
+ * @param low the index of the first element, inclusive, to be partitioned
+ * @param high the index of the last element, exclusive, to be partitioned
+ * @param pivotIndex1 the index of pivot1, the first pivot
+ * @param pivotIndex2 the index of pivot2, the second pivot
+ * @param po the method reference for the fallback implementation
+ */
+ private static <A> int[] partition(Class<?> elemType, A array, long offset, int low, int high, int pivotIndex1, int pivotIndex2, PartitionOperation<A> po) {
+ return po.partition(array, low, high, pivotIndex1, pivotIndex2);
+ }
+
+ /**
+ * Sorts the specified range of the array using parallel merge
+ * sort and/or Dual-Pivot Quicksort.
+ *
+ * To balance the faster splitting and parallelism of merge sort
+ * with the faster element partitioning of Quicksort, ranges are
+ * subdivided in tiers such that, if there is enough parallelism,
+ * the four-way parallel merge is started, still ensuring enough
+ * parallelism to process the partitions.
+ *
+ * @param a the array to be sorted
+ * @param low the index of the first element, inclusive, to be sorted
+ * @param high the index of the last element, exclusive, to be sorted
+ */
+ public static void sort(int[] a, int low, int high) {
+ int size = high - low;
+
+ sort(a, 0, low, high);
+ }
+
+ /**
+ * Sorts the specified array using the Dual-Pivot Quicksort and/or
+ * other sorts in special-cases, possibly with parallel partitions.
+ *
+ * @param a the array to be sorted
+ * @param bits the combination of recursion depth and bit flag, where
+ * the right bit "0" indicates that array is the leftmost part
+ * @param low the index of the first element, inclusive, to be sorted
+ * @param high the index of the last element, exclusive, to be sorted
+ */
+ static void sort(int[] a, int bits, int low, int high) {
+ while (true) {
+ int end = high - 1, size = high - low;
+ /*
+ * Run mixed insertion sort on small non-leftmost parts.
+ */
+ if (size < MAX_MIXED_INSERTION_SORT_SIZE + bits && (bits & 1) > 0) {
+ sort(int.class, a, Unsafe.ARRAY_INT_BASE_OFFSET, low, high, DualPivotQuicksort::mixedInsertionSort);
+ return;
+ }
+
+ /*
+ * Invoke insertion sort on small leftmost part.
+ */
+ if (size < MAX_INSERTION_SORT_SIZE) {
+ sort(int.class, a, Unsafe.ARRAY_INT_BASE_OFFSET, low, high, DualPivotQuicksort::insertionSort);
+ return;
+ }
+
+ /*
+ * Check if the whole array or large non-leftmost
+ * parts are nearly sorted and then merge runs.
+ */
+ if ((bits == 0 || size > MIN_TRY_MERGE_SIZE && (bits & 1) > 0)
+ && tryMergeRuns(a, low, size)) {
+ return;
+ }
+
+ /*
+ * Switch to heap sort if execution
+ * time is becoming quadratic.
+ */
+ if ((bits += DELTA) > MAX_RECURSION_DEPTH) {
+ heapSort(a, low, high);
+ return;
+ }
+
+ /*
+ * Use an inexpensive approximation of the golden ratio
+ * to select five sample elements and determine pivots.
+ */
+ int step = (size >> 3) * 3 + 3;
+
+ /*
+ * Five elements around (and including) the central element
+ * will be used for pivot selection as described below. The
+ * unequal choice of spacing these elements was empirically
+ * determined to work well on a wide variety of inputs.
+ */
+ int e1 = low + step;
+ int e5 = end - step;
+ int e3 = (e1 + e5) >>> 1;
+ int e2 = (e1 + e3) >>> 1;
+ int e4 = (e3 + e5) >>> 1;
+ int a3 = a[e3];
+
+ /*
+ * Sort these elements in place by the combination
+ * of 4-element sorting network and insertion sort.
+ *
+ * 5 ------o-----------o------------
+ * | |
+ * 4 ------|-----o-----o-----o------
+ * | | |
+ * 2 ------o-----|-----o-----o------
+ * | |
+ * 1 ------------o-----o------------
+ */
+ if (a[e5] < a[e2]) { int t = a[e5]; a[e5] = a[e2]; a[e2] = t; }
+ if (a[e4] < a[e1]) { int t = a[e4]; a[e4] = a[e1]; a[e1] = t; }
+ if (a[e5] < a[e4]) { int t = a[e5]; a[e5] = a[e4]; a[e4] = t; }
+ 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; }
+
+ if (a3 < a[e2]) {
+ if (a3 < a[e1]) {
+ a[e3] = a[e2]; a[e2] = a[e1]; a[e1] = a3;
+ } else {
+ a[e3] = a[e2]; a[e2] = a3;
+ }
+ } else if (a3 > a[e4]) {
+ if (a3 > a[e5]) {
+ a[e3] = a[e4]; a[e4] = a[e5]; a[e5] = a3;
+ } else {
+ a[e3] = a[e4]; a[e4] = a3;
+ }
+ }
+
+ // Pointers
+ int lower; // The index of the last element of the left part
+ int upper; // The index of the first element of the right part
+
+ /*
+ * Partitioning with 2 pivots in case of different elements.
+ */
+ if (a[e1] < a[e2] && a[e2] < a[e3] && a[e3] < a[e4] && a[e4] < a[e5]) {
+ /*
+ * Use the first and fifth of the five sorted elements as
+ * the pivots. These values are inexpensive approximation
+ * of tertiles. Note, that pivot1 < pivot2.
+ */
+ int[] pivotIndices = partition(int.class, a, Unsafe.ARRAY_INT_BASE_OFFSET, low, high, e1, e5, DualPivotQuicksort::partitionDualPivot);
+ lower = pivotIndices[0];
+ upper = pivotIndices[1];
+
+
+
+ /*
+ * Sort non-left parts recursively,
+ * excluding known pivots.
+ */
+ sort(a, bits | 1, lower + 1, upper);
+ sort(a, bits | 1, upper + 1, high);
+
+ } else { // Use single pivot in case of many equal elements
+
+ /*
+ * Use the third of the five sorted elements as the pivot.
+ * This value is inexpensive approximation of the median.
+ */
+ int[] pivotIndices = partition(int.class, a, Unsafe.ARRAY_INT_BASE_OFFSET, low, high, e3, e3, DualPivotQuicksort::partitionSinglePivot);
+ lower = pivotIndices[0];
+ upper = pivotIndices[1];
+ /*
+ * Sort the right part, excluding
+ * known pivot. All elements from the central part are
+ * equal and therefore already sorted.
+ */
+ sort(a, bits | 1, upper, high);
+ }
+ high = lower; // Iterate along the left part
+ }
+ }
+
+ /**
+ * Partitions the specified range of the array using the two pivots provided.
+ *
+ * @param a the array to be partitioned
+ * @param low the index of the first element, inclusive, for partitioning
+ * @param high the index of the last element, exclusive, for partitioning
+ * @param pivotIndex1 the index of pivot1, the first pivot
+ * @param pivotIndex2 the index of pivot2, the second pivot
+ *
+ */
+ private static int[] partitionDualPivot(int[] a, int low, int high, int pivotIndex1, int pivotIndex2) {
+ int end = high - 1;
+ int lower = low;
+ int upper = end;
+
+ int e1 = pivotIndex1;
+ int e5 = pivotIndex2;
+ int pivot1 = a[e1];
+ int pivot2 = a[e5];
+
+ /*
+ * The first and the last elements to be sorted are moved
+ * to the locations formerly occupied by the pivots. When
+ * partitioning is completed, the pivots are swapped back
+ * into their final positions, and excluded from the next
+ * subsequent sorting.
+ */
+ a[e1] = a[lower];
+ a[e5] = a[upper];
+
+ /*
+ * Skip elements, which are less or greater than the pivots.
+ */
+ while (a[++lower] < pivot1);
+ while (a[--upper] > pivot2);
+
+ /*
+ * Backward 3-interval partitioning
+ *
+ * left part central part right part
+ * +------------------------------------------------------------+
+ * | < pivot1 | ? | pivot1 <= && <= pivot2 | > pivot2 |
+ * +------------------------------------------------------------+
+ * ^ ^ ^
+ * | | |
+ * lower k upper
+ *
+ * Invariants:
+ *
+ * all in (low, lower] < pivot1
+ * pivot1 <= all in (k, upper) <= pivot2
+ * all in [upper, end) > pivot2
+ *
+ * Pointer k is the last index of ?-part
+ */
+ for (int unused = --lower, k = ++upper; --k > lower; ) {
+ int ak = a[k];
+
+ if (ak < pivot1) { // Move a[k] to the left side
+ while (lower < k) {
+ if (a[++lower] >= pivot1) {
+ if (a[lower] > pivot2) {
+ a[k] = a[--upper];
+ a[upper] = a[lower];
+ } else {
+ a[k] = a[lower];
+ }
+ a[lower] = ak;
+ break;
+ }
+ }
+ } else if (ak > pivot2) { // Move a[k] to the right side
+ a[k] = a[--upper];
+ a[upper] = ak;
+ }
+ }
+
+ /*
+ * Swap the pivots into their final positions.
+ */
+ a[low] = a[lower]; a[lower] = pivot1;
+ a[end] = a[upper]; a[upper] = pivot2;
+
+ return new int[] {lower, upper};
+ }
+
+ /**
+ * Partitions the specified range of the array using a single pivot provided.
+ *
+ * @param a the array to be partitioned
+ * @param low the index of the first element, inclusive, for partitioning
+ * @param high the index of the last element, exclusive, for partitioning
+ * @param pivotIndex1 the index of pivot1, the first pivot
+ * @param pivotIndex2 the index of pivot2, the second pivot
+ *
+ */
+ private static int[] partitionSinglePivot(int[] a, int low, int high, int pivotIndex1, int pivotIndex2) {
+
+ int end = high - 1;
+ int lower = low;
+ int upper = end;
+ int e3 = pivotIndex1;
+ int pivot = a[e3];
+
+ /*
+ * The first element to be sorted is moved to the
+ * location formerly occupied by the pivot. After
+ * completion of partitioning the pivot is swapped
+ * back into its final position, and excluded from
+ * the next subsequent sorting.
+ */
+ a[e3] = a[lower];
+
+ /*
+ * Traditional 3-way (Dutch National Flag) partitioning
+ *
+ * left part central part right part
+ * +------------------------------------------------------+
+ * | < pivot | ? | == pivot | > pivot |
+ * +------------------------------------------------------+
+ * ^ ^ ^
+ * | | |
+ * lower k upper
+ *
+ * Invariants:
+ *
+ * all in (low, lower] < pivot
+ * all in (k, upper) == pivot
+ * all in [upper, end] > pivot
+ *
+ * Pointer k is the last index of ?-part
+ */
+ for (int k = ++upper; --k > lower; ) {
+ int ak = a[k];
+
+ if (ak != pivot) {
+ a[k] = pivot;
+
+ if (ak < pivot) { // Move a[k] to the left side
+ while (a[++lower] < pivot);
+
+ if (a[lower] > pivot) {
+ a[--upper] = a[lower];
+ }
+ a[lower] = ak;
+ } else { // ak > pivot - Move a[k] to the right side
+ a[--upper] = ak;
+ }
+ }
+ }
+
+ /*
+ * Swap the pivot into its final position.
+ */
+ a[low] = a[lower]; a[lower] = pivot;
+ return new int[] {lower, upper};
+ }
+
+ /**
+ * Sorts the specified range of the array using mixed insertion sort.
+ *
+ * Mixed insertion sort is combination of simple insertion sort,
+ * pin insertion sort and pair insertion sort.
+ *
+ * In the context of Dual-Pivot Quicksort, the pivot element
+ * from the left part plays the role of sentinel, because it
+ * is less than any elements from the given part. Therefore,
+ * expensive check of the left range can be skipped on each
+ * iteration unless it is the leftmost call.
+ *
+ * @param a the array to be sorted
+ * @param low the index of the first element, inclusive, to be sorted
+ * @param high the index of the last element, exclusive, to be sorted
+ */
+ private static void mixedInsertionSort(int[] a, int low, int high) {
+ int size = high - low;
+ int end = high - 3 * ((size >> 5) << 3);
+ if (end == high) {
+
+ /*
+ * Invoke simple insertion sort on tiny array.
+ */
+ for (int i; ++low < end; ) {
+ 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]) { // Small element
+
+ /*
+ * Insert small 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) { // Large element
+
+ /*
+ * Find element smaller than pin.
+ */
+ while (a[--p] > pin);
+
+ /*
+ * Swap it with large element.
+ */
+ if (p > i) {
+ ai = a[p];
+ a[p] = a[i];
+ }
+
+ /*
+ * Insert small element into sorted part.
+ */
+ while (ai < a[--i]) {
+ a[i + 1] = a[i];
+ }
+ a[i + 1] = ai;
+ }
+ }
+
+ /*
+ * Continue with pair insertion sort on remain part.
+ */
+ for (int i; low < high; ++low) {
+ int a1 = a[i = low], a2 = a[++low];
+
+ /*
+ * Insert two elements per iteration: at first, insert the
+ * larger element and then insert the smaller element, but
+ * from the position where the larger element was inserted.
+ */
+ if (a1 > a2) {
+
+ while (a1 < a[--i]) {
+ a[i + 2] = a[i];
+ }
+ a[++i + 1] = a1;
+
+ while (a2 < a[--i]) {
+ a[i + 1] = a[i];
+ }
+ a[i + 1] = a2;
+
+ } else if (a1 < a[i - 1]) {
+
+ while (a2 < a[--i]) {
+ a[i + 2] = a[i];
+ }
+ a[++i + 1] = a2;
+
+ while (a1 < a[--i]) {
+ a[i + 1] = a[i];
+ }
+ a[i + 1] = a1;
+ }
+ }
+ }
+ }
+
+ /**
+ * Sorts the specified range of the array using insertion sort.
+ *
+ * @param a the array to be sorted
+ * @param low the index of the first element, inclusive, to be sorted
+ * @param high the index of the last element, exclusive, to be sorted
+ */
+ private static void insertionSort(int[] a, int low, int high) {
+ for (int i, k = low; ++k < high; ) {
+ int ai = a[i = k];
+
+ if (ai < a[i - 1]) {
+ while (--i >= low && ai < a[i]) {
+ a[i + 1] = a[i];
+ }
+ a[i + 1] = ai;
+ }
+ }
+ }
+
+ /**
+ * Sorts the specified range of the array using heap sort.
+ *
+ * @param a the array to be sorted
+ * @param low the index of the first element, inclusive, to be sorted
+ * @param high the index of the last element, exclusive, to be sorted
+ */
+ private static void heapSort(int[] a, int low, int high) {
+ for (int k = (low + high) >>> 1; k > low; ) {
+ pushDown(a, --k, a[k], low, high);
+ }
+ while (--high > low) {
+ int max = a[low];
+ pushDown(a, low, a[high], low, high);
+ a[high] = max;
+ }
+ }
+
+ /**
+ * Pushes specified element down during heap sort.
+ *
+ * @param a the given array
+ * @param p the start index
+ * @param value the given element
+ * @param low the index of the first element, inclusive, to be sorted
+ * @param high the index of the last element, exclusive, to be sorted
+ */
+ private static void pushDown(int[] a, int p, int value, int low, int high) {
+ for (int k ;; a[p] = a[p = k]) {
+ k = (p << 1) - low + 2; // Index of the right child
+
+ if (k > high) {
+ break;
+ }
+ if (k == high || a[k] < a[k - 1]) {
+ --k;
+ }
+ if (a[k] <= value) {
+ break;
+ }
+ }
+ a[p] = value;
+ }
+
+ /**
+ * Tries to sort the specified range of the array.
+ *
+ * @param a the array to be sorted
+ * @param low the index of the first element to be sorted
+ * @param size the array size
+ * @return true if finally sorted, false otherwise
+ */
+ private static boolean tryMergeRuns(int[] a, int low, int size) {
+
+ /*
+ * The run array is constructed only if initial runs are
+ * long enough to continue, run[i] then holds start index
+ * of the i-th sequence of elements in non-descending order.
+ */
+ int[] run = null;
+ int high = low + size;
+ int count = 1, last = low;
+
+ /*
+ * Identify all possible runs.
+ */
+ for (int k = low + 1; k < high; ) {
+
+ /*
+ * Find the end index of the current run.
+ */
+ if (a[k - 1] < a[k]) {
+
+ // Identify ascending sequence
+ while (++k < high && a[k - 1] <= a[k]);
+
+ } else if (a[k - 1] > a[k]) {
+
+ // Identify descending sequence
+ while (++k < high && a[k - 1] >= a[k]);
+
+ // Reverse into ascending order
+ for (int i = last - 1, j = k; ++i < --j && a[i] > a[j]; ) {
+ int ai = a[i]; a[i] = a[j]; a[j] = ai;
+ }
+ } else { // Identify constant sequence
+ for (int ak = a[k]; ++k < high && ak == a[k]; );
+
+ if (k < high) {
+ continue;
+ }
+ }
+
+ /*
+ * Check special cases.
+ */
+ if (run == null) {
+ if (k == high) {
+
+ /*
+ * The array is monotonous sequence,
+ * and therefore already sorted.
+ */
+ return true;
+ }
+
+ if (k - low < MIN_FIRST_RUN_SIZE) {
+
+ /*
+ * The first run is too small
+ * to proceed with scanning.
+ */
+ return false;
+ }
+
+ run = new int[((size >> 10) | 0x7F) & 0x3FF];
+ run[0] = low;
+
+ } else if (a[last - 1] > a[last]) {
+
+ if (count > (k - low) >> MIN_FIRST_RUNS_FACTOR) {
+
+ /*
+ * The first runs are not long
+ * enough to continue scanning.
+ */
+ return false;
+ }
+
+ if (++count == MAX_RUN_CAPACITY) {
+
+ /*
+ * Array is not highly structured.
+ */
+ return false;
+ }
+
+ if (count == run.length) {
+
+ /*
+ * Increase capacity of index array.
+ */
+ run = Arrays.copyOf(run, count << 1);
+ }
+ }
+ run[count] = (last = k);
+ }
+
+ /*
+ * Merge runs of highly structured array.
+ */
+ if (count > 1) {
+ int[] b; int offset = low;
+
+ b = new int[size];
+ mergeRuns(a, b, offset, 1, run, 0, count);
+ }
+ return true;
+ }
+
+ /**
+ * Merges the specified runs.
+ *
+ * @param a the source array
+ * @param b the temporary buffer used in merging
+ * @param offset the start index in the source, inclusive
+ * @param aim specifies merging: to source ( > 0), buffer ( < 0) or any ( == 0)
+ * @param run the start indexes of the runs, inclusive
+ * @param lo the start index of the first run, inclusive
+ * @param hi the start index of the last run, inclusive
+ * @return the destination where runs are merged
+ */
+ private static int[] mergeRuns(int[] a, int[] b, int offset,
+ int aim, int[] run, int lo, int hi) {
+
+ if (hi - lo == 1) {
+ if (aim >= 0) {
+ return a;
+ }
+ for (int i = run[hi], j = i - offset, low = run[lo]; i > low;
+ b[--j] = a[--i]
+ );
+ return b;
+ }
+
+ /*
+ * Split into approximately equal parts.
+ */
+ int mi = lo, rmi = (run[lo] + run[hi]) >>> 1;
+ while (run[++mi + 1] <= rmi);
+
+ /*
+ * Merge the left and right parts.
+ */
+ int[] a1, a2;
+
+ a1 = mergeRuns(a, b, offset, -aim, run, lo, mi);
+ a2 = mergeRuns(a, b, offset, 0, run, mi, hi);
+
+ int[] dst = a1 == a ? b : a;
+
+ int k = a1 == a ? run[lo] - offset : run[lo];
+ int lo1 = a1 == b ? run[lo] - offset : run[lo];
+ int hi1 = a1 == b ? run[mi] - offset : run[mi];
+ int lo2 = a2 == b ? run[mi] - offset : run[mi];
+ int hi2 = a2 == b ? run[hi] - offset : run[hi];
+
+ mergeParts(dst, k, a1, lo1, hi1, a2, lo2, hi2);
+ return dst;
+ }
+
+ /**
+ * Merges the sorted parts.
+ *
+ * @param dst the destination where parts are merged
+ * @param k the start index of the destination, inclusive
+ * @param a1 the first part
+ * @param lo1 the start index of the first part, inclusive
+ * @param hi1 the end index of the first part, exclusive
+ * @param a2 the second part
+ * @param lo2 the start index of the second part, inclusive
+ * @param hi2 the end index of the second part, exclusive
+ */
+ private static void mergeParts(int[] dst, int k,
+ int[] a1, int lo1, int hi1, int[] a2, int lo2, int hi2) {
+
+
+ /*
+ * Merge small parts sequentially.
+ */
+ while (lo1 < hi1 && lo2 < hi2) {
+ dst[k++] = a1[lo1] < a2[lo2] ? a1[lo1++] : a2[lo2++];
+ }
+ if (dst != a1 || k < lo1) {
+ while (lo1 < hi1) {
+ dst[k++] = a1[lo1++];
+ }
+ }
+ if (dst != a2 || k < lo2) {
+ while (lo2 < hi2) {
+ dst[k++] = a2[lo2++];
+ }
+ }
+ }
+
+// [long]
+
+// [byte]
+
+// [char]
+
+// [short]
+
+// [float]
+
+// [double]
+
+}
\ No newline at end of file
diff --git a/app/src/main/java/de/uni_marburg/powersort/sort/dpqs/Unsafe.java b/app/src/main/java/de/uni_marburg/powersort/sort/dpqs/Unsafe.java
new file mode 100644
index 0000000..2395c0b
--- /dev/null
+++ b/app/src/main/java/de/uni_marburg/powersort/sort/dpqs/Unsafe.java
@@ -0,0 +1,8 @@
+package de.uni_marburg.powersort.sort.dpqs;
+
+public final class Unsafe {
+ private Unsafe() {
+ }
+ public static final int ARRAY_INT_BASE_OFFSET
+ = 16; // Taken from debugging JDK 23 Unsafe.ARRAY_INT_BASE_OFFSET
+}
From fe7fe86dee1e4e3c15caa61dcab8f84e11082987 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 17 Dec 2024 20:28:46 +0000
Subject: [PATCH 10/70] adjust QuickSort
---
.../sort/dpqs/DualPivotQuicksort.java | 237 ++++++++++--------
1 file changed, 128 insertions(+), 109 deletions(-)
diff --git a/app/src/main/java/de/uni_marburg/powersort/sort/dpqs/DualPivotQuicksort.java b/app/src/main/java/de/uni_marburg/powersort/sort/dpqs/DualPivotQuicksort.java
index d98bf5b..1177807 100644
--- a/app/src/main/java/de/uni_marburg/powersort/sort/dpqs/DualPivotQuicksort.java
+++ b/app/src/main/java/de/uni_marburg/powersort/sort/dpqs/DualPivotQuicksort.java
@@ -28,8 +28,6 @@ package de.uni_marburg.powersort.sort.dpqs;
*/
import java.util.Arrays;
-import java.util.concurrent.CountedCompleter;
-import java.util.concurrent.RecursiveTask;
/**
* This class implements powerful and fully optimized versions, both
@@ -37,7 +35,7 @@ import java.util.concurrent.RecursiveTask;
* Vladimir Yaroslavskiy, Jon Bentley and Josh Bloch. This algorithm
* offers O(n log(n)) performance on all data sets, and is typically
* faster than traditional (one-pivot) Quicksort implementations.
- *
+ * <p>
* There are also additional algorithms, invoked from the Dual-Pivot
* Quicksort, such as mixed insertion sort, merging of runs and heap
* sort, counting sort and parallel merge sort.
@@ -46,9 +44,7 @@ import java.util.concurrent.RecursiveTask;
* @author Jon Bentley
* @author Josh Bloch
* @author Doug Lea
- *
* @version 2018.08.18
- *
* @since 1.7 * 14
*/
public final class DualPivotQuicksort {
@@ -56,7 +52,8 @@ public final class DualPivotQuicksort {
/**
* Prevents instantiation.
*/
- private DualPivotQuicksort() {}
+ private DualPivotQuicksort() {
+ }
/**
* Max array size to use mixed insertion sort.
@@ -103,12 +100,12 @@ public final class DualPivotQuicksort {
* of the array into ascending order.
*/
@FunctionalInterface
- private static interface SortOperation<A> {
+ private interface SortOperation<A> {
/**
* Sorts the specified range of the array.
*
- * @param a the array to be sorted
- * @param low the index of the first element, inclusive, to be sorted
+ * @param a the array to be sorted
+ * @param low the index of the first element, inclusive, to be sorted
* @param high the index of the last element, exclusive, to be sorted
*/
void sort(A a, int low, int high);
@@ -117,16 +114,14 @@ public final class DualPivotQuicksort {
/**
* Sorts the specified range of the array into ascending numerical order.
*
- * @param elemType the class of the elements of the array to be sorted
- * @param array the array to be sorted
- * @param offset the relative offset, in bytes, from the base address of
- * the array to sort, otherwise if the array is {@code null},an absolute
- * address pointing to the first element to sort from.
- * @param low the index of the first element, inclusive, to be sorted
- * @param high the index of the last element, exclusive, to be sorted
- * @param so the method reference for the fallback implementation
+ * @param array the array to be sorted
+ * the array to sort, otherwise if the array is {@code null},an absolute
+ * address pointing to the first element to sort from.
+ * @param low the index of the first element, inclusive, to be sorted
+ * @param high the index of the last element, exclusive, to be sorted
+ * @param so the method reference for the fallback implementation
*/
- private static <A> void sort(Class<?> elemType, A array, long offset, int low, int high, SortOperation<A> so) {
+ private static <A> void sort(A array, int low, int high, SortOperation<A> so) {
so.sort(array, low, high);
}
@@ -139,9 +134,9 @@ public final class DualPivotQuicksort {
/**
* Partitions the specified range of the array using the given pivots.
*
- * @param a the array to be partitioned
- * @param low the index of the first element, inclusive, to be partitioned
- * @param high the index of the last element, exclusive, to be partitioned
+ * @param a the array to be partitioned
+ * @param low the index of the first element, inclusive, to be partitioned
+ * @param high the index of the last element, exclusive, to be partitioned
* @param pivotIndex1 the index of pivot1, the first pivot
* @param pivotIndex2 the index of pivot2, the second pivot
*/
@@ -151,49 +146,42 @@ public final class DualPivotQuicksort {
/**
* Partitions the specified range of the array using the two pivots provided.
*
- * @param elemType the class of the array to be partitioned
- * @param array the array to be partitioned
- * @param offset the relative offset, in bytes, from the base address of
- * the array to partition, otherwise if the array is {@code null},an absolute
- * address pointing to the first element to partition from.
- * @param low the index of the first element, inclusive, to be partitioned
- * @param high the index of the last element, exclusive, to be partitioned
+ * @param array the array to be partitioned
+ * @param high the index of the last element, exclusive, to be partitioned
* @param pivotIndex1 the index of pivot1, the first pivot
* @param pivotIndex2 the index of pivot2, the second pivot
- * @param po the method reference for the fallback implementation
+ * @param po the method reference for the fallback implementation
*/
- private static <A> int[] partition(Class<?> elemType, A array, long offset, int low, int high, int pivotIndex1, int pivotIndex2, PartitionOperation<A> po) {
- return po.partition(array, low, high, pivotIndex1, pivotIndex2);
+ private static <A> int[] partition(A array, int high, int pivotIndex1, int pivotIndex2, PartitionOperation<A> po) {
+ return po.partition(array, Unsafe.ARRAY_INT_BASE_OFFSET, high, pivotIndex1, pivotIndex2);
}
/**
* Sorts the specified range of the array using parallel merge
* sort and/or Dual-Pivot Quicksort.
- *
+ * <p>
* To balance the faster splitting and parallelism of merge sort
* with the faster element partitioning of Quicksort, ranges are
* subdivided in tiers such that, if there is enough parallelism,
* the four-way parallel merge is started, still ensuring enough
* parallelism to process the partitions.
*
- * @param a the array to be sorted
- * @param low the index of the first element, inclusive, to be sorted
+ * @param a the array to be sorted
+ * @param low the index of the first element, inclusive, to be sorted
* @param high the index of the last element, exclusive, to be sorted
*/
public static void sort(int[] a, int low, int high) {
- int size = high - low;
-
- sort(a, 0, low, high);
+ sort(a, 0, low, high);
}
/**
* Sorts the specified array using the Dual-Pivot Quicksort and/or
* other sorts in special-cases, possibly with parallel partitions.
*
- * @param a the array to be sorted
+ * @param a the array to be sorted
* @param bits the combination of recursion depth and bit flag, where
- * the right bit "0" indicates that array is the leftmost part
- * @param low the index of the first element, inclusive, to be sorted
+ * the right bit "0" indicates that array is the leftmost part
+ * @param low the index of the first element, inclusive, to be sorted
* @param high the index of the last element, exclusive, to be sorted
*/
static void sort(int[] a, int bits, int low, int high) {
@@ -203,7 +191,7 @@ public final class DualPivotQuicksort {
* Run mixed insertion sort on small non-leftmost parts.
*/
if (size < MAX_MIXED_INSERTION_SORT_SIZE + bits && (bits & 1) > 0) {
- sort(int.class, a, Unsafe.ARRAY_INT_BASE_OFFSET, low, high, DualPivotQuicksort::mixedInsertionSort);
+ sort(a, low, high, DualPivotQuicksort::mixedInsertionSort);
return;
}
@@ -211,7 +199,7 @@ public final class DualPivotQuicksort {
* Invoke insertion sort on small leftmost part.
*/
if (size < MAX_INSERTION_SORT_SIZE) {
- sort(int.class, a, Unsafe.ARRAY_INT_BASE_OFFSET, low, high, DualPivotQuicksort::insertionSort);
+ sort(a, low, high, DualPivotQuicksort::insertionSort);
return;
}
@@ -264,23 +252,49 @@ public final class DualPivotQuicksort {
* | |
* 1 ------------o-----o------------
*/
- if (a[e5] < a[e2]) { int t = a[e5]; a[e5] = a[e2]; a[e2] = t; }
- if (a[e4] < a[e1]) { int t = a[e4]; a[e4] = a[e1]; a[e1] = t; }
- if (a[e5] < a[e4]) { int t = a[e5]; a[e5] = a[e4]; a[e4] = t; }
- 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; }
+ if (a[e5] < a[e2]) {
+ int t = a[e5];
+ a[e5] = a[e2];
+ a[e2] = t;
+ }
+ if (a[e4] < a[e1]) {
+ int t = a[e4];
+ a[e4] = a[e1];
+ a[e1] = t;
+ }
+ if (a[e5] < a[e4]) {
+ int t = a[e5];
+ a[e5] = a[e4];
+ a[e4] = t;
+ }
+ 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;
+ }
if (a3 < a[e2]) {
if (a3 < a[e1]) {
- a[e3] = a[e2]; a[e2] = a[e1]; a[e1] = a3;
+ a[e3] = a[e2];
+ a[e2] = a[e1];
+ a[e1] = a3;
} else {
- a[e3] = a[e2]; a[e2] = a3;
+ a[e3] = a[e2];
+ a[e2] = a3;
}
} else if (a3 > a[e4]) {
if (a3 > a[e5]) {
- a[e3] = a[e4]; a[e4] = a[e5]; a[e5] = a3;
+ a[e3] = a[e4];
+ a[e4] = a[e5];
+ a[e5] = a3;
} else {
- a[e3] = a[e4]; a[e4] = a3;
+ a[e3] = a[e4];
+ a[e4] = a3;
}
}
@@ -297,7 +311,7 @@ public final class DualPivotQuicksort {
* the pivots. These values are inexpensive approximation
* of tertiles. Note, that pivot1 < pivot2.
*/
- int[] pivotIndices = partition(int.class, a, Unsafe.ARRAY_INT_BASE_OFFSET, low, high, e1, e5, DualPivotQuicksort::partitionDualPivot);
+ int[] pivotIndices = partition(a, high, e1, e5, DualPivotQuicksort::partitionDualPivot);
lower = pivotIndices[0];
upper = pivotIndices[1];
@@ -307,8 +321,8 @@ public final class DualPivotQuicksort {
* Sort non-left parts recursively,
* excluding known pivots.
*/
- sort(a, bits | 1, lower + 1, upper);
- sort(a, bits | 1, upper + 1, high);
+ sort(a, bits | 1, lower + 1, upper);
+ sort(a, bits | 1, upper + 1, high);
} else { // Use single pivot in case of many equal elements
@@ -316,7 +330,7 @@ public final class DualPivotQuicksort {
* Use the third of the five sorted elements as the pivot.
* This value is inexpensive approximation of the median.
*/
- int[] pivotIndices = partition(int.class, a, Unsafe.ARRAY_INT_BASE_OFFSET, low, high, e3, e3, DualPivotQuicksort::partitionSinglePivot);
+ int[] pivotIndices = partition(a, high, e3, e3, DualPivotQuicksort::partitionSinglePivot);
lower = pivotIndices[0];
upper = pivotIndices[1];
/*
@@ -324,7 +338,7 @@ public final class DualPivotQuicksort {
* known pivot. All elements from the central part are
* equal and therefore already sorted.
*/
- sort(a, bits | 1, upper, high);
+ sort(a, bits | 1, upper, high);
}
high = lower; // Iterate along the left part
}
@@ -333,12 +347,11 @@ public final class DualPivotQuicksort {
/**
* Partitions the specified range of the array using the two pivots provided.
*
- * @param a the array to be partitioned
- * @param low the index of the first element, inclusive, for partitioning
- * @param high the index of the last element, exclusive, for partitioning
+ * @param a the array to be partitioned
+ * @param low the index of the first element, inclusive, for partitioning
+ * @param high the index of the last element, exclusive, for partitioning
* @param pivotIndex1 the index of pivot1, the first pivot
* @param pivotIndex2 the index of pivot2, the second pivot
- *
*/
private static int[] partitionDualPivot(int[] a, int low, int high, int pivotIndex1, int pivotIndex2) {
int end = high - 1;
@@ -363,8 +376,8 @@ public final class DualPivotQuicksort {
/*
* Skip elements, which are less or greater than the pivots.
*/
- while (a[++lower] < pivot1);
- while (a[--upper] > pivot2);
+ while (a[++lower] < pivot1) ;
+ while (a[--upper] > pivot2) ;
/*
* Backward 3-interval partitioning
@@ -410,21 +423,22 @@ public final class DualPivotQuicksort {
/*
* Swap the pivots into their final positions.
*/
- a[low] = a[lower]; a[lower] = pivot1;
- a[end] = a[upper]; a[upper] = pivot2;
+ a[low] = a[lower];
+ a[lower] = pivot1;
+ a[end] = a[upper];
+ a[upper] = pivot2;
- return new int[] {lower, upper};
+ return new int[]{lower, upper};
}
/**
* Partitions the specified range of the array using a single pivot provided.
*
- * @param a the array to be partitioned
- * @param low the index of the first element, inclusive, for partitioning
- * @param high the index of the last element, exclusive, for partitioning
+ * @param a the array to be partitioned
+ * @param low the index of the first element, inclusive, for partitioning
+ * @param high the index of the last element, exclusive, for partitioning
* @param pivotIndex1 the index of pivot1, the first pivot
* @param pivotIndex2 the index of pivot2, the second pivot
- *
*/
private static int[] partitionSinglePivot(int[] a, int low, int high, int pivotIndex1, int pivotIndex2) {
@@ -469,7 +483,7 @@ public final class DualPivotQuicksort {
a[k] = pivot;
if (ak < pivot) { // Move a[k] to the left side
- while (a[++lower] < pivot);
+ while (a[++lower] < pivot) ;
if (a[lower] > pivot) {
a[--upper] = a[lower];
@@ -484,24 +498,25 @@ public final class DualPivotQuicksort {
/*
* Swap the pivot into its final position.
*/
- a[low] = a[lower]; a[lower] = pivot;
- return new int[] {lower, upper};
+ a[low] = a[lower];
+ a[lower] = pivot;
+ return new int[]{lower, upper};
}
/**
* Sorts the specified range of the array using mixed insertion sort.
- *
+ * <p>
* Mixed insertion sort is combination of simple insertion sort,
* pin insertion sort and pair insertion sort.
- *
+ * <p>
* In the context of Dual-Pivot Quicksort, the pivot element
* from the left part plays the role of sentinel, because it
* is less than any elements from the given part. Therefore,
* expensive check of the left range can be skipped on each
* iteration unless it is the leftmost call.
*
- * @param a the array to be sorted
- * @param low the index of the first element, inclusive, to be sorted
+ * @param a the array to be sorted
+ * @param low the index of the first element, inclusive, to be sorted
* @param high the index of the last element, exclusive, to be sorted
*/
private static void mixedInsertionSort(int[] a, int low, int high) {
@@ -553,7 +568,7 @@ public final class DualPivotQuicksort {
/*
* Find element smaller than pin.
*/
- while (a[--p] > pin);
+ while (a[--p] > pin) ;
/*
* Swap it with large element.
@@ -615,8 +630,8 @@ public final class DualPivotQuicksort {
/**
* Sorts the specified range of the array using insertion sort.
*
- * @param a the array to be sorted
- * @param low the index of the first element, inclusive, to be sorted
+ * @param a the array to be sorted
+ * @param low the index of the first element, inclusive, to be sorted
* @param high the index of the last element, exclusive, to be sorted
*/
private static void insertionSort(int[] a, int low, int high) {
@@ -635,8 +650,8 @@ public final class DualPivotQuicksort {
/**
* Sorts the specified range of the array using heap sort.
*
- * @param a the array to be sorted
- * @param low the index of the first element, inclusive, to be sorted
+ * @param a the array to be sorted
+ * @param low the index of the first element, inclusive, to be sorted
* @param high the index of the last element, exclusive, to be sorted
*/
private static void heapSort(int[] a, int low, int high) {
@@ -653,14 +668,14 @@ public final class DualPivotQuicksort {
/**
* Pushes specified element down during heap sort.
*
- * @param a the given array
- * @param p the start index
+ * @param a the given array
+ * @param p the start index
* @param value the given element
- * @param low the index of the first element, inclusive, to be sorted
- * @param high the index of the last element, exclusive, to be sorted
+ * @param low the index of the first element, inclusive, to be sorted
+ * @param high the index of the last element, exclusive, to be sorted
*/
private static void pushDown(int[] a, int p, int value, int low, int high) {
- for (int k ;; a[p] = a[p = k]) {
+ for (int k; ; a[p] = a[p = k]) {
k = (p << 1) - low + 2; // Index of the right child
if (k > high) {
@@ -679,8 +694,8 @@ public final class DualPivotQuicksort {
/**
* Tries to sort the specified range of the array.
*
- * @param a the array to be sorted
- * @param low the index of the first element to be sorted
+ * @param a the array to be sorted
+ * @param low the index of the first element to be sorted
* @param size the array size
* @return true if finally sorted, false otherwise
*/
@@ -706,19 +721,21 @@ public final class DualPivotQuicksort {
if (a[k - 1] < a[k]) {
// Identify ascending sequence
- while (++k < high && a[k - 1] <= a[k]);
+ while (++k < high && a[k - 1] <= a[k]) ;
} else if (a[k - 1] > a[k]) {
// Identify descending sequence
- while (++k < high && a[k - 1] >= a[k]);
+ while (++k < high && a[k - 1] >= a[k]) ;
// Reverse into ascending order
for (int i = last - 1, j = k; ++i < --j && a[i] > a[j]; ) {
- int ai = a[i]; a[i] = a[j]; a[j] = ai;
+ int ai = a[i];
+ a[i] = a[j];
+ a[j] = ai;
}
} else { // Identify constant sequence
- for (int ak = a[k]; ++k < high && ak == a[k]; );
+ for (int ak = a[k]; ++k < high && ak == a[k]; ) ;
if (k < high) {
continue;
@@ -784,9 +801,10 @@ public final class DualPivotQuicksort {
* Merge runs of highly structured array.
*/
if (count > 1) {
- int[] b; int offset = low;
+ int[] b;
+ int offset = low;
- b = new int[size];
+ b = new int[size];
mergeRuns(a, b, offset, 1, run, 0, count);
}
return true;
@@ -795,13 +813,13 @@ public final class DualPivotQuicksort {
/**
* Merges the specified runs.
*
- * @param a the source array
- * @param b the temporary buffer used in merging
+ * @param a the source array
+ * @param b the temporary buffer used in merging
* @param offset the start index in the source, inclusive
- * @param aim specifies merging: to source ( > 0), buffer ( < 0) or any ( == 0)
- * @param run the start indexes of the runs, inclusive
- * @param lo the start index of the first run, inclusive
- * @param hi the start index of the last run, inclusive
+ * @param aim specifies merging: to source ( > 0), buffer ( < 0) or any ( == 0)
+ * @param run the start indexes of the runs, inclusive
+ * @param lo the start index of the first run, inclusive
+ * @param hi the start index of the last run, inclusive
* @return the destination where runs are merged
*/
private static int[] mergeRuns(int[] a, int[] b, int offset,
@@ -813,7 +831,8 @@ public final class DualPivotQuicksort {
}
for (int i = run[hi], j = i - offset, low = run[lo]; i > low;
b[--j] = a[--i]
- );
+ )
+ ;
return b;
}
@@ -821,25 +840,25 @@ public final class DualPivotQuicksort {
* Split into approximately equal parts.
*/
int mi = lo, rmi = (run[lo] + run[hi]) >>> 1;
- while (run[++mi + 1] <= rmi);
+ while (run[++mi + 1] <= rmi) ;
/*
* Merge the left and right parts.
*/
int[] a1, a2;
- a1 = mergeRuns(a, b, offset, -aim, run, lo, mi);
- a2 = mergeRuns(a, b, offset, 0, run, mi, hi);
+ a1 = mergeRuns(a, b, offset, -aim, run, lo, mi);
+ a2 = mergeRuns(a, b, offset, 0, run, mi, hi);
int[] dst = a1 == a ? b : a;
- int k = a1 == a ? run[lo] - offset : run[lo];
+ int k = a1 == a ? run[lo] - offset : run[lo];
int lo1 = a1 == b ? run[lo] - offset : run[lo];
int hi1 = a1 == b ? run[mi] - offset : run[mi];
int lo2 = a2 == b ? run[mi] - offset : run[mi];
int hi2 = a2 == b ? run[hi] - offset : run[hi];
- mergeParts(dst, k, a1, lo1, hi1, a2, lo2, hi2);
+ mergeParts(dst, k, a1, lo1, hi1, a2, lo2, hi2);
return dst;
}
@@ -847,11 +866,11 @@ public final class DualPivotQuicksort {
* Merges the sorted parts.
*
* @param dst the destination where parts are merged
- * @param k the start index of the destination, inclusive
- * @param a1 the first part
+ * @param k the start index of the destination, inclusive
+ * @param a1 the first part
* @param lo1 the start index of the first part, inclusive
* @param hi1 the end index of the first part, exclusive
- * @param a2 the second part
+ * @param a2 the second part
* @param lo2 the start index of the second part, inclusive
* @param hi2 the end index of the second part, exclusive
*/
From cca298709f61b1a7a6a0829ba8f7f28141d3ab12 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 17 Dec 2024 21:23:44 +0000
Subject: [PATCH 11/70] adjust QuickSort & add test case
---
.../uni_marburg/powersort/sort/SortEnum.java | 3 +
.../sort/dpqs/DualPivotQuicksort.java | 214 ++++++++----------
.../powersort/sort/dpqs/Unsafe.java | 8 -
.../powersort/sort/AbstractSortTest.java | 6 +-
.../powersort/sort/DualPivotQuicksort.java | 7 +
5 files changed, 105 insertions(+), 133 deletions(-)
delete mode 100644 app/src/main/java/de/uni_marburg/powersort/sort/dpqs/Unsafe.java
create mode 100644 app/src/test/java/de/uni_marburg/powersort/sort/DualPivotQuicksort.java
diff --git a/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java b/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
index 8ae042a..56a9901 100644
--- a/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
+++ b/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
@@ -2,10 +2,12 @@ package de.uni_marburg.powersort.sort;
import de.uni_marburg.powersort.FinnSort.FinnSort;
import de.uni_marburg.powersort.benchmark.NaturalOrder;
+import de.uni_marburg.powersort.sort.dpqs.DualPivotQuicksort;
public enum SortEnum {
BUBBLE_SORT,
QUICK_SORT,
+ DPQS,
MERGE_SORT,
TIM_SORT,
FINN_SORT,
@@ -15,6 +17,7 @@ public enum SortEnum {
return switch (this) {
case BUBBLE_SORT -> array -> BubbleSort.sort(array, NaturalOrder.INSTANCE);
case QUICK_SORT -> array -> QuickSort.sort(array, NaturalOrder.INSTANCE);
+ case DPQS -> array -> DualPivotQuicksort.sort(array, 0, array.length);
case MERGE_SORT -> array -> MergeSort.legacyMergeSort(array, NaturalOrder.INSTANCE);
case TIM_SORT -> array -> TimSort.sort(array, 0, array.length, NaturalOrder.INSTANCE, null, 0, 0);
case FINN_SORT -> array -> FinnSort.sort(array, NaturalOrder.INSTANCE);
diff --git a/app/src/main/java/de/uni_marburg/powersort/sort/dpqs/DualPivotQuicksort.java b/app/src/main/java/de/uni_marburg/powersort/sort/dpqs/DualPivotQuicksort.java
index 1177807..ed95833 100644
--- a/app/src/main/java/de/uni_marburg/powersort/sort/dpqs/DualPivotQuicksort.java
+++ b/app/src/main/java/de/uni_marburg/powersort/sort/dpqs/DualPivotQuicksort.java
@@ -1,4 +1,6 @@
// Imported from JDK23 DualPivotQuicksort.java
+// Removed parallel parts
+// Changed from int[] to Object[]
package de.uni_marburg.powersort.sort.dpqs;
@@ -27,6 +29,8 @@ package de.uni_marburg.powersort.sort.dpqs;
* questions.
*/
+import de.uni_marburg.powersort.benchmark.NaturalOrder;
+
import java.util.Arrays;
/**
@@ -95,35 +99,6 @@ public final class DualPivotQuicksort {
*/
private static final int MAX_RECURSION_DEPTH = 64 * DELTA;
- /**
- * Represents a function that accepts the array and sorts the specified range
- * of the array into ascending order.
- */
- @FunctionalInterface
- private interface SortOperation<A> {
- /**
- * Sorts the specified range of the array.
- *
- * @param a the array to be sorted
- * @param low the index of the first element, inclusive, to be sorted
- * @param high the index of the last element, exclusive, to be sorted
- */
- void sort(A a, int low, int high);
- }
-
- /**
- * Sorts the specified range of the array into ascending numerical order.
- *
- * @param array the array to be sorted
- * the array to sort, otherwise if the array is {@code null},an absolute
- * address pointing to the first element to sort from.
- * @param low the index of the first element, inclusive, to be sorted
- * @param high the index of the last element, exclusive, to be sorted
- * @param so the method reference for the fallback implementation
- */
- private static <A> void sort(A array, int low, int high, SortOperation<A> so) {
- so.sort(array, low, high);
- }
/**
* Represents a function that accepts the array and partitions the specified range
@@ -153,24 +128,17 @@ public final class DualPivotQuicksort {
* @param po the method reference for the fallback implementation
*/
private static <A> int[] partition(A array, int high, int pivotIndex1, int pivotIndex2, PartitionOperation<A> po) {
- return po.partition(array, Unsafe.ARRAY_INT_BASE_OFFSET, high, pivotIndex1, pivotIndex2);
+ return po.partition(array, 0, high, pivotIndex1, pivotIndex2);
}
/**
- * Sorts the specified range of the array using parallel merge
- * sort and/or Dual-Pivot Quicksort.
- * <p>
- * To balance the faster splitting and parallelism of merge sort
- * with the faster element partitioning of Quicksort, ranges are
- * subdivided in tiers such that, if there is enough parallelism,
- * the four-way parallel merge is started, still ensuring enough
- * parallelism to process the partitions.
+ * Sorts the specified range of the array Dual-Pivot Quicksort.
*
* @param a the array to be sorted
* @param low the index of the first element, inclusive, to be sorted
* @param high the index of the last element, exclusive, to be sorted
*/
- public static void sort(int[] a, int low, int high) {
+ public static void sort(Object[] a, int low, int high) {
sort(a, 0, low, high);
}
@@ -184,14 +152,14 @@ public final class DualPivotQuicksort {
* @param low the index of the first element, inclusive, to be sorted
* @param high the index of the last element, exclusive, to be sorted
*/
- static void sort(int[] a, int bits, int low, int high) {
+ static void sort(Object[] a, int bits, int low, int high) {
while (true) {
int end = high - 1, size = high - low;
/*
* Run mixed insertion sort on small non-leftmost parts.
*/
if (size < MAX_MIXED_INSERTION_SORT_SIZE + bits && (bits & 1) > 0) {
- sort(a, low, high, DualPivotQuicksort::mixedInsertionSort);
+ mixedInsertionSort(a, low, high);
return;
}
@@ -199,7 +167,7 @@ public final class DualPivotQuicksort {
* Invoke insertion sort on small leftmost part.
*/
if (size < MAX_INSERTION_SORT_SIZE) {
- sort(a, low, high, DualPivotQuicksort::insertionSort);
+ insertionSort(a, low, high);
return;
}
@@ -238,7 +206,7 @@ public final class DualPivotQuicksort {
int e3 = (e1 + e5) >>> 1;
int e2 = (e1 + e3) >>> 1;
int e4 = (e3 + e5) >>> 1;
- int a3 = a[e3];
+ Object a3 = a[e3];
/*
* Sort these elements in place by the combination
@@ -252,34 +220,34 @@ public final class DualPivotQuicksort {
* | |
* 1 ------------o-----o------------
*/
- if (a[e5] < a[e2]) {
- int t = a[e5];
+ if (NaturalOrder.INSTANCE.compare(a[e5] , a[e2])<0) {
+ Object t = a[e5];
a[e5] = a[e2];
a[e2] = t;
}
- if (a[e4] < a[e1]) {
- int t = a[e4];
+ if (NaturalOrder.INSTANCE.compare(a[e4] , a[e1])<0) {
+ Object t = a[e4];
a[e4] = a[e1];
a[e1] = t;
}
- if (a[e5] < a[e4]) {
- int t = a[e5];
+ if (NaturalOrder.INSTANCE.compare(a[e5] , a[e4])<0) {
+ Object t = a[e5];
a[e5] = a[e4];
a[e4] = t;
}
- if (a[e2] < a[e1]) {
- int t = a[e2];
+ if (NaturalOrder.INSTANCE.compare(a[e2] , a[e1])<0) {
+ Object t = a[e2];
a[e2] = a[e1];
a[e1] = t;
}
- if (a[e4] < a[e2]) {
- int t = a[e4];
+ if (NaturalOrder.INSTANCE.compare(a[e4] , a[e2])<0) {
+ Object t = a[e4];
a[e4] = a[e2];
a[e2] = t;
}
- if (a3 < a[e2]) {
- if (a3 < a[e1]) {
+ if (NaturalOrder.INSTANCE.compare(a3 , a[e2])<0) {
+ if (NaturalOrder.INSTANCE.compare(a3 , a[e1])<0) {
a[e3] = a[e2];
a[e2] = a[e1];
a[e1] = a3;
@@ -287,8 +255,8 @@ public final class DualPivotQuicksort {
a[e3] = a[e2];
a[e2] = a3;
}
- } else if (a3 > a[e4]) {
- if (a3 > a[e5]) {
+ } else if (NaturalOrder.INSTANCE.compare(a3 , a[e4])>0) {
+ if (NaturalOrder.INSTANCE.compare(a3 , a[e5])>0) {
a[e3] = a[e4];
a[e4] = a[e5];
a[e5] = a3;
@@ -305,7 +273,7 @@ public final class DualPivotQuicksort {
/*
* Partitioning with 2 pivots in case of different elements.
*/
- if (a[e1] < a[e2] && a[e2] < a[e3] && a[e3] < a[e4] && a[e4] < a[e5]) {
+ if (NaturalOrder.INSTANCE.compare(a[e1] , a[e2])<0 && NaturalOrder.INSTANCE.compare(a[e2] , a[e3])<0 && NaturalOrder.INSTANCE.compare(a[e3] , a[e4])<0 && NaturalOrder.INSTANCE.compare(a[e4] , a[e5])<0) {
/*
* Use the first and fifth of the five sorted elements as
* the pivots. These values are inexpensive approximation
@@ -353,15 +321,15 @@ public final class DualPivotQuicksort {
* @param pivotIndex1 the index of pivot1, the first pivot
* @param pivotIndex2 the index of pivot2, the second pivot
*/
- private static int[] partitionDualPivot(int[] a, int low, int high, int pivotIndex1, int pivotIndex2) {
+ private static int[] partitionDualPivot(Object[] a, int low, int high, int pivotIndex1, int pivotIndex2) {
int end = high - 1;
int lower = low;
int upper = end;
int e1 = pivotIndex1;
int e5 = pivotIndex2;
- int pivot1 = a[e1];
- int pivot2 = a[e5];
+ Object pivot1 = a[e1];
+ Object pivot2 = a[e5];
/*
* The first and the last elements to be sorted are moved
@@ -376,8 +344,8 @@ public final class DualPivotQuicksort {
/*
* Skip elements, which are less or greater than the pivots.
*/
- while (a[++lower] < pivot1) ;
- while (a[--upper] > pivot2) ;
+ while (NaturalOrder.INSTANCE.compare(a[++lower] , pivot1)<0) ;
+ while (NaturalOrder.INSTANCE.compare(a[--upper] , pivot2)>0) ;
/*
* Backward 3-interval partitioning
@@ -399,12 +367,12 @@ public final class DualPivotQuicksort {
* Pointer k is the last index of ?-part
*/
for (int unused = --lower, k = ++upper; --k > lower; ) {
- int ak = a[k];
+ Object ak = a[k];
- if (ak < pivot1) { // Move a[k] to the left side
+ if (NaturalOrder.INSTANCE.compare(ak , pivot1)<0) { // Move a[k] to the left side
while (lower < k) {
- if (a[++lower] >= pivot1) {
- if (a[lower] > pivot2) {
+ if (NaturalOrder.INSTANCE.compare(a[++lower] , pivot1)>=0) {
+ if (NaturalOrder.INSTANCE.compare(a[lower] , pivot2)>0) {
a[k] = a[--upper];
a[upper] = a[lower];
} else {
@@ -414,7 +382,7 @@ public final class DualPivotQuicksort {
break;
}
}
- } else if (ak > pivot2) { // Move a[k] to the right side
+ } else if (NaturalOrder.INSTANCE.compare(ak , pivot2)>0) { // Move a[k] to the right side
a[k] = a[--upper];
a[upper] = ak;
}
@@ -440,13 +408,13 @@ public final class DualPivotQuicksort {
* @param pivotIndex1 the index of pivot1, the first pivot
* @param pivotIndex2 the index of pivot2, the second pivot
*/
- private static int[] partitionSinglePivot(int[] a, int low, int high, int pivotIndex1, int pivotIndex2) {
+ private static int[] partitionSinglePivot(Object[] a, int low, int high, int pivotIndex1, int pivotIndex2) {
int end = high - 1;
int lower = low;
int upper = end;
int e3 = pivotIndex1;
- int pivot = a[e3];
+ Object pivot = a[e3];
/*
* The first element to be sorted is moved to the
@@ -477,15 +445,15 @@ public final class DualPivotQuicksort {
* Pointer k is the last index of ?-part
*/
for (int k = ++upper; --k > lower; ) {
- int ak = a[k];
+ Object ak = a[k];
- if (ak != pivot) {
+ if (NaturalOrder.INSTANCE.compare(ak , pivot)!=0) {
a[k] = pivot;
- if (ak < pivot) { // Move a[k] to the left side
- while (a[++lower] < pivot) ;
+ if (NaturalOrder.INSTANCE.compare(ak , pivot)<0) { // Move a[k] to the left side
+ while (NaturalOrder.INSTANCE.compare(a[++lower] , pivot)<0) ;
- if (a[lower] > pivot) {
+ if (NaturalOrder.INSTANCE.compare(a[lower] , pivot)>0) {
a[--upper] = a[lower];
}
a[lower] = ak;
@@ -519,7 +487,7 @@ public final class DualPivotQuicksort {
* @param low the index of the first element, inclusive, to be sorted
* @param high the index of the last element, exclusive, to be sorted
*/
- private static void mixedInsertionSort(int[] a, int low, int high) {
+ private static void mixedInsertionSort(Object[] a, int low, int high) {
int size = high - low;
int end = high - 3 * ((size >> 5) << 3);
if (end == high) {
@@ -528,9 +496,9 @@ public final class DualPivotQuicksort {
* Invoke simple insertion sort on tiny array.
*/
for (int i; ++low < end; ) {
- int ai = a[i = low];
+ Object ai = a[i = low];
- while (ai < a[--i]) {
+ while (NaturalOrder.INSTANCE.compare(ai,a[--i])<0) {
a[i + 1] = a[i];
}
a[i + 1] = ai;
@@ -546,29 +514,29 @@ public final class DualPivotQuicksort {
* proper area for such elements). It avoids expensive
* movements of these elements through the whole array.
*/
- int pin = a[end];
+ Object pin = a[end];
for (int i, p = high; ++low < end; ) {
- int ai = a[i = low];
+ Object ai = a[i = low];
- if (ai < a[i - 1]) { // Small element
+ if (NaturalOrder.INSTANCE.compare(ai,a[i - 1])<0) { // Small element
/*
* Insert small element into sorted part.
*/
a[i] = a[--i];
- while (ai < a[--i]) {
+ while (NaturalOrder.INSTANCE.compare(ai,a[--i])<0) {
a[i + 1] = a[i];
}
a[i + 1] = ai;
- } else if (p > i && ai > pin) { // Large element
+ } else if (p > i && NaturalOrder.INSTANCE.compare(ai,pin)>0) { // Large element
/*
* Find element smaller than pin.
*/
- while (a[--p] > pin) ;
+ while (NaturalOrder.INSTANCE.compare(a[--p] , pin)>0) ;
/*
* Swap it with large element.
@@ -581,7 +549,7 @@ public final class DualPivotQuicksort {
/*
* Insert small element into sorted part.
*/
- while (ai < a[--i]) {
+ while (NaturalOrder.INSTANCE.compare(ai , a[--i])<0) {
a[i + 1] = a[i];
}
a[i + 1] = ai;
@@ -592,33 +560,33 @@ public final class DualPivotQuicksort {
* Continue with pair insertion sort on remain part.
*/
for (int i; low < high; ++low) {
- int a1 = a[i = low], a2 = a[++low];
+ Object a1 = a[i = low], a2 = a[++low];
/*
* Insert two elements per iteration: at first, insert the
* larger element and then insert the smaller element, but
* from the position where the larger element was inserted.
*/
- if (a1 > a2) {
+ if (NaturalOrder.INSTANCE.compare(a1 , a2)>0) {
- while (a1 < a[--i]) {
+ while (NaturalOrder.INSTANCE.compare(a1 , a[--i])<0) {
a[i + 2] = a[i];
}
a[++i + 1] = a1;
- while (a2 < a[--i]) {
+ while (NaturalOrder.INSTANCE.compare(a2 , a[--i])<0) {
a[i + 1] = a[i];
}
a[i + 1] = a2;
- } else if (a1 < a[i - 1]) {
+ } else if (NaturalOrder.INSTANCE.compare(a1 , a[i - 1])<0) {
- while (a2 < a[--i]) {
+ while (NaturalOrder.INSTANCE.compare(a2 , a[--i])<0) {
a[i + 2] = a[i];
}
a[++i + 1] = a2;
- while (a1 < a[--i]) {
+ while (NaturalOrder.INSTANCE.compare(a1 , a[--i])<0) {
a[i + 1] = a[i];
}
a[i + 1] = a1;
@@ -634,12 +602,12 @@ public final class DualPivotQuicksort {
* @param low the index of the first element, inclusive, to be sorted
* @param high the index of the last element, exclusive, to be sorted
*/
- private static void insertionSort(int[] a, int low, int high) {
+ private static void insertionSort(Object[] a, int low, int high) {
for (int i, k = low; ++k < high; ) {
- int ai = a[i = k];
+ Object ai = a[i = k];
- if (ai < a[i - 1]) {
- while (--i >= low && ai < a[i]) {
+ if (NaturalOrder.INSTANCE.compare(ai , a[i - 1])<0) {
+ while (--i >= low && NaturalOrder.INSTANCE.compare(ai , a[i])<0) {
a[i + 1] = a[i];
}
a[i + 1] = ai;
@@ -654,12 +622,12 @@ public final class DualPivotQuicksort {
* @param low the index of the first element, inclusive, to be sorted
* @param high the index of the last element, exclusive, to be sorted
*/
- private static void heapSort(int[] a, int low, int high) {
+ private static void heapSort(Object[] a, int low, int high) {
for (int k = (low + high) >>> 1; k > low; ) {
pushDown(a, --k, a[k], low, high);
}
while (--high > low) {
- int max = a[low];
+ Object max = a[low];
pushDown(a, low, a[high], low, high);
a[high] = max;
}
@@ -674,17 +642,17 @@ public final class DualPivotQuicksort {
* @param low the index of the first element, inclusive, to be sorted
* @param high the index of the last element, exclusive, to be sorted
*/
- private static void pushDown(int[] a, int p, int value, int low, int high) {
+ private static void pushDown(Object[] a, int p, Object value, int low, int high) {
for (int k; ; a[p] = a[p = k]) {
k = (p << 1) - low + 2; // Index of the right child
if (k > high) {
break;
}
- if (k == high || a[k] < a[k - 1]) {
+ if (k == high || NaturalOrder.INSTANCE.compare(a[k] , a[k - 1])<0) {
--k;
}
- if (a[k] <= value) {
+ if (NaturalOrder.INSTANCE.compare(a[k] , value)<=0) {
break;
}
}
@@ -699,7 +667,7 @@ public final class DualPivotQuicksort {
* @param size the array size
* @return true if finally sorted, false otherwise
*/
- private static boolean tryMergeRuns(int[] a, int low, int size) {
+ private static boolean tryMergeRuns(Object[] a, int low, int size) {
/*
* The run array is constructed only if initial runs are
@@ -718,24 +686,24 @@ public final class DualPivotQuicksort {
/*
* Find the end index of the current run.
*/
- if (a[k - 1] < a[k]) {
+ if (NaturalOrder.INSTANCE.compare(a[k - 1] , a[k])<0) {
// Identify ascending sequence
- while (++k < high && a[k - 1] <= a[k]) ;
+ while (++k < high && NaturalOrder.INSTANCE.compare(a[k - 1] , a[k])<=0) ;
- } else if (a[k - 1] > a[k]) {
+ } else if (NaturalOrder.INSTANCE.compare(a[k - 1] , a[k])>0) {
// Identify descending sequence
- while (++k < high && a[k - 1] >= a[k]) ;
+ while (++k < high && NaturalOrder.INSTANCE.compare(a[k - 1] , a[k])>=0) ;
// Reverse into ascending order
- for (int i = last - 1, j = k; ++i < --j && a[i] > a[j]; ) {
- int ai = a[i];
+ for (int i = last - 1, j = k; ++i < --j && NaturalOrder.INSTANCE.compare(a[i] , a[j])>0; ) {
+ Object ai = a[i];
a[i] = a[j];
a[j] = ai;
}
} else { // Identify constant sequence
- for (int ak = a[k]; ++k < high && ak == a[k]; ) ;
+ for (Object ak = a[k]; ++k < high && NaturalOrder.INSTANCE.compare(ak , a[k])==0; ) ;
if (k < high) {
continue;
@@ -767,7 +735,7 @@ public final class DualPivotQuicksort {
run = new int[((size >> 10) | 0x7F) & 0x3FF];
run[0] = low;
- } else if (a[last - 1] > a[last]) {
+ } else if (NaturalOrder.INSTANCE.compare(a[last - 1] , a[last])>0) {
if (count > (k - low) >> MIN_FIRST_RUNS_FACTOR) {
@@ -801,10 +769,10 @@ public final class DualPivotQuicksort {
* Merge runs of highly structured array.
*/
if (count > 1) {
- int[] b;
+ Object[] b;
int offset = low;
- b = new int[size];
+ b = new Object[size];
mergeRuns(a, b, offset, 1, run, 0, count);
}
return true;
@@ -822,7 +790,7 @@ public final class DualPivotQuicksort {
* @param hi the start index of the last run, inclusive
* @return the destination where runs are merged
*/
- private static int[] mergeRuns(int[] a, int[] b, int offset,
+ private static Object[] mergeRuns(Object[] a, Object[] b, int offset,
int aim, int[] run, int lo, int hi) {
if (hi - lo == 1) {
@@ -845,18 +813,18 @@ public final class DualPivotQuicksort {
/*
* Merge the left and right parts.
*/
- int[] a1, a2;
+ Object[] a1, a2;
a1 = mergeRuns(a, b, offset, -aim, run, lo, mi);
a2 = mergeRuns(a, b, offset, 0, run, mi, hi);
- int[] dst = a1 == a ? b : a;
+ Object[] dst = NaturalOrder.INSTANCE.compare(a1, a) == 0 ? b : a;
- int k = a1 == a ? run[lo] - offset : run[lo];
- int lo1 = a1 == b ? run[lo] - offset : run[lo];
- int hi1 = a1 == b ? run[mi] - offset : run[mi];
- int lo2 = a2 == b ? run[mi] - offset : run[mi];
- int hi2 = a2 == b ? run[hi] - offset : run[hi];
+ int k = NaturalOrder.INSTANCE.compare(a1 , a)==0 ? run[lo] - offset : run[lo];
+ int lo1 = NaturalOrder.INSTANCE.compare(a1 , b)==0 ? run[lo] - offset : run[lo];
+ int hi1 = NaturalOrder.INSTANCE.compare(a1 , b)==0 ? run[mi] - offset : run[mi];
+ int lo2 = NaturalOrder.INSTANCE.compare(a2 , b)==0 ? run[mi] - offset : run[mi];
+ int hi2 = NaturalOrder.INSTANCE.compare(a2 , b)==0 ? run[hi] - offset : run[hi];
mergeParts(dst, k, a1, lo1, hi1, a2, lo2, hi2);
return dst;
@@ -874,15 +842,15 @@ public final class DualPivotQuicksort {
* @param lo2 the start index of the second part, inclusive
* @param hi2 the end index of the second part, exclusive
*/
- private static void mergeParts(int[] dst, int k,
- int[] a1, int lo1, int hi1, int[] a2, int lo2, int hi2) {
+ private static void mergeParts(Object[] dst, int k,
+ Object[] a1, int lo1, int hi1, Object[] a2, int lo2, int hi2) {
/*
* Merge small parts sequentially.
*/
while (lo1 < hi1 && lo2 < hi2) {
- dst[k++] = a1[lo1] < a2[lo2] ? a1[lo1++] : a2[lo2++];
+ dst[k++] = NaturalOrder.INSTANCE.compare(a1[lo1] , a2[lo2])<0 ? a1[lo1++] : a2[lo2++];
}
if (dst != a1 || k < lo1) {
while (lo1 < hi1) {
diff --git a/app/src/main/java/de/uni_marburg/powersort/sort/dpqs/Unsafe.java b/app/src/main/java/de/uni_marburg/powersort/sort/dpqs/Unsafe.java
deleted file mode 100644
index 2395c0b..0000000
--- a/app/src/main/java/de/uni_marburg/powersort/sort/dpqs/Unsafe.java
+++ /dev/null
@@ -1,8 +0,0 @@
-package de.uni_marburg.powersort.sort.dpqs;
-
-public final class Unsafe {
- private Unsafe() {
- }
- public static final int ARRAY_INT_BASE_OFFSET
- = 16; // Taken from debugging JDK 23 Unsafe.ARRAY_INT_BASE_OFFSET
-}
diff --git a/app/src/test/java/de/uni_marburg/powersort/sort/AbstractSortTest.java b/app/src/test/java/de/uni_marburg/powersort/sort/AbstractSortTest.java
index 2c0e5a7..99bbf0c 100644
--- a/app/src/test/java/de/uni_marburg/powersort/sort/AbstractSortTest.java
+++ b/app/src/test/java/de/uni_marburg/powersort/sort/AbstractSortTest.java
@@ -30,6 +30,8 @@ public abstract class AbstractSortTest {
@CsvSource({
"3,7,-13",
"3,7,-3",
+ "10,10,-5",
+ "17,17,-17",
})
void test2(int numOfRuns, int runLength, int decreaseBetweenRuns) {
Integer[] array = AscendingRuns.newAscendingRuns(numOfRuns, runLength, decreaseBetweenRuns).getCopy();
@@ -42,7 +44,7 @@ public abstract class AbstractSortTest {
"13",
"1337",
})
- void test2(int size) {
+ void test3(int size) {
Integer[] array = new DescendingIntegers(size).getCopy();
sortAndCheckResult(array);
}
@@ -52,6 +54,6 @@ public abstract class AbstractSortTest {
Arrays.sort(expected);
sortAlg.getSortImpl().sort(array);
- assertArrayEquals(expected, array);
+ assertArrayEquals(expected, array, Arrays.toString(array) + "\n\n");
}
}
diff --git a/app/src/test/java/de/uni_marburg/powersort/sort/DualPivotQuicksort.java b/app/src/test/java/de/uni_marburg/powersort/sort/DualPivotQuicksort.java
new file mode 100644
index 0000000..7824ad6
--- /dev/null
+++ b/app/src/test/java/de/uni_marburg/powersort/sort/DualPivotQuicksort.java
@@ -0,0 +1,7 @@
+package de.uni_marburg.powersort.sort;
+
+public class DualPivotQuicksort extends AbstractSortTest {
+ DualPivotQuicksort() {
+ sortAlg = SortEnum.DPQS;
+ }
+}
From b1df4366e649cdc95a963bafaac87ae913c1ccac Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 17 Dec 2024 21:24:54 +0000
Subject: [PATCH 12/70] benchmark: update filter
---
.../java/de/uni_marburg/powersort/benchmark/Filter.java | 9 +++++++++
1 file changed, 9 insertions(+)
diff --git a/app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java b/app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java
index 023403c..f64984f 100644
--- a/app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java
+++ b/app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java
@@ -12,6 +12,15 @@ public class Filter {
public static boolean isFiltered(DataEnum d, SortEnum s) {
+ if (s == SortEnum.QUICK_SORT) {
+ return List.of(
+ DataEnum.RANDOM_INTEGERS_300M,
+ DataEnum.ASCENDING_INTEGERS_300M,
+ DataEnum.DESCENDING_INTEGERS_250M,
+ DataEnum.ASCENDING_RUNS_1M
+ ).contains(d);
+ }
+
if (s == SortEnum.MERGE_SORT) {
return List.of(
DataEnum.RANDOM_INTEGERS_300M,
From d06cb9eebdb1c5beb903b2167d474c92b02933fd Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Mon, 30 Dec 2024 16:09:20 +0000
Subject: [PATCH 13/70] shell.nix: cleanup
---
shell.nix | 7 ++++++-
1 file changed, 6 insertions(+), 1 deletion(-)
diff --git a/shell.nix b/shell.nix
index 9a49d71..1560ed6 100644
--- a/shell.nix
+++ b/shell.nix
@@ -2,14 +2,19 @@
# https://discourse.nixos.org/t/how-to-create-a-development-environment-with-intellij-idea-and-openjdk/10153
{
+ # NixOS stable
pkgs ? import <nixpkgs> {
# https://github.com/NixOS/nixpkgs/issues/166220#issuecomment-1745803058
config.allowUnfree = true;
+ },
+ # NixOS unstable
+ unstable ? import <unstable> {
+ # https://github.com/NixOS/nixpkgs/issues/166220#issuecomment-1745803058
+ config.allowUnfree = true;
}
}:
let
- unstable = import (fetchTarball https://github.com/NixOS/nixpkgs/archive/nixos-unstable.tar.gz) { };
jdk = unstable.jdk23;
gradle = unstable.gradle;
in
From 4528a544b7bf759b4abc6f3a8a5af5129f3afb72 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Mon, 30 Dec 2024 16:10:37 +0000
Subject: [PATCH 14/70] fix: QuickSort
---
.../powersort/sort/dpqs/DualPivotQuicksort.java | 8 ++++----
.../de/uni_marburg/powersort/sort/AbstractSortTest.java | 3 ++-
.../de/uni_marburg/powersort/sort/DualPivotQuicksort.java | 7 -------
.../powersort/sort/DualPivotQuicksortTest.java | 7 +++++++
4 files changed, 13 insertions(+), 12 deletions(-)
delete mode 100644 app/src/test/java/de/uni_marburg/powersort/sort/DualPivotQuicksort.java
create mode 100644 app/src/test/java/de/uni_marburg/powersort/sort/DualPivotQuicksortTest.java
diff --git a/app/src/main/java/de/uni_marburg/powersort/sort/dpqs/DualPivotQuicksort.java b/app/src/main/java/de/uni_marburg/powersort/sort/dpqs/DualPivotQuicksort.java
index ed95833..0d50d43 100644
--- a/app/src/main/java/de/uni_marburg/powersort/sort/dpqs/DualPivotQuicksort.java
+++ b/app/src/main/java/de/uni_marburg/powersort/sort/dpqs/DualPivotQuicksort.java
@@ -127,8 +127,8 @@ public final class DualPivotQuicksort {
* @param pivotIndex2 the index of pivot2, the second pivot
* @param po the method reference for the fallback implementation
*/
- private static <A> int[] partition(A array, int high, int pivotIndex1, int pivotIndex2, PartitionOperation<A> po) {
- return po.partition(array, 0, high, pivotIndex1, pivotIndex2);
+ private static <A> int[] partition(A array, int low, int high, int pivotIndex1, int pivotIndex2, PartitionOperation<A> po) {
+ return po.partition(array, low, high, pivotIndex1, pivotIndex2);
}
/**
@@ -279,7 +279,7 @@ public final class DualPivotQuicksort {
* the pivots. These values are inexpensive approximation
* of tertiles. Note, that pivot1 < pivot2.
*/
- int[] pivotIndices = partition(a, high, e1, e5, DualPivotQuicksort::partitionDualPivot);
+ int[] pivotIndices = partition(a, low, high, e1, e5, DualPivotQuicksort::partitionDualPivot);
lower = pivotIndices[0];
upper = pivotIndices[1];
@@ -298,7 +298,7 @@ public final class DualPivotQuicksort {
* Use the third of the five sorted elements as the pivot.
* This value is inexpensive approximation of the median.
*/
- int[] pivotIndices = partition(a, high, e3, e3, DualPivotQuicksort::partitionSinglePivot);
+ int[] pivotIndices = partition(a, low, high, e3, e3, DualPivotQuicksort::partitionSinglePivot);
lower = pivotIndices[0];
upper = pivotIndices[1];
/*
diff --git a/app/src/test/java/de/uni_marburg/powersort/sort/AbstractSortTest.java b/app/src/test/java/de/uni_marburg/powersort/sort/AbstractSortTest.java
index 99bbf0c..4802fcf 100644
--- a/app/src/test/java/de/uni_marburg/powersort/sort/AbstractSortTest.java
+++ b/app/src/test/java/de/uni_marburg/powersort/sort/AbstractSortTest.java
@@ -37,6 +37,7 @@ public abstract class AbstractSortTest {
Integer[] array = AscendingRuns.newAscendingRuns(numOfRuns, runLength, decreaseBetweenRuns).getCopy();
sortAndCheckResult(array);
}
+
@ParameterizedTest
@CsvSource({
"2",
@@ -49,7 +50,7 @@ public abstract class AbstractSortTest {
sortAndCheckResult(array);
}
- void sortAndCheckResult(Integer[] array){
+ void sortAndCheckResult(Integer[] array) {
Integer[] expected = Arrays.copyOf(array, array.length);
Arrays.sort(expected);
diff --git a/app/src/test/java/de/uni_marburg/powersort/sort/DualPivotQuicksort.java b/app/src/test/java/de/uni_marburg/powersort/sort/DualPivotQuicksort.java
deleted file mode 100644
index 7824ad6..0000000
--- a/app/src/test/java/de/uni_marburg/powersort/sort/DualPivotQuicksort.java
+++ /dev/null
@@ -1,7 +0,0 @@
-package de.uni_marburg.powersort.sort;
-
-public class DualPivotQuicksort extends AbstractSortTest {
- DualPivotQuicksort() {
- sortAlg = SortEnum.DPQS;
- }
-}
diff --git a/app/src/test/java/de/uni_marburg/powersort/sort/DualPivotQuicksortTest.java b/app/src/test/java/de/uni_marburg/powersort/sort/DualPivotQuicksortTest.java
new file mode 100644
index 0000000..1264661
--- /dev/null
+++ b/app/src/test/java/de/uni_marburg/powersort/sort/DualPivotQuicksortTest.java
@@ -0,0 +1,7 @@
+package de.uni_marburg.powersort.sort;
+
+public class DualPivotQuicksortTest extends AbstractSortTest {
+ DualPivotQuicksortTest() {
+ sortAlg = SortEnum.DPQS;
+ }
+}
From 48a2db7beeba63488cdcb826d1ca023e8c2421e5 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Mon, 30 Dec 2024 16:22:17 +0000
Subject: [PATCH 15/70] fix: QuickSort mergeRuns
---
.../powersort/sort/dpqs/DualPivotQuicksort.java | 12 ++++++------
.../uni_marburg/powersort/sort/AbstractSortTest.java | 1 +
2 files changed, 7 insertions(+), 6 deletions(-)
diff --git a/app/src/main/java/de/uni_marburg/powersort/sort/dpqs/DualPivotQuicksort.java b/app/src/main/java/de/uni_marburg/powersort/sort/dpqs/DualPivotQuicksort.java
index 0d50d43..2587829 100644
--- a/app/src/main/java/de/uni_marburg/powersort/sort/dpqs/DualPivotQuicksort.java
+++ b/app/src/main/java/de/uni_marburg/powersort/sort/dpqs/DualPivotQuicksort.java
@@ -818,13 +818,13 @@ public final class DualPivotQuicksort {
a1 = mergeRuns(a, b, offset, -aim, run, lo, mi);
a2 = mergeRuns(a, b, offset, 0, run, mi, hi);
- Object[] dst = NaturalOrder.INSTANCE.compare(a1, a) == 0 ? b : a;
+ Object[] dst = a1 == a ? b : a;
- int k = NaturalOrder.INSTANCE.compare(a1 , a)==0 ? run[lo] - offset : run[lo];
- int lo1 = NaturalOrder.INSTANCE.compare(a1 , b)==0 ? run[lo] - offset : run[lo];
- int hi1 = NaturalOrder.INSTANCE.compare(a1 , b)==0 ? run[mi] - offset : run[mi];
- int lo2 = NaturalOrder.INSTANCE.compare(a2 , b)==0 ? run[mi] - offset : run[mi];
- int hi2 = NaturalOrder.INSTANCE.compare(a2 , b)==0 ? run[hi] - offset : run[hi];
+ int k = a1 == a ? run[lo] - offset : run[lo];
+ int lo1 = a1 == b ? run[lo] - offset : run[lo];
+ int hi1 = a1 == b ? run[mi] - offset : run[mi];
+ int lo2 = a2 == b ? run[mi] - offset : run[mi];
+ int hi2 = a2 == b ? run[hi] - offset : run[hi];
mergeParts(dst, k, a1, lo1, hi1, a2, lo2, hi2);
return dst;
diff --git a/app/src/test/java/de/uni_marburg/powersort/sort/AbstractSortTest.java b/app/src/test/java/de/uni_marburg/powersort/sort/AbstractSortTest.java
index 4802fcf..e3c4f71 100644
--- a/app/src/test/java/de/uni_marburg/powersort/sort/AbstractSortTest.java
+++ b/app/src/test/java/de/uni_marburg/powersort/sort/AbstractSortTest.java
@@ -32,6 +32,7 @@ public abstract class AbstractSortTest {
"3,7,-3",
"10,10,-5",
"17,17,-17",
+ "2,128,-64", // Large runs to trigger function `mergeRuns` of DualPivotQuicksort
})
void test2(int numOfRuns, int runLength, int decreaseBetweenRuns) {
Integer[] array = AscendingRuns.newAscendingRuns(numOfRuns, runLength, decreaseBetweenRuns).getCopy();
From 798ed8502c6489784085ae30cb6f1658b6fb68b1 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Mon, 30 Dec 2024 16:37:45 +0000
Subject: [PATCH 16/70] benchmark: update filter
---
.../uni_marburg/powersort/benchmark/Filter.java | 16 ++++++++++++++--
1 file changed, 14 insertions(+), 2 deletions(-)
diff --git a/app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java b/app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java
index f64984f..c3bffa3 100644
--- a/app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java
+++ b/app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java
@@ -11,13 +11,24 @@ public class Filter {
}
public static boolean isFiltered(DataEnum d, SortEnum s) {
+ // To skip some of the inputs for all inputs, uncomment it here.
+// if (List.of(
+// DataEnum.RANDOM_INTEGERS_300M,
+// DataEnum.ASCENDING_INTEGERS_300M,
+// DataEnum.DESCENDING_INTEGERS_250M,
+// DataEnum.ASCENDING_RUNS_1M,
+// DataEnum.ASCENDING_RUNS_WITH_OVERLAP_1M
+// ).contains(d)) {
+// return true;
+// }
if (s == SortEnum.QUICK_SORT) {
return List.of(
DataEnum.RANDOM_INTEGERS_300M,
DataEnum.ASCENDING_INTEGERS_300M,
DataEnum.DESCENDING_INTEGERS_250M,
- DataEnum.ASCENDING_RUNS_1M
+ DataEnum.ASCENDING_RUNS_1M,
+ DataEnum.ASCENDING_RUNS_WITH_OVERLAP_1M
).contains(d);
}
@@ -40,7 +51,8 @@ public class Filter {
// TODO: Remove this once performance of FinnSort improved
if (s == SortEnum.FINN_SORT) {
return List.of(
- DataEnum.DESCENDING_INTEGERS_250M
+ DataEnum.DESCENDING_INTEGERS_250M,
+ DataEnum.ASCENDING_RUNS_1M
).contains(d);
}
From 21940b29dfd185603f3fb65be657973bb68c1898 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Mon, 30 Dec 2024 16:49:40 +0000
Subject: [PATCH 17/70] docs: README
---
README.md | 13 +++++++++++--
1 file changed, 11 insertions(+), 2 deletions(-)
diff --git a/README.md b/README.md
index 7c50e36..b4c8fa5 100644
--- a/README.md
+++ b/README.md
@@ -4,7 +4,7 @@
### Setup
-Dependencies (JDK23, Gradle, IntelliJ) can be installed by running `nix-shell`.
+The development dependencies (JDK23, Gradle, IntelliJ) can e.g. be installed with `nix` by running `nix-shell`.
**Commandline**
@@ -28,7 +28,7 @@ This should include version >= 23, e.g.:
**IntelliJ**
-When using `nix-shell`, some configuration is necessary:
+When using `nix-shell`, some manual configuration is necessary:
- STRG ALT SHIFT s -> SDK -> add JDK ->
- home path: /usr/lib/openjdk
@@ -56,3 +56,12 @@ Run the task "test":
```shell
./gradlew test
```
+
+### Benchmark
+
+There are two different benchmarks. One is based on the JMH benchmark framework, the other one is a custom benchmark implementation.
+
+```shell
+./gradlew jmh
+./gradlew runCustomBenchmark
+```
From df26347fbbdfa08a0e538a6c4cd7a26e1ed4c093 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 31 Dec 2024 14:21:14 +0000
Subject: [PATCH 18/70] docs: README
---
README.md | 40 ++++++++++++++++++++++++++++------------
1 file changed, 28 insertions(+), 12 deletions(-)
diff --git a/README.md b/README.md
index b4c8fa5..b20670e 100644
--- a/README.md
+++ b/README.md
@@ -1,10 +1,10 @@
# Bring Powersort to Java
-## Gradle
+Implementation of Powersort with the aim of integrating it into OpenJDK. Benchmarks are used to ensure that the runtime of the new sorting algorithm is never slower than the current Timsort implementation.
-### Setup
+## Setup
-The development dependencies (JDK23, Gradle, IntelliJ) can e.g. be installed with `nix` by running `nix-shell`.
+We use Gradle for dependency and build management.
**Commandline**
@@ -26,18 +26,34 @@ This should include version >= 23, e.g.:
| Detected by: Current JVM
```
+### Development Setup with nix
+
+The provided [shell.nix](shell.nix) file can be used to set up a development environment with IntelliJ. The only prerequisite is to have a working `nix` installation for which there are multiple possibilities, e.g:
+
+```shell
+# https://github.com/DeterminateSystems/nix-installer?tab=readme-ov-file#determinate-nix-installer
+curl --proto '=https' --tlsv1.2 -sSf -L https://install.determinate.systems/nix | \
+ sh -s -- install
+```
+
+Then the dependencies (JDK23, Gradle, IntelliJ) can be installed with:
+
+```shell
+nix-shell
+```
+
**IntelliJ**
When using `nix-shell`, some manual configuration is necessary:
-- STRG ALT SHIFT s -> SDK -> add JDK ->
- - home path: /usr/lib/openjdk
- - name: usr-lib-jdk
-- STRG ALT s -> build tools -> gradle ->
- - local installation: /usr/lib/gradle
- - Gradle JVM: usr-lib-jdk
+- `STRG` `ALT` `SHIFT` `s` -> SDK -> add JDK ->
+ - home path: `/usr/lib/openjdk`
+ - name: `usr-lib-jdk`
+- `STRG` `ALT` `s` -> build tools -> gradle ->
+ - local installation: `/usr/lib/gradle`
+ - Gradle JVM: `usr-lib-jdk`
-### Tasks
+## Tasks
List all Gradle tasks which can be run:
@@ -49,7 +65,7 @@ This can also be done graphically in IntelliJ:
-### Test Cases
+## Test Cases
Run the task "test":
@@ -57,7 +73,7 @@ Run the task "test":
./gradlew test
```
-### Benchmark
+## Benchmark
There are two different benchmarks. One is based on the JMH benchmark framework, the other one is a custom benchmark implementation.
From cd34a1cb827fc0fe791cb8fb7f676115adaeb299 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Wed, 1 Jan 2025 14:50:41 +0000
Subject: [PATCH 19/70] shell.nix: declarative dependency management
---
nix/sources.json | 26 +++++++
nix/sources.nix | 198 +++++++++++++++++++++++++++++++++++++++++++++++
shell.nix | 33 +++++---
3 files changed, 248 insertions(+), 9 deletions(-)
create mode 100644 nix/sources.json
create mode 100644 nix/sources.nix
diff --git a/nix/sources.json b/nix/sources.json
new file mode 100644
index 0000000..2fcaaba
--- /dev/null
+++ b/nix/sources.json
@@ -0,0 +1,26 @@
+{
+ "nixpkgs": {
+ "branch": "nixos-24.11",
+ "description": "Nix Packages collection & NixOS",
+ "homepage": "",
+ "owner": "NixOS",
+ "repo": "nixpkgs",
+ "rev": "3ffbbdbac0566a0977da3d2657b89cbcfe9a173b",
+ "sha256": "0m3zh14is40vixpv125alyacd22835v0v845dsnk5d68wvwhikq2",
+ "type": "tarball",
+ "url": "https://github.com/NixOS/nixpkgs/archive/3ffbbdbac0566a0977da3d2657b89cbcfe9a173b.tar.gz",
+ "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
+ },
+ "unstable": {
+ "branch": "nixpkgs-unstable",
+ "description": "Nix Packages collection & NixOS",
+ "homepage": "",
+ "owner": "NixOS",
+ "repo": "nixpkgs",
+ "rev": "69b9a8c860bdbb977adfa9c5e817ccb717884182",
+ "sha256": "12ljkkjg3gicamvryxr2bnfcdb05qdlbc5wv4lcw9sxamszp4cp7",
+ "type": "tarball",
+ "url": "https://github.com/NixOS/nixpkgs/archive/69b9a8c860bdbb977adfa9c5e817ccb717884182.tar.gz",
+ "url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
+ }
+}
diff --git a/nix/sources.nix b/nix/sources.nix
new file mode 100644
index 0000000..fe3dadf
--- /dev/null
+++ b/nix/sources.nix
@@ -0,0 +1,198 @@
+# This file has been generated by Niv.
+
+let
+
+ #
+ # The fetchers. fetch_<type> fetches specs of type <type>.
+ #
+
+ fetch_file = pkgs: name: spec:
+ let
+ name' = sanitizeName name + "-src";
+ in
+ if spec.builtin or true then
+ builtins_fetchurl { inherit (spec) url sha256; name = name'; }
+ else
+ pkgs.fetchurl { inherit (spec) url sha256; name = name'; };
+
+ fetch_tarball = pkgs: name: spec:
+ let
+ name' = sanitizeName name + "-src";
+ in
+ if spec.builtin or true then
+ builtins_fetchTarball { name = name'; inherit (spec) url sha256; }
+ else
+ pkgs.fetchzip { name = name'; inherit (spec) url sha256; };
+
+ fetch_git = name: spec:
+ let
+ ref =
+ spec.ref or (
+ if spec ? branch then "refs/heads/${spec.branch}" else
+ if spec ? tag then "refs/tags/${spec.tag}" else
+ abort "In git source '${name}': Please specify `ref`, `tag` or `branch`!"
+ );
+ submodules = spec.submodules or false;
+ submoduleArg =
+ let
+ nixSupportsSubmodules = builtins.compareVersions builtins.nixVersion "2.4" >= 0;
+ emptyArgWithWarning =
+ if submodules
+ then
+ builtins.trace
+ (
+ "The niv input \"${name}\" uses submodules "
+ + "but your nix's (${builtins.nixVersion}) builtins.fetchGit "
+ + "does not support them"
+ )
+ { }
+ else { };
+ in
+ if nixSupportsSubmodules
+ then { inherit submodules; }
+ else emptyArgWithWarning;
+ in
+ builtins.fetchGit
+ ({ url = spec.repo; inherit (spec) rev; inherit ref; } // submoduleArg);
+
+ fetch_local = spec: spec.path;
+
+ fetch_builtin-tarball = name: throw
+ ''[${name}] The niv type "builtin-tarball" is deprecated. You should instead use `builtin = true`.
+ $ niv modify ${name} -a type=tarball -a builtin=true'';
+
+ fetch_builtin-url = name: throw
+ ''[${name}] The niv type "builtin-url" will soon be deprecated. You should instead use `builtin = true`.
+ $ niv modify ${name} -a type=file -a builtin=true'';
+
+ #
+ # Various helpers
+ #
+
+ # https://github.com/NixOS/nixpkgs/pull/83241/files#diff-c6f540a4f3bfa4b0e8b6bafd4cd54e8bR695
+ sanitizeName = name:
+ (
+ concatMapStrings (s: if builtins.isList s then "-" else s)
+ (
+ builtins.split "[^[:alnum:]+._?=-]+"
+ ((x: builtins.elemAt (builtins.match "\\.*(.*)" x) 0) name)
+ )
+ );
+
+ # The set of packages used when specs are fetched using non-builtins.
+ mkPkgs = sources: system:
+ let
+ sourcesNixpkgs =
+ import (builtins_fetchTarball { inherit (sources.nixpkgs) url sha256; }) { inherit system; };
+ hasNixpkgsPath = builtins.any (x: x.prefix == "nixpkgs") builtins.nixPath;
+ hasThisAsNixpkgsPath = <nixpkgs> == ./.;
+ in
+ if builtins.hasAttr "nixpkgs" sources
+ then sourcesNixpkgs
+ else if hasNixpkgsPath && ! hasThisAsNixpkgsPath then
+ import <nixpkgs> { }
+ else
+ abort
+ ''
+ Please specify either <nixpkgs> (through -I or NIX_PATH=nixpkgs=...) or
+ add a package called "nixpkgs" to your sources.json.
+ '';
+
+ # The actual fetching function.
+ fetch = pkgs: name: spec:
+
+ if ! builtins.hasAttr "type" spec then
+ abort "ERROR: niv spec ${name} does not have a 'type' attribute"
+ else if spec.type == "file" then fetch_file pkgs name spec
+ else if spec.type == "tarball" then fetch_tarball pkgs name spec
+ else if spec.type == "git" then fetch_git name spec
+ else if spec.type == "local" then fetch_local spec
+ else if spec.type == "builtin-tarball" then fetch_builtin-tarball name
+ else if spec.type == "builtin-url" then fetch_builtin-url name
+ else
+ abort "ERROR: niv spec ${name} has unknown type ${builtins.toJSON spec.type}";
+
+ # If the environment variable NIV_OVERRIDE_${name} is set, then use
+ # the path directly as opposed to the fetched source.
+ replace = name: drv:
+ let
+ saneName = stringAsChars (c: if (builtins.match "[a-zA-Z0-9]" c) == null then "_" else c) name;
+ ersatz = builtins.getEnv "NIV_OVERRIDE_${saneName}";
+ in
+ if ersatz == "" then drv else
+ # this turns the string into an actual Nix path (for both absolute and
+ # relative paths)
+ if builtins.substring 0 1 ersatz == "/" then /. + ersatz else /. + builtins.getEnv "PWD" + "/${ersatz}";
+
+ # Ports of functions for older nix versions
+
+ # a Nix version of mapAttrs if the built-in doesn't exist
+ mapAttrs = builtins.mapAttrs or (
+ f: set: with builtins;
+ listToAttrs (map (attr: { name = attr; value = f attr set.${attr}; }) (attrNames set))
+ );
+
+ # https://github.com/NixOS/nixpkgs/blob/0258808f5744ca980b9a1f24fe0b1e6f0fecee9c/lib/lists.nix#L295
+ range = first: last: if first > last then [ ] else builtins.genList (n: first + n) (last - first + 1);
+
+ # https://github.com/NixOS/nixpkgs/blob/0258808f5744ca980b9a1f24fe0b1e6f0fecee9c/lib/strings.nix#L257
+ stringToCharacters = s: map (p: builtins.substring p 1 s) (range 0 (builtins.stringLength s - 1));
+
+ # https://github.com/NixOS/nixpkgs/blob/0258808f5744ca980b9a1f24fe0b1e6f0fecee9c/lib/strings.nix#L269
+ stringAsChars = f: s: concatStrings (map f (stringToCharacters s));
+ concatMapStrings = f: list: concatStrings (map f list);
+ concatStrings = builtins.concatStringsSep "";
+
+ # https://github.com/NixOS/nixpkgs/blob/8a9f58a375c401b96da862d969f66429def1d118/lib/attrsets.nix#L331
+ optionalAttrs = cond: as: if cond then as else { };
+
+ # fetchTarball version that is compatible between all the versions of Nix
+ builtins_fetchTarball = { url, name ? null, sha256 }@attrs:
+ let
+ inherit (builtins) lessThan nixVersion fetchTarball;
+ in
+ if lessThan nixVersion "1.12" then
+ fetchTarball ({ inherit url; } // (optionalAttrs (name != null) { inherit name; }))
+ else
+ fetchTarball attrs;
+
+ # fetchurl version that is compatible between all the versions of Nix
+ builtins_fetchurl = { url, name ? null, sha256 }@attrs:
+ let
+ inherit (builtins) lessThan nixVersion fetchurl;
+ in
+ if lessThan nixVersion "1.12" then
+ fetchurl ({ inherit url; } // (optionalAttrs (name != null) { inherit name; }))
+ else
+ fetchurl attrs;
+
+ # Create the final "sources" from the config
+ mkSources = config:
+ mapAttrs
+ (
+ name: spec:
+ if builtins.hasAttr "outPath" spec
+ then
+ abort
+ "The values in sources.json should not have an 'outPath' attribute"
+ else
+ spec // { outPath = replace name (fetch config.pkgs name spec); }
+ )
+ config.sources;
+
+ # The "config" used by the fetchers
+ mkConfig =
+ { sourcesFile ? if builtins.pathExists ./sources.json then ./sources.json else null
+ , sources ? if sourcesFile == null then { } else builtins.fromJSON (builtins.readFile sourcesFile)
+ , system ? builtins.currentSystem
+ , pkgs ? mkPkgs sources system
+ }: rec {
+ # The sources, i.e. the attribute set of spec name to spec
+ inherit sources;
+
+ # The "pkgs" (evaluated nixpkgs) to use for e.g. non-builtin fetchers
+ inherit pkgs;
+ };
+
+in
+mkSources (mkConfig { }) // { __functor = _: settings: mkSources (mkConfig settings); }
diff --git a/shell.nix b/shell.nix
index 1560ed6..36f2e31 100644
--- a/shell.nix
+++ b/shell.nix
@@ -1,20 +1,35 @@
# Gradle's toolchain support does not work with IntelliJ, thus we have to use buildFHSUserEnv
-
# https://discourse.nixos.org/t/how-to-create-a-development-environment-with-intellij-idea-and-openjdk/10153
+
+# How to use `config.allowUnfree` in shell.nix
+# https://github.com/NixOS/nixpkgs/issues/166220#issuecomment-1745803058
+
{
+ ### Import with nix channels ###
+ #
# NixOS stable
- pkgs ? import <nixpkgs> {
- # https://github.com/NixOS/nixpkgs/issues/166220#issuecomment-1745803058
- config.allowUnfree = true;
- },
+ #pkgs ? import <nixpkgs> {
+ # config.allowUnfree = true;
+ #},
# NixOS unstable
- unstable ? import <unstable> {
- # https://github.com/NixOS/nixpkgs/issues/166220#issuecomment-1745803058
- config.allowUnfree = true;
- }
+ #unstable ? import <unstable> {
+ # config.allowUnfree = true;
+ #}
}:
let
+ ### Import with Niv ###
+ #
+ sources = import ./nix/sources.nix;
+ # NixOS stable
+ pkgs = import sources.nixpkgs {
+ config.allowUnfree = true;
+ };
+ # NixOS unstable
+ unstable = import sources.unstable {
+ config.allowUnfree = true;
+ };
+
jdk = unstable.jdk23;
gradle = unstable.gradle;
in
From 515104fd9e3670d93017b58d98f88873df253784 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Wed, 1 Jan 2025 18:00:25 +0000
Subject: [PATCH 20/70] shell.nix: fix IntelliJ missing font
---
shell.nix | 4 ++++
1 file changed, 4 insertions(+)
diff --git a/shell.nix b/shell.nix
index 36f2e31..ae27378 100644
--- a/shell.nix
+++ b/shell.nix
@@ -40,6 +40,10 @@ in
name = "intellij-gradle-jdk23";
targetPkgs = pkgs_: [
pkgs_.jetbrains.idea-ultimate
+ # IntelliJ needs at least one font installed.
+ # If this shell.nix is run on a non-NixOS system, that might not be the case.
+ # Thus, we manually add one font.
+ pkgs_.noto-fonts
jdk
gradle
];
From 8c75ff36cd089a3e8f5a9efe8df97a06d610b6eb Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Wed, 1 Jan 2025 18:00:44 +0000
Subject: [PATCH 21/70] docs: README
---
README.md | 9 +++++++++
1 file changed, 9 insertions(+)
diff --git a/README.md b/README.md
index b20670e..165230d 100644
--- a/README.md
+++ b/README.md
@@ -2,6 +2,15 @@
Implementation of Powersort with the aim of integrating it into OpenJDK. Benchmarks are used to ensure that the runtime of the new sorting algorithm is never slower than the current Timsort implementation.
+<!-- TOC -->
+* [Bring Powersort to Java](#bring-powersort-to-java)
+ * [Setup](#setup)
+ * [Development Setup with nix](#development-setup-with-nix)
+ * [Tasks](#tasks)
+ * [Test Cases](#test-cases)
+ * [Benchmark](#benchmark)
+<!-- TOC -->
+
## Setup
We use Gradle for dependency and build management.
From a2dd6ac325c47fbc306d34528512edb49642166f Mon Sep 17 00:00:00 2001
From: finnm <finn.moltmann@tu-dortmund.de>
Date: Tue, 17 Dec 2024 17:55:36 +0100
Subject: [PATCH 22/70] Handling of descending runs
---
.../powersort/FinnSort/FinnSort.java | 35 ++++++++++++++++---
1 file changed, 30 insertions(+), 5 deletions(-)
diff --git a/app/src/main/java/de/uni_marburg/powersort/FinnSort/FinnSort.java b/app/src/main/java/de/uni_marburg/powersort/FinnSort/FinnSort.java
index ae5f1c5..657e532 100644
--- a/app/src/main/java/de/uni_marburg/powersort/FinnSort/FinnSort.java
+++ b/app/src/main/java/de/uni_marburg/powersort/FinnSort/FinnSort.java
@@ -15,7 +15,7 @@ public class FinnSort {
int i = 0;
int j = extendRunRight(a, i, c);
-// printList(a, c);
+ //printList(a, c);
runs.add(new Run(i, j, 0));
@@ -63,17 +63,40 @@ public class FinnSort {
System.arraycopy(merge.toArray(), 0, a, min(r1.start, r2.start), merge.size());
Run r = new Run(min(r1.start, r2.start), max(r1.end, r2.end), min(r1.power, r2.power));
runs.add(r);
-// printList(a, c);
+ //printList(a, c);
}
private static <T> int extendRunRight(T[] a, int i, Comparator<? super T> c) {
+ if (i >= a.length - 1)
+ return i + 1;
+
+
int j = i + 1;
- while (j < a.length && c.compare(a[j-1], a[j]) <= 0) {
- j++;
+ if (c.compare(a[i], a[j]) < 0) { //
+ while (j < a.length && c.compare(a[j - 1], a[j]) <= 0) {
+ j++;
+ }
+ } else {
+ while (j < a.length && c.compare(a[j - 1], a[j]) >= 0) {
+ j++;
+ }
+ makeAscending(a, i, j);
}
return j;
}
+ private static <T> void makeAscending(T[] a, int i, int j) {
+ for (int p = 0; p < (j - i) / 2; p++) {
+ swap(a, i + p ,j - p - 1);
+ }
+ }
+
+ private static <T> void swap(T[] a, int i, int j) {
+ T temp = a[i];
+ a[i] = a[j];
+ a[j] = temp;
+ }
+
private static int power(Run run1, Run run2, int n) {
if (run1.start == 0) {
return 0;
@@ -89,7 +112,7 @@ public class FinnSort {
}
return l;
}
-
+/*
public static void printRuns() {
String s = "";
for (Run run : runs) {
@@ -111,4 +134,6 @@ public class FinnSort {
}
System.out.println(s);
}
+
+ */
}
\ No newline at end of file
From 3974f575a96992328c18a77b53f53a09b46fdec0 Mon Sep 17 00:00:00 2001
From: finnm <finn.moltmann@tu-dortmund.de>
Date: Sun, 5 Jan 2025 12:33:08 +0100
Subject: [PATCH 23/70] Faster Merging of FinnSort
---
.../powersort/FinnSort/FinnSort.java | 19 +++++++++++++++++++
1 file changed, 19 insertions(+)
diff --git a/app/src/main/java/de/uni_marburg/powersort/FinnSort/FinnSort.java b/app/src/main/java/de/uni_marburg/powersort/FinnSort/FinnSort.java
index 657e532..598a44c 100644
--- a/app/src/main/java/de/uni_marburg/powersort/FinnSort/FinnSort.java
+++ b/app/src/main/java/de/uni_marburg/powersort/FinnSort/FinnSort.java
@@ -66,6 +66,25 @@ public class FinnSort {
//printList(a, c);
}
+ private static <T> void merge(T[] a, Run r1, Run r2, Comparator<? super T> c) {
+ T[] left = java.util.Arrays.copyOfRange(a, r1.start, r1.end);
+ int l = 0;
+ int r = r2.start;
+ int k = r1.start;
+
+ while (l < left.length && r < r2.end) {
+ if (c.compare(left[l], a[r]) <= 0) {
+ a[k++] = left[l++];
+ } else {
+ a[k++] = a[r++];
+ }
+ }
+
+ while (l < left.length) {
+ a[k++] = left[l++];
+ }
+ }
+
private static <T> int extendRunRight(T[] a, int i, Comparator<? super T> c) {
if (i >= a.length - 1)
return i + 1;
From c8bed52bf68e1939eb05daa0368c2edd97abe709 Mon Sep 17 00:00:00 2001
From: finnm <finn.moltmann@tu-dortmund.de>
Date: Sun, 5 Jan 2025 14:25:41 +0100
Subject: [PATCH 24/70] Added FasterFinnSort to the Sort-Enum and created a
test class
---
.../java/de/uni_marburg/powersort/benchmark/Main.java | 5 +++--
.../main/java/de/uni_marburg/powersort/sort/SortEnum.java | 3 +++
.../de/uni_marburg/powersort/sort/FasterFinnSortTest.java | 8 ++++++++
3 files changed, 14 insertions(+), 2 deletions(-)
create mode 100644 app/src/test/java/de/uni_marburg/powersort/sort/FasterFinnSortTest.java
diff --git a/app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java b/app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java
index 29a88b0..b022e79 100644
--- a/app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java
+++ b/app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java
@@ -1,6 +1,7 @@
package de.uni_marburg.powersort.benchmark;
-import de.uni_marburg.powersort.data.DataEnum;
+import
+ de.uni_marburg.powersort.data.DataEnum;
import de.uni_marburg.powersort.sort.SortEnum;
import de.uni_marburg.powersort.data.ObjectSupplier;
@@ -17,7 +18,7 @@ public class Main {
System.out.println();
for (DataEnum dataEnum : dataEnums) {
- System.out.println("⏳ Creating object supplier " + dataEnum + " ⏳");
+ System.out.println(" Creating object supplier " + dataEnum + " ");
ObjectSupplier objectSupplier = dataEnum.getObjectSupplier();
for (SortEnum sortImplementation : sortImplementations) {
diff --git a/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java b/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
index 56a9901..9228eb6 100644
--- a/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
+++ b/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
@@ -1,6 +1,7 @@
package de.uni_marburg.powersort.sort;
import de.uni_marburg.powersort.FinnSort.FinnSort;
+import de.uni_marburg.powersort.FinnSort.FasterFinnSort;
import de.uni_marburg.powersort.benchmark.NaturalOrder;
import de.uni_marburg.powersort.sort.dpqs.DualPivotQuicksort;
@@ -11,6 +12,7 @@ public enum SortEnum {
MERGE_SORT,
TIM_SORT,
FINN_SORT,
+ FASTER_FINN_SORT,
ASORT;
public SortImpl getSortImpl() {
@@ -21,6 +23,7 @@ public enum SortEnum {
case MERGE_SORT -> array -> MergeSort.legacyMergeSort(array, NaturalOrder.INSTANCE);
case TIM_SORT -> array -> TimSort.sort(array, 0, array.length, NaturalOrder.INSTANCE, null, 0, 0);
case FINN_SORT -> array -> FinnSort.sort(array, NaturalOrder.INSTANCE);
+ case FASTER_FINN_SORT -> array -> FasterFinnSort.sort(array, 0, array.length, NaturalOrder.INSTANCE, null, 0, 0);
case ASORT -> array -> ASort.sort(array, NaturalOrder.INSTANCE);
};
}
diff --git a/app/src/test/java/de/uni_marburg/powersort/sort/FasterFinnSortTest.java b/app/src/test/java/de/uni_marburg/powersort/sort/FasterFinnSortTest.java
new file mode 100644
index 0000000..1eff05c
--- /dev/null
+++ b/app/src/test/java/de/uni_marburg/powersort/sort/FasterFinnSortTest.java
@@ -0,0 +1,8 @@
+package de.uni_marburg.powersort.sort;
+
+public class FasterFinnSortTest extends AbstractSortTest {
+ FasterFinnSortTest() {
+ sortAlg = SortEnum.FASTER_FINN_SORT;
+ }
+
+}
From 4268315f062d8f59554716815fffb2bf1ed58f09 Mon Sep 17 00:00:00 2001
From: finnm <finn.moltmann@tu-dortmund.de>
Date: Sun, 5 Jan 2025 14:26:07 +0100
Subject: [PATCH 25/70] Changed FasterFinnSort to use the PowerSort merge
policy
---
.../powersort/FinnSort/FasterFinnSort.java | 38 ++++++++++++++-----
1 file changed, 28 insertions(+), 10 deletions(-)
diff --git a/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java b/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java
index 37072ae..1f7dc8f 100644
--- a/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java
+++ b/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java
@@ -28,6 +28,8 @@ package de.uni_marburg.powersort.FinnSort;
import java.util.Comparator;
+import static java.lang.Math.pow;
+
/**
* A stable, adaptive, iterative mergesort that requires far fewer than
* n lg(n) comparisons when running on partially sorted arrays, while
@@ -61,7 +63,7 @@ import java.util.Comparator;
*
* @author Josh Bloch
*/
-class FasterFinnSort<T> {
+public class FasterFinnSort<T> {
/**
* This is the minimum sized sequence that will be merged. Shorter
* sequences will be lengthened by calling binarySort. If the entire
@@ -135,6 +137,7 @@ class FasterFinnSort<T> {
private int stackSize = 0; // Number of pending runs on stack
private final int[] runBase;
private final int[] runLen;
+ private final int[] runPower;
/**
* Creates a TimSort instance to maintain the state of an ongoing sort.
@@ -186,6 +189,7 @@ class FasterFinnSort<T> {
len < 119151 ? 24 : 49);
runBase = new int[stackLen];
runLen = new int[stackLen];
+ runPower = new int[stackLen];
}
/*
@@ -209,7 +213,7 @@ class FasterFinnSort<T> {
* @param workLen usable size of work array
* @since 1.8
*/
- static <T> void sort(T[] a, int lo, int hi, Comparator<? super T> c,
+ public static <T> void sort(T[] a, int lo, int hi, Comparator<? super T> c,
T[] work, int workBase, int workLen) {
assert c != null && a != null && lo >= 0 && lo <= hi && hi <= a.length;
@@ -243,7 +247,7 @@ class FasterFinnSort<T> {
}
// Push run onto pending-run stack, and maybe merge
- ts.pushRun(lo, runLen);
+ ts.pushRun(lo, runLen, hi - lo);
ts.mergeCollapse();
// Advance to find next run
@@ -415,9 +419,10 @@ class FasterFinnSort<T> {
* @param runBase index of the first element in the run
* @param runLen the number of elements in the run
*/
- private void pushRun(int runBase, int runLen) {
+ private void pushRun(int runBase, int runLen, int rangeSize) {
this.runBase[stackSize] = runBase;
this.runLen[stackSize] = runLen;
+ this.runPower[stackSize] = power(stackSize, rangeSize);
stackSize++;
}
@@ -440,16 +445,29 @@ class FasterFinnSort<T> {
private void mergeCollapse() {
while (stackSize > 1) {
int n = stackSize - 2;
- if (n > 0 && runLen[n-1] <= runLen[n] + runLen[n+1] ||
- n > 1 && runLen[n-2] <= runLen[n] + runLen[n-1]) {
- if (runLen[n - 1] < runLen[n + 1])
- n--;
- } else if (n < 0 || runLen[n] > runLen[n + 1]) {
+ if (n > 0 && runPower[n + 1] < runPower[n]) {
+ mergeAt(n);
+ } else {
break; // Invariant is established
}
- mergeAt(n);
}
}
+
+ private int power(int stackSize, int rangeSize) {
+ if (stackSize == 0)
+ return 0;
+
+ int n_1 = this.runLen[stackSize - 1];
+ int n_2 = this.runLen[stackSize];
+ double a = ((double) this.runBase[stackSize - 1] + 0.5d * n_1 - 1d) / rangeSize;
+ double b = ((double) this.runBase[stackSize] + 0.5d * n_2 - 1d) / rangeSize;
+ int l = 0;
+ while ((int) (a * pow(2, l)) == (int) (b * pow(2 ,l))) {
+ l++;
+ }
+ return l;
+ }
+
/*
Backup mergeCollapse() von TimSort:
From 54f3ea6d42d45f5b592cace448e1fea9e96bf0d3 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Sun, 5 Jan 2025 22:32:53 +0100
Subject: [PATCH 26/70] benchmark: add input from competition
# Conflicts:
# app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java
# app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
---
.../powersort/benchmark/Filter.java | 119 ++++-
.../uni_marburg/powersort/benchmark/Main.java | 11 +-
.../uni_marburg/powersort/data/DataEnum.java | 487 +++++++++++++++++-
.../powersort/data/IntegerSerializer.java | 89 ++++
.../uni_marburg/powersort/sort/SortEnum.java | 12 +-
5 files changed, 701 insertions(+), 17 deletions(-)
create mode 100644 app/src/main/java/de/uni_marburg/powersort/data/IntegerSerializer.java
diff --git a/app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java b/app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java
index c3bffa3..0547850 100644
--- a/app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java
+++ b/app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java
@@ -1,8 +1,10 @@
package de.uni_marburg.powersort.benchmark;
import de.uni_marburg.powersort.data.DataEnum;
+import de.uni_marburg.powersort.data.IntegerSerializer;
import de.uni_marburg.powersort.sort.SortEnum;
+import java.nio.file.Files;
import java.util.List;
public class Filter {
@@ -11,7 +13,7 @@ public class Filter {
}
public static boolean isFiltered(DataEnum d, SortEnum s) {
- // To skip some of the inputs for all inputs, uncomment it here.
+ // To skip some of the inputs for all sort algorithms, uncomment them here.
// if (List.of(
// DataEnum.RANDOM_INTEGERS_300M,
// DataEnum.ASCENDING_INTEGERS_300M,
@@ -22,13 +24,77 @@ public class Filter {
// return true;
// }
+ // Skip some sort algorithms for all competition input data.
+ if(d.isCompetitionInput()){
+ if(List.of(
+ SortEnum.BUBBLE_SORT,
+ SortEnum.MERGE_SORT
+ ).contains(s)){
+ return true;
+ }
+
+ if(!Files.exists(IntegerSerializer.DATA_DIR)){
+ System.err.println("Folder with inputs of competition missing: " + IntegerSerializer.DATA_DIR.toAbsolutePath());
+ return true;
+ }
+ }
+
+ //
+ // Filter based on SortEnum values.
+ //
+
if (s == SortEnum.QUICK_SORT) {
return List.of(
DataEnum.RANDOM_INTEGERS_300M,
DataEnum.ASCENDING_INTEGERS_300M,
DataEnum.DESCENDING_INTEGERS_250M,
DataEnum.ASCENDING_RUNS_1M,
- DataEnum.ASCENDING_RUNS_WITH_OVERLAP_1M
+ DataEnum.ASCENDING_RUNS_WITH_OVERLAP_1M,
+
+ DataEnum.COMPETITION_34,
+ DataEnum.COMPETITION_35,
+ DataEnum.COMPETITION_36,
+ DataEnum.COMPETITION_37,
+ DataEnum.COMPETITION_38,
+ DataEnum.COMPETITION_39,
+ DataEnum.COMPETITION_83,
+ DataEnum.COMPETITION_85,
+ DataEnum.COMPETITION_153,
+ DataEnum.COMPETITION_163,
+ DataEnum.COMPETITION_164,
+ DataEnum.COMPETITION_165,
+ DataEnum.COMPETITION_166,
+ DataEnum.COMPETITION_167,
+ DataEnum.COMPETITION_168,
+ DataEnum.COMPETITION_169,
+ DataEnum.COMPETITION_170,
+ DataEnum.COMPETITION_171,
+ DataEnum.COMPETITION_172,
+ DataEnum.COMPETITION_173,
+ DataEnum.COMPETITION_174,
+ DataEnum.COMPETITION_181,
+ DataEnum.COMPETITION_182,
+ DataEnum.COMPETITION_183,
+ DataEnum.COMPETITION_184,
+ DataEnum.COMPETITION_185,
+ DataEnum.COMPETITION_186,
+ DataEnum.COMPETITION_187,
+ DataEnum.COMPETITION_205,
+ DataEnum.COMPETITION_206,
+ DataEnum.COMPETITION_207,
+ DataEnum.COMPETITION_213,
+ DataEnum.COMPETITION_214,
+ DataEnum.COMPETITION_216,
+ DataEnum.COMPETITION_218,
+ DataEnum.COMPETITION_220,
+ DataEnum.COMPETITION_222,
+ DataEnum.COMPETITION_225,
+ DataEnum.COMPETITION_226,
+ DataEnum.COMPETITION_228,
+ DataEnum.COMPETITION_231,
+ DataEnum.COMPETITION_232,
+ DataEnum.COMPETITION_235,
+ DataEnum.COMPETITION_236
).contains(d);
}
@@ -52,7 +118,54 @@ public class Filter {
if (s == SortEnum.FINN_SORT) {
return List.of(
DataEnum.DESCENDING_INTEGERS_250M,
- DataEnum.ASCENDING_RUNS_1M
+ DataEnum.ASCENDING_RUNS_1M,
+
+ DataEnum.COMPETITION_83,
+ DataEnum.COMPETITION_85,
+ DataEnum.COMPETITION_153,
+ DataEnum.COMPETITION_163,
+ DataEnum.COMPETITION_164,
+ DataEnum.COMPETITION_165,
+ DataEnum.COMPETITION_166,
+ DataEnum.COMPETITION_167,
+ DataEnum.COMPETITION_168,
+ DataEnum.COMPETITION_169,
+ DataEnum.COMPETITION_170,
+ DataEnum.COMPETITION_171,
+ DataEnum.COMPETITION_172,
+ DataEnum.COMPETITION_173,
+ DataEnum.COMPETITION_174,
+ DataEnum.COMPETITION_181,
+ DataEnum.COMPETITION_182,
+ DataEnum.COMPETITION_183,
+ DataEnum.COMPETITION_184,
+ DataEnum.COMPETITION_185,
+ DataEnum.COMPETITION_186,
+ DataEnum.COMPETITION_187,
+ DataEnum.COMPETITION_198,
+ DataEnum.COMPETITION_199,
+ DataEnum.COMPETITION_205,
+ DataEnum.COMPETITION_206,
+ DataEnum.COMPETITION_207,
+ DataEnum.COMPETITION_213,
+ DataEnum.COMPETITION_214,
+ DataEnum.COMPETITION_216,
+ DataEnum.COMPETITION_218,
+ DataEnum.COMPETITION_220,
+ DataEnum.COMPETITION_222,
+ DataEnum.COMPETITION_226,
+ DataEnum.COMPETITION_228,
+ DataEnum.COMPETITION_231,
+ DataEnum.COMPETITION_232,
+ DataEnum.COMPETITION_236
+ ).contains(d);
+ }
+
+ // TODO: Remove this once performance of ASort improved
+ if (s == SortEnum.ASORT) {
+ return List.of(
+ DataEnum.COMPETITION_173,
+ DataEnum.COMPETITION_174
).contains(d);
}
diff --git a/app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java b/app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java
index b022e79..2045149 100644
--- a/app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java
+++ b/app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java
@@ -1,7 +1,6 @@
package de.uni_marburg.powersort.benchmark;
-import
- de.uni_marburg.powersort.data.DataEnum;
+import de.uni_marburg.powersort.data.DataEnum;
import de.uni_marburg.powersort.sort.SortEnum;
import de.uni_marburg.powersort.data.ObjectSupplier;
@@ -18,11 +17,13 @@ public class Main {
System.out.println();
for (DataEnum dataEnum : dataEnums) {
- System.out.println(" Creating object supplier " + dataEnum + " ");
- ObjectSupplier objectSupplier = dataEnum.getObjectSupplier();
-
+ ObjectSupplier objectSupplier = null;
for (SortEnum sortImplementation : sortImplementations) {
if(!Filter.isFiltered(dataEnum, sortImplementation)) {
+ if(objectSupplier == null){
+ System.out.println("⏳ Creating object supplier " + dataEnum + " ⏳");
+ objectSupplier = dataEnum.getObjectSupplier();
+ }
benchmark(objectSupplier, sortImplementation);
}
}
diff --git a/app/src/main/java/de/uni_marburg/powersort/data/DataEnum.java b/app/src/main/java/de/uni_marburg/powersort/data/DataEnum.java
index 7c8a783..e6aa2b9 100644
--- a/app/src/main/java/de/uni_marburg/powersort/data/DataEnum.java
+++ b/app/src/main/java/de/uni_marburg/powersort/data/DataEnum.java
@@ -5,7 +5,252 @@ public enum DataEnum {
ASCENDING_INTEGERS_300M,
DESCENDING_INTEGERS_250M,
ASCENDING_RUNS_1M,
- ASCENDING_RUNS_WITH_OVERLAP_1M;
+ ASCENDING_RUNS_WITH_OVERLAP_1M,
+
+ COMPETITION_1,
+ COMPETITION_2,
+ COMPETITION_3,
+// COMPETITION_4, // Invalid input file.
+ COMPETITION_5,
+ COMPETITION_6,
+ COMPETITION_7,
+ COMPETITION_8,
+ COMPETITION_9,
+ COMPETITION_10,
+ COMPETITION_11,
+ COMPETITION_12,
+ COMPETITION_13,
+// COMPETITION_14, // Invalid input file.
+ COMPETITION_15,
+ COMPETITION_16,
+ COMPETITION_17,
+ COMPETITION_18,
+ COMPETITION_19,
+ COMPETITION_20,
+ COMPETITION_21,
+ COMPETITION_22,
+ COMPETITION_23,
+ COMPETITION_24,
+ COMPETITION_25,
+ COMPETITION_26,
+ COMPETITION_27,
+ COMPETITION_28,
+ COMPETITION_29,
+ COMPETITION_30,
+ COMPETITION_31,
+ COMPETITION_32,
+ COMPETITION_33,
+ COMPETITION_34,
+ COMPETITION_35,
+ COMPETITION_36,
+ COMPETITION_37,
+ COMPETITION_38,
+ COMPETITION_39,
+ COMPETITION_40,
+ COMPETITION_41,
+ COMPETITION_42,
+ COMPETITION_43,
+ COMPETITION_44,
+ COMPETITION_45,
+ COMPETITION_46,
+ COMPETITION_47,
+ COMPETITION_48,
+ COMPETITION_49,
+ COMPETITION_50,
+ COMPETITION_51,
+ COMPETITION_52,
+ COMPETITION_53,
+ COMPETITION_54,
+ COMPETITION_55,
+ COMPETITION_56,
+ COMPETITION_57,
+ COMPETITION_58,
+ COMPETITION_59,
+ COMPETITION_60,
+ COMPETITION_61,
+ COMPETITION_62,
+ COMPETITION_63,
+ COMPETITION_64,
+ COMPETITION_65,
+ COMPETITION_66,
+ COMPETITION_67,
+ COMPETITION_68,
+ COMPETITION_69,
+ COMPETITION_70,
+ COMPETITION_71,
+ COMPETITION_72,
+ COMPETITION_73,
+ COMPETITION_74,
+ COMPETITION_75,
+ COMPETITION_76,
+ COMPETITION_77,
+ COMPETITION_78,
+ COMPETITION_79,
+ COMPETITION_80,
+ COMPETITION_81,
+ COMPETITION_82,
+ COMPETITION_83,
+ COMPETITION_84,
+ COMPETITION_85,
+ COMPETITION_86,
+ COMPETITION_87,
+ COMPETITION_88,
+ COMPETITION_89,
+ COMPETITION_90,
+ COMPETITION_91,
+ COMPETITION_92,
+ COMPETITION_93,
+ COMPETITION_94,
+ COMPETITION_95,
+ COMPETITION_96,
+ COMPETITION_97,
+// COMPETITION_98, // Invalid input file (floats not integers).
+ COMPETITION_99,
+ COMPETITION_100,
+ COMPETITION_101,
+ COMPETITION_102,
+ COMPETITION_103,
+ COMPETITION_104,
+ COMPETITION_105,
+ COMPETITION_106,
+ COMPETITION_107,
+ COMPETITION_108,
+ COMPETITION_109,
+ COMPETITION_110,
+ COMPETITION_111,
+ COMPETITION_112,
+ COMPETITION_113,
+ COMPETITION_114,
+ COMPETITION_115,
+ COMPETITION_116,
+ COMPETITION_117,
+ COMPETITION_118,
+ COMPETITION_119,
+ COMPETITION_120,
+ COMPETITION_121,
+ COMPETITION_122,
+ COMPETITION_123,
+ COMPETITION_124,
+ COMPETITION_125,
+ COMPETITION_126,
+ COMPETITION_127,
+ COMPETITION_128,
+ COMPETITION_129,
+ COMPETITION_130,
+ COMPETITION_131,
+ COMPETITION_132,
+ COMPETITION_133,
+ COMPETITION_134,
+ COMPETITION_135,
+ COMPETITION_136,
+ COMPETITION_137,
+ COMPETITION_138,
+ COMPETITION_139,
+ COMPETITION_140,
+ COMPETITION_141,
+ COMPETITION_142,
+ COMPETITION_143,
+ COMPETITION_144,
+ COMPETITION_145,
+ COMPETITION_146,
+ COMPETITION_147,
+ COMPETITION_148,
+ COMPETITION_149,
+ COMPETITION_150,
+ COMPETITION_151,
+ COMPETITION_152,
+ COMPETITION_153,
+ COMPETITION_154,
+ COMPETITION_155,
+ COMPETITION_156,
+ COMPETITION_157,
+ COMPETITION_158,
+ COMPETITION_159,
+ COMPETITION_160,
+ COMPETITION_161,
+ COMPETITION_162,
+ COMPETITION_163,
+ COMPETITION_164,
+ COMPETITION_165,
+ COMPETITION_166,
+ COMPETITION_167,
+ COMPETITION_168,
+ COMPETITION_169,
+ COMPETITION_170,
+ COMPETITION_171,
+ COMPETITION_172,
+ COMPETITION_173,
+ COMPETITION_174,
+ COMPETITION_175,
+ COMPETITION_176,
+ COMPETITION_177,
+ COMPETITION_178,
+ COMPETITION_179,
+ COMPETITION_180,
+ COMPETITION_181,
+ COMPETITION_182,
+ COMPETITION_183,
+ COMPETITION_184,
+ COMPETITION_185,
+ COMPETITION_186,
+ COMPETITION_187,
+ COMPETITION_188,
+ COMPETITION_189,
+ COMPETITION_190,
+ COMPETITION_191,
+ COMPETITION_192,
+ COMPETITION_193,
+ COMPETITION_194,
+ COMPETITION_195,
+ COMPETITION_196,
+ COMPETITION_197,
+ COMPETITION_198,
+ COMPETITION_199,
+ COMPETITION_200,
+ COMPETITION_201,
+ COMPETITION_202,
+ COMPETITION_203,
+ COMPETITION_204,
+ COMPETITION_205,
+ COMPETITION_206,
+ COMPETITION_207,
+ COMPETITION_208,
+ COMPETITION_209,
+ COMPETITION_210,
+ COMPETITION_211,
+ COMPETITION_212,
+ COMPETITION_213,
+ COMPETITION_214,
+ COMPETITION_215,
+ COMPETITION_216,
+ COMPETITION_217,
+ COMPETITION_218,
+ COMPETITION_219,
+ COMPETITION_220,
+ COMPETITION_221,
+ COMPETITION_222,
+ COMPETITION_223,
+ COMPETITION_224,
+ COMPETITION_225,
+ COMPETITION_226,
+ COMPETITION_227,
+ COMPETITION_228,
+ COMPETITION_229,
+ COMPETITION_230,
+ COMPETITION_231,
+ COMPETITION_232,
+ COMPETITION_233,
+ COMPETITION_234,
+ COMPETITION_235,
+ COMPETITION_236,
+ COMPETITION_237,
+ COMPETITION_238;
+
+ public static final String COMPETITION_PREFIX = "COMPETITION_";
+
+ public boolean isCompetitionInput(){
+ return this.toString().startsWith(COMPETITION_PREFIX);
+ }
public ObjectSupplier getObjectSupplier() {
// We use a seed to get the same random list every time -> Repeatable benchmarks on same input data!
@@ -21,9 +266,245 @@ public enum DataEnum {
case RANDOM_INTEGERS_300M -> new RandomIntegers(longListSize, seed);
case ASCENDING_INTEGERS_300M -> new AscendingIntegers(longListSize);
case DESCENDING_INTEGERS_250M -> new DescendingIntegers(middleListSize);
-
case ASCENDING_RUNS_1M -> AscendingRuns.newAscendingRuns(runs, runLength, -runLength);
- case ASCENDING_RUNS_WITH_OVERLAP_1M -> AscendingRuns.newAscendingRuns(runs, runLength, (int) (-0.5 * runLength));
+ case ASCENDING_RUNS_WITH_OVERLAP_1M ->
+ AscendingRuns.newAscendingRuns(runs, runLength, (int) (-0.5 * runLength));
+
+ case COMPETITION_1 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_2 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_3 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_5 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_6 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_7 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_8 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_9 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_10 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_11 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_12 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_13 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_15 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_16 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_17 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_18 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_19 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_20 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_21 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_22 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_23 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_24 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_25 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_26 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_27 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_28 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_29 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_30 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_31 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_32 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_33 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_34 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_35 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_36 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_37 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_38 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_39 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_40 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_41 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_42 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_43 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_44 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_45 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_46 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_47 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_48 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_49 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_50 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_51 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_52 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_53 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_54 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_55 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_56 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_57 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_58 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_59 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_60 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_61 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_62 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_63 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_64 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_65 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_66 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_67 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_68 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_69 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_70 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_71 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_72 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_73 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_74 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_75 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_76 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_77 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_78 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_79 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_80 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_81 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_82 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_83 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_84 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_85 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_86 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_87 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_88 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_89 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_90 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_91 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_92 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_93 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_94 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_95 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_96 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_97 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_99 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_100 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_101 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_102 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_103 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_104 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_105 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_106 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_107 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_108 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_109 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_110 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_111 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_112 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_113 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_114 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_115 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_116 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_117 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_118 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_119 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_120 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_121 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_122 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_123 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_124 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_125 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_126 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_127 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_128 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_129 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_130 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_131 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_132 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_133 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_134 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_135 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_136 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_137 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_138 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_139 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_140 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_141 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_142 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_143 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_144 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_145 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_146 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_147 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_148 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_149 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_150 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_151 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_152 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_153 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_154 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_155 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_156 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_157 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_158 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_159 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_160 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_161 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_162 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_163 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_164 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_165 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_166 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_167 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_168 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_169 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_170 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_171 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_172 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_173 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_174 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_175 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_176 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_177 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_178 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_179 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_180 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_181 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_182 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_183 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_184 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_185 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_186 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_187 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_188 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_189 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_190 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_191 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_192 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_193 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_194 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_195 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_196 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_197 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_198 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_199 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_200 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_201 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_202 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_203 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_204 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_205 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_206 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_207 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_208 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_209 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_210 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_211 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_212 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_213 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_214 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_215 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_216 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_217 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_218 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_219 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_220 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_221 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_222 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_223 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_224 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_225 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_226 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_227 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_228 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_229 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_230 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_231 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_232 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_233 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_234 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_235 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_236 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_237 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_238 -> IntegerSerializer.fromEnum(this);
};
}
}
diff --git a/app/src/main/java/de/uni_marburg/powersort/data/IntegerSerializer.java b/app/src/main/java/de/uni_marburg/powersort/data/IntegerSerializer.java
new file mode 100644
index 0000000..72d0449
--- /dev/null
+++ b/app/src/main/java/de/uni_marburg/powersort/data/IntegerSerializer.java
@@ -0,0 +1,89 @@
+package de.uni_marburg.powersort.data;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+
+public class IntegerSerializer {
+ public static final Path DATA_DIR = Paths.get("integer_lists");
+
+ private final int id;
+
+ public static ObjectSupplier fromEnum(DataEnum dataEnum) {
+ if(!dataEnum.isCompetitionInput()){
+ throw new IllegalArgumentException();
+ }
+
+ String prefixedId = dataEnum.toString();
+ IntegerSerializer serializer = new IntegerSerializer(Integer.parseInt(prefixedId.substring(DataEnum.COMPETITION_PREFIX.length())));
+ return serializer.getObjectSupplier();
+ }
+
+ public IntegerSerializer(int id) {
+ this.id = id;
+ }
+
+ public ObjectSupplier getObjectSupplier() {
+ Integer[] list = read();
+ return new IntegerSupplier(list) {
+ @Override
+ public Integer[] getCopy() {
+ return super.getCopy();
+ }
+ };
+ }
+
+ public Integer[] read() {
+ Path path = getPath();
+ String content;
+ try {
+ content = Files.readString(path);
+ } catch (IOException e) {
+ System.err.println(this + ": Could not read file " + path.toAbsolutePath());
+ System.exit(1);
+ return null;
+ }
+
+ content = content.strip();
+ if (content.charAt(0) != '[' || content.charAt(content.length() - 1) != ']') {
+ System.err.println(this + ": Illegal data format: Expected list of integers surrounded by square brackets.");
+ System.exit(1);
+ return null;
+ }
+ content = content.substring(1, content.length() - 1);
+
+ // Remove spaces
+ content = content.replaceAll(" ", "");
+
+ String[] elements = content.split(",");
+ try {
+ return Arrays.stream(elements).map(Integer::valueOf).toArray(Integer[]::new);
+ } catch (NumberFormatException e) {
+ System.err.println(this + ": Number format exception: " + e.getMessage());
+ System.exit(1);
+ return null;
+ }
+ }
+
+ public void write(Integer[] list) throws IOException {
+ Path path = getPath();
+ if (Files.exists(path)) {
+ throw new IOException(this + ": Target file does already exist");
+ }
+
+ String[] elements = Arrays.stream(list).map(Object::toString).toArray(String[]::new);
+ String content = "[" + String.join(",", elements) + "]";
+ Files.writeString(path, content);
+ }
+
+ private Path getPath() {
+ return DATA_DIR.resolve(Integer.toString(id));
+ }
+
+ @Override
+ public String toString() {
+ return "IntegerSerializer{" + id + "}";
+ }
+}
diff --git a/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java b/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
index 9228eb6..4a203f6 100644
--- a/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
+++ b/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
@@ -6,14 +6,14 @@ import de.uni_marburg.powersort.benchmark.NaturalOrder;
import de.uni_marburg.powersort.sort.dpqs.DualPivotQuicksort;
public enum SortEnum {
- BUBBLE_SORT,
- QUICK_SORT,
- DPQS,
- MERGE_SORT,
TIM_SORT,
- FINN_SORT,
+ ASORT,
FASTER_FINN_SORT,
- ASORT;
+ FINN_SORT,
+ DPQS,
+ QUICK_SORT,
+ MERGE_SORT,
+ BUBBLE_SORT;
public SortImpl getSortImpl() {
return switch (this) {
From 4223f76727a6adb8221b64398ef111a8229d9222 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 7 Jan 2025 13:09:21 +0000
Subject: [PATCH 27/70] benchmark: cleanup
---
.../powersort/benchmark/MainJmh.java | 17 ++++++-------
.../powersort/benchmark/Filter.java | 7 +++++-
.../uni_marburg/powersort/benchmark/Main.java | 24 ++++---------------
.../powersort/data/ObjectSupplier.java | 7 ++++--
4 files changed, 25 insertions(+), 30 deletions(-)
diff --git a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/MainJmh.java b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/MainJmh.java
index c806c34..f678db8 100644
--- a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/MainJmh.java
+++ b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/MainJmh.java
@@ -18,13 +18,11 @@ import org.openjdk.jmh.annotations.Warmup;
import java.util.concurrent.TimeUnit;
-import static de.uni_marburg.powersort.data.ObjectSupplier.EMPTY_ARRAY;
-
// TODO: The parameters are way too low. Use for debugging only!
/*
* Benchmark parameters
*/
-@Fork(1)
+@Fork(value = 1, jvmArgsAppend = "-Xmx8g")
@Warmup(iterations = 1)
@Measurement(iterations = 6)
@BenchmarkMode(Mode.AverageTime)
@@ -42,7 +40,7 @@ public class MainJmh {
@Param()
private SortEnum sortEnum;
- private ObjectSupplier data = EMPTY_ARRAY;
+ private ObjectSupplier data = null;
/* package-protected */ Object[] workingCopy;
// TODO: This is inaccurate. How to create and use separate arrays for each warmup x iteration x sortAlgorithm ?
@@ -50,15 +48,18 @@ public class MainJmh {
public void setup() {
if(Filter.isFiltered(dataEnum, sortEnum)) {
// This combination of DataEnum and SortEnum should be skipped.
- // We can't tell JMH to not run the benchmark at all,
- // so we'll let it sort an empty list instead ;)
- data = EMPTY_ARRAY;
+ // We can't tell JMH to not run the benchmark at all.
+ // Instead, we let it sort an invalid list which results in an exception.
+ // This way the filtered combinations are skipped quickly
+ // and not included in the benchmark results.
+ data = null;
+ workingCopy = null;
return;
}
// A new MainJmh object is created for each @Param variation.
// Then, `data` is `null` again.
- if (data == EMPTY_ARRAY) {
+ if (data == null) {
data = dataEnum.getObjectSupplier();
}
// For all warmup and measurement iterations of one @Param variation, the MainJmh object is reused.
diff --git a/app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java b/app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java
index 0547850..a3d401f 100644
--- a/app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java
+++ b/app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java
@@ -24,7 +24,12 @@ public class Filter {
// return true;
// }
- // Skip some sort algorithms for all competition input data.
+ // To skip all competition inputs, uncomment the next line.
+// if(d.isCompetitionInput()){
+// return true;
+// }
+
+ // Skip some sort algorithms for all competition inputs.
if(d.isCompetitionInput()){
if(List.of(
SortEnum.BUBBLE_SORT,
diff --git a/app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java b/app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java
index 2045149..8eb858b 100644
--- a/app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java
+++ b/app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java
@@ -4,7 +4,6 @@ import de.uni_marburg.powersort.data.DataEnum;
import de.uni_marburg.powersort.sort.SortEnum;
import de.uni_marburg.powersort.data.ObjectSupplier;
-import java.util.EnumSet;
import java.util.concurrent.TimeUnit;
/**
@@ -12,15 +11,15 @@ import java.util.concurrent.TimeUnit;
*/
public class Main {
public static void main(final String[] args) {
- final EnumSet<SortEnum> sortImplementations = getSortImplementations();
- final EnumSet<DataEnum> dataEnums = getSortInputSuppliers();
+ final SortEnum[] sortImplementations = SortEnum.values();
+ final DataEnum[] dataEnums = DataEnum.values();
System.out.println();
for (DataEnum dataEnum : dataEnums) {
ObjectSupplier objectSupplier = null;
for (SortEnum sortImplementation : sortImplementations) {
- if(!Filter.isFiltered(dataEnum, sortImplementation)) {
- if(objectSupplier == null){
+ if (!Filter.isFiltered(dataEnum, sortImplementation)) {
+ if (objectSupplier == null) {
System.out.println("⏳ Creating object supplier " + dataEnum + " ⏳");
objectSupplier = dataEnum.getObjectSupplier();
}
@@ -32,7 +31,7 @@ public class Main {
}
}
- static void benchmark(ObjectSupplier objectSupplier, SortEnum sortImplementation){
+ static void benchmark(ObjectSupplier objectSupplier, SortEnum sortImplementation) {
System.out.print(sortImplementation);
System.out.flush();
Object[] sortInput = objectSupplier.getCopy();
@@ -48,17 +47,4 @@ public class Main {
System.out.println("," + durFormatted);
}
-
- static EnumSet<SortEnum> getSortImplementations() {
- return EnumSet.allOf(SortEnum.class);
- }
-
- /**
- * The returned ObjectSupplier objects are wrapped by DataEnum objects.
- * This way they are lazily created on their first access with DataEnum.get().
- * This saves memory if we work with large lists.
- */
- static EnumSet<DataEnum> getSortInputSuppliers() {
- return EnumSet.allOf(DataEnum.class);
- }
}
diff --git a/app/src/main/java/de/uni_marburg/powersort/data/ObjectSupplier.java b/app/src/main/java/de/uni_marburg/powersort/data/ObjectSupplier.java
index 5805157..f2814cd 100644
--- a/app/src/main/java/de/uni_marburg/powersort/data/ObjectSupplier.java
+++ b/app/src/main/java/de/uni_marburg/powersort/data/ObjectSupplier.java
@@ -3,8 +3,6 @@ package de.uni_marburg.powersort.data;
import java.util.Arrays;
public abstract class ObjectSupplier {
- public static final ObjectSupplier EMPTY_ARRAY = new ObjectSupplier(new Object[0]) {};
-
/* package-protected */ final Object[] readOnly;
ObjectSupplier(Object[] readOnly) {
@@ -17,4 +15,9 @@ public abstract class ObjectSupplier {
public Object[] getCopy(){
return Arrays.copyOf(readOnly, readOnly.length);
}
+
+ @Override
+ public String toString() {
+ return "ObjectSupplier{" + readOnly.length + "}";
+ }
}
From 5e2425bbca17b87812ce47710283a1bec1a71f7e Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 7 Jan 2025 13:19:41 +0000
Subject: [PATCH 28/70] benchmark: refactor
---
.gitignore | 1 +
.../java/de/uni_marburg/powersort/data/IntegerSerializer.java | 2 +-
2 files changed, 2 insertions(+), 1 deletion(-)
diff --git a/.gitignore b/.gitignore
index 7f936b2..13b9d57 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,5 +1,6 @@
/.idea
/app/bin/
+/app/powersort-competition
# Ignore Gradle project-specific cache directory
/.gradle
diff --git a/app/src/main/java/de/uni_marburg/powersort/data/IntegerSerializer.java b/app/src/main/java/de/uni_marburg/powersort/data/IntegerSerializer.java
index 72d0449..6604256 100644
--- a/app/src/main/java/de/uni_marburg/powersort/data/IntegerSerializer.java
+++ b/app/src/main/java/de/uni_marburg/powersort/data/IntegerSerializer.java
@@ -7,7 +7,7 @@ import java.nio.file.Paths;
import java.util.Arrays;
public class IntegerSerializer {
- public static final Path DATA_DIR = Paths.get("integer_lists");
+ public static final Path DATA_DIR = Paths.get("powersort-competition");
private final int id;
From ddbf8c1174c0bf5a9e3a2d8abc228cbd23384094 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 7 Jan 2025 16:07:41 +0000
Subject: [PATCH 29/70] benchmark: JMH config
---
.../jmh/java/de/uni_marburg/powersort/benchmark/MainJmh.java | 4 +++-
1 file changed, 3 insertions(+), 1 deletion(-)
diff --git a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/MainJmh.java b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/MainJmh.java
index f678db8..3327260 100644
--- a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/MainJmh.java
+++ b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/MainJmh.java
@@ -14,6 +14,7 @@ import org.openjdk.jmh.annotations.Param;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Timeout;
import org.openjdk.jmh.annotations.Warmup;
import java.util.concurrent.TimeUnit;
@@ -22,9 +23,10 @@ import java.util.concurrent.TimeUnit;
/*
* Benchmark parameters
*/
-@Fork(value = 1, jvmArgsAppend = "-Xmx8g")
+@Fork(value = 1, jvmArgsAppend = {"-Xms8g", "-Xmx8g"})
@Warmup(iterations = 1)
@Measurement(iterations = 6)
+@Timeout(time = 15, timeUnit = TimeUnit.SECONDS)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
/*
From 1a356490e40759e245e0acec3be082f29346994d Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 7 Jan 2025 16:36:52 +0000
Subject: [PATCH 30/70] .idea
---
.idea/compiler.xml | 5 ++++-
1 file changed, 4 insertions(+), 1 deletion(-)
diff --git a/.idea/compiler.xml b/.idea/compiler.xml
index c515aca..cbd75e9 100644
--- a/.idea/compiler.xml
+++ b/.idea/compiler.xml
@@ -1,6 +1,9 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="CompilerConfiguration">
+ <annotationProcessing>
+ <profile default="true" name="Default" enabled="true" />
+ </annotationProcessing>
<bytecodeTargetLevel target="23" />
</component>
-</project>
+</project>
\ No newline at end of file
From 648af1c4bee655878e70814107aeac030d240c0d Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 7 Jan 2025 16:43:15 +0000
Subject: [PATCH 31/70] benchmark: separate JMH benchmarks
---
app/build.gradle.kts | 28 +++++++++++++++--
.../benchmark/{MainJmh.java => JmhBase.java} | 29 ++++++++++--------
.../powersort/benchmark/JmhCompetition.java | 30 +++++++++++++++++++
.../powersort/benchmark/SortImpl.java | 14 ---------
.../powersort/data/ObjectSupplier.java | 2 +-
5 files changed, 73 insertions(+), 30 deletions(-)
rename app/src/jmh/java/de/uni_marburg/powersort/benchmark/{MainJmh.java => JmhBase.java} (81%)
create mode 100644 app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCompetition.java
delete mode 100644 app/src/main/java/de/uni_marburg/powersort/benchmark/SortImpl.java
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index 74f5fe8..e61acfb 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -6,7 +6,9 @@
plugins {
// Apply the application plugin to add support for building a CLI application in Java.
application
+
// JMH Gradle Plugin
+ // https://github.com/melix/jmh-gradle-plugin/blob/master/README.adoc#usage
id("me.champeau.jmh") version "0.7.2"
}
@@ -15,14 +17,17 @@ repositories {
mavenCentral()
}
+val latestJmhVersion = "1.37"
+
dependencies {
// Use JUnit Jupiter for testing.
testImplementation(libs.junit.jupiter)
testRuntimeOnly("org.junit.platform:junit-platform-launcher")
- // This dependency is used by the application.
- //implementation(libs.guava)
+ // Required to use the IntelliJ plugin "JMH Java Microbenchmark Harness".
+ // https://stackoverflow.com/a/71286156/6334421
+ jmhAnnotationProcessor("org.openjdk.jmh:jmh-generator-annprocess:$latestJmhVersion")
}
// Apply a specific Java toolchain to ease working on different environments.
@@ -57,4 +62,21 @@ tasks.named<Test>("test") {
// HTML reports to view with a webbrowser.
html.required.set(true)
}
-}
\ No newline at end of file
+}
+
+// https://github.com/melix/jmh-gradle-plugin/blob/master/README.adoc#configuration-options
+jmh {
+ // Use latest JMH version (1.37, https://github.com/openjdk/jmh/tags)
+ // instead of default (1.36, https://github.com/melix/jmh-gradle-plugin/blob/dfdbb0cd3a363e2dbbcaab93bb1be32178f4cae4/src/main/java/me/champeau/jmh/DefaultsConfigurer.java#L24)
+ jmhVersion = latestJmhVersion // Specifies JMH version
+
+ // Force GC (garbage collection) between iterations.
+ //
+ // Forcing the GC may help to lower the noise in GC-heavy benchmarks, at the expense of jeopardizing GC ergonomics decisions. Use with care.
+ // https://github.com/openjdk/jmh/blob/1be779e0b4af174b67abf8080d1b76dda570d88d/jmh-core/src/main/java/org/openjdk/jmh/runner/options/CommandLineOptions.java#L148-L152
+ forceGC = true
+
+ excludes = listOf(
+ "de.uni_marburg.powersort.benchmark.JmhBase.benchmark",
+ )
+}
diff --git a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/MainJmh.java b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhBase.java
similarity index 81%
rename from app/src/jmh/java/de/uni_marburg/powersort/benchmark/MainJmh.java
rename to app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhBase.java
index 3327260..237af37 100644
--- a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/MainJmh.java
+++ b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhBase.java
@@ -3,6 +3,7 @@ package de.uni_marburg.powersort.benchmark;
import de.uni_marburg.powersort.data.DataEnum;
import de.uni_marburg.powersort.data.ObjectSupplier;
import de.uni_marburg.powersort.sort.SortEnum;
+import de.uni_marburg.powersort.sort.SortImpl;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
@@ -10,7 +11,6 @@ import org.openjdk.jmh.annotations.Level;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;
-import org.openjdk.jmh.annotations.Param;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
@@ -36,19 +36,24 @@ import java.util.concurrent.TimeUnit;
* State objects naturally encapsulate the state on which benchmark is working on.
*/
@State(Scope.Benchmark)
-public class MainJmh {
- @Param()
- private DataEnum dataEnum;
- @Param()
- private SortEnum sortEnum;
+public class JmhBase {
+ DataEnum getDataEnum(){
+ return null;
+ }
+ SortEnum getSortEnum(){
+ return null;
+ }
private ObjectSupplier data = null;
- /* package-protected */ Object[] workingCopy;
+ Object[] workingCopy;
+ SortImpl sortImpl;
// TODO: This is inaccurate. How to create and use separate arrays for each warmup x iteration x sortAlgorithm ?
@Setup(Level.Invocation)
public void setup() {
- if(Filter.isFiltered(dataEnum, sortEnum)) {
+ sortImpl = getSortEnum().getSortImpl();
+
+ if (Filter.isFiltered(getDataEnum(), getSortEnum())) {
// This combination of DataEnum and SortEnum should be skipped.
// We can't tell JMH to not run the benchmark at all.
// Instead, we let it sort an invalid list which results in an exception.
@@ -59,12 +64,12 @@ public class MainJmh {
return;
}
- // A new MainJmh object is created for each @Param variation.
+ // A new JmhRunner object is created for each @Param variation.
// Then, `data` is `null` again.
if (data == null) {
- data = dataEnum.getObjectSupplier();
+ data = getDataEnum().getObjectSupplier();
}
- // For all warmup and measurement iterations of one @Param variation, the MainJmh object is reused.
+ // For all warmup and measurement iterations of one @Param variation, the JmhRunner object is reused.
// Thus, we can't just sort `data` directly.
// Instead, we have to create a copy of it on which the sort algorithm can work.
// This way, all iterations sort the same input.
@@ -73,6 +78,6 @@ public class MainJmh {
@Benchmark
public void benchmark() {
- sortEnum.getSortImpl().sort(workingCopy);
+ sortImpl.sort(workingCopy);
}
}
diff --git a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCompetition.java b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCompetition.java
new file mode 100644
index 0000000..2fc07c6
--- /dev/null
+++ b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCompetition.java
@@ -0,0 +1,30 @@
+package de.uni_marburg.powersort.benchmark;
+
+import de.uni_marburg.powersort.data.DataEnum;
+import de.uni_marburg.powersort.sort.SortEnum;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.State;
+
+/*
+ * Benchmark state parameters
+ *
+ * Quote from JMH:
+ * State objects naturally encapsulate the state on which benchmark is working on.
+ */
+@State(Scope.Benchmark)
+public class JmhCompetition extends JmhBase {
+ @Param()
+ DataEnum dataEnum;
+ @Param()
+ SortEnum sortEnum;
+
+ @Override
+ DataEnum getDataEnum(){
+ return dataEnum;
+ }
+ @Override
+ SortEnum getSortEnum(){
+ return sortEnum;
+ }
+}
diff --git a/app/src/main/java/de/uni_marburg/powersort/benchmark/SortImpl.java b/app/src/main/java/de/uni_marburg/powersort/benchmark/SortImpl.java
deleted file mode 100644
index e9552fd..0000000
--- a/app/src/main/java/de/uni_marburg/powersort/benchmark/SortImpl.java
+++ /dev/null
@@ -1,14 +0,0 @@
-package de.uni_marburg.powersort.benchmark;
-
-public abstract class SortImpl {
- final String title;
-
- public SortImpl(String title) {
- this.title = title;
- }
-
- /**
- * Apply the sort algorithm.
- */
- public abstract void sort(Object[] a);
-}
diff --git a/app/src/main/java/de/uni_marburg/powersort/data/ObjectSupplier.java b/app/src/main/java/de/uni_marburg/powersort/data/ObjectSupplier.java
index f2814cd..e7e59db 100644
--- a/app/src/main/java/de/uni_marburg/powersort/data/ObjectSupplier.java
+++ b/app/src/main/java/de/uni_marburg/powersort/data/ObjectSupplier.java
@@ -3,7 +3,7 @@ package de.uni_marburg.powersort.data;
import java.util.Arrays;
public abstract class ObjectSupplier {
- /* package-protected */ final Object[] readOnly;
+ final Object[] readOnly;
ObjectSupplier(Object[] readOnly) {
this.readOnly = readOnly;
From 1133c069f81f49ad808b962888bf05911eb0f322 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 7 Jan 2025 17:26:25 +0000
Subject: [PATCH 32/70] shell.nix: fix JDK23
---
shell.nix | 6 +++++-
1 file changed, 5 insertions(+), 1 deletion(-)
diff --git a/shell.nix b/shell.nix
index ae27378..b04b53a 100644
--- a/shell.nix
+++ b/shell.nix
@@ -31,7 +31,11 @@ let
};
jdk = unstable.jdk23;
- gradle = unstable.gradle;
+ gradle = unstable.gradle.override {
+ java = jdk;
+ # Required for `gradle javaToolchains` to list JDK23
+ javaToolchains = [ jdk ];
+ };
in
(
From e6ab4f665649b8cbd765f850c0b463b1063933ed Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 7 Jan 2025 17:32:18 +0000
Subject: [PATCH 33/70] benchmark: separate benchmarks
---
README.md | 26 +-
app/build.gradle.kts | 14 +-
.../powersort/benchmark/JmhCgl.java | 31 ++
.../powersort/benchmark/JmhCompetition.java | 3 +-
.../benchmark/{Main.java => CbmBase.java} | 9 +-
.../powersort/benchmark/CbmCgl.java | 13 +
.../powersort/benchmark/CbmCompetition.java | 13 +
.../powersort/benchmark/Filter.java | 212 ++++----
.../uni_marburg/powersort/data/CglEnum.java | 33 ++
.../powersort/data/CompetitionEnum.java | 500 +++++++++++++++++
.../uni_marburg/powersort/data/DataEnum.java | 512 +-----------------
.../powersort/data/IntegerSerializer.java | 6 +-
12 files changed, 746 insertions(+), 626 deletions(-)
create mode 100644 app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
rename app/src/main/java/de/uni_marburg/powersort/benchmark/{Main.java => CbmBase.java} (87%)
create mode 100644 app/src/main/java/de/uni_marburg/powersort/benchmark/CbmCgl.java
create mode 100644 app/src/main/java/de/uni_marburg/powersort/benchmark/CbmCompetition.java
create mode 100644 app/src/main/java/de/uni_marburg/powersort/data/CglEnum.java
create mode 100644 app/src/main/java/de/uni_marburg/powersort/data/CompetitionEnum.java
diff --git a/README.md b/README.md
index 165230d..e81cd12 100644
--- a/README.md
+++ b/README.md
@@ -9,6 +9,8 @@ Implementation of Powersort with the aim of integrating it into OpenJDK. Benchma
* [Tasks](#tasks)
* [Test Cases](#test-cases)
* [Benchmark](#benchmark)
+ * [Custom](#custom)
+ * [JMH](#jmh)
<!-- TOC -->
## Setup
@@ -86,7 +88,29 @@ Run the task "test":
There are two different benchmarks. One is based on the JMH benchmark framework, the other one is a custom benchmark implementation.
+### Custom
+
+Run custom benchmark:
+
+```shell
+./gradlew runCbmCgl
+./gradlew runCbmCompetition
+```
+
+### JMH
+
+Run JMH benchmark:
+
```shell
./gradlew jmh
-./gradlew runCustomBenchmark
```
+
+IntelliJ plugin:
+
+The [JMH Java Microbenchmark Harness](https://plugins.jetbrains.com/plugin/7529-jmh-java-microbenchmark-harness) plugin allows running benchmarks from within the IDE in a similar way as JUnit test cases. This can be used for development but yields less accurate results.
+
+Further notes:
+
+- JHM: https://github.com/openjdk/jmh?tab=readme-ov-file#other-build-systems
+- We use the JMH Gradle plugin: https://github.com/melix/jmh-gradle-plugin
+- Sample JMH Gradle project: https://github.com/twoVersatile/jmhsample
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index e61acfb..1628776 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -22,7 +22,6 @@ val latestJmhVersion = "1.37"
dependencies {
// Use JUnit Jupiter for testing.
testImplementation(libs.junit.jupiter)
-
testRuntimeOnly("org.junit.platform:junit-platform-launcher")
// Required to use the IntelliJ plugin "JMH Java Microbenchmark Harness".
@@ -42,14 +41,21 @@ java {
// It is not possible to rename it.
// Thus, we remove it and add two custom named `JavaExec` tasks instead.
tasks.getByName("run") {
- enabled = false
description = "This task has been disabled. It does nothing o.O"
+ enabled = false
}
-tasks.register<JavaExec>("runCustomBenchmark") {
+tasks.register<JavaExec>("runCbmCgl") {
+ description = "Run Custom Benchmark (CBM) with Custom Generated Lists (CGL)"
group = "application"
classpath = sourceSets["main"].runtimeClasspath
- mainClass = "de.uni_marburg.powersort.benchmark.Main"
+ mainClass = "de.uni_marburg.powersort.benchmark.CbmCgl"
+}
+tasks.register<JavaExec>("runCbmCompetition") {
+ description = "Run Custom Benchmark (CBM) with Powersort competition lists"
+ group = "application"
+ classpath = sourceSets["main"].runtimeClasspath
+ mainClass = "de.uni_marburg.powersort.benchmark.CbmCompetition"
}
tasks.named<Test>("test") {
diff --git a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
new file mode 100644
index 0000000..ede8f4a
--- /dev/null
+++ b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
@@ -0,0 +1,31 @@
+package de.uni_marburg.powersort.benchmark;
+
+import de.uni_marburg.powersort.data.CglEnum;
+import de.uni_marburg.powersort.data.DataEnum;
+import de.uni_marburg.powersort.sort.SortEnum;
+import org.openjdk.jmh.annotations.Param;
+import org.openjdk.jmh.annotations.Scope;
+import org.openjdk.jmh.annotations.State;
+
+/*
+ * Benchmark state parameters
+ *
+ * Quote from JMH:
+ * State objects naturally encapsulate the state on which benchmark is working on.
+ */
+@State(Scope.Benchmark)
+public class JmhCgl extends JmhBase {
+ @Param()
+ CglEnum dataEnum;
+ @Param()
+ SortEnum sortEnum;
+
+ @Override
+ DataEnum getDataEnum(){
+ return dataEnum;
+ }
+ @Override
+ SortEnum getSortEnum(){
+ return sortEnum;
+ }
+}
diff --git a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCompetition.java b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCompetition.java
index 2fc07c6..f6b4cba 100644
--- a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCompetition.java
+++ b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCompetition.java
@@ -1,5 +1,6 @@
package de.uni_marburg.powersort.benchmark;
+import de.uni_marburg.powersort.data.CompetitionEnum;
import de.uni_marburg.powersort.data.DataEnum;
import de.uni_marburg.powersort.sort.SortEnum;
import org.openjdk.jmh.annotations.Param;
@@ -15,7 +16,7 @@ import org.openjdk.jmh.annotations.State;
@State(Scope.Benchmark)
public class JmhCompetition extends JmhBase {
@Param()
- DataEnum dataEnum;
+ CompetitionEnum dataEnum;
@Param()
SortEnum sortEnum;
diff --git a/app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java b/app/src/main/java/de/uni_marburg/powersort/benchmark/CbmBase.java
similarity index 87%
rename from app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java
rename to app/src/main/java/de/uni_marburg/powersort/benchmark/CbmBase.java
index 8eb858b..57172b4 100644
--- a/app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java
+++ b/app/src/main/java/de/uni_marburg/powersort/benchmark/CbmBase.java
@@ -7,13 +7,10 @@ import de.uni_marburg.powersort.data.ObjectSupplier;
import java.util.concurrent.TimeUnit;
/**
- * Custom benchmark.
+ * Custom Benchmark (CBM).
*/
-public class Main {
- public static void main(final String[] args) {
- final SortEnum[] sortImplementations = SortEnum.values();
- final DataEnum[] dataEnums = DataEnum.values();
-
+public class CbmBase {
+ static void run(SortEnum[] sortImplementations, DataEnum[] dataEnums) {
System.out.println();
for (DataEnum dataEnum : dataEnums) {
ObjectSupplier objectSupplier = null;
diff --git a/app/src/main/java/de/uni_marburg/powersort/benchmark/CbmCgl.java b/app/src/main/java/de/uni_marburg/powersort/benchmark/CbmCgl.java
new file mode 100644
index 0000000..bc8ec7a
--- /dev/null
+++ b/app/src/main/java/de/uni_marburg/powersort/benchmark/CbmCgl.java
@@ -0,0 +1,13 @@
+package de.uni_marburg.powersort.benchmark;
+
+import de.uni_marburg.powersort.data.CglEnum;
+import de.uni_marburg.powersort.sort.SortEnum;
+
+public class CbmCgl {
+ public static void main(String[] args) {
+ CbmBase.run(
+ SortEnum.values(),
+ CglEnum.values()
+ );
+ }
+}
diff --git a/app/src/main/java/de/uni_marburg/powersort/benchmark/CbmCompetition.java b/app/src/main/java/de/uni_marburg/powersort/benchmark/CbmCompetition.java
new file mode 100644
index 0000000..03f4d6a
--- /dev/null
+++ b/app/src/main/java/de/uni_marburg/powersort/benchmark/CbmCompetition.java
@@ -0,0 +1,13 @@
+package de.uni_marburg.powersort.benchmark;
+
+import de.uni_marburg.powersort.data.CompetitionEnum;
+import de.uni_marburg.powersort.sort.SortEnum;
+
+public class CbmCompetition {
+ public static void main(String[] args) {
+ CbmBase.run(
+ SortEnum.values(),
+ CompetitionEnum.values()
+ );
+ }
+}
diff --git a/app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java b/app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java
index a3d401f..353277b 100644
--- a/app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java
+++ b/app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java
@@ -1,5 +1,7 @@
package de.uni_marburg.powersort.benchmark;
+import de.uni_marburg.powersort.data.CglEnum;
+import de.uni_marburg.powersort.data.CompetitionEnum;
import de.uni_marburg.powersort.data.DataEnum;
import de.uni_marburg.powersort.data.IntegerSerializer;
import de.uni_marburg.powersort.sort.SortEnum;
@@ -7,6 +9,8 @@ import de.uni_marburg.powersort.sort.SortEnum;
import java.nio.file.Files;
import java.util.List;
+import static de.uni_marburg.powersort.data.CompetitionEnum.isCompetitionInput;
+
public class Filter {
/* Utility Class */
private Filter() {
@@ -15,22 +19,22 @@ public class Filter {
public static boolean isFiltered(DataEnum d, SortEnum s) {
// To skip some of the inputs for all sort algorithms, uncomment them here.
// if (List.of(
-// DataEnum.RANDOM_INTEGERS_300M,
-// DataEnum.ASCENDING_INTEGERS_300M,
-// DataEnum.DESCENDING_INTEGERS_250M,
-// DataEnum.ASCENDING_RUNS_1M,
-// DataEnum.ASCENDING_RUNS_WITH_OVERLAP_1M
+// CglEnum.RANDOM_INTEGERS_300M,
+// CglEnum.ASCENDING_INTEGERS_300M,
+// CglEnum.DESCENDING_INTEGERS_250M,
+// CglEnum.ASCENDING_RUNS_1M,
+// CglEnum.ASCENDING_RUNS_WITH_OVERLAP_1M
// ).contains(d)) {
// return true;
// }
// To skip all competition inputs, uncomment the next line.
-// if(d.isCompetitionInput()){
+// if(isCompetitionInput(d)){
// return true;
// }
// Skip some sort algorithms for all competition inputs.
- if(d.isCompetitionInput()){
+ if(isCompetitionInput(d)){
if(List.of(
SortEnum.BUBBLE_SORT,
SortEnum.MERGE_SORT
@@ -50,127 +54,127 @@ public class Filter {
if (s == SortEnum.QUICK_SORT) {
return List.of(
- DataEnum.RANDOM_INTEGERS_300M,
- DataEnum.ASCENDING_INTEGERS_300M,
- DataEnum.DESCENDING_INTEGERS_250M,
- DataEnum.ASCENDING_RUNS_1M,
- DataEnum.ASCENDING_RUNS_WITH_OVERLAP_1M,
+ CglEnum.RANDOM_INTEGERS_300M,
+ CglEnum.ASCENDING_INTEGERS_300M,
+ CglEnum.DESCENDING_INTEGERS_250M,
+ CglEnum.ASCENDING_RUNS_1M,
+ CglEnum.ASCENDING_RUNS_WITH_OVERLAP_1M,
- DataEnum.COMPETITION_34,
- DataEnum.COMPETITION_35,
- DataEnum.COMPETITION_36,
- DataEnum.COMPETITION_37,
- DataEnum.COMPETITION_38,
- DataEnum.COMPETITION_39,
- DataEnum.COMPETITION_83,
- DataEnum.COMPETITION_85,
- DataEnum.COMPETITION_153,
- DataEnum.COMPETITION_163,
- DataEnum.COMPETITION_164,
- DataEnum.COMPETITION_165,
- DataEnum.COMPETITION_166,
- DataEnum.COMPETITION_167,
- DataEnum.COMPETITION_168,
- DataEnum.COMPETITION_169,
- DataEnum.COMPETITION_170,
- DataEnum.COMPETITION_171,
- DataEnum.COMPETITION_172,
- DataEnum.COMPETITION_173,
- DataEnum.COMPETITION_174,
- DataEnum.COMPETITION_181,
- DataEnum.COMPETITION_182,
- DataEnum.COMPETITION_183,
- DataEnum.COMPETITION_184,
- DataEnum.COMPETITION_185,
- DataEnum.COMPETITION_186,
- DataEnum.COMPETITION_187,
- DataEnum.COMPETITION_205,
- DataEnum.COMPETITION_206,
- DataEnum.COMPETITION_207,
- DataEnum.COMPETITION_213,
- DataEnum.COMPETITION_214,
- DataEnum.COMPETITION_216,
- DataEnum.COMPETITION_218,
- DataEnum.COMPETITION_220,
- DataEnum.COMPETITION_222,
- DataEnum.COMPETITION_225,
- DataEnum.COMPETITION_226,
- DataEnum.COMPETITION_228,
- DataEnum.COMPETITION_231,
- DataEnum.COMPETITION_232,
- DataEnum.COMPETITION_235,
- DataEnum.COMPETITION_236
+ CompetitionEnum.COMPETITION_34,
+ CompetitionEnum.COMPETITION_35,
+ CompetitionEnum.COMPETITION_36,
+ CompetitionEnum.COMPETITION_37,
+ CompetitionEnum.COMPETITION_38,
+ CompetitionEnum.COMPETITION_39,
+ CompetitionEnum.COMPETITION_83,
+ CompetitionEnum.COMPETITION_85,
+ CompetitionEnum.COMPETITION_153,
+ CompetitionEnum.COMPETITION_163,
+ CompetitionEnum.COMPETITION_164,
+ CompetitionEnum.COMPETITION_165,
+ CompetitionEnum.COMPETITION_166,
+ CompetitionEnum.COMPETITION_167,
+ CompetitionEnum.COMPETITION_168,
+ CompetitionEnum.COMPETITION_169,
+ CompetitionEnum.COMPETITION_170,
+ CompetitionEnum.COMPETITION_171,
+ CompetitionEnum.COMPETITION_172,
+ CompetitionEnum.COMPETITION_173,
+ CompetitionEnum.COMPETITION_174,
+ CompetitionEnum.COMPETITION_181,
+ CompetitionEnum.COMPETITION_182,
+ CompetitionEnum.COMPETITION_183,
+ CompetitionEnum.COMPETITION_184,
+ CompetitionEnum.COMPETITION_185,
+ CompetitionEnum.COMPETITION_186,
+ CompetitionEnum.COMPETITION_187,
+ CompetitionEnum.COMPETITION_205,
+ CompetitionEnum.COMPETITION_206,
+ CompetitionEnum.COMPETITION_207,
+ CompetitionEnum.COMPETITION_213,
+ CompetitionEnum.COMPETITION_214,
+ CompetitionEnum.COMPETITION_216,
+ CompetitionEnum.COMPETITION_218,
+ CompetitionEnum.COMPETITION_220,
+ CompetitionEnum.COMPETITION_222,
+ CompetitionEnum.COMPETITION_225,
+ CompetitionEnum.COMPETITION_226,
+ CompetitionEnum.COMPETITION_228,
+ CompetitionEnum.COMPETITION_231,
+ CompetitionEnum.COMPETITION_232,
+ CompetitionEnum.COMPETITION_235,
+ CompetitionEnum.COMPETITION_236
).contains(d);
}
if (s == SortEnum.MERGE_SORT) {
return List.of(
- DataEnum.RANDOM_INTEGERS_300M,
- DataEnum.ASCENDING_INTEGERS_300M,
- DataEnum.DESCENDING_INTEGERS_250M
+ CglEnum.RANDOM_INTEGERS_300M,
+ CglEnum.ASCENDING_INTEGERS_300M,
+ CglEnum.DESCENDING_INTEGERS_250M
).contains(d);
}
if (s == SortEnum.BUBBLE_SORT) {
return List.of(
- DataEnum.DESCENDING_INTEGERS_250M,
- DataEnum.ASCENDING_RUNS_1M,
- DataEnum.ASCENDING_RUNS_WITH_OVERLAP_1M
+ CglEnum.DESCENDING_INTEGERS_250M,
+ CglEnum.ASCENDING_RUNS_1M,
+ CglEnum.ASCENDING_RUNS_WITH_OVERLAP_1M
).contains(d);
}
// TODO: Remove this once performance of FinnSort improved
if (s == SortEnum.FINN_SORT) {
return List.of(
- DataEnum.DESCENDING_INTEGERS_250M,
- DataEnum.ASCENDING_RUNS_1M,
+ CglEnum.DESCENDING_INTEGERS_250M,
+ CglEnum.ASCENDING_RUNS_1M,
- DataEnum.COMPETITION_83,
- DataEnum.COMPETITION_85,
- DataEnum.COMPETITION_153,
- DataEnum.COMPETITION_163,
- DataEnum.COMPETITION_164,
- DataEnum.COMPETITION_165,
- DataEnum.COMPETITION_166,
- DataEnum.COMPETITION_167,
- DataEnum.COMPETITION_168,
- DataEnum.COMPETITION_169,
- DataEnum.COMPETITION_170,
- DataEnum.COMPETITION_171,
- DataEnum.COMPETITION_172,
- DataEnum.COMPETITION_173,
- DataEnum.COMPETITION_174,
- DataEnum.COMPETITION_181,
- DataEnum.COMPETITION_182,
- DataEnum.COMPETITION_183,
- DataEnum.COMPETITION_184,
- DataEnum.COMPETITION_185,
- DataEnum.COMPETITION_186,
- DataEnum.COMPETITION_187,
- DataEnum.COMPETITION_198,
- DataEnum.COMPETITION_199,
- DataEnum.COMPETITION_205,
- DataEnum.COMPETITION_206,
- DataEnum.COMPETITION_207,
- DataEnum.COMPETITION_213,
- DataEnum.COMPETITION_214,
- DataEnum.COMPETITION_216,
- DataEnum.COMPETITION_218,
- DataEnum.COMPETITION_220,
- DataEnum.COMPETITION_222,
- DataEnum.COMPETITION_226,
- DataEnum.COMPETITION_228,
- DataEnum.COMPETITION_231,
- DataEnum.COMPETITION_232,
- DataEnum.COMPETITION_236
+ CompetitionEnum.COMPETITION_83,
+ CompetitionEnum.COMPETITION_85,
+ CompetitionEnum.COMPETITION_153,
+ CompetitionEnum.COMPETITION_163,
+ CompetitionEnum.COMPETITION_164,
+ CompetitionEnum.COMPETITION_165,
+ CompetitionEnum.COMPETITION_166,
+ CompetitionEnum.COMPETITION_167,
+ CompetitionEnum.COMPETITION_168,
+ CompetitionEnum.COMPETITION_169,
+ CompetitionEnum.COMPETITION_170,
+ CompetitionEnum.COMPETITION_171,
+ CompetitionEnum.COMPETITION_172,
+ CompetitionEnum.COMPETITION_173,
+ CompetitionEnum.COMPETITION_174,
+ CompetitionEnum.COMPETITION_181,
+ CompetitionEnum.COMPETITION_182,
+ CompetitionEnum.COMPETITION_183,
+ CompetitionEnum.COMPETITION_184,
+ CompetitionEnum.COMPETITION_185,
+ CompetitionEnum.COMPETITION_186,
+ CompetitionEnum.COMPETITION_187,
+ CompetitionEnum.COMPETITION_198,
+ CompetitionEnum.COMPETITION_199,
+ CompetitionEnum.COMPETITION_205,
+ CompetitionEnum.COMPETITION_206,
+ CompetitionEnum.COMPETITION_207,
+ CompetitionEnum.COMPETITION_213,
+ CompetitionEnum.COMPETITION_214,
+ CompetitionEnum.COMPETITION_216,
+ CompetitionEnum.COMPETITION_218,
+ CompetitionEnum.COMPETITION_220,
+ CompetitionEnum.COMPETITION_222,
+ CompetitionEnum.COMPETITION_226,
+ CompetitionEnum.COMPETITION_228,
+ CompetitionEnum.COMPETITION_231,
+ CompetitionEnum.COMPETITION_232,
+ CompetitionEnum.COMPETITION_236
).contains(d);
}
// TODO: Remove this once performance of ASort improved
if (s == SortEnum.ASORT) {
return List.of(
- DataEnum.COMPETITION_173,
- DataEnum.COMPETITION_174
+ CompetitionEnum.COMPETITION_173,
+ CompetitionEnum.COMPETITION_174
).contains(d);
}
diff --git a/app/src/main/java/de/uni_marburg/powersort/data/CglEnum.java b/app/src/main/java/de/uni_marburg/powersort/data/CglEnum.java
new file mode 100644
index 0000000..94da3e1
--- /dev/null
+++ b/app/src/main/java/de/uni_marburg/powersort/data/CglEnum.java
@@ -0,0 +1,33 @@
+package de.uni_marburg.powersort.data;
+
+/**
+ * Enumeration of Custom Generated Lists (CGL).
+ */
+public enum CglEnum implements DataEnum{
+ RANDOM_INTEGERS_300M,
+ ASCENDING_INTEGERS_300M,
+ DESCENDING_INTEGERS_250M,
+ ASCENDING_RUNS_1M,
+ ASCENDING_RUNS_WITH_OVERLAP_1M;
+
+ @Override
+ public ObjectSupplier getObjectSupplier() {
+ // We use a seed to get the same random list every time -> Repeatable benchmarks on same input data!
+ // final long seed = 3651660232967549736L; // System.nanoTime() ++ Math.random()
+ final long seed = 140506881906827520L; // (long) 'P' * (long) 'O' *(long) 'W' * (long) 'E' * (long) 'R' * (long) 'S' * (long) 'O' * (long) 'R' * (long) 'T';
+
+ int longListSize = 300_000_000; // Any larger: Out of Heap Space. TODO GRADLE config
+ int middleListSize = 250_000_000;
+ int runs = 1_000;
+ int runLength = 1_000;
+
+ return switch (this) {
+ case RANDOM_INTEGERS_300M -> new RandomIntegers(longListSize, seed);
+ case ASCENDING_INTEGERS_300M -> new AscendingIntegers(longListSize);
+ case DESCENDING_INTEGERS_250M -> new DescendingIntegers(middleListSize);
+ case ASCENDING_RUNS_1M -> AscendingRuns.newAscendingRuns(runs, runLength, -runLength);
+ case ASCENDING_RUNS_WITH_OVERLAP_1M ->
+ AscendingRuns.newAscendingRuns(runs, runLength, (int) (-0.5 * runLength));
+ };
+ }
+}
diff --git a/app/src/main/java/de/uni_marburg/powersort/data/CompetitionEnum.java b/app/src/main/java/de/uni_marburg/powersort/data/CompetitionEnum.java
new file mode 100644
index 0000000..074a7ab
--- /dev/null
+++ b/app/src/main/java/de/uni_marburg/powersort/data/CompetitionEnum.java
@@ -0,0 +1,500 @@
+package de.uni_marburg.powersort.data;
+
+/**
+ * Enumeration of integer lists from the Powersort competition.
+ */
+public enum CompetitionEnum implements DataEnum {
+ COMPETITION_1,
+ COMPETITION_2,
+ COMPETITION_3,
+ // COMPETITION_4, // Invalid input file.
+ COMPETITION_5,
+ COMPETITION_6,
+ COMPETITION_7,
+ COMPETITION_8,
+ COMPETITION_9,
+ COMPETITION_10,
+ COMPETITION_11,
+ COMPETITION_12,
+ COMPETITION_13,
+ // COMPETITION_14, // Invalid input file.
+ COMPETITION_15,
+ COMPETITION_16,
+ COMPETITION_17,
+ COMPETITION_18,
+ COMPETITION_19,
+ COMPETITION_20,
+ COMPETITION_21,
+ COMPETITION_22,
+ COMPETITION_23,
+ COMPETITION_24,
+ COMPETITION_25,
+ COMPETITION_26,
+ COMPETITION_27,
+ COMPETITION_28,
+ COMPETITION_29,
+ COMPETITION_30,
+ COMPETITION_31,
+ COMPETITION_32,
+ COMPETITION_33,
+ COMPETITION_34,
+ COMPETITION_35,
+ COMPETITION_36,
+ COMPETITION_37,
+ COMPETITION_38,
+ COMPETITION_39,
+ COMPETITION_40,
+ COMPETITION_41,
+ COMPETITION_42,
+ COMPETITION_43,
+ COMPETITION_44,
+ COMPETITION_45,
+ COMPETITION_46,
+ COMPETITION_47,
+ COMPETITION_48,
+ COMPETITION_49,
+ COMPETITION_50,
+ COMPETITION_51,
+ COMPETITION_52,
+ COMPETITION_53,
+ COMPETITION_54,
+ COMPETITION_55,
+ COMPETITION_56,
+ COMPETITION_57,
+ COMPETITION_58,
+ COMPETITION_59,
+ COMPETITION_60,
+ COMPETITION_61,
+ COMPETITION_62,
+ COMPETITION_63,
+ COMPETITION_64,
+ COMPETITION_65,
+ COMPETITION_66,
+ COMPETITION_67,
+ COMPETITION_68,
+ COMPETITION_69,
+ COMPETITION_70,
+ COMPETITION_71,
+ COMPETITION_72,
+ COMPETITION_73,
+ COMPETITION_74,
+ COMPETITION_75,
+ COMPETITION_76,
+ COMPETITION_77,
+ COMPETITION_78,
+ COMPETITION_79,
+ COMPETITION_80,
+ COMPETITION_81,
+ COMPETITION_82,
+ COMPETITION_83,
+ COMPETITION_84,
+ COMPETITION_85,
+ COMPETITION_86,
+ COMPETITION_87,
+ COMPETITION_88,
+ COMPETITION_89,
+ COMPETITION_90,
+ COMPETITION_91,
+ COMPETITION_92,
+ COMPETITION_93,
+ COMPETITION_94,
+ COMPETITION_95,
+ COMPETITION_96,
+ COMPETITION_97,
+ // COMPETITION_98, // Invalid input file (floats not integers).
+ COMPETITION_99,
+ COMPETITION_100,
+ COMPETITION_101,
+ COMPETITION_102,
+ COMPETITION_103,
+ COMPETITION_104,
+ COMPETITION_105,
+ COMPETITION_106,
+ COMPETITION_107,
+ COMPETITION_108,
+ COMPETITION_109,
+ COMPETITION_110,
+ COMPETITION_111,
+ COMPETITION_112,
+ COMPETITION_113,
+ COMPETITION_114,
+ COMPETITION_115,
+ COMPETITION_116,
+ COMPETITION_117,
+ COMPETITION_118,
+ COMPETITION_119,
+ COMPETITION_120,
+ COMPETITION_121,
+ COMPETITION_122,
+ COMPETITION_123,
+ COMPETITION_124,
+ COMPETITION_125,
+ COMPETITION_126,
+ COMPETITION_127,
+ COMPETITION_128,
+ COMPETITION_129,
+ COMPETITION_130,
+ COMPETITION_131,
+ COMPETITION_132,
+ COMPETITION_133,
+ COMPETITION_134,
+ COMPETITION_135,
+ COMPETITION_136,
+ COMPETITION_137,
+ COMPETITION_138,
+ COMPETITION_139,
+ COMPETITION_140,
+ COMPETITION_141,
+ COMPETITION_142,
+ COMPETITION_143,
+ COMPETITION_144,
+ COMPETITION_145,
+ COMPETITION_146,
+ COMPETITION_147,
+ COMPETITION_148,
+ COMPETITION_149,
+ COMPETITION_150,
+ COMPETITION_151,
+ COMPETITION_152,
+ COMPETITION_153,
+ COMPETITION_154,
+ COMPETITION_155,
+ COMPETITION_156,
+ COMPETITION_157,
+ COMPETITION_158,
+ COMPETITION_159,
+ COMPETITION_160,
+ COMPETITION_161,
+ COMPETITION_162,
+ COMPETITION_163,
+ COMPETITION_164,
+ COMPETITION_165,
+ COMPETITION_166,
+ COMPETITION_167,
+ COMPETITION_168,
+ COMPETITION_169,
+ COMPETITION_170,
+ COMPETITION_171,
+ COMPETITION_172,
+ COMPETITION_173,
+ COMPETITION_174,
+ COMPETITION_175,
+ COMPETITION_176,
+ COMPETITION_177,
+ COMPETITION_178,
+ COMPETITION_179,
+ COMPETITION_180,
+ COMPETITION_181,
+ COMPETITION_182,
+ COMPETITION_183,
+ COMPETITION_184,
+ COMPETITION_185,
+ COMPETITION_186,
+ COMPETITION_187,
+ COMPETITION_188,
+ COMPETITION_189,
+ COMPETITION_190,
+ COMPETITION_191,
+ COMPETITION_192,
+ COMPETITION_193,
+ COMPETITION_194,
+ COMPETITION_195,
+ COMPETITION_196,
+ COMPETITION_197,
+ COMPETITION_198,
+ COMPETITION_199,
+ COMPETITION_200,
+ COMPETITION_201,
+ COMPETITION_202,
+ COMPETITION_203,
+ COMPETITION_204,
+ COMPETITION_205,
+ COMPETITION_206,
+ COMPETITION_207,
+ COMPETITION_208,
+ COMPETITION_209,
+ COMPETITION_210,
+ COMPETITION_211,
+ COMPETITION_212,
+ COMPETITION_213,
+ COMPETITION_214,
+ COMPETITION_215,
+ COMPETITION_216,
+ COMPETITION_217,
+ COMPETITION_218,
+ COMPETITION_219,
+ COMPETITION_220,
+ COMPETITION_221,
+ COMPETITION_222,
+ COMPETITION_223,
+ COMPETITION_224,
+ COMPETITION_225,
+ COMPETITION_226,
+ COMPETITION_227,
+ COMPETITION_228,
+ COMPETITION_229,
+ COMPETITION_230,
+ COMPETITION_231,
+ COMPETITION_232,
+ COMPETITION_233,
+ COMPETITION_234,
+ COMPETITION_235,
+ COMPETITION_236,
+ COMPETITION_237,
+ COMPETITION_238;
+
+ public static final String COMPETITION_PREFIX = "COMPETITION_";
+
+ public static boolean isCompetitionInput(DataEnum dataEnum) {
+ if (dataEnum instanceof CompetitionEnum) {
+ return ((CompetitionEnum) dataEnum).isCompetitionInput();
+ } else {
+ return false;
+ }
+ }
+
+ public boolean isCompetitionInput() {
+ return this.toString().startsWith(COMPETITION_PREFIX);
+ }
+
+ @Override
+ public ObjectSupplier getObjectSupplier() {
+ return switch (this) {
+ case COMPETITION_1 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_2 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_3 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_5 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_6 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_7 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_8 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_9 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_10 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_11 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_12 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_13 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_15 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_16 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_17 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_18 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_19 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_20 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_21 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_22 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_23 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_24 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_25 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_26 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_27 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_28 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_29 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_30 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_31 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_32 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_33 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_34 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_35 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_36 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_37 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_38 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_39 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_40 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_41 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_42 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_43 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_44 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_45 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_46 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_47 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_48 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_49 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_50 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_51 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_52 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_53 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_54 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_55 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_56 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_57 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_58 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_59 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_60 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_61 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_62 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_63 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_64 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_65 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_66 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_67 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_68 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_69 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_70 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_71 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_72 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_73 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_74 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_75 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_76 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_77 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_78 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_79 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_80 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_81 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_82 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_83 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_84 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_85 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_86 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_87 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_88 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_89 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_90 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_91 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_92 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_93 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_94 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_95 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_96 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_97 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_99 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_100 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_101 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_102 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_103 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_104 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_105 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_106 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_107 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_108 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_109 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_110 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_111 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_112 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_113 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_114 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_115 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_116 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_117 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_118 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_119 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_120 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_121 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_122 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_123 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_124 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_125 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_126 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_127 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_128 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_129 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_130 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_131 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_132 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_133 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_134 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_135 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_136 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_137 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_138 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_139 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_140 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_141 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_142 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_143 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_144 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_145 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_146 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_147 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_148 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_149 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_150 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_151 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_152 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_153 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_154 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_155 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_156 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_157 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_158 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_159 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_160 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_161 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_162 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_163 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_164 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_165 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_166 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_167 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_168 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_169 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_170 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_171 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_172 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_173 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_174 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_175 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_176 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_177 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_178 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_179 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_180 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_181 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_182 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_183 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_184 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_185 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_186 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_187 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_188 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_189 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_190 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_191 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_192 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_193 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_194 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_195 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_196 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_197 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_198 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_199 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_200 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_201 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_202 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_203 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_204 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_205 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_206 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_207 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_208 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_209 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_210 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_211 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_212 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_213 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_214 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_215 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_216 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_217 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_218 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_219 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_220 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_221 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_222 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_223 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_224 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_225 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_226 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_227 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_228 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_229 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_230 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_231 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_232 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_233 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_234 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_235 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_236 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_237 -> IntegerSerializer.fromEnum(this);
+ case COMPETITION_238 -> IntegerSerializer.fromEnum(this);
+ };
+ }
+}
diff --git a/app/src/main/java/de/uni_marburg/powersort/data/DataEnum.java b/app/src/main/java/de/uni_marburg/powersort/data/DataEnum.java
index e6aa2b9..ce2c2b4 100644
--- a/app/src/main/java/de/uni_marburg/powersort/data/DataEnum.java
+++ b/app/src/main/java/de/uni_marburg/powersort/data/DataEnum.java
@@ -1,510 +1,8 @@
package de.uni_marburg.powersort.data;
-public enum DataEnum {
- RANDOM_INTEGERS_300M,
- ASCENDING_INTEGERS_300M,
- DESCENDING_INTEGERS_250M,
- ASCENDING_RUNS_1M,
- ASCENDING_RUNS_WITH_OVERLAP_1M,
-
- COMPETITION_1,
- COMPETITION_2,
- COMPETITION_3,
-// COMPETITION_4, // Invalid input file.
- COMPETITION_5,
- COMPETITION_6,
- COMPETITION_7,
- COMPETITION_8,
- COMPETITION_9,
- COMPETITION_10,
- COMPETITION_11,
- COMPETITION_12,
- COMPETITION_13,
-// COMPETITION_14, // Invalid input file.
- COMPETITION_15,
- COMPETITION_16,
- COMPETITION_17,
- COMPETITION_18,
- COMPETITION_19,
- COMPETITION_20,
- COMPETITION_21,
- COMPETITION_22,
- COMPETITION_23,
- COMPETITION_24,
- COMPETITION_25,
- COMPETITION_26,
- COMPETITION_27,
- COMPETITION_28,
- COMPETITION_29,
- COMPETITION_30,
- COMPETITION_31,
- COMPETITION_32,
- COMPETITION_33,
- COMPETITION_34,
- COMPETITION_35,
- COMPETITION_36,
- COMPETITION_37,
- COMPETITION_38,
- COMPETITION_39,
- COMPETITION_40,
- COMPETITION_41,
- COMPETITION_42,
- COMPETITION_43,
- COMPETITION_44,
- COMPETITION_45,
- COMPETITION_46,
- COMPETITION_47,
- COMPETITION_48,
- COMPETITION_49,
- COMPETITION_50,
- COMPETITION_51,
- COMPETITION_52,
- COMPETITION_53,
- COMPETITION_54,
- COMPETITION_55,
- COMPETITION_56,
- COMPETITION_57,
- COMPETITION_58,
- COMPETITION_59,
- COMPETITION_60,
- COMPETITION_61,
- COMPETITION_62,
- COMPETITION_63,
- COMPETITION_64,
- COMPETITION_65,
- COMPETITION_66,
- COMPETITION_67,
- COMPETITION_68,
- COMPETITION_69,
- COMPETITION_70,
- COMPETITION_71,
- COMPETITION_72,
- COMPETITION_73,
- COMPETITION_74,
- COMPETITION_75,
- COMPETITION_76,
- COMPETITION_77,
- COMPETITION_78,
- COMPETITION_79,
- COMPETITION_80,
- COMPETITION_81,
- COMPETITION_82,
- COMPETITION_83,
- COMPETITION_84,
- COMPETITION_85,
- COMPETITION_86,
- COMPETITION_87,
- COMPETITION_88,
- COMPETITION_89,
- COMPETITION_90,
- COMPETITION_91,
- COMPETITION_92,
- COMPETITION_93,
- COMPETITION_94,
- COMPETITION_95,
- COMPETITION_96,
- COMPETITION_97,
-// COMPETITION_98, // Invalid input file (floats not integers).
- COMPETITION_99,
- COMPETITION_100,
- COMPETITION_101,
- COMPETITION_102,
- COMPETITION_103,
- COMPETITION_104,
- COMPETITION_105,
- COMPETITION_106,
- COMPETITION_107,
- COMPETITION_108,
- COMPETITION_109,
- COMPETITION_110,
- COMPETITION_111,
- COMPETITION_112,
- COMPETITION_113,
- COMPETITION_114,
- COMPETITION_115,
- COMPETITION_116,
- COMPETITION_117,
- COMPETITION_118,
- COMPETITION_119,
- COMPETITION_120,
- COMPETITION_121,
- COMPETITION_122,
- COMPETITION_123,
- COMPETITION_124,
- COMPETITION_125,
- COMPETITION_126,
- COMPETITION_127,
- COMPETITION_128,
- COMPETITION_129,
- COMPETITION_130,
- COMPETITION_131,
- COMPETITION_132,
- COMPETITION_133,
- COMPETITION_134,
- COMPETITION_135,
- COMPETITION_136,
- COMPETITION_137,
- COMPETITION_138,
- COMPETITION_139,
- COMPETITION_140,
- COMPETITION_141,
- COMPETITION_142,
- COMPETITION_143,
- COMPETITION_144,
- COMPETITION_145,
- COMPETITION_146,
- COMPETITION_147,
- COMPETITION_148,
- COMPETITION_149,
- COMPETITION_150,
- COMPETITION_151,
- COMPETITION_152,
- COMPETITION_153,
- COMPETITION_154,
- COMPETITION_155,
- COMPETITION_156,
- COMPETITION_157,
- COMPETITION_158,
- COMPETITION_159,
- COMPETITION_160,
- COMPETITION_161,
- COMPETITION_162,
- COMPETITION_163,
- COMPETITION_164,
- COMPETITION_165,
- COMPETITION_166,
- COMPETITION_167,
- COMPETITION_168,
- COMPETITION_169,
- COMPETITION_170,
- COMPETITION_171,
- COMPETITION_172,
- COMPETITION_173,
- COMPETITION_174,
- COMPETITION_175,
- COMPETITION_176,
- COMPETITION_177,
- COMPETITION_178,
- COMPETITION_179,
- COMPETITION_180,
- COMPETITION_181,
- COMPETITION_182,
- COMPETITION_183,
- COMPETITION_184,
- COMPETITION_185,
- COMPETITION_186,
- COMPETITION_187,
- COMPETITION_188,
- COMPETITION_189,
- COMPETITION_190,
- COMPETITION_191,
- COMPETITION_192,
- COMPETITION_193,
- COMPETITION_194,
- COMPETITION_195,
- COMPETITION_196,
- COMPETITION_197,
- COMPETITION_198,
- COMPETITION_199,
- COMPETITION_200,
- COMPETITION_201,
- COMPETITION_202,
- COMPETITION_203,
- COMPETITION_204,
- COMPETITION_205,
- COMPETITION_206,
- COMPETITION_207,
- COMPETITION_208,
- COMPETITION_209,
- COMPETITION_210,
- COMPETITION_211,
- COMPETITION_212,
- COMPETITION_213,
- COMPETITION_214,
- COMPETITION_215,
- COMPETITION_216,
- COMPETITION_217,
- COMPETITION_218,
- COMPETITION_219,
- COMPETITION_220,
- COMPETITION_221,
- COMPETITION_222,
- COMPETITION_223,
- COMPETITION_224,
- COMPETITION_225,
- COMPETITION_226,
- COMPETITION_227,
- COMPETITION_228,
- COMPETITION_229,
- COMPETITION_230,
- COMPETITION_231,
- COMPETITION_232,
- COMPETITION_233,
- COMPETITION_234,
- COMPETITION_235,
- COMPETITION_236,
- COMPETITION_237,
- COMPETITION_238;
-
- public static final String COMPETITION_PREFIX = "COMPETITION_";
-
- public boolean isCompetitionInput(){
- return this.toString().startsWith(COMPETITION_PREFIX);
- }
-
- public ObjectSupplier getObjectSupplier() {
- // We use a seed to get the same random list every time -> Repeatable benchmarks on same input data!
- // final long seed = 3651660232967549736L; // System.nanoTime() ++ Math.random()
- final long seed = 140506881906827520L; // (long) 'P' * (long) 'O' *(long) 'W' * (long) 'E' * (long) 'R' * (long) 'S' * (long) 'O' * (long) 'R' * (long) 'T';
-
- int longListSize = 300_000_000; // Any larger: Out of Heap Space. TODO GRADLE config
- int middleListSize = 250_000_000;
- int runs = 1_000;
- int runLength = 1_000;
-
- return switch (this) {
- case RANDOM_INTEGERS_300M -> new RandomIntegers(longListSize, seed);
- case ASCENDING_INTEGERS_300M -> new AscendingIntegers(longListSize);
- case DESCENDING_INTEGERS_250M -> new DescendingIntegers(middleListSize);
- case ASCENDING_RUNS_1M -> AscendingRuns.newAscendingRuns(runs, runLength, -runLength);
- case ASCENDING_RUNS_WITH_OVERLAP_1M ->
- AscendingRuns.newAscendingRuns(runs, runLength, (int) (-0.5 * runLength));
-
- case COMPETITION_1 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_2 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_3 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_5 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_6 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_7 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_8 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_9 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_10 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_11 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_12 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_13 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_15 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_16 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_17 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_18 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_19 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_20 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_21 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_22 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_23 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_24 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_25 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_26 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_27 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_28 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_29 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_30 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_31 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_32 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_33 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_34 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_35 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_36 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_37 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_38 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_39 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_40 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_41 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_42 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_43 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_44 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_45 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_46 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_47 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_48 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_49 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_50 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_51 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_52 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_53 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_54 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_55 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_56 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_57 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_58 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_59 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_60 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_61 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_62 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_63 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_64 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_65 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_66 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_67 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_68 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_69 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_70 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_71 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_72 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_73 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_74 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_75 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_76 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_77 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_78 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_79 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_80 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_81 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_82 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_83 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_84 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_85 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_86 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_87 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_88 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_89 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_90 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_91 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_92 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_93 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_94 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_95 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_96 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_97 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_99 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_100 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_101 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_102 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_103 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_104 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_105 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_106 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_107 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_108 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_109 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_110 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_111 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_112 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_113 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_114 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_115 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_116 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_117 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_118 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_119 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_120 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_121 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_122 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_123 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_124 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_125 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_126 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_127 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_128 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_129 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_130 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_131 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_132 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_133 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_134 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_135 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_136 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_137 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_138 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_139 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_140 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_141 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_142 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_143 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_144 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_145 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_146 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_147 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_148 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_149 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_150 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_151 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_152 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_153 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_154 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_155 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_156 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_157 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_158 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_159 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_160 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_161 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_162 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_163 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_164 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_165 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_166 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_167 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_168 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_169 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_170 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_171 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_172 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_173 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_174 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_175 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_176 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_177 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_178 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_179 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_180 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_181 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_182 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_183 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_184 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_185 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_186 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_187 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_188 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_189 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_190 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_191 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_192 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_193 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_194 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_195 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_196 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_197 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_198 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_199 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_200 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_201 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_202 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_203 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_204 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_205 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_206 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_207 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_208 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_209 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_210 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_211 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_212 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_213 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_214 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_215 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_216 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_217 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_218 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_219 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_220 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_221 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_222 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_223 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_224 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_225 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_226 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_227 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_228 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_229 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_230 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_231 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_232 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_233 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_234 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_235 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_236 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_237 -> IntegerSerializer.fromEnum(this);
- case COMPETITION_238 -> IntegerSerializer.fromEnum(this);
- };
- }
+/**
+ * Interface for generic usage of different concrete Enum classes.
+ */
+public interface DataEnum {
+ ObjectSupplier getObjectSupplier();
}
diff --git a/app/src/main/java/de/uni_marburg/powersort/data/IntegerSerializer.java b/app/src/main/java/de/uni_marburg/powersort/data/IntegerSerializer.java
index 6604256..ef417a0 100644
--- a/app/src/main/java/de/uni_marburg/powersort/data/IntegerSerializer.java
+++ b/app/src/main/java/de/uni_marburg/powersort/data/IntegerSerializer.java
@@ -11,13 +11,13 @@ public class IntegerSerializer {
private final int id;
- public static ObjectSupplier fromEnum(DataEnum dataEnum) {
- if(!dataEnum.isCompetitionInput()){
+ public static ObjectSupplier fromEnum(CompetitionEnum dataEnum) {
+ if (!dataEnum.isCompetitionInput()) {
throw new IllegalArgumentException();
}
String prefixedId = dataEnum.toString();
- IntegerSerializer serializer = new IntegerSerializer(Integer.parseInt(prefixedId.substring(DataEnum.COMPETITION_PREFIX.length())));
+ IntegerSerializer serializer = new IntegerSerializer(Integer.parseInt(prefixedId.substring(CompetitionEnum.COMPETITION_PREFIX.length())));
return serializer.getObjectSupplier();
}
From 20bd4629b38b2fc79e25aed917d7ed7a5d99e9f2 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 7 Jan 2025 17:54:06 +0000
Subject: [PATCH 34/70] benchmark: JMH IntelliJ plugin
---
README.md | 21 +++++++++++++-----
app/build.gradle.kts | 4 +++-
.../powersort/benchmark/JmhBase.java | 6 -----
.../powersort/benchmark/JmhCgl.java | 9 ++++++++
.../powersort/benchmark/JmhCompetition.java | 6 +++++
intellij-jmh.png | Bin 0 -> 14199 bytes
6 files changed, 34 insertions(+), 12 deletions(-)
create mode 100644 intellij-jmh.png
diff --git a/README.md b/README.md
index e81cd12..023dc9d 100644
--- a/README.md
+++ b/README.md
@@ -39,7 +39,7 @@ This should include version >= 23, e.g.:
### Development Setup with nix
-The provided [shell.nix](shell.nix) file can be used to set up a development environment with IntelliJ. The only prerequisite is to have a working `nix` installation for which there are multiple possibilities, e.g:
+The provided [./shell.nix](./shell.nix) file can be used to set up a development environment with IntelliJ. The only prerequisite is to have a working `nix` installation for which there are multiple possibilities, e.g:
```shell
# https://github.com/DeterminateSystems/nix-installer?tab=readme-ov-file#determinate-nix-installer
@@ -90,26 +90,37 @@ There are two different benchmarks. One is based on the JMH benchmark framework,
### Custom
-Run custom benchmark:
+Run Custom Benchmark (CGM) with
+
+- Custom Generated Lists (CGL):
```shell
./gradlew runCbmCgl
+```
+
+- Powersort competition lists:
+
+```shell
./gradlew runCbmCompetition
```
### JMH
-Run JMH benchmark:
+#### Run JMH with CGL and Powersort competition lists
```shell
./gradlew jmh
```
-IntelliJ plugin:
+- To benchmark only one of the different list collections, see `jmh { excludes }` at the bottom of [./app/build.gradle.kts](./app/build.gradle.kts).
+
+#### IntelliJ plugin
The [JMH Java Microbenchmark Harness](https://plugins.jetbrains.com/plugin/7529-jmh-java-microbenchmark-harness) plugin allows running benchmarks from within the IDE in a similar way as JUnit test cases. This can be used for development but yields less accurate results.
-Further notes:
+
+
+#### Further notes
- JHM: https://github.com/openjdk/jmh?tab=readme-ov-file#other-build-systems
- We use the JMH Gradle plugin: https://github.com/melix/jmh-gradle-plugin
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index 1628776..6aadce9 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -83,6 +83,8 @@ jmh {
forceGC = true
excludes = listOf(
- "de.uni_marburg.powersort.benchmark.JmhBase.benchmark",
+ // To skip JmhCgl or JmhCompetition, uncomment it below.
+// "de.uni_marburg.powersort.benchmark.JmhCgl.benchmark",
+// "de.uni_marburg.powersort.benchmark.JmhCompetition.benchmark",
)
}
diff --git a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhBase.java b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhBase.java
index 237af37..f8b3e81 100644
--- a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhBase.java
+++ b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhBase.java
@@ -4,7 +4,6 @@ import de.uni_marburg.powersort.data.DataEnum;
import de.uni_marburg.powersort.data.ObjectSupplier;
import de.uni_marburg.powersort.sort.SortEnum;
import de.uni_marburg.powersort.sort.SortImpl;
-import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Level;
@@ -75,9 +74,4 @@ public class JmhBase {
// This way, all iterations sort the same input.
workingCopy = data.getCopy();
}
-
- @Benchmark
- public void benchmark() {
- sortImpl.sort(workingCopy);
- }
}
diff --git a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
index ede8f4a..96d2355 100644
--- a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
+++ b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
@@ -3,6 +3,7 @@ package de.uni_marburg.powersort.benchmark;
import de.uni_marburg.powersort.data.CglEnum;
import de.uni_marburg.powersort.data.DataEnum;
import de.uni_marburg.powersort.sort.SortEnum;
+import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.Param;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.State;
@@ -28,4 +29,12 @@ public class JmhCgl extends JmhBase {
SortEnum getSortEnum(){
return sortEnum;
}
+
+ // We could move this method up to JmhBase to avoid redundancy in the subclasses.
+ // But this would remove the run button of the IntelliJ plugin "JMH Java Microbenchmark Harness".
+ // Furthermore, with this approach we don't need to exclude JmhBase as it has no benchmark methods.
+ @Benchmark
+ public void benchmark() {
+ sortImpl.sort(workingCopy);
+ }
}
diff --git a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCompetition.java b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCompetition.java
index f6b4cba..8d77a10 100644
--- a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCompetition.java
+++ b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCompetition.java
@@ -3,6 +3,7 @@ package de.uni_marburg.powersort.benchmark;
import de.uni_marburg.powersort.data.CompetitionEnum;
import de.uni_marburg.powersort.data.DataEnum;
import de.uni_marburg.powersort.sort.SortEnum;
+import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.Param;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.State;
@@ -28,4 +29,9 @@ public class JmhCompetition extends JmhBase {
SortEnum getSortEnum(){
return sortEnum;
}
+
+ @Benchmark
+ public void benchmark() {
+ sortImpl.sort(workingCopy);
+ }
}
diff --git a/intellij-jmh.png b/intellij-jmh.png
new file mode 100644
index 0000000000000000000000000000000000000000..68ffbf4e4117e442a1ef7e42ebd3cd477488664c
GIT binary patch
literal 14199
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
E0Rhm)&j0`b
literal 0
HcmV?d00001
From baa0a44b34b62c1efe5a85bce0dbab2c61e91a78 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Thu, 9 Jan 2025 11:53:05 +0000
Subject: [PATCH 35/70] docs: README
---
README.md | 3 +++
1 file changed, 3 insertions(+)
diff --git a/README.md b/README.md
index 023dc9d..dd21c02 100644
--- a/README.md
+++ b/README.md
@@ -11,6 +11,9 @@ Implementation of Powersort with the aim of integrating it into OpenJDK. Benchma
* [Benchmark](#benchmark)
* [Custom](#custom)
* [JMH](#jmh)
+ * [Run JMH with CGL and Powersort competition lists](#run-jmh-with-cgl-and-powersort-competition-lists)
+ * [IntelliJ plugin](#intellij-plugin)
+ * [Further notes](#further-notes)
<!-- TOC -->
## Setup
From 88f8df3c07be21213f3775d802aebbe5f94919f6 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Thu, 9 Jan 2025 11:53:38 +0000
Subject: [PATCH 36/70] benchmark: Java max heap
---
app/build.gradle.kts | 2 ++
1 file changed, 2 insertions(+)
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index 6aadce9..06c6b26 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -50,6 +50,8 @@ tasks.register<JavaExec>("runCbmCgl") {
group = "application"
classpath = sourceSets["main"].runtimeClasspath
mainClass = "de.uni_marburg.powersort.benchmark.CbmCgl"
+ // Results in `-Xmx8g` being passed to JVM
+ maxHeapSize = "8g"
}
tasks.register<JavaExec>("runCbmCompetition") {
description = "Run Custom Benchmark (CBM) with Powersort competition lists"
From 2b85e4e956c16703b3f38fa770c664f84a725bd1 Mon Sep 17 00:00:00 2001
From: finnm <finn.moltmann@tu-dortmund.de>
Date: Fri, 10 Jan 2025 14:35:15 +0100
Subject: [PATCH 37/70] Updated the power function to use integers
---
.../powersort/FinnSort/FasterFinnSort.java | 21 +++++++++++++------
1 file changed, 15 insertions(+), 6 deletions(-)
diff --git a/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java b/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java
index 1f7dc8f..650ed97 100644
--- a/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java
+++ b/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java
@@ -459,13 +459,22 @@ public class FasterFinnSort<T> {
int n_1 = this.runLen[stackSize - 1];
int n_2 = this.runLen[stackSize];
- double a = ((double) this.runBase[stackSize - 1] + 0.5d * n_1 - 1d) / rangeSize;
- double b = ((double) this.runBase[stackSize] + 0.5d * n_2 - 1d) / rangeSize;
- int l = 0;
- while ((int) (a * pow(2, l)) == (int) (b * pow(2 ,l))) {
- l++;
+
+ int a = 2 * this.runBase[stackSize - 1] + n_1;
+ int b = a + n_1 + n_2;
+
+ int result = 0;
+
+ while (b < rangeSize) {
+ ++result;
+ if (a >= rangeSize) {
+ a -= rangeSize;
+ b -= rangeSize;
+ }
+ a <<= 1;
+ b <<= 1;
}
- return l;
+ return result;
}
/*
From a7f3ebfe50a61818bfdf7b0a95e757a3a9cdf84b Mon Sep 17 00:00:00 2001
From: M-H9 <mohammed.othman.omer97@gmail.com>
Date: Mon, 13 Jan 2025 22:58:28 +0100
Subject: [PATCH 38/70] Converted IMPL_M_1 to Generic
---
.../powersort/MSort/PowerSortT.java | 89 +++++++++++++++++++
.../powersort/MSort/PowerSortTest.java | 44 +++++++++
.../powersort/msort/PowerSortTest.java | 37 --------
3 files changed, 133 insertions(+), 37 deletions(-)
create mode 100644 app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortT.java
create mode 100644 app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortTest.java
delete mode 100644 app/src/test/java/de/uni_marburg/powersort/msort/PowerSortTest.java
diff --git a/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortT.java b/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortT.java
new file mode 100644
index 0000000..8a0bd76
--- /dev/null
+++ b/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortT.java
@@ -0,0 +1,89 @@
+package de.uni_marburg.powersort.MSort;
+
+import static de.uni_marburg.powersort.MSort.IMPL_M_1.*;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+public class PowerSortT {
+
+ public static void main(String[] args) {
+ testFillWithAscRunsHighToLow();
+ testMerge();
+ testMergeInplace();
+ testExtendRun();
+ testPower();
+ testPowerFast();
+ testMergeTopmost2();
+ testPowerSort();
+ }
+
+ // Test for fillWithAscRunsHighToLow
+ public static void testFillWithAscRunsHighToLow() {
+ List<Integer> A = new ArrayList<>(Collections.nCopies(10, 0));
+ int[] runLengths = {2, 3, 5};
+ int runLenFactor = 1;
+ fillWithAscRunsHighToLow(A, runLengths, runLenFactor);
+ System.out.println("Test fillWithAscRunsHighToLow: " + A);
+ }
+
+ // Test for merge
+ public static void testMerge() {
+ List<Integer> run1 = new ArrayList<>(Arrays.asList(1, 4, 6));
+ List<Integer> run2 = new ArrayList<>(Arrays.asList(2, 3, 5));
+ List<Integer> result = merge(run1, run2);
+ System.out.println("Test merge: " + result);
+ }
+
+ // Test for mergeInplace
+ public static void testMergeInplace() {
+ List<Integer> A = new ArrayList<>(Arrays.asList(1, 4, 6, 2, 3, 5));
+ mergeInplace(A, 0, 3, 6);
+ System.out.println("Test mergeInplace: " + A);
+ }
+
+ // Test for extendRun
+ public static void testExtendRun() {
+ List<Integer> A = new ArrayList<>(Arrays.asList(1, 2, 3, 6, 5, 4));
+ int endIndex = extendRun(A, 0);
+ System.out.println("Test extendRun (from 0): " + endIndex);
+ System.out.println("Modified List: " + A);
+ }
+
+ // Test for power
+ public static void testPower() {
+ int[] run1 = {0, 3};
+ int[] run2 = {3, 3};
+ int n = 6;
+ int powerValue = power(run1, run2, n);
+ System.out.println("Test power: " + powerValue);
+ }
+
+ // Test for powerFast
+ public static void testPowerFast() {
+ int[] run1 = {0, 3};
+ int[] run2 = {3, 3};
+ int n = 6;
+ int powerFastValue = powerFast(run1, run2, n);
+ System.out.println("Test powerFast: " + powerFastValue);
+ }
+
+ // Test for mergeTopmost2
+ public static void testMergeTopmost2() {
+ List<Integer> A = new ArrayList<>(Arrays.asList(1, 3, 5, 2, 4, 6));
+ List<int[]> runs = new ArrayList<>();
+ runs.add(new int[]{0, 3, 1});
+ runs.add(new int[]{3, 3, 1});
+ mergeTopmost2(A, runs);
+ System.out.println("Test mergeTopmost2: " + A);
+ }
+
+ // Test for powerSort
+ public static void testPowerSort() {
+ List<Integer> A = new ArrayList<>(Arrays.asList(10, 9, 8, 7, 6, 5, 4, 3, 2, 1));
+ powerSort(A);
+ System.out.println("Test powerSort: " + A);
+ }
+ }
diff --git a/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortTest.java b/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortTest.java
new file mode 100644
index 0000000..1d1bb78
--- /dev/null
+++ b/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortTest.java
@@ -0,0 +1,44 @@
+package de.uni_marburg.powersort.MSort;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+import org.junit.jupiter.api.Test;
+
+import static de.uni_marburg.powersort.MSort.IMPL_M_1.MERGE_COST;
+import static de.uni_marburg.powersort.MSort.IMPL_M_1.fillWithAscRunsHighToLow;
+import static de.uni_marburg.powersort.MSort.IMPL_M_1.powerSort;
+
+class PowerSortTest {
+ @Test
+ public void testWithOneInputList() {
+ // List<Integer> list = new ArrayList<>(List.of(5, 2, 8, 12, 1, 6));
+ // extendRun(list, 0);
+//System.out.println(list);
+ // example from slides he wrote this
+ int[] runs = {5, 3, 3, 14, 1, 2};
+ runs = new int[]{9, 16, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7};
+
+ List<Integer> a = new ArrayList<>(IntStream.range(0, Arrays.stream(runs).sum()).boxed().collect(Collectors.toList()));
+
+ System.out.println();
+ fillWithAscRunsHighToLow(a, runs, 1);
+ MERGE_COST = 0;
+ System.out.println("Sorting with Powersort:");
+ powerSort(a);
+ System.out.println("Merge cost: " + MERGE_COST);
+ }
+
+ @Test
+ public void testWithFinnInputList() {
+ List<Integer> numbers = List.of(new Integer[] {24, 25, 26, 27, 28, 21, 22, 23, 18, 19, 20, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 3, 1, 2});
+
+ powerSort(numbers);
+ System.out.println("Result: ");
+ System.out.println(new ArrayList<>(List.of(numbers)));
+
+ }
+}
diff --git a/app/src/test/java/de/uni_marburg/powersort/msort/PowerSortTest.java b/app/src/test/java/de/uni_marburg/powersort/msort/PowerSortTest.java
deleted file mode 100644
index dc2bfa5..0000000
--- a/app/src/test/java/de/uni_marburg/powersort/msort/PowerSortTest.java
+++ /dev/null
@@ -1,37 +0,0 @@
-package de.uni_marburg.powersort.msort;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.stream.Collectors;
-import java.util.stream.IntStream;
-
-import org.junit.jupiter.api.Test;
-
-import static de.uni_marburg.powersort.msort.IMPL_M_1.MERGE_COST;
-import static de.uni_marburg.powersort.msort.IMPL_M_1.extendRun;
-import static de.uni_marburg.powersort.msort.IMPL_M_1.fillWithAscRunsHighToLow;
-import static de.uni_marburg.powersort.msort.IMPL_M_1.powerSort;
-
-class PowerSortTest {
- @Test
-
- public void testWithOneInputList() {
- List<Integer> list = new ArrayList<>(List.of(5, 2, 8, 12, 1, 6));
- extendRun(list, 0);
- System.out.println(list);
- // example from slides he wrote this
- int[] runs = {5, 3, 3, 14, 1, 2};
- // runs = new int[]{9, 16, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7};
-
- List<Integer> a = new ArrayList<>(IntStream.range(0, Arrays.stream(runs).sum()).boxed().collect(Collectors.toList()));
-
- System.out.println();
- fillWithAscRunsHighToLow(a, runs, 1);
- MERGE_COST = 0;
- System.out.println("Sorting with Powersort:");
- powerSort(a);
- System.out.println("Merge cost: " + MERGE_COST);
- }
-
- }
\ No newline at end of file
From 5637ee115fe9724838fb58fa05f74f37b7e8840e Mon Sep 17 00:00:00 2001
From: M-H9 <mohammed.othman.omer97@gmail.com>
Date: Mon, 13 Jan 2025 22:58:45 +0100
Subject: [PATCH 39/70] Converted IMPL_M_1 to Generic
---
.../uni_marburg/powersort/MSort/IMPL_M_1.java | 221 +++++++++++++
.../uni_marburg/powersort/msort/IMPL_M_1.java | 298 ------------------
2 files changed, 221 insertions(+), 298 deletions(-)
create mode 100644 app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_1.java
delete mode 100644 app/src/main/java/de/uni_marburg/powersort/msort/IMPL_M_1.java
diff --git a/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_1.java b/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_1.java
new file mode 100644
index 0000000..bcfecb9
--- /dev/null
+++ b/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_1.java
@@ -0,0 +1,221 @@
+package de.uni_marburg.powersort.MSort;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.IntStream;
+
+public class IMPL_M_1 <T extends Comparable<? super T>> {
+
+ private IMPL_M_1() {
+ }
+
+ /**
+ * Sorts the given range, using the given workspace array slice
+ * for temp storage when possible. This method is designed to be
+ * invoked from public methods (in class Arrays) after performing
+ * any necessary array bounds checks and expanding parameters into
+ * the required forms.
+ *
+ * @param a the array to be sorted
+ * @param lo the index of the first element, inclusive, to be sorted
+ * @param hi the index of the last element, exclusive, to be sorted
+ * @param c the comparator to use
+ * @param work a workspace array (slice)
+ * @param workBase origin of usable space in work array
+ * @param workLen usable size of work array
+ * @since 1.8
+ */
+ protected static int MERGE_COST = 0;
+
+
+ public static void fillWithAscRunsHighToLow(List<Integer> A, int[] runLengths, int runLenFactor) {
+ //A has a fixed size, but it doesn't have any meaningful values
+ int n = A.size();
+ //This ensures that the sum of runLengths multiplied by runLenFactor equals the list size n. If not, an AssertionError is thrown.
+ assert IntStream.of(runLengths).sum() * runLenFactor == n;
+
+ //System.out.println("IntStream Of run length output: "+IntStream.of(runLengths).sum());
+ //IntStream.of(runLengths).forEach(System.out::println);
+ for (int i = 0; i < n; i++) {
+ //putting i in set a, while a is always the last index of n
+ A.set(i, n - i);
+ }
+
+ int i = 0;
+ //For each value l in the array runLengths, do the following
+ // runLengths = {2, 3, 5}, the loop will run three times, with l taking values 2, 3, and 5 respectively.
+ for (int l : runLengths) {
+ int L = l * runLenFactor;
+ List<Integer> sublist = A.subList(i, i + L);
+ Collections.sort(sublist);
+ i += L;
+ }
+ }
+
+
+ static <T extends Comparable<? super T>> List<T> merge(List<T> run1, List<T> run2) {
+ List<T> result = new ArrayList<>();
+ while (!run1.isEmpty() && !run2.isEmpty()) {
+ //This comparison only works if the lists are sorted
+ if (run1.get(0).compareTo(run2.get(0)) < 0) {
+ result.add(run1.remove(0));
+ } else {
+ result.add(run2.remove(0));
+ }
+ }
+ /// can be improved by finding out which one is empty and only add the other one
+ result.addAll(run1);
+ result.addAll(run2);
+ return result;
+ }
+
+ static <T extends Comparable<? super T>> void mergeInplace(List<T> a, int i, int m, int j) {
+ // System.out.printf("Merge(%d, %d, %d)%n", i, m, j);
+ MERGE_COST += j - i;
+ List<T> sublist = merge(
+ new ArrayList<>(a.subList(i, m)),
+ new ArrayList<>(a.subList(m, j))
+ );
+ for (int k = 0; k < sublist.size(); k++) {
+ a.set(i + k, sublist.get(k));
+ }
+ }
+
+ static <T extends Comparable<? super T>> int extendRun(List<T> a, int i) {
+ // if i was the element before end so just return the last element
+ if (i == a.size() - 1) {
+ return i + 1;
+ }
+ //we're looking at the element next to a[i]
+ int j = i + 1;
+ if (a.get(i).compareTo( a.get(j)) <=0) {
+ while (j < a.size() && a.get(j - 1).compareTo( a.get(j)) <= 0) {
+ j++;
+ }
+ } else {
+ while (j < a.size() && a.get(j - 1).compareTo(a.get(j)) > 0) {
+ j++;
+ }
+ List<T> sublist = a.subList(i, j);
+ Collections.reverse(sublist);
+ }
+ return j;
+ }
+
+ public static int power(int[] run1, int[] run2, int n) {
+ int i1 = run1[0], n1 = run1[1];
+ int i2 = run2[0], n2 = run2[1];
+
+ assert i1 >= 0;
+ assert i2 == i1 + n1;
+ assert n1 >= 1 && n2 >= 1;
+ assert i2 + n2 <= n;
+
+ double a = ((i1 + n1 / 2.0d) / n);
+ double b = ((i2 + n2 / 2.0d) / n);
+
+ int l = 0;
+ while (Math.floor(a * Math.pow(2, l)) == Math.floor(b * Math.pow(2, l))) {
+ l++;
+ }
+ return l;
+ }
+
+ public static <T extends Comparable<? super T>> void mergeTopmost2(List<T> a, List<int []> runs) {
+ assert runs.size() >= 2;
+
+ int[] Y = runs.get(runs.size() - 2);
+ int[] Z = runs.get(runs.size() - 1);
+
+ assert Z[0] == Y[0] + Y[1];
+
+ mergeInplace(a, Y[0], Z[0], Z[0] + Z[1]);
+
+ runs.set(runs.size() - 2, new int[] {Y[0], Y[1] + Z[1], Y[2]});
+ runs.removeLast();
+ }
+
+ public static <T extends Comparable<? super T>> void powerSort(List<T> a) {
+ int n = a.size();
+ int i = 0;
+ List<int[]> runs = new ArrayList<>();
+
+ int j = extendRun(a, i);
+ runs.add(new int[] {i, j - i, 0});
+ i = j;
+
+ while (i < n) {
+ j = extendRun(a, i);
+ int p = power(runs.get(runs.size() - 1), new int[] {i, j - i}, n);
+
+ while (p <= runs.getLast()[2]) {
+ mergeTopmost2(a, runs);
+ }
+
+ runs.add(new int[] {i, j - i, p});
+ i = j;
+ }
+
+ while (runs.size() >= 2) {
+ mergeTopmost2(a, runs);
+ }
+ }
+
+ public static int extendRunIncreasingOnly(List<Integer> a, int i) {
+ if (i == a.size() - 1) {
+ return i + 1;
+ }
+ int j = i + 1;
+ while (j < a.size() && a.get(j - 1) <= a.get(j)) {
+ j++;
+ }
+ return j;
+ }
+
+ public static int powerFast(int[] run1, int[] run2, int n) {
+ int i1 = run1[0], n1 = run1[1];
+ int i2 = run2[0], n2 = run2[1];
+
+ int a = 2 * i1 + n1;
+ int b = a + n1 + n2;
+
+ int l = 0;
+ while (true) {
+ l++;
+ if (a >= n) {
+ assert b >= a;
+ a -= n;
+ b -= n;
+ } else if (b >= n) {
+ break;
+ }
+ assert a < b && b < n;
+ a <<= 1;
+ b <<= 1;
+ }
+ return l;
+ }
+//
+// ,
+// new SortImpl("MSort") {
+// @Override
+// @SuppressWarnings("unchecked")
+// public void sort(Object[] a) {
+// // Create a list of type that matches powerSort's requirements
+// List<Comparable<Object>> list = new ArrayList<>();
+// for (Object obj : a) {
+// // Since we know the input will be Integer objects in the benchmark
+// list.add((Comparable<Object>) obj);
+// }
+//
+// // Call powerSort with the proper type
+// IMPL_M_1.<Comparable<Object>>powerSort(list);
+//
+// // Copy back to array
+// for (int i = 0; i < a.length; i++) {
+// a[i] = list.get(i);
+// }
+// }
+// }
+}
\ No newline at end of file
diff --git a/app/src/main/java/de/uni_marburg/powersort/msort/IMPL_M_1.java b/app/src/main/java/de/uni_marburg/powersort/msort/IMPL_M_1.java
deleted file mode 100644
index 0d0f25d..0000000
--- a/app/src/main/java/de/uni_marburg/powersort/msort/IMPL_M_1.java
+++ /dev/null
@@ -1,298 +0,0 @@
-package de.uni_marburg.powersort.msort;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.stream.IntStream;
-
-public class IMPL_M_1 {
-
-
-
- private IMPL_M_1() {}
-
- /**
- * Sorts the given range, using the given workspace array slice
- * for temp storage when possible. This method is designed to be
- * invoked from public methods (in class Arrays) after performing
- * any necessary array bounds checks and expanding parameters into
- * the required forms.
- *
- * @param a the array to be sorted
- * @param lo the index of the first element, inclusive, to be sorted
- * @param hi the index of the last element, exclusive, to be sorted
- * @param c the comparator to use
- * @param work a workspace array (slice)
- * @param workBase origin of usable space in work array
- * @param workLen usable size of work array
- * @since 1.8
- */
- protected static int MERGE_COST = 0;
-
- // Example usage
-// int[] runs = new int[] {5, 3, 3, 14, 1, 2}; // example from slides
-// //runs = new int[]{9, 16, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7};
-//
-// ArrayList<Integer> a = new ArrayList<>(IntStream.range(0, Arrays.stream(runs).sum()).boxed().collect(Collectors.toList()));
-//
-// System.out.println();
-// fillWithAscRunsHighToLow(a, runs);
-// MERGE_COST = 0;
-// System.out.println("Sorting with Powersort:");
-// powersort(a, this::extendRunIncreasingOnly);
-// System.out.println("Merge cost: " + MERGE_COST);
-
-// runs = [5,3,3,14,1,2];
-// runs = [9,16,7,7,7,7,7,7,7,7,7,7];
-//
-// a = list(range(sum(runs)));
-// fill_with_asc_runs_high_to_low(a, runs);
-// MERGE_COST = 0;
-// System.out.println("Sorting with Powersort:");
-// powersort(a, extendRunIncreasingOnly);
-// System.out.println("Merge cost: " + MERGE_COST);
-
-
- public static void fillWithAscRunsHighToLow(List<Integer> A, int[] runLengths, int runLenFactor) {
- int n = A.size();
- assert IntStream.of(runLengths).sum() * runLenFactor == n;
-
- for (int i = 0; i < n; i++) {
- A.set(i, n - i);
- }
-
- int i = 0;
- for (int l : runLengths) {
- int L = l * runLenFactor;
- List<Integer> sublist = A.subList(i, i + L);
- Collections.sort(sublist);
- i += L;
- }
- }
-
- private static List<Integer> merge(List<Integer> run1, List<Integer> run2) {
- List<Integer> result = new ArrayList<>();
- while (!run1.isEmpty() && !run2.isEmpty()) {
- if (run1.get(0) < run2.get(0)) {
- result.add(run1.remove(0));
- } else {
- result.add(run2.remove(0));
- }
- }
- result.addAll(run1);
- result.addAll(run2);
- return result;
- }
-
- private static void mergeInplace(List<Integer> a, int i, int m, int j) {
- System.out.printf("Merge(%d, %d, %d)%n", i, m, j);
- MERGE_COST += j - i;
- List<Integer> sublist = merge(
- new ArrayList<>(a.subList(i, m)),
- new ArrayList<>(a.subList(m, j))
- );
- for (int k = 0; k < sublist.size(); k++) {
- a.set(i + k, sublist.get(k));
- }
- }
-
- static int extendRun(List<Integer> a, int i) {
- if (i == a.size() - 1) {
- return i + 1;
- }
- int j = i + 1;
- if (a.get(i) <= a.get(j)) {
- while (j < a.size() && a.get(j - 1) <= a.get(j)) {
- j++;
- }
- } else {
- while (j < a.size() && a.get(j - 1) > a.get(j)) {
- j++;
- }
- List<Integer> sublist = a.subList(i, j);
- Collections.reverse(sublist);
- }
- return j;
- }
-
- private static int extendRunIncreasingOnly(List<Integer> a, int i) {
- if (i == a.size() - 1) {
- return i + 1;
- }
- int j = i + 1;
- while (j < a.size() && a.get(j - 1) <= a.get(j)) {
- j++;
- }
- return j;
- }
-
- public static int power(int[] run1, int[] run2, int n) {
- int i1 = run1[0], n1 = run1[1];
- int i2 = run2[0], n2 = run2[1];
-
- assert i1 >= 0;
- assert i2 == i1 + n1;
- assert n1 >= 1 && n2 >= 1;
- assert i2 + n2 <= n;
-
- double a = ((i1 + n1 / 2.0d) / n);
- double b = ((i2 + n2 / 2.0d) / n);
-
- int l = 0;
- while (Math.floor(a * Math.pow(2, l)) == Math.floor(b * Math.pow(2, l))) {
- l++;
- }
- return l;
- }
-
- public static int powerFast(int[] run1, int[] run2, int n) {
- int i1 = run1[0], n1 = run1[1];
- int i2 = run2[0], n2 = run2[1];
-
- int a = 2 * i1 + n1;
- int b = a + n1 + n2;
-
- int l = 0;
- while (true) {
- l++;
- if (a >= n) {
- assert b >= a;
- a -= n;
- b -= n;
- } else if (b >= n) {
- break;
- }
- assert a < b && b < n;
- a <<= 1;
- b <<= 1;
- }
- return l;
- }
-
- public static void mergeTopmost2(List<Integer> a, List<int[]> runs) {
- assert runs.size() >= 2;
-
- int[] Y = runs.get(runs.size() - 2);
- int[] Z = runs.get(runs.size() - 1);
-
- assert Z[0] == Y[0] + Y[1];
-
- mergeInplace(a, Y[0], Z[0], Z[0] + Z[1]);
-
- runs.set(runs.size() - 2, new int[] {Y[0], Y[1] + Z[1], Y[2]});
- runs.remove(runs.size() - 1);
- }
-
- public static void powerSort(List<Integer> a) {
- int n = a.size();
- int i = 0;
- List<int[]> runs = new ArrayList<>();
-
- int j = extendRun(a, i);
- runs.add(new int[] {i, j - i, 0});
- i = j;
-
- while (i < n) {
- j = extendRun(a, i);
- int p = power(runs.get(runs.size() - 1), new int[] {i, j - i}, n);
-
- while (p <= runs.get(runs.size() - 1)[2]) {
- mergeTopmost2(a, runs);
- }
-
- runs.add(new int[] {i, j - i, p});
- i = j;
- }
-
- while (runs.size() >= 2) {
- mergeTopmost2(a, runs);
- }
- }
-
- /* """Fills the given array A with ascending runs of the given list of run
- lengths.
- More precisely, the array is first filled n, n-1, ..., 1
- and then for i=0..l-1 segments of runLengths.get(i) * runLenFactor
- are sorted ascending.
- The sum of all lengths in runLengths times runLenFactor should be equal to the
- length of A.
- """*/
-
-
- /* static <T> void sort(T[] a, int lo, int hi, Comparator<? super T> c,
- T[] work, int workBase, int workLen) {
- assert c != null && a != null && lo >= 0 && lo <= hi && hi <= a.length;
- }*/
-/*
- public static final int MIN_MERGE=24;
- public int mergeCost=0;
- private final T []sortedArray;
-
- public PowerSort(T[] sortedArray) {
- super();
- this.sortedArray = sortedArray;
- }
-
- ArrayList<Integer> run1 = new ArrayList<>();
- ArrayList<Integer> run2 = new ArrayList<>();
-
- private AbstractList<Integer> merge(ArrayList <Integer> run1, ArrayList<Integer> run2) {
- ArrayList<Integer> result = new ArrayList<>();
-
- while(run1.size() > 0 && run2.size() >0) {
- if (run1.getFirst()<run2.getFirst()){
- result.add(run1.getFirst());
- run1.removeFirst();
- }else {
- result.add(run2.getFirst());
- run2.removeFirst();
- }
- result.addAll(run1);
- result.addAll(run2);
- }
- return result;
- }
-
- public void mergeInplace(int[] a, int[] i, int[] m, int[] j) {
- //System.out.println("merge(" + i + "," + m + "," + j + ")");
-
- System.out.printf("Merge(%d, %d, %d)%n", i, m, j);
- // this.mergeCost += j - i;
-
-
- for(int s =0; s < i.length && s< j.length ; s++) {
-
-
-// int[] leftSubarray = copyOfRange(a, i, m);
-// int[] rightSubarray = copyOfRange(a, m, j);
-// int[] mergedSubarray = merge(leftSubarray, rightSubarray);
-// System.arraycopy(mergedSubarray, 0, a, i, mergedSubarray.length);
-//// mergeCost += j[s] - i[s];
-// System.arraycopy(merge(Arrays.copyOfRange(a, i, m), Arrays.copyOfRange(a, m, j)), 0, a, i, j - i);
-// a[i:j]=merge(a[i:m],a[m:j]);
- }
-
- }
-
-
-
- public void power(int run1,int run2, int n) {
- int i = run1;
- int n1 = run1;
- int j = run2;
- int n2 = run2;
- int a=(i + n1/2) / n;
- int b=(j + n2/2) / n;
- int l =0;
- //while( Math.floor(a * 2**1)){
- // Math.floor(b * );
- // }
-
- }
-
- public void sorting(final int[] Array, final int left, final int right) {
-
-
- }*/
-
-}
From d4463399832eba1392c294cef127333913f4141b Mon Sep 17 00:00:00 2001
From: M-H9 <mohammed.othman.omer97@gmail.com>
Date: Mon, 13 Jan 2025 23:05:54 +0100
Subject: [PATCH 40/70] Starting IMPL_M_2
---
.../uni_marburg/powersort/MSort/IMPL_M_2.java | 942 ++++++++++++++++++
.../uni_marburg/powersort/benchmark/Main.java | 2 +
2 files changed, 944 insertions(+)
create mode 100644 app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_2.java
diff --git a/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_2.java b/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_2.java
new file mode 100644
index 0000000..a552fca
--- /dev/null
+++ b/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_2.java
@@ -0,0 +1,942 @@
+/*
+ * Copyright (c) 2009, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright 2009 Google Inc. 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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 de.uni_marburg.powersort.MSort;
+
+import java.util.Comparator;
+
+/**
+ * A stable, adaptive, iterative mergesort that requires far fewer than
+ * n lg(n) comparisons when running on partially sorted arrays, while
+ * offering performance comparable to a traditional mergesort when run
+ * on random arrays. Like all proper mergesorts, this sort is stable and
+ * runs O(n log n) time (worst case). In the worst case, this sort requires
+ * temporary storage space for n/2 object references; in the best case,
+ * it requires only a small constant amount of space.
+ *
+ * This implementation was adapted from Tim Peters's list sort for
+ * Python, which is described in detail here:
+ *
+ * http://svn.python.org/projects/python/trunk/Objects/listsort.txt
+ *
+ * Tim's C code may be found here:
+ *
+ * http://svn.python.org/projects/python/trunk/Objects/listobject.c
+ *
+ * The underlying techniques are described in this paper (and may have
+ * even earlier origins):
+ *
+ * "Optimistic Sorting and Information Theoretic Complexity"
+ * Peter McIlroy
+ * SODA (Fourth Annual ACM-SIAM Symposium on Discrete Algorithms),
+ * pp 467-474, Austin, Texas, 25-27 January 1993.
+ *
+ * While the API to this class consists solely of static methods, it is
+ * (privately) instantiable; a TimSort instance holds the state of an ongoing
+ * sort, assuming the input array is large enough to warrant the full-blown
+ * TimSort. Small arrays are sorted in place, using a binary insertion sort.
+ *
+ * @author Josh Bloch
+ */
+public class IMPL_M_2<T>{
+
+ /**
+ * This is the minimum sized sequence that will be merged. Shorter
+ * sequences will be lengthened by calling binarySort. If the entire
+ * array is less than this length, no merges will be performed.
+ *
+ * This constant should be a power of two. It was 64 in Tim Peter's C
+ * implementation, but 32 was empirically determined to work better in
+ * this implementation. In the unlikely event that you set this constant
+ * to be a number that's not a power of two, you'll need to change the
+ * {@link #minRunLength} computation.
+ *
+ * If you decrease this constant, you must change the stackLen
+ * computation in the TimSort constructor, or you risk an
+ * ArrayOutOfBounds exception. See listsort.txt for a discussion
+ * of the minimum stack length required as a function of the length
+ * of the array being sorted and the minimum merge sequence length.
+ */
+ private static final int MIN_MERGE = 32;
+
+ /**
+ * The array being sorted.
+ */
+ private final T[] a;
+
+ /**
+ * The comparator for this sort.
+ */
+ private final Comparator<? super T> c;
+
+ /**
+ * When we get into galloping mode, we stay there until both runs win less
+ * often than MIN_GALLOP consecutive times.
+ */
+ private static final int MIN_GALLOP = 7;
+
+ /**
+ * This controls when we get *into* galloping mode. It is initialized
+ * to MIN_GALLOP. The mergeLo and mergeHi methods nudge it higher for
+ * random data, and lower for highly structured data.
+ */
+ private int minGallop = MIN_GALLOP;
+
+ /**
+ * Maximum initial size of tmp array, which is used for merging. The array
+ * can grow to accommodate demand.
+ *
+ * Unlike Tim's original C version, we do not allocate this much storage
+ * when sorting smaller arrays. This change was required for performance.
+ */
+ private static final int INITIAL_TMP_STORAGE_LENGTH = 256;
+
+ /**
+ * Temp storage for merges. A workspace array may optionally be
+ * provided in constructor, and if so will be used as long as it
+ * is big enough.
+ */
+ private T[] tmp;
+ private int tmpBase; // base of tmp array slice
+ private int tmpLen; // length of tmp array slice
+
+ /**
+ * A stack of pending runs yet to be merged. Run i starts at
+ * address base[i] and extends for len[i] elements. It's always
+ * true (so long as the indices are in bounds) that:
+ *
+ * runBase[i] + runLen[i] == runBase[i + 1]
+ *
+ * so we could cut the storage for this, but it's a minor amount,
+ * and keeping all the info explicit simplifies the code.
+ */
+ private int stackSize = 0; // Number of pending runs on stack
+ private final int[] runBase;
+ private final int[] runLen;
+
+ /**
+ * Creates a TimSort instance to maintain the state of an ongoing sort.
+ *
+ * @param a the array to be sorted
+ * @param c the comparator to determine the order of the sort
+ * @param work a workspace array (slice)
+ * @param workBase origin of usable space in work array
+ * @param workLen usable size of work array
+ */
+ private IMPL_M_2(T[] a, Comparator<? super T> c, T[] work, int workBase, int workLen) {
+ this.a = a;
+ this.c = c;
+
+ // Allocate temp storage (which may be increased later if necessary)
+ int len = a.length;
+ int tlen = (len < 2 * INITIAL_TMP_STORAGE_LENGTH) ?
+ len >>> 1 : INITIAL_TMP_STORAGE_LENGTH;
+ if (work == null || workLen < tlen || workBase + tlen > work.length) {
+ @SuppressWarnings({"unchecked", "UnnecessaryLocalVariable"})
+ T[] newArray = (T[])java.lang.reflect.Array.newInstance
+ (a.getClass().getComponentType(), tlen);
+ tmp = newArray;
+ tmpBase = 0;
+ tmpLen = tlen;
+ }
+ else {
+ tmp = work;
+ tmpBase = workBase;
+ tmpLen = workLen;
+ }
+
+ /*
+ * Allocate runs-to-be-merged stack (which cannot be expanded). The
+ * stack length requirements are described in listsort.txt. The C
+ * version always uses the same stack length (85), but this was
+ * measured to be too expensive when sorting "mid-sized" arrays (e.g.,
+ * 100 elements) in Java. Therefore, we use smaller (but sufficiently
+ * large) stack lengths for smaller arrays. The "magic numbers" in the
+ * computation below must be changed if MIN_MERGE is decreased. See
+ * the MIN_MERGE declaration above for more information.
+ * The maximum value of 49 allows for an array up to length
+ * Integer.MAX_VALUE-4, if array is filled by the worst case stack size
+ * increasing scenario. More explanations are given in section 4 of:
+ * http://envisage-project.eu/wp-content/uploads/2015/02/sorting.pdf
+ */
+ int stackLen = (len < 120 ? 5 :
+ len < 1542 ? 10 :
+ len < 119151 ? 24 : 49);
+ runBase = new int[stackLen];
+ runLen = new int[stackLen];
+ }
+
+ /*
+ * The next method (package private and static) constitutes the
+ * entire API of this class.
+ */
+
+ /**
+ * Sorts the given range, using the given workspace array slice
+ * for temp storage when possible. This method is designed to be
+ * invoked from public methods (in class Arrays) after performing
+ * any necessary array bounds checks and expanding parameters into
+ * the required forms.
+ *
+ * @param a the array to be sorted
+ * @param lo the index of the first element, inclusive, to be sorted
+ * @param hi the index of the last element, exclusive, to be sorted
+ * @param c the comparator to use
+ * @param work a workspace array (slice)
+ * @param workBase origin of usable space in work array
+ * @param workLen usable size of work array
+ * @since 1.8
+ */
+ public static <T> void sort(T[] a, int lo, int hi, Comparator<? super T> c,
+ T[] work, int workBase, int workLen) {
+ assert c != null && a != null && lo >= 0 && lo <= hi && hi <= a.length;
+
+ int nRemaining = hi - lo;
+ if (nRemaining < 2)
+ return; // Arrays of size 0 and 1 are always sorted
+
+ // If array is small, do a "mini-TimSort" with no merges
+ if (nRemaining < MIN_MERGE) {
+ int initRunLen = countRunAndMakeAscending(a, lo, hi, c);
+ binarySort(a, lo, hi, lo + initRunLen, c);
+ return;
+ }
+
+ /**
+ * March over the array once, left to right, finding natural runs,
+ * extending short natural runs to minRun elements, and merging runs
+ * to maintain stack invariant.
+ */
+ IMPL_M_2<T> ts = new IMPL_M_2<>(a, c, work, workBase, workLen);
+ int minRun = minRunLength(nRemaining);
+ do {
+ // Identify next run
+ int runLen = countRunAndMakeAscending(a, lo, hi, c);
+
+ // If run is short, extend to min(minRun, nRemaining)
+ if (runLen < minRun) {
+ int force = nRemaining <= minRun ? nRemaining : minRun;
+ binarySort(a, lo, lo + force, lo + runLen, c);
+ runLen = force;
+ }
+
+ // Push run onto pending-run stack, and maybe merge
+ ts.pushRun(lo, runLen);
+ ts.mergeCollapse();
+
+ // Advance to find next run
+ lo += runLen;
+ nRemaining -= runLen;
+ } while (nRemaining != 0);
+
+ // Merge all remaining runs to complete sort
+ assert lo == hi;
+ ts.mergeForceCollapse();
+ assert ts.stackSize == 1;
+ }
+
+ /**
+ * Sorts the specified portion of the specified array using a binary
+ * insertion sort. This is the best method for sorting small numbers
+ * of elements. It requires O(n log n) compares, but O(n^2) data
+ * movement (worst case).
+ *
+ * If the initial part of the specified range is already sorted,
+ * this method can take advantage of it: the method assumes that the
+ * elements from index {@code lo}, inclusive, to {@code start},
+ * exclusive are already sorted.
+ *
+ * @param a the array in which a range is to be sorted
+ * @param lo the index of the first element in the range to be sorted
+ * @param hi the index after the last element in the range to be sorted
+ * @param start the index of the first element in the range that is
+ * not already known to be sorted ({@code lo <= start <= hi})
+ * @param c comparator to used for the sort
+ */
+ @SuppressWarnings("fallthrough")
+ private static <T> void binarySort(T[] a, int lo, int hi, int start,
+ Comparator<? super T> c) {
+ assert lo <= start && start <= hi;
+ if (start == lo)
+ start++;
+ for ( ; start < hi; start++) {
+ T pivot = a[start];
+
+ // Set left (and right) to the index where a[start] (pivot) belongs
+ int left = lo;
+ int right = start;
+ assert left <= right;
+ /*
+ * Invariants:
+ * pivot >= all in [lo, left).
+ * pivot < all in [right, start).
+ */
+ while (left < right) {
+ int mid = (left + right) >>> 1;
+ if (c.compare(pivot, a[mid]) < 0)
+ right = mid;
+ else
+ left = mid + 1;
+ }
+ assert left == right;
+
+ /*
+ * The invariants still hold: pivot >= all in [lo, left) and
+ * pivot < all in [left, start), so pivot belongs at left. Note
+ * that if there are elements equal to pivot, left points to the
+ * first slot after them -- that's why this sort is stable.
+ * Slide elements over to make room for pivot.
+ */
+ int n = start - left; // The number of elements to move
+ // Switch is just an optimization for arraycopy in default case
+ switch (n) {
+ case 2: a[left + 2] = a[left + 1];
+ case 1: a[left + 1] = a[left];
+ break;
+ default: System.arraycopy(a, left, a, left + 1, n);
+ }
+ a[left] = pivot;
+ }
+ }
+
+ /**
+ * Returns the length of the run beginning at the specified position in
+ * the specified array and reverses the run if it is descending (ensuring
+ * that the run will always be ascending when the method returns).
+ *
+ * A run is the longest ascending sequence with:
+ *
+ * a[lo] <= a[lo + 1] <= a[lo + 2] <= ...
+ *
+ * or the longest descending sequence with:
+ *
+ * a[lo] > a[lo + 1] > a[lo + 2] > ...
+ *
+ * For its intended use in a stable mergesort, the strictness of the
+ * definition of "descending" is needed so that the call can safely
+ * reverse a descending sequence without violating stability.
+ *
+ * @param a the array in which a run is to be counted and possibly reversed
+ * @param lo index of the first element in the run
+ * @param hi index after the last element that may be contained in the run.
+ * It is required that {@code lo < hi}.
+ * @param c the comparator to used for the sort
+ * @return the length of the run beginning at the specified position in
+ * the specified array
+ */
+ private static <T> int countRunAndMakeAscending(T[] a, int lo, int hi,
+ Comparator<? super T> c) {
+ assert lo < hi;
+ int runHi = lo + 1;
+ if (runHi == hi)
+ return 1;
+
+ // Find end of run, and reverse range if descending
+ if (c.compare(a[runHi++], a[lo]) < 0) { // Descending
+ while (runHi < hi && c.compare(a[runHi], a[runHi - 1]) < 0)
+ runHi++;
+ reverseRange(a, lo, runHi);
+ } else { // Ascending
+ while (runHi < hi && c.compare(a[runHi], a[runHi - 1]) >= 0)
+ runHi++;
+ }
+
+ return runHi - lo;
+ }
+
+ /**
+ * Reverse the specified range of the specified array.
+ *
+ * @param a the array in which a range is to be reversed
+ * @param lo the index of the first element in the range to be reversed
+ * @param hi the index after the last element in the range to be reversed
+ */
+ private static void reverseRange(Object[] a, int lo, int hi) {
+ hi--;
+ while (lo < hi) {
+ Object t = a[lo];
+ a[lo++] = a[hi];
+ a[hi--] = t;
+ }
+ }
+
+ /**
+ * Returns the minimum acceptable run length for an array of the specified
+ * length. Natural runs shorter than this will be extended with
+ * {@link #binarySort}.
+ *
+ * Roughly speaking, the computation is:
+ *
+ * If n < MIN_MERGE, return n (it's too small to bother with fancy stuff).
+ * Else if n is an exact power of 2, return MIN_MERGE/2.
+ * Else return an int k, MIN_MERGE/2 <= k <= MIN_MERGE, such that n/k
+ * is close to, but strictly less than, an exact power of 2.
+ *
+ * For the rationale, see listsort.txt.
+ *
+ * @param n the length of the array to be sorted
+ * @return the length of the minimum run to be merged
+ */
+ private static int minRunLength(int n) {
+ assert n >= 0;
+ int r = 0; // Becomes 1 if any 1 bits are shifted off
+ while (n >= MIN_MERGE) {
+ r |= (n & 1);
+ n >>= 1;
+ }
+ return n + r;
+ }
+
+ /**
+ * Pushes the specified run onto the pending-run stack.
+ *
+ * @param runBase index of the first element in the run
+ * @param runLen the number of elements in the run
+ */
+ private void pushRun(int runBase, int runLen) {
+ this.runBase[stackSize] = runBase;
+ this.runLen[stackSize] = runLen;
+ stackSize++;
+ }
+
+ /**
+ * Examines the stack of runs waiting to be merged and merges adjacent runs
+ * until the stack invariants are reestablished:
+ *
+ * 1. runLen[i - 3] > runLen[i - 2] + runLen[i - 1]
+ * 2. runLen[i - 2] > runLen[i - 1]
+ *
+ * This method is called each time a new run is pushed onto the stack,
+ * so the invariants are guaranteed to hold for i < stackSize upon
+ * entry to the method.
+ *
+ * Thanks to Stijn de Gouw, Jurriaan Rot, Frank S. de Boer,
+ * Richard Bubel and Reiner Hahnle, this is fixed with respect to
+ * the analysis in "On the Worst-Case Complexity of TimSort" by
+ * Nicolas Auger, Vincent Jug, Cyril Nicaud, and Carine Pivoteau.
+ */
+ private void mergeCollapse() {
+ while (stackSize > 1) {
+ int n = stackSize - 2;
+ if (n > 0 && runLen[n-1] <= runLen[n] + runLen[n+1] ||
+ n > 1 && runLen[n-2] <= runLen[n] + runLen[n-1]) {
+ if (runLen[n - 1] < runLen[n + 1])
+ n--;
+ } else if (n < 0 || runLen[n] > runLen[n + 1]) {
+ break; // Invariant is established
+ }
+ mergeAt(n);
+ }
+ }
+
+ /**
+ * Merges all runs on the stack until only one remains. This method is
+ * called once, to complete the sort.
+ */
+ private void mergeForceCollapse() {
+ while (stackSize > 1) {
+ int n = stackSize - 2;
+ if (n > 0 && runLen[n - 1] < runLen[n + 1])
+ n--;
+ mergeAt(n);
+ }
+ }
+
+ /**
+ * Merges the two runs at stack indices i and i+1. Run i must be
+ * the penultimate or antepenultimate run on the stack. In other words,
+ * i must be equal to stackSize-2 or stackSize-3.
+ *
+ * @param i stack index of the first of the two runs to merge
+ */
+ private void mergeAt(int i) {
+ assert stackSize >= 2;
+ assert i >= 0;
+ assert i == stackSize - 2 || i == stackSize - 3;
+
+ int base1 = runBase[i];
+ int len1 = runLen[i];
+ int base2 = runBase[i + 1];
+ int len2 = runLen[i + 1];
+ assert len1 > 0 && len2 > 0;
+ assert base1 + len1 == base2;
+
+ /*
+ * Record the length of the combined runs; if i is the 3rd-last
+ * run now, also slide over the last run (which isn't involved
+ * in this merge). The current run (i+1) goes away in any case.
+ */
+ runLen[i] = len1 + len2;
+ if (i == stackSize - 3) {
+ runBase[i + 1] = runBase[i + 2];
+ runLen[i + 1] = runLen[i + 2];
+ }
+ stackSize--;
+
+ /*
+ * Find where the first element of run2 goes in run1. Prior elements
+ * in run1 can be ignored (because they're already in place).
+ */
+ int k = gallopRight(a[base2], a, base1, len1, 0, c);
+ assert k >= 0;
+ base1 += k;
+ len1 -= k;
+ if (len1 == 0)
+ return;
+
+ /*
+ * Find where the last element of run1 goes in run2. Subsequent elements
+ * in run2 can be ignored (because they're already in place).
+ */
+ len2 = gallopLeft(a[base1 + len1 - 1], a, base2, len2, len2 - 1, c);
+ assert len2 >= 0;
+ if (len2 == 0)
+ return;
+
+ // Merge remaining runs, using tmp array with min(len1, len2) elements
+ if (len1 <= len2)
+ mergeLo(base1, len1, base2, len2);
+ else
+ mergeHi(base1, len1, base2, len2);
+ }
+
+ /**
+ * Locates the position at which to insert the specified key into the
+ * specified sorted range; if the range contains an element equal to key,
+ * returns the index of the leftmost equal element.
+ *
+ * @param key the key whose insertion point to search for
+ * @param a the array in which to search
+ * @param base the index of the first element in the range
+ * @param len the length of the range; must be > 0
+ * @param hint the index at which to begin the search, 0 <= hint < n.
+ * The closer hint is to the result, the faster this method will run.
+ * @param c the comparator used to order the range, and to search
+ * @return the int k, 0 <= k <= n such that a[b + k - 1] < key <= a[b + k],
+ * pretending that a[b - 1] is minus infinity and a[b + n] is infinity.
+ * In other words, key belongs at index b + k; or in other words,
+ * the first k elements of a should precede key, and the last n - k
+ * should follow it.
+ */
+ private static <T> int gallopLeft(T key, T[] a, int base, int len, int hint,
+ Comparator<? super T> c) {
+ assert len > 0 && hint >= 0 && hint < len;
+ int lastOfs = 0;
+ int ofs = 1;
+ if (c.compare(key, a[base + hint]) > 0) {
+ // Gallop right until a[base+hint+lastOfs] < key <= a[base+hint+ofs]
+ int maxOfs = len - hint;
+ while (ofs < maxOfs && c.compare(key, a[base + hint + ofs]) > 0) {
+ lastOfs = ofs;
+ ofs = (ofs << 1) + 1;
+ if (ofs <= 0) // int overflow
+ ofs = maxOfs;
+ }
+ if (ofs > maxOfs)
+ ofs = maxOfs;
+
+ // Make offsets relative to base
+ lastOfs += hint;
+ ofs += hint;
+ } else { // key <= a[base + hint]
+ // Gallop left until a[base+hint-ofs] < key <= a[base+hint-lastOfs]
+ final int maxOfs = hint + 1;
+ while (ofs < maxOfs && c.compare(key, a[base + hint - ofs]) <= 0) {
+ lastOfs = ofs;
+ ofs = (ofs << 1) + 1;
+ if (ofs <= 0) // int overflow
+ ofs = maxOfs;
+ }
+ if (ofs > maxOfs)
+ ofs = maxOfs;
+
+ // Make offsets relative to base
+ int tmp = lastOfs;
+ lastOfs = hint - ofs;
+ ofs = hint - tmp;
+ }
+ assert -1 <= lastOfs && lastOfs < ofs && ofs <= len;
+
+ /*
+ * Now a[base+lastOfs] < key <= a[base+ofs], so key belongs somewhere
+ * to the right of lastOfs but no farther right than ofs. Do a binary
+ * search, with invariant a[base + lastOfs - 1] < key <= a[base + ofs].
+ */
+ lastOfs++;
+ while (lastOfs < ofs) {
+ int m = lastOfs + ((ofs - lastOfs) >>> 1);
+
+ if (c.compare(key, a[base + m]) > 0)
+ lastOfs = m + 1; // a[base + m] < key
+ else
+ ofs = m; // key <= a[base + m]
+ }
+ assert lastOfs == ofs; // so a[base + ofs - 1] < key <= a[base + ofs]
+ return ofs;
+ }
+
+ /**
+ * Like gallopLeft, except that if the range contains an element equal to
+ * key, gallopRight returns the index after the rightmost equal element.
+ *
+ * @param key the key whose insertion point to search for
+ * @param a the array in which to search
+ * @param base the index of the first element in the range
+ * @param len the length of the range; must be > 0
+ * @param hint the index at which to begin the search, 0 <= hint < n.
+ * The closer hint is to the result, the faster this method will run.
+ * @param c the comparator used to order the range, and to search
+ * @return the int k, 0 <= k <= n such that a[b + k - 1] <= key < a[b + k]
+ */
+ private static <T> int gallopRight(T key, T[] a, int base, int len,
+ int hint, Comparator<? super T> c) {
+ assert len > 0 && hint >= 0 && hint < len;
+
+ int ofs = 1;
+ int lastOfs = 0;
+ if (c.compare(key, a[base + hint]) < 0) {
+ // Gallop left until a[b+hint - ofs] <= key < a[b+hint - lastOfs]
+ int maxOfs = hint + 1;
+ while (ofs < maxOfs && c.compare(key, a[base + hint - ofs]) < 0) {
+ lastOfs = ofs;
+ ofs = (ofs << 1) + 1;
+ if (ofs <= 0) // int overflow
+ ofs = maxOfs;
+ }
+ if (ofs > maxOfs)
+ ofs = maxOfs;
+
+ // Make offsets relative to b
+ int tmp = lastOfs;
+ lastOfs = hint - ofs;
+ ofs = hint - tmp;
+ } else { // a[b + hint] <= key
+ // Gallop right until a[b+hint + lastOfs] <= key < a[b+hint + ofs]
+ int maxOfs = len - hint;
+ while (ofs < maxOfs && c.compare(key, a[base + hint + ofs]) >= 0) {
+ lastOfs = ofs;
+ ofs = (ofs << 1) + 1;
+ if (ofs <= 0) // int overflow
+ ofs = maxOfs;
+ }
+ if (ofs > maxOfs)
+ ofs = maxOfs;
+
+ // Make offsets relative to b
+ lastOfs += hint;
+ ofs += hint;
+ }
+ assert -1 <= lastOfs && lastOfs < ofs && ofs <= len;
+
+ /*
+ * Now a[b + lastOfs] <= key < a[b + ofs], so key belongs somewhere to
+ * the right of lastOfs but no farther right than ofs. Do a binary
+ * search, with invariant a[b + lastOfs - 1] <= key < a[b + ofs].
+ */
+ lastOfs++;
+ while (lastOfs < ofs) {
+ int m = lastOfs + ((ofs - lastOfs) >>> 1);
+
+ if (c.compare(key, a[base + m]) < 0)
+ ofs = m; // key < a[b + m]
+ else
+ lastOfs = m + 1; // a[b + m] <= key
+ }
+ assert lastOfs == ofs; // so a[b + ofs - 1] <= key < a[b + ofs]
+ return ofs;
+ }
+
+ /**
+ * Merges two adjacent runs in place, in a stable fashion. The first
+ * element of the first run must be greater than the first element of the
+ * second run (a[base1] > a[base2]), and the last element of the first run
+ * (a[base1 + len1-1]) must be greater than all elements of the second run.
+ *
+ * For performance, this method should be called only when len1 <= len2;
+ * its twin, mergeHi should be called if len1 >= len2. (Either method
+ * may be called if len1 == len2.)
+ *
+ * @param base1 index of first element in first run to be merged
+ * @param len1 length of first run to be merged (must be > 0)
+ * @param base2 index of first element in second run to be merged
+ * (must be aBase + aLen)
+ * @param len2 length of second run to be merged (must be > 0)
+ */
+ private void mergeLo(int base1, int len1, int base2, int len2) {
+ assert len1 > 0 && len2 > 0 && base1 + len1 == base2;
+
+ // Copy first run into temp array
+ T[] a = this.a; // For performance
+ T[] tmp = ensureCapacity(len1);
+ int cursor1 = tmpBase; // Indexes into tmp array
+ int cursor2 = base2; // Indexes int a
+ int dest = base1; // Indexes int a
+ System.arraycopy(a, base1, tmp, cursor1, len1);
+
+ // Move first element of second run and deal with degenerate cases
+ a[dest++] = a[cursor2++];
+ if (--len2 == 0) {
+ System.arraycopy(tmp, cursor1, a, dest, len1);
+ return;
+ }
+ if (len1 == 1) {
+ System.arraycopy(a, cursor2, a, dest, len2);
+ a[dest + len2] = tmp[cursor1]; // Last elt of run 1 to end of merge
+ return;
+ }
+
+ Comparator<? super T> c = this.c; // Use local variable for performance
+ int minGallop = this.minGallop; // " " " " "
+ outer:
+ while (true) {
+ int count1 = 0; // Number of times in a row that first run won
+ int count2 = 0; // Number of times in a row that second run won
+
+ /*
+ * Do the straightforward thing until (if ever) one run starts
+ * winning consistently.
+ */
+ do {
+ assert len1 > 1 && len2 > 0;
+ if (c.compare(a[cursor2], tmp[cursor1]) < 0) {
+ a[dest++] = a[cursor2++];
+ count2++;
+ count1 = 0;
+ if (--len2 == 0)
+ break outer;
+ } else {
+ a[dest++] = tmp[cursor1++];
+ count1++;
+ count2 = 0;
+ if (--len1 == 1)
+ break outer;
+ }
+ } while ((count1 | count2) < minGallop);
+
+ /*
+ * One run is winning so consistently that galloping may be a
+ * huge win. So try that, and continue galloping until (if ever)
+ * neither run appears to be winning consistently anymore.
+ */
+ do {
+ assert len1 > 1 && len2 > 0;
+ count1 = gallopRight(a[cursor2], tmp, cursor1, len1, 0, c);
+ if (count1 != 0) {
+ System.arraycopy(tmp, cursor1, a, dest, count1);
+ dest += count1;
+ cursor1 += count1;
+ len1 -= count1;
+ if (len1 <= 1) // len1 == 1 || len1 == 0
+ break outer;
+ }
+ a[dest++] = a[cursor2++];
+ if (--len2 == 0)
+ break outer;
+
+ count2 = gallopLeft(tmp[cursor1], a, cursor2, len2, 0, c);
+ if (count2 != 0) {
+ System.arraycopy(a, cursor2, a, dest, count2);
+ dest += count2;
+ cursor2 += count2;
+ len2 -= count2;
+ if (len2 == 0)
+ break outer;
+ }
+ a[dest++] = tmp[cursor1++];
+ if (--len1 == 1)
+ break outer;
+ minGallop--;
+ } while (count1 >= MIN_GALLOP | count2 >= MIN_GALLOP);
+ if (minGallop < 0)
+ minGallop = 0;
+ minGallop += 2; // Penalize for leaving gallop mode
+ } // End of "outer" loop
+ this.minGallop = minGallop < 1 ? 1 : minGallop; // Write back to field
+
+ if (len1 == 1) {
+ assert len2 > 0;
+ System.arraycopy(a, cursor2, a, dest, len2);
+ a[dest + len2] = tmp[cursor1]; // Last elt of run 1 to end of merge
+ } else if (len1 == 0) {
+ throw new IllegalArgumentException(
+ "Comparison method violates its general contract!");
+ } else {
+ assert len2 == 0;
+ assert len1 > 1;
+ System.arraycopy(tmp, cursor1, a, dest, len1);
+ }
+ }
+
+ /**
+ * Like mergeLo, except that this method should be called only if
+ * len1 >= len2; mergeLo should be called if len1 <= len2. (Either method
+ * may be called if len1 == len2.)
+ *
+ * @param base1 index of first element in first run to be merged
+ * @param len1 length of first run to be merged (must be > 0)
+ * @param base2 index of first element in second run to be merged
+ * (must be aBase + aLen)
+ * @param len2 length of second run to be merged (must be > 0)
+ */
+ private void mergeHi(int base1, int len1, int base2, int len2) {
+ assert len1 > 0 && len2 > 0 && base1 + len1 == base2;
+
+ // Copy second run into temp array
+ T[] a = this.a; // For performance
+ T[] tmp = ensureCapacity(len2);
+ int tmpBase = this.tmpBase;
+ System.arraycopy(a, base2, tmp, tmpBase, len2);
+
+ int cursor1 = base1 + len1 - 1; // Indexes into a
+ int cursor2 = tmpBase + len2 - 1; // Indexes into tmp array
+ int dest = base2 + len2 - 1; // Indexes into a
+
+ // Move last element of first run and deal with degenerate cases
+ a[dest--] = a[cursor1--];
+ if (--len1 == 0) {
+ System.arraycopy(tmp, tmpBase, a, dest - (len2 - 1), len2);
+ return;
+ }
+ if (len2 == 1) {
+ dest -= len1;
+ cursor1 -= len1;
+ System.arraycopy(a, cursor1 + 1, a, dest + 1, len1);
+ a[dest] = tmp[cursor2];
+ return;
+ }
+
+ Comparator<? super T> c = this.c; // Use local variable for performance
+ int minGallop = this.minGallop; // " " " " "
+ outer:
+ while (true) {
+ int count1 = 0; // Number of times in a row that first run won
+ int count2 = 0; // Number of times in a row that second run won
+
+ /*
+ * Do the straightforward thing until (if ever) one run
+ * appears to win consistently.
+ */
+ do {
+ assert len1 > 0 && len2 > 1;
+ if (c.compare(tmp[cursor2], a[cursor1]) < 0) {
+ a[dest--] = a[cursor1--];
+ count1++;
+ count2 = 0;
+ if (--len1 == 0)
+ break outer;
+ } else {
+ a[dest--] = tmp[cursor2--];
+ count2++;
+ count1 = 0;
+ if (--len2 == 1)
+ break outer;
+ }
+ } while ((count1 | count2) < minGallop);
+
+ /*
+ * One run is winning so consistently that galloping may be a
+ * huge win. So try that, and continue galloping until (if ever)
+ * neither run appears to be winning consistently anymore.
+ */
+ do {
+ assert len1 > 0 && len2 > 1;
+ count1 = len1 - gallopRight(tmp[cursor2], a, base1, len1, len1 - 1, c);
+ if (count1 != 0) {
+ dest -= count1;
+ cursor1 -= count1;
+ len1 -= count1;
+ System.arraycopy(a, cursor1 + 1, a, dest + 1, count1);
+ if (len1 == 0)
+ break outer;
+ }
+ a[dest--] = tmp[cursor2--];
+ if (--len2 == 1)
+ break outer;
+
+ count2 = len2 - gallopLeft(a[cursor1], tmp, tmpBase, len2, len2 - 1, c);
+ if (count2 != 0) {
+ dest -= count2;
+ cursor2 -= count2;
+ len2 -= count2;
+ System.arraycopy(tmp, cursor2 + 1, a, dest + 1, count2);
+ if (len2 <= 1) // len2 == 1 || len2 == 0
+ break outer;
+ }
+ a[dest--] = a[cursor1--];
+ if (--len1 == 0)
+ break outer;
+ minGallop--;
+ } while (count1 >= MIN_GALLOP | count2 >= MIN_GALLOP);
+ if (minGallop < 0)
+ minGallop = 0;
+ minGallop += 2; // Penalize for leaving gallop mode
+ } // End of "outer" loop
+ this.minGallop = minGallop < 1 ? 1 : minGallop; // Write back to field
+
+ if (len2 == 1) {
+ assert len1 > 0;
+ dest -= len1;
+ cursor1 -= len1;
+ System.arraycopy(a, cursor1 + 1, a, dest + 1, len1);
+ a[dest] = tmp[cursor2]; // Move first elt of run2 to front of merge
+ } else if (len2 == 0) {
+ throw new IllegalArgumentException(
+ "Comparison method violates its general contract!");
+ } else {
+ assert len1 == 0;
+ assert len2 > 0;
+ System.arraycopy(tmp, tmpBase, a, dest - (len2 - 1), len2);
+ }
+ }
+
+ /**
+ * Ensures that the external array tmp has at least the specified
+ * number of elements, increasing its size if necessary. The size
+ * increases exponentially to ensure amortized linear time complexity.
+ *
+ * @param minCapacity the minimum required capacity of the tmp array
+ * @return tmp, whether or not it grew
+ */
+ private T[] ensureCapacity(int minCapacity) {
+ if (tmpLen < minCapacity) {
+ // Compute smallest power of 2 > minCapacity
+ int newSize = -1 >>> Integer.numberOfLeadingZeros(minCapacity);
+ newSize++;
+
+ if (newSize < 0) // Not bloody likely!
+ newSize = minCapacity;
+ else
+ newSize = Math.min(newSize, a.length >>> 1);
+
+ @SuppressWarnings({"unchecked", "UnnecessaryLocalVariable"})
+ T[] newArray = (T[])java.lang.reflect.Array.newInstance
+ (a.getClass().getComponentType(), newSize);
+ tmp = newArray;
+ tmpLen = newSize;
+ tmpBase = 0;
+ }
+ return tmp;
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java b/app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java
index b4a5c48..5e8e5a1 100644
--- a/app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java
+++ b/app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java
@@ -1,5 +1,6 @@
package de.uni_marburg.powersort.benchmark;
+
import de.uni_marburg.powersort.sort.DummySort;
import de.uni_marburg.powersort.sort.MergeSort;
import de.uni_marburg.powersort.sort.TimSort;
@@ -7,6 +8,7 @@ import de.uni_marburg.powersort.data.DescendingIntegers;
import de.uni_marburg.powersort.data.RandomIntegers;
import de.uni_marburg.powersort.data.ObjectSupplier;
+import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.TimeUnit;
From ef9d8a512e1fa48b01c37fa68be7a029c54b7702 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Fri, 10 Jan 2025 20:56:55 +0000
Subject: [PATCH 41/70] shell.nix: cleanup
---
shell.nix | 22 ++++++++++------------
1 file changed, 10 insertions(+), 12 deletions(-)
diff --git a/shell.nix b/shell.nix
index b04b53a..65f3a06 100644
--- a/shell.nix
+++ b/shell.nix
@@ -5,30 +5,28 @@
# https://github.com/NixOS/nixpkgs/issues/166220#issuecomment-1745803058
{
- ### Import with nix channels ###
+ ### Import nixpkgs as channels ###
#
- # NixOS stable
+ # nixpkgs stable
#pkgs ? import <nixpkgs> {
+ # # Required for IntelliJ Ultimate
# config.allowUnfree = true;
#},
- # NixOS unstable
- #unstable ? import <unstable> {
- # config.allowUnfree = true;
- #}
+ # nixpkgs unstable
+ #unstable ? import <unstable> { }
}:
let
- ### Import with Niv ###
+ ### Import nixpkgs with Niv ###
#
sources = import ./nix/sources.nix;
- # NixOS stable
+ # nixpkgs stable
pkgs = import sources.nixpkgs {
+ # Required for IntelliJ Ultimate
config.allowUnfree = true;
};
- # NixOS unstable
- unstable = import sources.unstable {
- config.allowUnfree = true;
- };
+ # nixpkgs unstable
+ unstable = import sources.unstable { };
jdk = unstable.jdk23;
gradle = unstable.gradle.override {
From 1c810387735b21c14eca1e1518434e772d2b53c6 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 14 Jan 2025 10:20:48 +0000
Subject: [PATCH 42/70] chore: update Gradle
---
README.md | 6 ++++++
gradle/wrapper/gradle-wrapper.jar | Bin 43453 -> 43583 bytes
gradle/wrapper/gradle-wrapper.properties | 2 +-
gradlew | 7 +++++--
gradlew.bat | 2 ++
5 files changed, 14 insertions(+), 3 deletions(-)
diff --git a/README.md b/README.md
index dd21c02..3523f7f 100644
--- a/README.md
+++ b/README.md
@@ -22,6 +22,12 @@ We use Gradle for dependency and build management.
**Commandline**
+Update Gradle:
+
+```shell
+./gradlew wrapper --gradle-version latest
+```
+
Check which Java toolchains Gradle finds:
```shell
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
index e6441136f3d4ba8a0da8d277868979cfbc8ad796..a4b76b9530d66f5e68d973ea569d8e19de379189 100644
GIT binary patch
delta 12612
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
HJ<R_D`<Plw
delta 12460
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
L!=&c?m;C<#d67$>
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 9355b41..cea7a79 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.10-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.12-bin.zip
networkTimeout=10000
validateDistributionUrl=true
zipStoreBase=GRADLE_USER_HOME
diff --git a/gradlew b/gradlew
index 1aa94a4..f5feea6 100755
--- a/gradlew
+++ b/gradlew
@@ -15,6 +15,8 @@
# See the License for the specific language governing permissions and
# limitations under the License.
#
+# SPDX-License-Identifier: Apache-2.0
+#
##############################################################################
#
@@ -55,7 +57,7 @@
# Darwin, MinGW, and NonStop.
#
# (3) This script is generated from the Groovy template
-# https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+# https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
# within the Gradle project.
#
# You can find Gradle at https://github.com/gradle/gradle/.
@@ -84,7 +86,8 @@ done
# shellcheck disable=SC2034
APP_BASE_NAME=${0##*/}
# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
-APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s
+' "$PWD" ) || exit
# Use the maximum available, or set MAX_FD != -1 to use that value.
MAX_FD=maximum
diff --git a/gradlew.bat b/gradlew.bat
index 25da30d..9d21a21 100644
--- a/gradlew.bat
+++ b/gradlew.bat
@@ -13,6 +13,8 @@
@rem See the License for the specific language governing permissions and
@rem limitations under the License.
@rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
@if "%DEBUG%"=="" @echo off
@rem ##########################################################################
From dfb302d00910455612b79dd1f07f50f45be32a58 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 14 Jan 2025 10:21:18 +0000
Subject: [PATCH 43/70] chore: update nixpkgs
---
nix/sources.json | 12 ++++++------
1 file changed, 6 insertions(+), 6 deletions(-)
diff --git a/nix/sources.json b/nix/sources.json
index 2fcaaba..70d7ba5 100644
--- a/nix/sources.json
+++ b/nix/sources.json
@@ -5,10 +5,10 @@
"homepage": "",
"owner": "NixOS",
"repo": "nixpkgs",
- "rev": "3ffbbdbac0566a0977da3d2657b89cbcfe9a173b",
- "sha256": "0m3zh14is40vixpv125alyacd22835v0v845dsnk5d68wvwhikq2",
+ "rev": "cbd8ec4de4469333c82ff40d057350c30e9f7d36",
+ "sha256": "1bcgis62aj9slin2cm2h7ywqq4qswh4kzdlx0zgdwz80g4z10f8f",
"type": "tarball",
- "url": "https://github.com/NixOS/nixpkgs/archive/3ffbbdbac0566a0977da3d2657b89cbcfe9a173b.tar.gz",
+ "url": "https://github.com/NixOS/nixpkgs/archive/cbd8ec4de4469333c82ff40d057350c30e9f7d36.tar.gz",
"url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
},
"unstable": {
@@ -17,10 +17,10 @@
"homepage": "",
"owner": "NixOS",
"repo": "nixpkgs",
- "rev": "69b9a8c860bdbb977adfa9c5e817ccb717884182",
- "sha256": "12ljkkjg3gicamvryxr2bnfcdb05qdlbc5wv4lcw9sxamszp4cp7",
+ "rev": "3df3c47c19dc90fec35359e89ffb52b34d2b0e94",
+ "sha256": "1lhlm7czhwwys5ak6ngb5li6bxddilb9479k9nkss502kw8hwjyz",
"type": "tarball",
- "url": "https://github.com/NixOS/nixpkgs/archive/69b9a8c860bdbb977adfa9c5e817ccb717884182.tar.gz",
+ "url": "https://github.com/NixOS/nixpkgs/archive/3df3c47c19dc90fec35359e89ffb52b34d2b0e94.tar.gz",
"url_template": "https://github.com/<owner>/<repo>/archive/<rev>.tar.gz"
}
}
From 4c5f004b0649ea4c9ce1ecd11e66fb3d7a164ebd Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 14 Jan 2025 11:11:49 +0000
Subject: [PATCH 44/70] .idea
---
.idea/.gitignore | 8 --------
.idea/jarRepositories.xml | 20 --------------------
2 files changed, 28 deletions(-)
delete mode 100644 .idea/.gitignore
delete mode 100644 .idea/jarRepositories.xml
diff --git a/.idea/.gitignore b/.idea/.gitignore
deleted file mode 100644
index 13566b8..0000000
--- a/.idea/.gitignore
+++ /dev/null
@@ -1,8 +0,0 @@
-# Default ignored files
-/shelf/
-/workspace.xml
-# Editor-based HTTP Client requests
-/httpRequests/
-# Datasource local storage ignored files
-/dataSources/
-/dataSources.local.xml
diff --git a/.idea/jarRepositories.xml b/.idea/jarRepositories.xml
deleted file mode 100644
index fdc392f..0000000
--- a/.idea/jarRepositories.xml
+++ /dev/null
@@ -1,20 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
- <component name="RemoteRepositoriesConfiguration">
- <remote-repository>
- <option name="id" value="central" />
- <option name="name" value="Maven Central repository" />
- <option name="url" value="https://repo1.maven.org/maven2" />
- </remote-repository>
- <remote-repository>
- <option name="id" value="jboss.community" />
- <option name="name" value="JBoss Community repository" />
- <option name="url" value="https://repository.jboss.org/nexus/content/repositories/public/" />
- </remote-repository>
- <remote-repository>
- <option name="id" value="MavenRepo" />
- <option name="name" value="MavenRepo" />
- <option name="url" value="https://repo.maven.apache.org/maven2/" />
- </remote-repository>
- </component>
-</project>
\ No newline at end of file
From 82c58e403ca4670f9ebf1846d8c29164b55c0ed8 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 14 Jan 2025 11:17:00 +0000
Subject: [PATCH 45/70] benchmark - JMH: reduced time, improved filtering
---
app/build.gradle.kts | 12 ++++--
.../powersort/benchmark/JmhBase.java | 37 +++++++++++++-----
.../powersort/benchmark/JmhCgl.java | 5 +++
.../powersort/benchmark/Filter.java | 38 ++++++++++---------
.../uni_marburg/powersort/data/CglEnum.java | 36 ++++++++++--------
.../uni_marburg/powersort/sort/SortEnum.java | 2 +-
6 files changed, 82 insertions(+), 48 deletions(-)
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index 06c6b26..efbb5b8 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -50,8 +50,8 @@ tasks.register<JavaExec>("runCbmCgl") {
group = "application"
classpath = sourceSets["main"].runtimeClasspath
mainClass = "de.uni_marburg.powersort.benchmark.CbmCgl"
- // Results in `-Xmx8g` being passed to JVM
- maxHeapSize = "8g"
+ // Results in `-Xmx4g` being passed to JVM
+ maxHeapSize = "4g"
}
tasks.register<JavaExec>("runCbmCompetition") {
description = "Run Custom Benchmark (CBM) with Powersort competition lists"
@@ -84,9 +84,15 @@ jmh {
// https://github.com/openjdk/jmh/blob/1be779e0b4af174b67abf8080d1b76dda570d88d/jmh-core/src/main/java/org/openjdk/jmh/runner/options/CommandLineOptions.java#L148-L152
forceGC = true
+ // If human output is saved, it won't be written to stdout while running the benchmark!
+ //humanOutputFile = project.file("${project.layout.buildDirectory.get()}/reports/jmh/human.txt")
+
+ resultsFile = project.file("${project.layout.buildDirectory.get()}/reports/jmh/results.txt")
+ resultFormat = "CSV"
+
excludes = listOf(
// To skip JmhCgl or JmhCompetition, uncomment it below.
// "de.uni_marburg.powersort.benchmark.JmhCgl.benchmark",
-// "de.uni_marburg.powersort.benchmark.JmhCompetition.benchmark",
+ "de.uni_marburg.powersort.benchmark.JmhCompetition.benchmark",
)
}
diff --git a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhBase.java b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhBase.java
index f8b3e81..bc110cf 100644
--- a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhBase.java
+++ b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhBase.java
@@ -13,28 +13,45 @@ import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
+import org.openjdk.jmh.annotations.Threads;
import org.openjdk.jmh.annotations.Timeout;
import org.openjdk.jmh.annotations.Warmup;
import java.util.concurrent.TimeUnit;
-// TODO: The parameters are way too low. Use for debugging only!
/*
* Benchmark parameters
*/
-@Fork(value = 1, jvmArgsAppend = {"-Xms8g", "-Xmx8g"})
-@Warmup(iterations = 1)
-@Measurement(iterations = 6)
-@Timeout(time = 15, timeUnit = TimeUnit.SECONDS)
-@BenchmarkMode(Mode.AverageTime)
+
+@Fork(value = 1, jvmArgsAppend = {"-Xms4g", "-Xmx4g"})
+@Threads(1)
+@Timeout(time = 10, timeUnit = TimeUnit.SECONDS)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
/*
- * Benchmark state parameters
- *
- * Quote from JMH:
- * State objects naturally encapsulate the state on which benchmark is working on.
+ * Benchmark mode and related parameters
*/
+
+// AverageTime: "Average time per operation."
+// - "This mode is time-based, and it will run until the iteration time expires."
+//@BenchmarkMode(Mode.AverageTime)
+//@Warmup(iterations = 6, time = 1, timeUnit = TimeUnit.SECONDS)
+//@Measurement(iterations = 6, time = 1, timeUnit = TimeUnit.SECONDS)
+
+// SingleShotTime: "Time per single operation"
+// - "More warmup/measurement iterations are generally required."
+// - "Timers overhead might be significant if benchmarks are small;"
+@BenchmarkMode(Mode.SingleShotTime)
+@Warmup(iterations = 12)
+@Measurement(iterations = 6)
+
+/*
+ * State parameters
+ *
+ */
+
+// "State objects naturally encapsulate the state on which benchmark is working on."
@State(Scope.Benchmark)
+
public class JmhBase {
DataEnum getDataEnum(){
return null;
diff --git a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
index 96d2355..ad47b4b 100644
--- a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
+++ b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
@@ -16,9 +16,14 @@ import org.openjdk.jmh.annotations.State;
*/
@State(Scope.Benchmark)
public class JmhCgl extends JmhBase {
+ // Either all or a selection of input lists.
@Param()
+ //@Param({"ASCENDING_RUNS", "ASCENDING_RUNS_WITH_OVERLAP"})
CglEnum dataEnum;
+
+ // Either all or a selection of sort implementations.
@Param()
+ //@Param({"TIM_SORT", "FASTER_FINN_SORT"})
SortEnum sortEnum;
@Override
diff --git a/app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java b/app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java
index 353277b..9943b93 100644
--- a/app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java
+++ b/app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java
@@ -19,11 +19,11 @@ public class Filter {
public static boolean isFiltered(DataEnum d, SortEnum s) {
// To skip some of the inputs for all sort algorithms, uncomment them here.
// if (List.of(
-// CglEnum.RANDOM_INTEGERS_300M,
-// CglEnum.ASCENDING_INTEGERS_300M,
-// CglEnum.DESCENDING_INTEGERS_250M,
-// CglEnum.ASCENDING_RUNS_1M,
-// CglEnum.ASCENDING_RUNS_WITH_OVERLAP_1M
+// CglEnum.RANDOM_INTEGERS,
+// CglEnum.ASCENDING_INTEGERS,
+// CglEnum.DESCENDING_INTEGERS,
+// CglEnum.ASCENDING_RUNS,
+// CglEnum.ASCENDING_RUNS_WITH_OVERLAP
// ).contains(d)) {
// return true;
// }
@@ -54,11 +54,11 @@ public class Filter {
if (s == SortEnum.QUICK_SORT) {
return List.of(
- CglEnum.RANDOM_INTEGERS_300M,
- CglEnum.ASCENDING_INTEGERS_300M,
- CglEnum.DESCENDING_INTEGERS_250M,
- CglEnum.ASCENDING_RUNS_1M,
- CglEnum.ASCENDING_RUNS_WITH_OVERLAP_1M,
+ CglEnum.RANDOM_INTEGERS,
+ CglEnum.ASCENDING_INTEGERS,
+ CglEnum.DESCENDING_INTEGERS,
+ CglEnum.ASCENDING_RUNS,
+ CglEnum.ASCENDING_RUNS_WITH_OVERLAP,
CompetitionEnum.COMPETITION_34,
CompetitionEnum.COMPETITION_35,
@@ -109,25 +109,25 @@ public class Filter {
if (s == SortEnum.MERGE_SORT) {
return List.of(
- CglEnum.RANDOM_INTEGERS_300M,
- CglEnum.ASCENDING_INTEGERS_300M,
- CglEnum.DESCENDING_INTEGERS_250M
+ CglEnum.RANDOM_INTEGERS,
+ CglEnum.ASCENDING_INTEGERS,
+ CglEnum.DESCENDING_INTEGERS
).contains(d);
}
if (s == SortEnum.BUBBLE_SORT) {
return List.of(
- CglEnum.DESCENDING_INTEGERS_250M,
- CglEnum.ASCENDING_RUNS_1M,
- CglEnum.ASCENDING_RUNS_WITH_OVERLAP_1M
+ CglEnum.DESCENDING_INTEGERS,
+ CglEnum.ASCENDING_RUNS,
+ CglEnum.ASCENDING_RUNS_WITH_OVERLAP
).contains(d);
}
// TODO: Remove this once performance of FinnSort improved
if (s == SortEnum.FINN_SORT) {
return List.of(
- CglEnum.DESCENDING_INTEGERS_250M,
- CglEnum.ASCENDING_RUNS_1M,
+ CglEnum.DESCENDING_INTEGERS,
+ CglEnum.ASCENDING_RUNS,
CompetitionEnum.COMPETITION_83,
CompetitionEnum.COMPETITION_85,
@@ -173,6 +173,8 @@ public class Filter {
// TODO: Remove this once performance of ASort improved
if (s == SortEnum.ASORT) {
return List.of(
+ CglEnum.ASCENDING_RUNS,
+ CglEnum.ASCENDING_RUNS_WITH_OVERLAP,
CompetitionEnum.COMPETITION_173,
CompetitionEnum.COMPETITION_174
).contains(d);
diff --git a/app/src/main/java/de/uni_marburg/powersort/data/CglEnum.java b/app/src/main/java/de/uni_marburg/powersort/data/CglEnum.java
index 94da3e1..114d2dd 100644
--- a/app/src/main/java/de/uni_marburg/powersort/data/CglEnum.java
+++ b/app/src/main/java/de/uni_marburg/powersort/data/CglEnum.java
@@ -3,12 +3,12 @@ package de.uni_marburg.powersort.data;
/**
* Enumeration of Custom Generated Lists (CGL).
*/
-public enum CglEnum implements DataEnum{
- RANDOM_INTEGERS_300M,
- ASCENDING_INTEGERS_300M,
- DESCENDING_INTEGERS_250M,
- ASCENDING_RUNS_1M,
- ASCENDING_RUNS_WITH_OVERLAP_1M;
+public enum CglEnum implements DataEnum {
+ RANDOM_INTEGERS,
+ ASCENDING_INTEGERS,
+ DESCENDING_INTEGERS,
+ ASCENDING_RUNS,
+ ASCENDING_RUNS_WITH_OVERLAP;
@Override
public ObjectSupplier getObjectSupplier() {
@@ -16,18 +16,22 @@ public enum CglEnum implements DataEnum{
// final long seed = 3651660232967549736L; // System.nanoTime() ++ Math.random()
final long seed = 140506881906827520L; // (long) 'P' * (long) 'O' *(long) 'W' * (long) 'E' * (long) 'R' * (long) 'S' * (long) 'O' * (long) 'R' * (long) 'T';
- int longListSize = 300_000_000; // Any larger: Out of Heap Space. TODO GRADLE config
- int middleListSize = 250_000_000;
- int runs = 1_000;
- int runLength = 1_000;
+ int listSize = 66_000_000;
+ int runs = 3010;
+ int runLength = 3010;
+
+ // Constant factors
+ double a = 0.96;
+ double b = 0.25;
+ double c = 0.81;
return switch (this) {
- case RANDOM_INTEGERS_300M -> new RandomIntegers(longListSize, seed);
- case ASCENDING_INTEGERS_300M -> new AscendingIntegers(longListSize);
- case DESCENDING_INTEGERS_250M -> new DescendingIntegers(middleListSize);
- case ASCENDING_RUNS_1M -> AscendingRuns.newAscendingRuns(runs, runLength, -runLength);
- case ASCENDING_RUNS_WITH_OVERLAP_1M ->
- AscendingRuns.newAscendingRuns(runs, runLength, (int) (-0.5 * runLength));
+ case RANDOM_INTEGERS -> new RandomIntegers(listSize, seed);
+ case ASCENDING_INTEGERS -> new AscendingIntegers((int) (a * listSize));
+ case DESCENDING_INTEGERS -> new DescendingIntegers((int) (b * listSize));
+ case ASCENDING_RUNS -> AscendingRuns.newAscendingRuns(runs, runLength, -1 * runLength);
+ case ASCENDING_RUNS_WITH_OVERLAP ->
+ AscendingRuns.newAscendingRuns((int) (c * runs), (int) (c * runLength), (int) (-0.5 * c * runLength));
};
}
}
diff --git a/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java b/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
index 4a203f6..5883b93 100644
--- a/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
+++ b/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
@@ -7,8 +7,8 @@ import de.uni_marburg.powersort.sort.dpqs.DualPivotQuicksort;
public enum SortEnum {
TIM_SORT,
- ASORT,
FASTER_FINN_SORT,
+ ASORT,
FINN_SORT,
DPQS,
QUICK_SORT,
From 4198e28c797ab79bbb6c4a9393ecca39d5e07bab Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 14 Jan 2025 12:02:58 +0000
Subject: [PATCH 46/70] benchmark: warmup & iterations
---
.../powersort/benchmark/CbmBase.java | 52 ++++++++++--------
.../powersort/benchmark/CbmBench.java | 54 +++++++++++++++++++
.../powersort/benchmark/CbmCgl.java | 3 +-
.../powersort/benchmark/CbmCompetition.java | 3 +-
.../powersort/benchmark/Filter.java | 1 +
5 files changed, 89 insertions(+), 24 deletions(-)
create mode 100644 app/src/main/java/de/uni_marburg/powersort/benchmark/CbmBench.java
diff --git a/app/src/main/java/de/uni_marburg/powersort/benchmark/CbmBase.java b/app/src/main/java/de/uni_marburg/powersort/benchmark/CbmBase.java
index 57172b4..08c202d 100644
--- a/app/src/main/java/de/uni_marburg/powersort/benchmark/CbmBase.java
+++ b/app/src/main/java/de/uni_marburg/powersort/benchmark/CbmBase.java
@@ -4,44 +4,52 @@ import de.uni_marburg.powersort.data.DataEnum;
import de.uni_marburg.powersort.sort.SortEnum;
import de.uni_marburg.powersort.data.ObjectSupplier;
-import java.util.concurrent.TimeUnit;
+import java.util.Arrays;
/**
* Custom Benchmark (CBM).
*/
-public class CbmBase {
- static void run(SortEnum[] sortImplementations, DataEnum[] dataEnums) {
+public class CbmBase implements Runnable {
+ private final SortEnum[] sortImplementations;
+ private final DataEnum[] dataEnums;
+ private final int maxDataEnumStrLen;
+ private final int maxSortStrLen;
+
+ public CbmBase(SortEnum[] sortEnums, DataEnum[] dataEnums) {
+ this.sortImplementations = sortEnums;
+ this.dataEnums = dataEnums;
+
+ maxDataEnumStrLen = Arrays.stream(dataEnums).map(e -> e.toString().length()).max(Integer::compareTo).orElse(0);
+ maxSortStrLen = Arrays.stream(sortEnums).map(e -> e.toString().length()).max(Integer::compareTo).orElse(0);
+ }
+
+ @Override
+ public void run() {
System.out.println();
+
for (DataEnum dataEnum : dataEnums) {
ObjectSupplier objectSupplier = null;
for (SortEnum sortImplementation : sortImplementations) {
if (!Filter.isFiltered(dataEnum, sortImplementation)) {
if (objectSupplier == null) {
- System.out.println("⏳ Creating object supplier " + dataEnum + " ⏳");
+ System.out.println("Creating object supplier " + dataEnum);
+ System.out.println();
objectSupplier = dataEnum.getObjectSupplier();
}
- benchmark(objectSupplier, sortImplementation);
+
+ String dataEnumStr = dataEnum.toString();
+ dataEnumStr += " ".repeat(maxDataEnumStrLen - dataEnumStr.length());
+ String sortImplStr = sortImplementation.toString();
+ sortImplStr += " ".repeat(maxSortStrLen - sortImplStr.length());
+
+ CbmBench cbmBench = new CbmBench(dataEnumStr, sortImplStr, objectSupplier, sortImplementation);
+ cbmBench.run();
+
+ System.out.println();
}
}
System.out.println();
}
}
-
- static void benchmark(ObjectSupplier objectSupplier, SortEnum sortImplementation) {
- System.out.print(sortImplementation);
- System.out.flush();
- Object[] sortInput = objectSupplier.getCopy();
-
- // TODO: JVM warmup!
- final long startNanos = System.nanoTime();
- sortImplementation.getSortImpl().sort(sortInput);
- final long stopNanos = System.nanoTime();
-
- final long durNanos = stopNanos - startNanos;
- final long durMillis = TimeUnit.NANOSECONDS.toMillis(durNanos);
- final String durFormatted = LongFormatter.formatUnderscore(durMillis);
-
- System.out.println("," + durFormatted);
- }
}
diff --git a/app/src/main/java/de/uni_marburg/powersort/benchmark/CbmBench.java b/app/src/main/java/de/uni_marburg/powersort/benchmark/CbmBench.java
new file mode 100644
index 0000000..7009720
--- /dev/null
+++ b/app/src/main/java/de/uni_marburg/powersort/benchmark/CbmBench.java
@@ -0,0 +1,54 @@
+package de.uni_marburg.powersort.benchmark;
+
+import de.uni_marburg.powersort.data.ObjectSupplier;
+import de.uni_marburg.powersort.sort.SortEnum;
+
+import java.util.concurrent.TimeUnit;
+
+public class CbmBench implements Runnable{
+ private final String dataEnumStr;
+ private final String sortImplStr;
+ private final ObjectSupplier objectSupplier;
+ private final SortEnum sortImplementation;
+
+ public CbmBench(String dataEnumStr, String sortImplStr, ObjectSupplier objectSupplier, SortEnum sortImplementation) {
+ this.dataEnumStr = dataEnumStr;
+ this.sortImplStr = sortImplStr;
+ this.objectSupplier = objectSupplier;
+ this.sortImplementation = sortImplementation;
+ }
+
+ @Override
+ public void run() {
+ // Warmup
+ for (int i = 0; i < 3; i++) {
+ benchmark(true);
+ }
+ // Measure
+ for (int i = 0; i < 3; i++) {
+ benchmark(false);
+ }
+ }
+
+ private void benchmark(boolean warmup) {
+ System.out.print(dataEnumStr + "," + sortImplStr + ",");
+ if (warmup) {
+ System.out.print("WARMUP ,");
+ } else {
+ System.out.print("MEASURE,");
+ }
+ System.out.flush();
+
+ Object[] sortInput = objectSupplier.getCopy();
+
+ final long startNanos = System.nanoTime();
+ sortImplementation.getSortImpl().sort(sortInput);
+ final long stopNanos = System.nanoTime();
+
+ final long durNanos = stopNanos - startNanos;
+ final long durMillis = TimeUnit.NANOSECONDS.toMillis(durNanos);
+ final String durFormatted = LongFormatter.formatUnderscore(durMillis);
+
+ System.out.println(durFormatted);
+ }
+}
diff --git a/app/src/main/java/de/uni_marburg/powersort/benchmark/CbmCgl.java b/app/src/main/java/de/uni_marburg/powersort/benchmark/CbmCgl.java
index bc8ec7a..7ff471e 100644
--- a/app/src/main/java/de/uni_marburg/powersort/benchmark/CbmCgl.java
+++ b/app/src/main/java/de/uni_marburg/powersort/benchmark/CbmCgl.java
@@ -5,9 +5,10 @@ import de.uni_marburg.powersort.sort.SortEnum;
public class CbmCgl {
public static void main(String[] args) {
- CbmBase.run(
+ CbmBase cbmBase = new CbmBase(
SortEnum.values(),
CglEnum.values()
);
+ cbmBase.run();
}
}
diff --git a/app/src/main/java/de/uni_marburg/powersort/benchmark/CbmCompetition.java b/app/src/main/java/de/uni_marburg/powersort/benchmark/CbmCompetition.java
index 03f4d6a..b31b91a 100644
--- a/app/src/main/java/de/uni_marburg/powersort/benchmark/CbmCompetition.java
+++ b/app/src/main/java/de/uni_marburg/powersort/benchmark/CbmCompetition.java
@@ -5,9 +5,10 @@ import de.uni_marburg.powersort.sort.SortEnum;
public class CbmCompetition {
public static void main(String[] args) {
- CbmBase.run(
+ CbmBase cbmBase = new CbmBase(
SortEnum.values(),
CompetitionEnum.values()
);
+ cbmBase.run();
}
}
diff --git a/app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java b/app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java
index 9943b93..34ddc3e 100644
--- a/app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java
+++ b/app/src/main/java/de/uni_marburg/powersort/benchmark/Filter.java
@@ -128,6 +128,7 @@ public class Filter {
return List.of(
CglEnum.DESCENDING_INTEGERS,
CglEnum.ASCENDING_RUNS,
+ CglEnum.ASCENDING_RUNS_WITH_OVERLAP,
CompetitionEnum.COMPETITION_83,
CompetitionEnum.COMPETITION_85,
From e39a8082e36a97868e051175064962335da3c43e Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 14 Jan 2025 20:42:13 +0000
Subject: [PATCH 47/70] benchmark: add input "many ascending runs"
---
.../uni_marburg/powersort/benchmark/JmhCgl.java | 2 +-
.../de/uni_marburg/powersort/data/CglEnum.java | 15 ++++++++++++---
2 files changed, 13 insertions(+), 4 deletions(-)
diff --git a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
index ad47b4b..6f146b0 100644
--- a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
+++ b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
@@ -18,7 +18,7 @@ import org.openjdk.jmh.annotations.State;
public class JmhCgl extends JmhBase {
// Either all or a selection of input lists.
@Param()
- //@Param({"ASCENDING_RUNS", "ASCENDING_RUNS_WITH_OVERLAP"})
+ //@Param({"ASCENDING_RUNS", "ASCENDING_RUNS_WITH_OVERLAP", "MANY_ASCENDING_RUNS", "MANY_ASCENDING_RUNS_WITH_OVERLAP"})
CglEnum dataEnum;
// Either all or a selection of sort implementations.
diff --git a/app/src/main/java/de/uni_marburg/powersort/data/CglEnum.java b/app/src/main/java/de/uni_marburg/powersort/data/CglEnum.java
index 114d2dd..a7a37bd 100644
--- a/app/src/main/java/de/uni_marburg/powersort/data/CglEnum.java
+++ b/app/src/main/java/de/uni_marburg/powersort/data/CglEnum.java
@@ -8,7 +8,9 @@ public enum CglEnum implements DataEnum {
ASCENDING_INTEGERS,
DESCENDING_INTEGERS,
ASCENDING_RUNS,
- ASCENDING_RUNS_WITH_OVERLAP;
+ ASCENDING_RUNS_WITH_OVERLAP,
+ MANY_ASCENDING_RUNS,
+ MANY_ASCENDING_RUNS_WITH_OVERLAP;
@Override
public ObjectSupplier getObjectSupplier() {
@@ -17,13 +19,17 @@ public enum CglEnum implements DataEnum {
final long seed = 140506881906827520L; // (long) 'P' * (long) 'O' *(long) 'W' * (long) 'E' * (long) 'R' * (long) 'S' * (long) 'O' * (long) 'R' * (long) 'T';
int listSize = 66_000_000;
- int runs = 3010;
- int runLength = 3010;
+ int runs = 3_010;
+ int runLength = 3_010;
+
+ int manyRuns = 30_000;
+ int shortRunLength = 50;
// Constant factors
double a = 0.96;
double b = 0.25;
double c = 0.81;
+ double d = 1.0;
return switch (this) {
case RANDOM_INTEGERS -> new RandomIntegers(listSize, seed);
@@ -32,6 +38,9 @@ public enum CglEnum implements DataEnum {
case ASCENDING_RUNS -> AscendingRuns.newAscendingRuns(runs, runLength, -1 * runLength);
case ASCENDING_RUNS_WITH_OVERLAP ->
AscendingRuns.newAscendingRuns((int) (c * runs), (int) (c * runLength), (int) (-0.5 * c * runLength));
+ case MANY_ASCENDING_RUNS -> AscendingRuns.newAscendingRuns(manyRuns, shortRunLength, -1 * shortRunLength);
+ case MANY_ASCENDING_RUNS_WITH_OVERLAP ->
+ AscendingRuns.newAscendingRuns((int) (d * manyRuns), (int) (d * shortRunLength), (int) (-0.5 * d * shortRunLength));
};
}
}
From a684cb30ec3096215d591ac24f7937b0eaba0c1d Mon Sep 17 00:00:00 2001
From: M-H9 <mohammed.othman.omer97@gmail.com>
Date: Wed, 15 Jan 2025 21:48:33 +0100
Subject: [PATCH 48/70] Converting IMPL_M_1 to Object and it works fine
---
.idea/compiler.xml | 10 ++
.../powersort/benchmark/JmhCgl.java | 4 +-
.../uni_marburg/powersort/MSort/IMPL_M_1.java | 102 ++++++++++++------
.../uni_marburg/powersort/MSort/IMPL_M_2.java | 2 +-
.../uni_marburg/powersort/sort/SortEnum.java | 6 ++
.../powersort/MSort/PowerSortT.java | 14 +--
.../powersort/MSort/PowerSortTest.java | 4 +-
7 files changed, 97 insertions(+), 45 deletions(-)
diff --git a/.idea/compiler.xml b/.idea/compiler.xml
index cbd75e9..4ba6ee5 100644
--- a/.idea/compiler.xml
+++ b/.idea/compiler.xml
@@ -3,6 +3,16 @@
<component name="CompilerConfiguration">
<annotationProcessing>
<profile default="true" name="Default" enabled="true" />
+ <profile name="Gradle Imported" enabled="true">
+ <outputRelativeToContentRoot value="true" />
+ <processorPath useClasspath="false">
+ <entry name="$USER_HOME$/.gradle/caches/modules-2/files-2.1/org.openjdk.jmh/jmh-generator-annprocess/1.37/da93888682df163144edf9b13d2b78e54166063a/jmh-generator-annprocess-1.37.jar" />
+ <entry name="$USER_HOME$/.gradle/caches/modules-2/files-2.1/org.openjdk.jmh/jmh-core/1.37/896f27e49105b35ea1964319c83d12082e7a79ef/jmh-core-1.37.jar" />
+ <entry name="$USER_HOME$/.gradle/caches/modules-2/files-2.1/net.sf.jopt-simple/jopt-simple/5.0.4/4fdac2fbe92dfad86aa6e9301736f6b4342a3f5c/jopt-simple-5.0.4.jar" />
+ <entry name="$USER_HOME$/.gradle/caches/modules-2/files-2.1/org.apache.commons/commons-math3/3.6.1/e4ba98f1d4b3c80ec46392f25e094a6a2e58fcbf/commons-math3-3.6.1.jar" />
+ </processorPath>
+ <module name="powersort.app.jmh" />
+ </profile>
</annotationProcessing>
<bytecodeTargetLevel target="23" />
</component>
diff --git a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
index 6f146b0..a58942e 100644
--- a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
+++ b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
@@ -22,8 +22,8 @@ public class JmhCgl extends JmhBase {
CglEnum dataEnum;
// Either all or a selection of sort implementations.
- @Param()
- //@Param({"TIM_SORT", "FASTER_FINN_SORT"})
+ //@Param()
+ @Param({"TIM_SORT", "FINN_SORT", "IMPL_M_11"})
SortEnum sortEnum;
@Override
diff --git a/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_1.java b/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_1.java
index bcfecb9..54b8ea4 100644
--- a/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_1.java
+++ b/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_1.java
@@ -2,10 +2,11 @@ package de.uni_marburg.powersort.MSort;
import java.util.ArrayList;
import java.util.Collections;
+import java.util.Comparator;
import java.util.List;
import java.util.stream.IntStream;
-public class IMPL_M_1 <T extends Comparable<? super T>> {
+public class IMPL_M_1 {
private IMPL_M_1() {
}
@@ -28,7 +29,6 @@ public class IMPL_M_1 <T extends Comparable<? super T>> {
*/
protected static int MERGE_COST = 0;
-
public static void fillWithAscRunsHighToLow(List<Integer> A, int[] runLengths, int runLenFactor) {
//A has a fixed size, but it doesn't have any meaningful values
int n = A.size();
@@ -54,55 +54,91 @@ public class IMPL_M_1 <T extends Comparable<? super T>> {
}
- static <T extends Comparable<? super T>> List<T> merge(List<T> run1, List<T> run2) {
+ static <T> List<T> merge(List<T> run1, List<T> run2, Comparator<? super T> c) {
List<T> result = new ArrayList<>();
while (!run1.isEmpty() && !run2.isEmpty()) {
//This comparison only works if the lists are sorted
- if (run1.get(0).compareTo(run2.get(0)) < 0) {
- result.add(run1.remove(0));
+ if (c.compare(run1.getFirst(),run2.getFirst()) < 0) {
+ result.add(run1.removeFirst());
} else {
- result.add(run2.remove(0));
+ result.add(run2.removeFirst());
}
}
- /// can be improved by finding out which one is empty and only add the other one
+ // can be improved by finding out which one is empty and only add the other one
result.addAll(run1);
result.addAll(run2);
return result;
}
- static <T extends Comparable<? super T>> void mergeInplace(List<T> a, int i, int m, int j) {
- // System.out.printf("Merge(%d, %d, %d)%n", i, m, j);
- MERGE_COST += j - i;
- List<T> sublist = merge(
- new ArrayList<>(a.subList(i, m)),
- new ArrayList<>(a.subList(m, j))
- );
- for (int k = 0; k < sublist.size(); k++) {
- a.set(i + k, sublist.get(k));
+ // New helper method to handle range reversal
+ private static <T> void reverseRange(T[] a, int start, int end) {
+ // end is exclusive, so we need to use end-1 as the right boundary
+ int left = start;
+ int right = end - 1;
+ while (left < right) {
+ T temp = a[left];
+ a[left] = a[right];
+ a[right] = temp;
+ left++;
+ right--;
}
}
- static <T extends Comparable<? super T>> int extendRun(List<T> a, int i) {
+ static <T> void mergeInplace(T[] a, int i, int m, int j, Comparator<? super T> c) {
+ // System.out.printf("Merge(%d, %d, %d)%n", i, m, j);
+ MERGE_COST += j - i;
+// Create temporary arrays for merging
+ @SuppressWarnings("unchecked")
+ T[] left = (T[]) new Object[m - i];
+ @SuppressWarnings("unchecked")
+ T[] right = (T[]) new Object[j - m];
+
+ // Copy data to temporary arrays
+ System.arraycopy(a, i, left, 0, m - i);
+ System.arraycopy(a, m, right, 0, j - m);
+
+ // Merge back to original array
+ int k = i, l = 0, r = 0;
+ while (l < left.length && r < right.length) {
+ if (c.compare(left[l], right[r]) <= 0) {
+ a[k++] = left[l++];
+ } else {
+ a[k++] = right[r++];
+ }
+ }
+
+ // Copy remaining elements
+ while (l < left.length) {
+ a[k++] = left[l++];
+ }
+ while (r < right.length) {
+ a[k++] = right[r++];
+ }
+ }
+
+
+ static <T> int extendRun(T [] a, int i, Comparator<? super T> c) {
// if i was the element before end so just return the last element
- if (i == a.size() - 1) {
+ if (i == a.length - 1) {
return i + 1;
}
//we're looking at the element next to a[i]
int j = i + 1;
- if (a.get(i).compareTo( a.get(j)) <=0) {
- while (j < a.size() && a.get(j - 1).compareTo( a.get(j)) <= 0) {
+ if (c.compare(a[i],a[j]) <=0) {
+ while (j < a.length && c.compare(a[j - 1], a[j]) <= 0) {
j++;
}
} else {
- while (j < a.size() && a.get(j - 1).compareTo(a.get(j)) > 0) {
+ while (j < a.length && c.compare(a[j - 1],a[j]) > 0) {
j++;
}
- List<T> sublist = a.subList(i, j);
- Collections.reverse(sublist);
+ // Reverse the decreasing sequence
+ reverseRange(a,i,j);
}
return j;
}
+
public static int power(int[] run1, int[] run2, int n) {
int i1 = run1[0], n1 = run1[1];
int i2 = run2[0], n2 = run2[1];
@@ -122,35 +158,35 @@ public class IMPL_M_1 <T extends Comparable<? super T>> {
return l;
}
- public static <T extends Comparable<? super T>> void mergeTopmost2(List<T> a, List<int []> runs) {
+ public static <T> void mergeTopmost2(T[] a, List<int[]> runs, Comparator<? super T> c) {
assert runs.size() >= 2;
int[] Y = runs.get(runs.size() - 2);
- int[] Z = runs.get(runs.size() - 1);
+ int[] Z = runs.getLast();
assert Z[0] == Y[0] + Y[1];
- mergeInplace(a, Y[0], Z[0], Z[0] + Z[1]);
+ mergeInplace(a, Y[0], Z[0], Z[0] + Z[1], c);
runs.set(runs.size() - 2, new int[] {Y[0], Y[1] + Z[1], Y[2]});
runs.removeLast();
}
- public static <T extends Comparable<? super T>> void powerSort(List<T> a) {
- int n = a.size();
+ public static <T> void powerSort(T[] a, Comparator<? super T> c) {
+ int n = a.length;
int i = 0;
List<int[]> runs = new ArrayList<>();
- int j = extendRun(a, i);
+ int j = extendRun(a, i, c);
runs.add(new int[] {i, j - i, 0});
i = j;
while (i < n) {
- j = extendRun(a, i);
- int p = power(runs.get(runs.size() - 1), new int[] {i, j - i}, n);
+ j = extendRun(a, i, c);
+ int p = power(runs.getLast(), new int[] {i, j - i}, n);
while (p <= runs.getLast()[2]) {
- mergeTopmost2(a, runs);
+ mergeTopmost2(a, runs, c);
}
runs.add(new int[] {i, j - i, p});
@@ -158,7 +194,7 @@ public class IMPL_M_1 <T extends Comparable<? super T>> {
}
while (runs.size() >= 2) {
- mergeTopmost2(a, runs);
+ mergeTopmost2(a, runs, c);
}
}
diff --git a/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_2.java b/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_2.java
index a552fca..b892e84 100644
--- a/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_2.java
+++ b/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_2.java
@@ -79,7 +79,7 @@ public class IMPL_M_2<T>{
* of the minimum stack length required as a function of the length
* of the array being sorted and the minimum merge sequence length.
*/
- private static final int MIN_MERGE = 32;
+ private static final int MIN_MERGE = 24;
/**
* The array being sorted.
diff --git a/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java b/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
index 5883b93..105f6a0 100644
--- a/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
+++ b/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
@@ -2,6 +2,8 @@ package de.uni_marburg.powersort.sort;
import de.uni_marburg.powersort.FinnSort.FinnSort;
import de.uni_marburg.powersort.FinnSort.FasterFinnSort;
+import de.uni_marburg.powersort.MSort.IMPL_M_1;
+import de.uni_marburg.powersort.MSort.IMPL_M_2;
import de.uni_marburg.powersort.benchmark.NaturalOrder;
import de.uni_marburg.powersort.sort.dpqs.DualPivotQuicksort;
@@ -10,6 +12,8 @@ public enum SortEnum {
FASTER_FINN_SORT,
ASORT,
FINN_SORT,
+ IMPL_M_11,
+ IMPL_M_21,
DPQS,
QUICK_SORT,
MERGE_SORT,
@@ -23,6 +27,8 @@ public enum SortEnum {
case MERGE_SORT -> array -> MergeSort.legacyMergeSort(array, NaturalOrder.INSTANCE);
case TIM_SORT -> array -> TimSort.sort(array, 0, array.length, NaturalOrder.INSTANCE, null, 0, 0);
case FINN_SORT -> array -> FinnSort.sort(array, NaturalOrder.INSTANCE);
+ case IMPL_M_11 -> array -> IMPL_M_1.powerSort(array,NaturalOrder.INSTANCE);
+ case IMPL_M_21 -> array -> IMPL_M_2.sort(array, 0, array.length, NaturalOrder.INSTANCE, null, 0, 0);
case FASTER_FINN_SORT -> array -> FasterFinnSort.sort(array, 0, array.length, NaturalOrder.INSTANCE, null, 0, 0);
case ASORT -> array -> ASort.sort(array, NaturalOrder.INSTANCE);
};
diff --git a/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortT.java b/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortT.java
index 8a0bd76..feb81dc 100644
--- a/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortT.java
+++ b/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortT.java
@@ -33,22 +33,22 @@ public class PowerSortT {
public static void testMerge() {
List<Integer> run1 = new ArrayList<>(Arrays.asList(1, 4, 6));
List<Integer> run2 = new ArrayList<>(Arrays.asList(2, 3, 5));
- List<Integer> result = merge(run1, run2);
- System.out.println("Test merge: " + result);
+ // List<Integer> result = merge(run1, run2);
+ // System.out.println("Test merge: " + result);
}
// Test for mergeInplace
public static void testMergeInplace() {
List<Integer> A = new ArrayList<>(Arrays.asList(1, 4, 6, 2, 3, 5));
- mergeInplace(A, 0, 3, 6);
+ //mergeInplace(A, 0, 3, 6);
System.out.println("Test mergeInplace: " + A);
}
// Test for extendRun
public static void testExtendRun() {
List<Integer> A = new ArrayList<>(Arrays.asList(1, 2, 3, 6, 5, 4));
- int endIndex = extendRun(A, 0);
- System.out.println("Test extendRun (from 0): " + endIndex);
+ // int endIndex = extendRun(A, 0);
+ // System.out.println("Test extendRun (from 0): " + endIndex);
System.out.println("Modified List: " + A);
}
@@ -76,14 +76,14 @@ public class PowerSortT {
List<int[]> runs = new ArrayList<>();
runs.add(new int[]{0, 3, 1});
runs.add(new int[]{3, 3, 1});
- mergeTopmost2(A, runs);
+ // mergeTopmost2(A, runs);
System.out.println("Test mergeTopmost2: " + A);
}
// Test for powerSort
public static void testPowerSort() {
List<Integer> A = new ArrayList<>(Arrays.asList(10, 9, 8, 7, 6, 5, 4, 3, 2, 1));
- powerSort(A);
+ // powerSort(A);
System.out.println("Test powerSort: " + A);
}
}
diff --git a/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortTest.java b/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortTest.java
index 1d1bb78..07d5ab6 100644
--- a/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortTest.java
+++ b/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortTest.java
@@ -28,7 +28,7 @@ class PowerSortTest {
fillWithAscRunsHighToLow(a, runs, 1);
MERGE_COST = 0;
System.out.println("Sorting with Powersort:");
- powerSort(a);
+ //powerSort(a);
System.out.println("Merge cost: " + MERGE_COST);
}
@@ -36,7 +36,7 @@ class PowerSortTest {
public void testWithFinnInputList() {
List<Integer> numbers = List.of(new Integer[] {24, 25, 26, 27, 28, 21, 22, 23, 18, 19, 20, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 3, 1, 2});
- powerSort(numbers);
+ // powerSort(numbers);
System.out.println("Result: ");
System.out.println(new ArrayList<>(List.of(numbers)));
From 1ab2bdc2a0fdba51709b8548a3caca51cf440ab5 Mon Sep 17 00:00:00 2001
From: M-H9 <mohammed.othman.omer97@gmail.com>
Date: Wed, 15 Jan 2025 22:53:17 +0100
Subject: [PATCH 49/70] adding IMPL_M_1Test sort method to the abstract list
sorting test
---
.../java/de/uni_marburg/powersort/benchmark/JmhCgl.java | 4 ++--
.../test/java/de/uni_marburg/powersort/sort/ASortTest.java | 2 +-
.../de/uni_marburg/powersort/sort/FasterFinnSortTest.java | 2 +-
.../java/de/uni_marburg/powersort/sort/FinnSortTest.java | 2 +-
.../java/de/uni_marburg/powersort/sort/IMPL_M_1Test.java | 7 +++++++
5 files changed, 12 insertions(+), 5 deletions(-)
create mode 100644 app/src/test/java/de/uni_marburg/powersort/sort/IMPL_M_1Test.java
diff --git a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
index a58942e..484668f 100644
--- a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
+++ b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
@@ -23,7 +23,7 @@ public class JmhCgl extends JmhBase {
// Either all or a selection of sort implementations.
//@Param()
- @Param({"TIM_SORT", "FINN_SORT", "IMPL_M_11"})
+ @Param({"TIM_SORT", "FASTER_FINN_SORT", "IMPL_M_11"})
SortEnum sortEnum;
@Override
@@ -42,4 +42,4 @@ public class JmhCgl extends JmhBase {
public void benchmark() {
sortImpl.sort(workingCopy);
}
-}
+}
\ No newline at end of file
diff --git a/app/src/test/java/de/uni_marburg/powersort/sort/ASortTest.java b/app/src/test/java/de/uni_marburg/powersort/sort/ASortTest.java
index dc7acf5..ca1e42f 100644
--- a/app/src/test/java/de/uni_marburg/powersort/sort/ASortTest.java
+++ b/app/src/test/java/de/uni_marburg/powersort/sort/ASortTest.java
@@ -4,4 +4,4 @@ public class ASortTest extends AbstractSortTest {
ASortTest() {
sortAlg = SortEnum.ASORT;
}
-}
+}
\ No newline at end of file
diff --git a/app/src/test/java/de/uni_marburg/powersort/sort/FasterFinnSortTest.java b/app/src/test/java/de/uni_marburg/powersort/sort/FasterFinnSortTest.java
index 1eff05c..d050e33 100644
--- a/app/src/test/java/de/uni_marburg/powersort/sort/FasterFinnSortTest.java
+++ b/app/src/test/java/de/uni_marburg/powersort/sort/FasterFinnSortTest.java
@@ -5,4 +5,4 @@ public class FasterFinnSortTest extends AbstractSortTest {
sortAlg = SortEnum.FASTER_FINN_SORT;
}
-}
+}
\ No newline at end of file
diff --git a/app/src/test/java/de/uni_marburg/powersort/sort/FinnSortTest.java b/app/src/test/java/de/uni_marburg/powersort/sort/FinnSortTest.java
index 4ec57dd..d86cf07 100644
--- a/app/src/test/java/de/uni_marburg/powersort/sort/FinnSortTest.java
+++ b/app/src/test/java/de/uni_marburg/powersort/sort/FinnSortTest.java
@@ -4,4 +4,4 @@ public class FinnSortTest extends AbstractSortTest {
FinnSortTest() {
sortAlg = SortEnum.FINN_SORT;
}
-}
+}
\ No newline at end of file
diff --git a/app/src/test/java/de/uni_marburg/powersort/sort/IMPL_M_1Test.java b/app/src/test/java/de/uni_marburg/powersort/sort/IMPL_M_1Test.java
new file mode 100644
index 0000000..0b82c4b
--- /dev/null
+++ b/app/src/test/java/de/uni_marburg/powersort/sort/IMPL_M_1Test.java
@@ -0,0 +1,7 @@
+package de.uni_marburg.powersort.sort;
+
+public class IMPL_M_1Test extends AbstractSortTest {
+ IMPL_M_1Test() {
+ sortAlg = SortEnum.IMPL_M_11;
+ }
+}
\ No newline at end of file
From 37ea4b66258f20bfe0d880c619e649d5814e8d40 Mon Sep 17 00:00:00 2001
From: M-H9 <mohammed.othman.omer97@gmail.com>
Date: Wed, 15 Jan 2025 23:11:25 +0100
Subject: [PATCH 50/70] changing 1 to 0
---
.../java/de/uni_marburg/powersort/benchmark/JmhCgl.java | 2 +-
.../main/java/de/uni_marburg/powersort/sort/SortEnum.java | 8 ++++----
.../java/de/uni_marburg/powersort/sort/IMPL_M_1Test.java | 2 +-
3 files changed, 6 insertions(+), 6 deletions(-)
diff --git a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
index 484668f..dff9de6 100644
--- a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
+++ b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
@@ -23,7 +23,7 @@ public class JmhCgl extends JmhBase {
// Either all or a selection of sort implementations.
//@Param()
- @Param({"TIM_SORT", "FASTER_FINN_SORT", "IMPL_M_11"})
+ @Param({"TIM_SORT", "FASTER_FINN_SORT", "IMPL_M_11", "IMPL_M_21"})
SortEnum sortEnum;
@Override
diff --git a/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java b/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
index 105f6a0..bac315d 100644
--- a/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
+++ b/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
@@ -12,8 +12,8 @@ public enum SortEnum {
FASTER_FINN_SORT,
ASORT,
FINN_SORT,
- IMPL_M_11,
- IMPL_M_21,
+ IMPL_M_10,
+ IMPL_M_20,
DPQS,
QUICK_SORT,
MERGE_SORT,
@@ -27,8 +27,8 @@ public enum SortEnum {
case MERGE_SORT -> array -> MergeSort.legacyMergeSort(array, NaturalOrder.INSTANCE);
case TIM_SORT -> array -> TimSort.sort(array, 0, array.length, NaturalOrder.INSTANCE, null, 0, 0);
case FINN_SORT -> array -> FinnSort.sort(array, NaturalOrder.INSTANCE);
- case IMPL_M_11 -> array -> IMPL_M_1.powerSort(array,NaturalOrder.INSTANCE);
- case IMPL_M_21 -> array -> IMPL_M_2.sort(array, 0, array.length, NaturalOrder.INSTANCE, null, 0, 0);
+ case IMPL_M_10 -> array -> IMPL_M_1.powerSort(array,NaturalOrder.INSTANCE);
+ case IMPL_M_20 -> array -> IMPL_M_2.sort(array, 0, array.length, NaturalOrder.INSTANCE, null, 0, 0);
case FASTER_FINN_SORT -> array -> FasterFinnSort.sort(array, 0, array.length, NaturalOrder.INSTANCE, null, 0, 0);
case ASORT -> array -> ASort.sort(array, NaturalOrder.INSTANCE);
};
diff --git a/app/src/test/java/de/uni_marburg/powersort/sort/IMPL_M_1Test.java b/app/src/test/java/de/uni_marburg/powersort/sort/IMPL_M_1Test.java
index 0b82c4b..b527e7a 100644
--- a/app/src/test/java/de/uni_marburg/powersort/sort/IMPL_M_1Test.java
+++ b/app/src/test/java/de/uni_marburg/powersort/sort/IMPL_M_1Test.java
@@ -2,6 +2,6 @@ package de.uni_marburg.powersort.sort;
public class IMPL_M_1Test extends AbstractSortTest {
IMPL_M_1Test() {
- sortAlg = SortEnum.IMPL_M_11;
+ sortAlg = SortEnum.IMPL_M_10;
}
}
\ No newline at end of file
From 42a0c24f67e90b002851f4f25e6ecc17548c4485 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Thu, 16 Jan 2025 08:06:44 +0000
Subject: [PATCH 51/70] cleanup
---
app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java | 0
1 file changed, 0 insertions(+), 0 deletions(-)
delete mode 100644 app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java
diff --git a/app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java b/app/src/main/java/de/uni_marburg/powersort/benchmark/Main.java
deleted file mode 100644
index e69de29..0000000
From e526c67c3caf50cd1b3921e3fb01c0f854de4d7d Mon Sep 17 00:00:00 2001
From: M-H9 <mohammed.othman.omer97@gmail.com>
Date: Thu, 16 Jan 2025 09:59:27 +0100
Subject: [PATCH 52/70] Reusing "merge" method again and getting a little
better results in IMPL_M_1
---
.../uni_marburg/powersort/MSort/IMPL_M_1.java | 52 ++++++++++---------
.../uni_marburg/powersort/MSort/IMPL_M_2.java | 2 +-
.../powersort/MSort/PowerSortTest.java | 7 +--
3 files changed, 33 insertions(+), 28 deletions(-)
diff --git a/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_1.java b/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_1.java
index 54b8ea4..b1cdab4 100644
--- a/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_1.java
+++ b/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_1.java
@@ -54,19 +54,34 @@ public class IMPL_M_1 {
}
- static <T> List<T> merge(List<T> run1, List<T> run2, Comparator<? super T> c) {
- List<T> result = new ArrayList<>();
- while (!run1.isEmpty() && !run2.isEmpty()) {
+ static <T> T[] merge(T[] run1, T[] run2, Comparator<? super T> c) {
+ /**
+ * We need this because:
+ * In Java, you cannot create generic arrays directly (can't write new T[size])
+ * The workaround is to create an Object array and cast it to T[]
+ * This casting generates a warning because the compiler can't verify the type safety at runtime due to Java's type erasure
+ * **/
+ @SuppressWarnings("unchecked")
+ T[] result = (T[]) new Object[run1.length + run2.length];
+ int i = 0, j = 0, k = 0;
+
+ while (i < run1.length && j < run2.length) {
//This comparison only works if the lists are sorted
- if (c.compare(run1.getFirst(),run2.getFirst()) < 0) {
- result.add(run1.removeFirst());
+ if (c.compare(run1[i], run2[j]) <= 0) {
+ result[k++] = run1[i++];
} else {
- result.add(run2.removeFirst());
+ result[k++] = run2[j++];
}
}
// can be improved by finding out which one is empty and only add the other one
- result.addAll(run1);
- result.addAll(run2);
+ // Copy remaining elements
+ while (i < run1.length) {
+ result[k++] = run1[i++];
+ }
+ while (j < run2.length) {
+ result[k++] = run2[j++];
+ }
+
return result;
}
@@ -87,7 +102,7 @@ public class IMPL_M_1 {
static <T> void mergeInplace(T[] a, int i, int m, int j, Comparator<? super T> c) {
// System.out.printf("Merge(%d, %d, %d)%n", i, m, j);
MERGE_COST += j - i;
-// Create temporary arrays for merging
+ // Create temporary arrays for merging
@SuppressWarnings("unchecked")
T[] left = (T[]) new Object[m - i];
@SuppressWarnings("unchecked")
@@ -98,22 +113,11 @@ public class IMPL_M_1 {
System.arraycopy(a, m, right, 0, j - m);
// Merge back to original array
- int k = i, l = 0, r = 0;
- while (l < left.length && r < right.length) {
- if (c.compare(left[l], right[r]) <= 0) {
- a[k++] = left[l++];
- } else {
- a[k++] = right[r++];
- }
- }
+ // Merge the runs
+ T[] merged = merge(left, right, c);
- // Copy remaining elements
- while (l < left.length) {
- a[k++] = left[l++];
- }
- while (r < right.length) {
- a[k++] = right[r++];
- }
+ //copy back to original array
+ System.arraycopy(merged, 0, a, i,merged.length);
}
diff --git a/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_2.java b/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_2.java
index b892e84..a552fca 100644
--- a/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_2.java
+++ b/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_2.java
@@ -79,7 +79,7 @@ public class IMPL_M_2<T>{
* of the minimum stack length required as a function of the length
* of the array being sorted and the minimum merge sequence length.
*/
- private static final int MIN_MERGE = 24;
+ private static final int MIN_MERGE = 32;
/**
* The array being sorted.
diff --git a/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortTest.java b/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortTest.java
index 07d5ab6..da12352 100644
--- a/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortTest.java
+++ b/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortTest.java
@@ -6,6 +6,7 @@ import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
+import de.uni_marburg.powersort.benchmark.NaturalOrder;
import org.junit.jupiter.api.Test;
import static de.uni_marburg.powersort.MSort.IMPL_M_1.MERGE_COST;
@@ -34,11 +35,11 @@ class PowerSortTest {
@Test
public void testWithFinnInputList() {
- List<Integer> numbers = List.of(new Integer[] {24, 25, 26, 27, 28, 21, 22, 23, 18, 19, 20, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 3, 1, 2});
+ //T [] numbers = (new Integer[] {24, 25, 26, 27, 28, 21, 22, 23, 18, 19, 20, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 3, 1, 2});
- // powerSort(numbers);
+ //powerSort(numbers, NaturalOrder.INSTANCE);
System.out.println("Result: ");
- System.out.println(new ArrayList<>(List.of(numbers)));
+ // System.out.println(new ArrayList<>(List.of(numbers)));
}
}
From f851b9784d98c6a82c899c971176cf3d6283e3fd Mon Sep 17 00:00:00 2001
From: M-H9 <mohammed.othman.omer97@gmail.com>
Date: Thu, 16 Jan 2025 11:49:22 +0100
Subject: [PATCH 53/70] Integrating my test classes with the Object version
IMPL_M_1 and passed the tests
---
.../uni_marburg/powersort/MSort/IMPL_M_1.java | 27 ++++++++++-----
.../powersort/MSort/PowerSortT.java | 30 ++++++++--------
.../powersort/MSort/PowerSortTest.java | 34 ++++++++++---------
3 files changed, 53 insertions(+), 38 deletions(-)
diff --git a/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_1.java b/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_1.java
index b1cdab4..4dc8dcd 100644
--- a/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_1.java
+++ b/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_1.java
@@ -1,6 +1,7 @@
package de.uni_marburg.powersort.MSort;
import java.util.ArrayList;
+import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
@@ -29,9 +30,9 @@ public class IMPL_M_1 {
*/
protected static int MERGE_COST = 0;
- public static void fillWithAscRunsHighToLow(List<Integer> A, int[] runLengths, int runLenFactor) {
+ public static void fillWithAscRunsHighToLow(Integer[] A, int[] runLengths, int runLenFactor) {
//A has a fixed size, but it doesn't have any meaningful values
- int n = A.size();
+ int n = A.length;
//This ensures that the sum of runLengths multiplied by runLenFactor equals the list size n. If not, an AssertionError is thrown.
assert IntStream.of(runLengths).sum() * runLenFactor == n;
@@ -39,17 +40,27 @@ public class IMPL_M_1 {
//IntStream.of(runLengths).forEach(System.out::println);
for (int i = 0; i < n; i++) {
//putting i in set a, while a is always the last index of n
- A.set(i, n - i);
+ A[i] = n - i;
}
- int i = 0;
+
//For each value l in the array runLengths, do the following
// runLengths = {2, 3, 5}, the loop will run three times, with l taking values 2, 3, and 5 respectively.
+ int startIndex = 0;
for (int l : runLengths) {
int L = l * runLenFactor;
- List<Integer> sublist = A.subList(i, i + L);
- Collections.sort(sublist);
- i += L;
+ // Sort the subarray from startIndex to startIndex+L manually
+ for (int i = startIndex; i < startIndex + L - 1; i++) {
+ for (int j = startIndex; j < startIndex + L - 1 - (i - startIndex); j++) {
+ if (A[j] > A[j + 1]) {
+ // Swap elements
+ int temp = A[j];
+ A[j] = A[j + 1];
+ A[j + 1] = temp;
+ }
+ }
+ }
+ startIndex += L;
}
}
@@ -100,7 +111,7 @@ public class IMPL_M_1 {
}
static <T> void mergeInplace(T[] a, int i, int m, int j, Comparator<? super T> c) {
- // System.out.printf("Merge(%d, %d, %d)%n", i, m, j);
+ System.out.printf("Merge(%d, %d, %d)%n", i, m, j);
MERGE_COST += j - i;
// Create temporary arrays for merging
@SuppressWarnings("unchecked")
diff --git a/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortT.java b/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortT.java
index feb81dc..0664717 100644
--- a/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortT.java
+++ b/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortT.java
@@ -7,6 +7,8 @@ import java.util.Arrays;
import java.util.Collections;
import java.util.List;
+import de.uni_marburg.powersort.benchmark.NaturalOrder;
+
public class PowerSortT {
public static void main(String[] args) {
@@ -22,7 +24,7 @@ public class PowerSortT {
// Test for fillWithAscRunsHighToLow
public static void testFillWithAscRunsHighToLow() {
- List<Integer> A = new ArrayList<>(Collections.nCopies(10, 0));
+ Integer[] A = new Integer[10];
int[] runLengths = {2, 3, 5};
int runLenFactor = 1;
fillWithAscRunsHighToLow(A, runLengths, runLenFactor);
@@ -31,24 +33,24 @@ public class PowerSortT {
// Test for merge
public static void testMerge() {
- List<Integer> run1 = new ArrayList<>(Arrays.asList(1, 4, 6));
- List<Integer> run2 = new ArrayList<>(Arrays.asList(2, 3, 5));
- // List<Integer> result = merge(run1, run2);
- // System.out.println("Test merge: " + result);
+ Integer[] run1 ={1,4,6};
+ Integer []run2 = {2, 3, 5};
+ Integer[] result = merge(run1, run2, NaturalOrder.INSTANCE);
+ System.out.println("Test merge: " + result);
}
// Test for mergeInplace
public static void testMergeInplace() {
- List<Integer> A = new ArrayList<>(Arrays.asList(1, 4, 6, 2, 3, 5));
- //mergeInplace(A, 0, 3, 6);
+ Integer[] A = {1,4,6,2,3,5};
+ mergeInplace(A, 0, 3, 6,NaturalOrder.INSTANCE);
System.out.println("Test mergeInplace: " + A);
}
// Test for extendRun
public static void testExtendRun() {
- List<Integer> A = new ArrayList<>(Arrays.asList(1, 2, 3, 6, 5, 4));
- // int endIndex = extendRun(A, 0);
- // System.out.println("Test extendRun (from 0): " + endIndex);
+ Integer [] A = {1, 2, 3, 6, 5, 4};
+ int endIndex = extendRun(A, 0,NaturalOrder.INSTANCE);
+ System.out.println("Test extendRun (from 0): " + endIndex);
System.out.println("Modified List: " + A);
}
@@ -72,18 +74,18 @@ public class PowerSortT {
// Test for mergeTopmost2
public static void testMergeTopmost2() {
- List<Integer> A = new ArrayList<>(Arrays.asList(1, 3, 5, 2, 4, 6));
+ Integer[] A = {1, 3, 5, 2, 4, 6};
List<int[]> runs = new ArrayList<>();
runs.add(new int[]{0, 3, 1});
runs.add(new int[]{3, 3, 1});
- // mergeTopmost2(A, runs);
+ mergeTopmost2(A, runs,NaturalOrder.INSTANCE);
System.out.println("Test mergeTopmost2: " + A);
}
// Test for powerSort
public static void testPowerSort() {
- List<Integer> A = new ArrayList<>(Arrays.asList(10, 9, 8, 7, 6, 5, 4, 3, 2, 1));
- // powerSort(A);
+ Integer [] A = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
+ powerSort(A, NaturalOrder.INSTANCE);
System.out.println("Test powerSort: " + A);
}
}
diff --git a/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortTest.java b/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortTest.java
index da12352..134834e 100644
--- a/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortTest.java
+++ b/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortTest.java
@@ -18,28 +18,30 @@ class PowerSortTest {
public void testWithOneInputList() {
// List<Integer> list = new ArrayList<>(List.of(5, 2, 8, 12, 1, 6));
// extendRun(list, 0);
-//System.out.println(list);
+ //System.out.println(list);
// example from slides he wrote this
- int[] runs = {5, 3, 3, 14, 1, 2};
- runs = new int[]{9, 16, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7};
+ // int[] runs = {5, 3, 3, 14, 1, 2};
+ int [] runs = new int[]{9, 16, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7};
+ int totalSize = Arrays.stream(runs).sum();
- List<Integer> a = new ArrayList<>(IntStream.range(0, Arrays.stream(runs).sum()).boxed().collect(Collectors.toList()));
+ Integer[] a = new Integer[totalSize];
- System.out.println();
- fillWithAscRunsHighToLow(a, runs, 1);
- MERGE_COST = 0;
- System.out.println("Sorting with Powersort:");
- //powerSort(a);
- System.out.println("Merge cost: " + MERGE_COST);
+ System.out.println();
+ fillWithAscRunsHighToLow(a, runs, 1);
+ MERGE_COST = 0;
+ System.out.println("Sorting with Powersort:");
+ powerSort(a,NaturalOrder.INSTANCE);
+ System.out.println("Sorted Array"+Arrays.toString(a));
+ System.out.println("Merge cost: " + MERGE_COST);
}
@Test
- public void testWithFinnInputList() {
- //T [] numbers = (new Integer[] {24, 25, 26, 27, 28, 21, 22, 23, 18, 19, 20, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 3, 1, 2});
-
- //powerSort(numbers, NaturalOrder.INSTANCE);
- System.out.println("Result: ");
- // System.out.println(new ArrayList<>(List.of(numbers)));
+ public void testWithFinnInputList() {
+ Integer [] numbers = new Integer[] {24, 25, 26, 27, 28, 21, 22, 23, 18, 19, 20, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 3, 1, 2};
+ System.out.println("Original array"+Arrays.toString(numbers));
+ powerSort(numbers, NaturalOrder.INSTANCE);
+ System.out.println("Result: "+Arrays.toString(numbers));
+ // System.out.println(new ArrayList<>(List.of(numbers)));
}
}
From 8be6fa32a86aa6b35d8fad47b2aadea666b8e942 Mon Sep 17 00:00:00 2001
From: finnm <finn.moltmann@tu-dortmund.de>
Date: Sun, 19 Jan 2025 13:09:36 +0100
Subject: [PATCH 54/70] Fixed merge order of FinnSort and added some testing
methods
---
.../powersort/FinnSort/FasterFinnSort.java | 204 +++++++++++-------
.../uni_marburg/powersort/FinnSort/Run.java | 8 +-
.../powersort/sort/FasterFinnSortTest.java | 71 +++++-
3 files changed, 204 insertions(+), 79 deletions(-)
diff --git a/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java b/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java
index 650ed97..9e911d2 100644
--- a/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java
+++ b/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java
@@ -26,6 +26,7 @@ package de.uni_marburg.powersort.FinnSort;
*/
+import java.util.Arrays;
import java.util.Comparator;
import static java.lang.Math.pow;
@@ -68,13 +69,13 @@ public class FasterFinnSort<T> {
* This is the minimum sized sequence that will be merged. Shorter
* sequences will be lengthened by calling binarySort. If the entire
* array is less than this length, no merges will be performed.
- *
+ * <p>
* This constant should be a power of two. It was 64 in Tim Peter's C
* implementation, but 32 was empirically determined to work better in
* this implementation. In the unlikely event that you set this constant
* to be a number that's not a power of two, you'll need to change the
* {@link #minRunLength} computation.
- *
+ * <p>
* If you decrease this constant, you must change the stackLen
* computation in the TimSort constructor, or you risk an
* ArrayOutOfBounds exception. See listsort.txt for a discussion
@@ -87,6 +88,7 @@ public class FasterFinnSort<T> {
* The array being sorted.
*/
private final T[] a;
+ private final int rangeSize;
/**
* The comparator for this sort.
@@ -97,7 +99,7 @@ public class FasterFinnSort<T> {
* When we get into galloping mode, we stay there until both runs win less
* often than MIN_GALLOP consecutive times.
*/
- private static final int MIN_GALLOP = 7;
+ private static final int MIN_GALLOP = 7;
/**
* This controls when we get *into* galloping mode. It is initialized
@@ -128,9 +130,9 @@ public class FasterFinnSort<T> {
* A stack of pending runs yet to be merged. Run i starts at
* address base[i] and extends for len[i] elements. It's always
* true (so long as the indices are in bounds) that:
- *
- * runBase[i] + runLen[i] == runBase[i + 1]
- *
+ * <p>
+ * runBase[i] + runLen[i] == runBase[i + 1]
+ * <p>
* so we could cut the storage for this, but it's a minor amount,
* and keeping all the info explicit simplifies the code.
*/
@@ -142,29 +144,28 @@ public class FasterFinnSort<T> {
/**
* Creates a TimSort instance to maintain the state of an ongoing sort.
*
- * @param a the array to be sorted
- * @param c the comparator to determine the order of the sort
- * @param work a workspace array (slice)
+ * @param a the array to be sorted
+ * @param c the comparator to determine the order of the sort
+ * @param work a workspace array (slice)
* @param workBase origin of usable space in work array
- * @param workLen usable size of work array
+ * @param workLen usable size of work array
*/
- private FasterFinnSort(T[] a, Comparator<? super T> c, T[] work, int workBase, int workLen) {
+ private FasterFinnSort(T[] a, Comparator<? super T> c, T[] work, int workBase, int workLen, int rangeSize) {
this.a = a;
this.c = c;
-
+ this.rangeSize = rangeSize;
// Allocate temp storage (which may be increased later if necessary)
int len = a.length;
int tlen = (len < 2 * INITIAL_TMP_STORAGE_LENGTH) ?
len >>> 1 : INITIAL_TMP_STORAGE_LENGTH;
if (work == null || workLen < tlen || workBase + tlen > work.length) {
@SuppressWarnings({"unchecked", "UnnecessaryLocalVariable"})
- T[] newArray = (T[])java.lang.reflect.Array.newInstance
+ T[] newArray = (T[]) java.lang.reflect.Array.newInstance
(a.getClass().getComponentType(), tlen);
tmp = newArray;
tmpBase = 0;
tmpLen = tlen;
- }
- else {
+ } else {
tmp = work;
tmpBase = workBase;
tmpLen = workLen;
@@ -204,24 +205,24 @@ public class FasterFinnSort<T> {
* any necessary array bounds checks and expanding parameters into
* the required forms.
*
- * @param a the array to be sorted
- * @param lo the index of the first element, inclusive, to be sorted
- * @param hi the index of the last element, exclusive, to be sorted
- * @param c the comparator to use
- * @param work a workspace array (slice)
+ * @param a the array to be sorted
+ * @param lo the index of the first element, inclusive, to be sorted
+ * @param hi the index of the last element, exclusive, to be sorted
+ * @param c the comparator to use
+ * @param work a workspace array (slice)
* @param workBase origin of usable space in work array
- * @param workLen usable size of work array
+ * @param workLen usable size of work array
* @since 1.8
*/
public static <T> void sort(T[] a, int lo, int hi, Comparator<? super T> c,
- T[] work, int workBase, int workLen) {
+ T[] work, int workBase, int workLen) {
assert c != null && a != null && lo >= 0 && lo <= hi && hi <= a.length;
-
- int nRemaining = hi - lo;
+ int nRemaining = hi - lo;
if (nRemaining < 2)
return; // Arrays of size 0 and 1 are always sorted
// If array is small, do a "mini-TimSort" with no merges
+
if (nRemaining < MIN_MERGE) {
int initRunLen = countRunAndMakeAscending(a, lo, hi, c);
binarySort(a, lo, hi, lo + initRunLen, c);
@@ -233,7 +234,7 @@ public class FasterFinnSort<T> {
* extending short natural runs to minRun elements, and merging runs
* to maintain stack invariant.
*/
- FasterFinnSort<T> ts = new FasterFinnSort<>(a, c, work, workBase, workLen);
+ FasterFinnSort<T> fs = new FasterFinnSort<>(a, c, work, workBase, workLen, hi - lo);
int minRun = minRunLength(nRemaining);
do {
// Identify next run
@@ -247,8 +248,8 @@ public class FasterFinnSort<T> {
}
// Push run onto pending-run stack, and maybe merge
- ts.pushRun(lo, runLen, hi - lo);
- ts.mergeCollapse();
+ fs.pushRun(lo, runLen);
+ fs.mergeCollapse();
// Advance to find next run
lo += runLen;
@@ -257,8 +258,8 @@ public class FasterFinnSort<T> {
// Merge all remaining runs to complete sort
assert lo == hi;
- ts.mergeForceCollapse();
- assert ts.stackSize == 1;
+ fs.mergeForceCollapse();
+ assert fs.stackSize == 1;
}
/**
@@ -266,18 +267,18 @@ public class FasterFinnSort<T> {
* insertion sort. This is the best method for sorting small numbers
* of elements. It requires O(n log n) compares, but O(n^2) data
* movement (worst case).
- *
+ * <p>
* If the initial part of the specified range is already sorted,
* this method can take advantage of it: the method assumes that the
* elements from index {@code lo}, inclusive, to {@code start},
* exclusive are already sorted.
*
- * @param a the array in which a range is to be sorted
- * @param lo the index of the first element in the range to be sorted
- * @param hi the index after the last element in the range to be sorted
+ * @param a the array in which a range is to be sorted
+ * @param lo the index of the first element in the range to be sorted
+ * @param hi the index after the last element in the range to be sorted
* @param start the index of the first element in the range that is
- * not already known to be sorted ({@code lo <= start <= hi})
- * @param c comparator to used for the sort
+ * not already known to be sorted ({@code lo <= start <= hi})
+ * @param c comparator to used for the sort
*/
@SuppressWarnings("fallthrough")
private static <T> void binarySort(T[] a, int lo, int hi, int start,
@@ -285,7 +286,7 @@ public class FasterFinnSort<T> {
assert lo <= start && start <= hi;
if (start == lo)
start++;
- for ( ; start < hi; start++) {
+ for (; start < hi; start++) {
T pivot = a[start];
// Set left (and right) to the index where a[start] (pivot) belongs
@@ -329,26 +330,26 @@ public class FasterFinnSort<T> {
* Returns the length of the run beginning at the specified position in
* the specified array and reverses the run if it is descending (ensuring
* that the run will always be ascending when the method returns).
- *
+ * <p>
* A run is the longest ascending sequence with:
- *
- * a[lo] <= a[lo + 1] <= a[lo + 2] <= ...
- *
+ * <p>
+ * a[lo] <= a[lo + 1] <= a[lo + 2] <= ...
+ * <p>
* or the longest descending sequence with:
- *
- * a[lo] > a[lo + 1] > a[lo + 2] > ...
- *
+ * <p>
+ * a[lo] > a[lo + 1] > a[lo + 2] > ...
+ * <p>
* For its intended use in a stable mergesort, the strictness of the
* definition of "descending" is needed so that the call can safely
* reverse a descending sequence without violating stability.
*
- * @param a the array in which a run is to be counted and possibly reversed
+ * @param a the array in which a run is to be counted and possibly reversed
* @param lo index of the first element in the run
* @param hi index after the last element that may be contained in the run.
- * It is required that {@code lo < hi}.
- * @param c the comparator to used for the sort
- * @return the length of the run beginning at the specified position in
- * the specified array
+ * It is required that {@code lo < hi}.
+ * @param c the comparator to used for the sort
+ * @return the length of the run beginning at the specified position in
+ * the specified array
*/
private static <T> int countRunAndMakeAscending(T[] a, int lo, int hi,
Comparator<? super T> c) {
@@ -373,7 +374,7 @@ public class FasterFinnSort<T> {
/**
* Reverse the specified range of the specified array.
*
- * @param a the array in which a range is to be reversed
+ * @param a the array in which a range is to be reversed
* @param lo the index of the first element in the range to be reversed
* @param hi the index after the last element in the range to be reversed
*/
@@ -390,14 +391,14 @@ public class FasterFinnSort<T> {
* Returns the minimum acceptable run length for an array of the specified
* length. Natural runs shorter than this will be extended with
* {@link #binarySort}.
- *
+ * <p>
* Roughly speaking, the computation is:
- *
- * If n < MIN_MERGE, return n (it's too small to bother with fancy stuff).
- * Else if n is an exact power of 2, return MIN_MERGE/2.
- * Else return an int k, MIN_MERGE/2 <= k <= MIN_MERGE, such that n/k
- * is close to, but strictly less than, an exact power of 2.
- *
+ * <p>
+ * If n < MIN_MERGE, return n (it's too small to bother with fancy stuff).
+ * Else if n is an exact power of 2, return MIN_MERGE/2.
+ * Else return an int k, MIN_MERGE/2 <= k <= MIN_MERGE, such that n/k
+ * is close to, but strictly less than, an exact power of 2.
+ * <p>
* For the rationale, see listsort.txt.
*
* @param n the length of the array to be sorted
@@ -419,24 +420,24 @@ public class FasterFinnSort<T> {
* @param runBase index of the first element in the run
* @param runLen the number of elements in the run
*/
- private void pushRun(int runBase, int runLen, int rangeSize) {
+ private void pushRun(int runBase, int runLen) {
this.runBase[stackSize] = runBase;
this.runLen[stackSize] = runLen;
- this.runPower[stackSize] = power(stackSize, rangeSize);
+ this.runPower[stackSize] = power(stackSize);
stackSize++;
}
/**
* Examines the stack of runs waiting to be merged and merges adjacent runs
* until the stack invariants are reestablished:
- *
- * 1. runLen[i - 3] > runLen[i - 2] + runLen[i - 1]
- * 2. runLen[i - 2] > runLen[i - 1]
- *
+ * <p>
+ * 1. runLen[i - 3] > runLen[i - 2] + runLen[i - 1]
+ * 2. runLen[i - 2] > runLen[i - 1]
+ * <p>
* This method is called each time a new run is pushed onto the stack,
* so the invariants are guaranteed to hold for i < stackSize upon
* entry to the method.
- *
+ * <p>
* Thanks to Stijn de Gouw, Jurriaan Rot, Frank S. de Boer,
* Richard Bubel and Reiner Hahnle, this is fixed with respect to
* the analysis in "On the Worst-Case Complexity of TimSort" by
@@ -444,16 +445,35 @@ public class FasterFinnSort<T> {
*/
private void mergeCollapse() {
while (stackSize > 1) {
- int n = stackSize - 2;
- if (n > 0 && runPower[n + 1] < runPower[n]) {
- mergeAt(n);
+ if (runPower[stackSize - 1] < runPower[stackSize - 2]) {
+ mergeAt(stackSize - 3);
} else {
break; // Invariant is established
}
}
}
-
- private int power(int stackSize, int rangeSize) {
+/*
+ private int power(int stackSize) {
+ if (stackSize == 0) {
+ return 0;
+ }
+ // int = (right - left + 1); = RangeSize
+ long l = runLen[stackSize - 1]; // + (long) runBase[stackSize]; // - ((long) left << 1); // 2*middleA
+ long r = runLen[stackSize]; // - ((long) left << 1); // 2*middleB
+ int a = (int) ((l << 30) / rangeSize); // middleA / 2n
+ int b = (int) ((r << 30) / rangeSize); // middleB / 2n
+ return Integer.numberOfLeadingZeros(a ^ b);
+ }
+*/
+ private int power(int stackSize) {
+ /*
+ System.out.println(Arrays.toString(runBase));
+ System.out.println(Arrays.toString(runLen));
+ System.out.println(Arrays.toString(runPower));
+ System.out.println(stackSize);
+ System.out.println(rangeSize);
+ System.out.println();
+ */
if (stackSize == 0)
return 0;
@@ -465,18 +485,50 @@ public class FasterFinnSort<T> {
int result = 0;
- while (b < rangeSize) {
+ while (true) {
++result;
if (a >= rangeSize) {
a -= rangeSize;
b -= rangeSize;
}
+ if (b >= rangeSize) {
+ break;
+ }
a <<= 1;
b <<= 1;
}
return result;
}
+/*
+ public int power(int stackSize) {
+
+ System.out.println(Arrays.toString(runBase));
+ System.out.println(Arrays.toString(runLen));
+ System.out.println(Arrays.toString(runPower));
+ System.out.println(stackSize);
+ System.out.println(rangeSize);
+ System.out.println();
+
+
+ if (stackSize == 0)
+ return 0;
+
+ int n_1 = this.runLen[stackSize - 1];
+ int n_2 = this.runLen[stackSize];
+
+ double a = ((double) this.runBase[stackSize - 1] + 0.5d * n_1 - 1d) / this.rangeSize;
+ double b = ((double) this.runBase[stackSize] + 0.5d * n_2 - 1d) / this.rangeSize;
+ int l = 0;
+ while ((int) (a * pow(2, l)) == (int) (b * pow(2 ,l))) {
+
+ l++;
+ }
+ return l;
+ }
+ */
+
+
/*
Backup mergeCollapse() von TimSort:
@@ -519,7 +571,7 @@ public class FasterFinnSort<T> {
private void mergeAt(int i) {
assert stackSize >= 2;
assert i >= 0;
- assert i == stackSize - 2 || i == stackSize - 3;
+ //assert i == stackSize - 3;
int base1 = runBase[i];
int len1 = runLen[i];
@@ -533,12 +585,14 @@ public class FasterFinnSort<T> {
* run now, also slide over the last run (which isn't involved
* in this merge). The current run (i+1) goes away in any case.
*/
- runLen[i] = len1 + len2;
- if (i == stackSize - 3) {
- runBase[i + 1] = runBase[i + 2];
- runLen[i + 1] = runLen[i + 2];
- }
stackSize--;
+ runLen[i] = len1 + len2;
+
+ // @TODO: Check power before pushing the run
+ runLen[i + 1] = runLen[i + 2];
+ runBase[i + 1] = runBase[i + 2];
+ runPower[i + 1] = runPower[i + 2];
+ //runPower[i] = power(i);
/*
* Find where the first element of run2 goes in run1. Prior elements
diff --git a/app/src/main/java/de/uni_marburg/powersort/FinnSort/Run.java b/app/src/main/java/de/uni_marburg/powersort/FinnSort/Run.java
index eba6fc6..2a23c52 100644
--- a/app/src/main/java/de/uni_marburg/powersort/FinnSort/Run.java
+++ b/app/src/main/java/de/uni_marburg/powersort/FinnSort/Run.java
@@ -1,14 +1,16 @@
package de.uni_marburg.powersort.FinnSort;
-class Run {
- int start;
- int end;
+public class Run {
+ public int start;
+ public int end;
int power;
+ public int len;
public Run(int i, int j, int p) {
start = i;
end = j;
power = p;
+ len = end - start;
}
}
diff --git a/app/src/test/java/de/uni_marburg/powersort/sort/FasterFinnSortTest.java b/app/src/test/java/de/uni_marburg/powersort/sort/FasterFinnSortTest.java
index d050e33..ec99a0f 100644
--- a/app/src/test/java/de/uni_marburg/powersort/sort/FasterFinnSortTest.java
+++ b/app/src/test/java/de/uni_marburg/powersort/sort/FasterFinnSortTest.java
@@ -1,8 +1,77 @@
package de.uni_marburg.powersort.sort;
+import de.uni_marburg.powersort.FinnSort.FasterFinnSort;
+import de.uni_marburg.powersort.FinnSort.Run;
+import de.uni_marburg.powersort.benchmark.NaturalOrder;
+import org.junit.jupiter.api.Test;
+
+import java.lang.reflect.Method;
+
+import static java.lang.Math.pow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
public class FasterFinnSortTest extends AbstractSortTest {
FasterFinnSortTest() {
sortAlg = SortEnum.FASTER_FINN_SORT;
}
-}
\ No newline at end of file
+ @Test
+ public void testMergeOrder() {
+ Integer[] input = {24,25,26,27,28,21,22,23,18,19,20,4,5,6,7,8,9,10,11,12,13,14,15,16,17,3,1,2};
+ FasterFinnSort.sort(input, 0, input.length, NaturalOrder.INSTANCE,null, 0, 0);
+ }
+ @Test
+ public void powerTest() {
+ Run run1 = new Run(0, 10, 0);
+ Run run2 = new Run(10, 20, 0);
+
+ for (int i = 20; i < 10100; i++) {
+ System.out.println(i);
+ //assertEquals(integerPower(run1, run2, i), power(run1, run2, i));
+ assertEquals(power(run1, run2, i),
+ power2(run1, run2, i));
+ }
+
+ }
+ private static int integerPower(Run run1, Run run2, int n) {
+
+ int n_1 = run1.len;
+ int n_2 = run2.len;
+
+ int a = 2 * run1.start + n_1 - 1;
+ int b = a + n_1 + n_2;
+
+ int result = 0;
+
+ while (a * pow(2, result) == b * pow(2, result)) {
+ result++;
+ }
+
+ return result;
+ }
+ private static int power(Run run1, Run run2, int n) {
+ /*
+ if (run1.start == 0) {
+ return 0;
+ }
+
+ */
+ int n_1 = run1.end - run1.start;
+ int n_2 = run2.end - run2.start;
+ double a = ((double) run1.start + 0.5d * n_1) / n;
+ double b = ((double) run2.start + 0.5d * n_2) / n;
+ int l = 1;
+ while ((int) (a * pow(2, l)) == (int) (b * pow(2 ,l))) {
+ l++;
+ }
+ return l;
+ }
+
+ private int power2(Run run1, Run run2, int n) {
+ long l = (long) run1.start + (long) run2.start; // 2*middleA
+ long r = (long) run2.start + (long) run2.end + 1; // 2*middleB
+ int a = (int) ((l << 30) / n); // middleA / 2n
+ int b = (int) ((r << 30) / n); // middleB / 2n
+ return Integer.numberOfLeadingZeros(a ^ b);
+ }
+}
From 9a6359d576014433b75cbf70dc71ab59e5d72727 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 21 Jan 2025 13:10:12 +0000
Subject: [PATCH 55/70] FasterFinnSort: change access
---
.../powersort/FinnSort/FasterFinnSort.java | 22 +++++++++----------
1 file changed, 11 insertions(+), 11 deletions(-)
diff --git a/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java b/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java
index 650ed97..5e92f96 100644
--- a/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java
+++ b/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java
@@ -81,7 +81,7 @@ public class FasterFinnSort<T> {
* of the minimum stack length required as a function of the length
* of the array being sorted and the minimum merge sequence length.
*/
- private static final int MIN_MERGE = 32;
+ static final int MIN_MERGE = 32;
/**
* The array being sorted.
@@ -134,7 +134,7 @@ public class FasterFinnSort<T> {
* so we could cut the storage for this, but it's a minor amount,
* and keeping all the info explicit simplifies the code.
*/
- private int stackSize = 0; // Number of pending runs on stack
+ int stackSize = 0; // Number of pending runs on stack
private final int[] runBase;
private final int[] runLen;
private final int[] runPower;
@@ -148,7 +148,7 @@ public class FasterFinnSort<T> {
* @param workBase origin of usable space in work array
* @param workLen usable size of work array
*/
- private FasterFinnSort(T[] a, Comparator<? super T> c, T[] work, int workBase, int workLen) {
+ FasterFinnSort(T[] a, Comparator<? super T> c, T[] work, int workBase, int workLen) {
this.a = a;
this.c = c;
@@ -234,7 +234,7 @@ public class FasterFinnSort<T> {
* to maintain stack invariant.
*/
FasterFinnSort<T> ts = new FasterFinnSort<>(a, c, work, workBase, workLen);
- int minRun = minRunLength(nRemaining);
+ int minRun = ts.minRunLength(nRemaining);
do {
// Identify next run
int runLen = countRunAndMakeAscending(a, lo, hi, c);
@@ -280,7 +280,7 @@ public class FasterFinnSort<T> {
* @param c comparator to used for the sort
*/
@SuppressWarnings("fallthrough")
- private static <T> void binarySort(T[] a, int lo, int hi, int start,
+ static <T> void binarySort(T[] a, int lo, int hi, int start,
Comparator<? super T> c) {
assert lo <= start && start <= hi;
if (start == lo)
@@ -350,7 +350,7 @@ public class FasterFinnSort<T> {
* @return the length of the run beginning at the specified position in
* the specified array
*/
- private static <T> int countRunAndMakeAscending(T[] a, int lo, int hi,
+ static <T> int countRunAndMakeAscending(T[] a, int lo, int hi,
Comparator<? super T> c) {
assert lo < hi;
int runHi = lo + 1;
@@ -403,7 +403,7 @@ public class FasterFinnSort<T> {
* @param n the length of the array to be sorted
* @return the length of the minimum run to be merged
*/
- private static int minRunLength(int n) {
+ int minRunLength(int n) {
assert n >= 0;
int r = 0; // Becomes 1 if any 1 bits are shifted off
while (n >= MIN_MERGE) {
@@ -419,7 +419,7 @@ public class FasterFinnSort<T> {
* @param runBase index of the first element in the run
* @param runLen the number of elements in the run
*/
- private void pushRun(int runBase, int runLen, int rangeSize) {
+ void pushRun(int runBase, int runLen, int rangeSize) {
this.runBase[stackSize] = runBase;
this.runLen[stackSize] = runLen;
this.runPower[stackSize] = power(stackSize, rangeSize);
@@ -442,7 +442,7 @@ public class FasterFinnSort<T> {
* the analysis in "On the Worst-Case Complexity of TimSort" by
* Nicolas Auger, Vincent Jug, Cyril Nicaud, and Carine Pivoteau.
*/
- private void mergeCollapse() {
+ void mergeCollapse() {
while (stackSize > 1) {
int n = stackSize - 2;
if (n > 0 && runPower[n + 1] < runPower[n]) {
@@ -453,7 +453,7 @@ public class FasterFinnSort<T> {
}
}
- private int power(int stackSize, int rangeSize) {
+ int power(int stackSize, int rangeSize) {
if (stackSize == 0)
return 0;
@@ -500,7 +500,7 @@ public class FasterFinnSort<T> {
* Merges all runs on the stack until only one remains. This method is
* called once, to complete the sort.
*/
- private void mergeForceCollapse() {
+ void mergeForceCollapse() {
while (stackSize > 1) {
int n = stackSize - 2;
if (n > 0 && runLen[n - 1] < runLen[n + 1])
From e631d5161e2e7895d08ad0e73346434de15190b2 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 21 Jan 2025 13:12:05 +0000
Subject: [PATCH 56/70] add Mockito
---
app/build.gradle.kts | 28 ++++++++++++++++++++--------
gradle/libs.versions.toml | 6 +++---
2 files changed, 23 insertions(+), 11 deletions(-)
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index efbb5b8..af1ddc6 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -18,6 +18,7 @@ repositories {
}
val latestJmhVersion = "1.37"
+val mockitoAgent = configurations.create("mockitoAgent")
dependencies {
// Use JUnit Jupiter for testing.
@@ -27,6 +28,11 @@ dependencies {
// Required to use the IntelliJ plugin "JMH Java Microbenchmark Harness".
// https://stackoverflow.com/a/71286156/6334421
jmhAnnotationProcessor("org.openjdk.jmh:jmh-generator-annprocess:$latestJmhVersion")
+
+ // Use Mockito for mocking.
+ // https://javadoc.io/doc/org.mockito/mockito-core/latest/org/mockito/Mockito.html#mockito-instrumentation
+ testImplementation(libs.mockito)
+ mockitoAgent(libs.mockito) { isTransitive = false }
}
// Apply a specific Java toolchain to ease working on different environments.
@@ -60,15 +66,21 @@ tasks.register<JavaExec>("runCbmCompetition") {
mainClass = "de.uni_marburg.powersort.benchmark.CbmCompetition"
}
-tasks.named<Test>("test") {
- // Use JUnit Platform for unit tests.
- useJUnitPlatform()
+tasks {
+ test {
+ // Use JUnit Platform for unit tests.
+ useJUnitPlatform()
- reports {
- // XML reports for GitLab CI.
- junitXml.required.set(true)
- // HTML reports to view with a webbrowser.
- html.required.set(true)
+ reports {
+ // XML reports for GitLab CI.
+ junitXml.required.set(true)
+ // HTML reports to view with a webbrowser.
+ html.required.set(true)
+ }
+
+ // Mockito JDK21+ config
+ // https://javadoc.io/doc/org.mockito/mockito-core/latest/org/mockito/Mockito.html#mockito-instrumentation
+ jvmArgs("-javaagent:${mockitoAgent.asPath}")
}
}
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 843e91d..dffb973 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -2,9 +2,9 @@
# https://docs.gradle.org/current/userguide/platforms.html#sub::toml-dependencies-format
[versions]
-guava = "32.1.3-jre"
-junit-jupiter = "5.10.1"
+junit-jupiter = "5.10.3"
+mockito = "5.14.0"
[libraries]
-guava = { module = "com.google.guava:guava", version.ref = "guava" }
junit-jupiter = { module = "org.junit.jupiter:junit-jupiter", version.ref = "junit-jupiter" }
+mockito = { module = "org.mockito:mockito-core", version.ref = "mockito" }
From 5ea120013caec03d8d7646e72c89ff0a20911302 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 21 Jan 2025 13:12:45 +0000
Subject: [PATCH 57/70] WIP: use Mockito
---
.../FinnSort/FasterFinnSortMockitoTest.java | 58 ++++++++++++++++
.../FinnSort/FasterFinnSortWrapper.java | 66 +++++++++++++++++++
.../powersort/FinnSort/ResultCaptor.java | 31 +++++++++
3 files changed, 155 insertions(+)
create mode 100644 app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortMockitoTest.java
create mode 100644 app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortWrapper.java
create mode 100644 app/src/test/java/de/uni_marburg/powersort/FinnSort/ResultCaptor.java
diff --git a/app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortMockitoTest.java b/app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortMockitoTest.java
new file mode 100644
index 0000000..b52c0ab
--- /dev/null
+++ b/app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortMockitoTest.java
@@ -0,0 +1,58 @@
+package de.uni_marburg.powersort.FinnSort;
+
+import de.uni_marburg.powersort.JUnitUtil;
+import de.uni_marburg.powersort.benchmark.NaturalOrder;
+import org.junit.jupiter.api.RepeatedTest;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.converter.ConvertWith;
+import org.junit.jupiter.params.provider.CsvSource;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+public class FasterFinnSortMockitoTest {
+ @ParameterizedTest
+ @CsvSource({
+ "4|5|6|1|2|3",
+ "100|10|11|1|2|3",
+ "100|11|10|3|2|1",
+ "24|25|26|27|28|21|22|23|18|19|20|4|5|6|7|8|9|10|11|12|13|14|15|16|17|3|1|2",
+ })
+ void foo(@ConvertWith(JUnitUtil.IntegerArrayConverter.class) Integer[] a) {
+ printPowers(a);
+ }
+
+ void printPowers(Object[] a) {
+ FasterFinnSort<Object> ffs = new FasterFinnSort<>(a, NaturalOrder.INSTANCE, null, 0, 0);
+ FasterFinnSort<Object> spiedFfs = spy(ffs);
+
+ // Don't extend short runs with `binarySort()`
+ when(spiedFfs.minRunLength(anyInt())).thenReturn(0);
+
+ // Capture calculated power values.
+ final ResultCaptor<Integer> resultCaptor = new ResultCaptor<>();
+ doAnswer(resultCaptor).when(spiedFfs).power(anyInt(), anyInt());
+
+
+ sort(a, spiedFfs);
+
+
+ List<Integer> calculatedPowers = resultCaptor.getAllValues();
+ System.out.println(Arrays.toString(calculatedPowers.toArray()));
+ }
+
+ /**
+ * Sorts the given array using FasterFinnSort.
+ */
+ void sort(Object[] a, FasterFinnSort<Object> ffs) {
+ // Don't sort short array with `binarySort()`
+ boolean forcePowersortShortArray = true;
+
+ FasterFinnSortWrapper.sort(a, 0, a.length, NaturalOrder.INSTANCE, null, 0, 0, ffs, forcePowersortShortArray);
+ }
+}
diff --git a/app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortWrapper.java b/app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortWrapper.java
new file mode 100644
index 0000000..5be0cf1
--- /dev/null
+++ b/app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortWrapper.java
@@ -0,0 +1,66 @@
+package de.uni_marburg.powersort.FinnSort;
+
+import java.util.Comparator;
+
+import static de.uni_marburg.powersort.FinnSort.FasterFinnSort.MIN_MERGE;
+import static de.uni_marburg.powersort.FinnSort.FasterFinnSort.binarySort;
+import static de.uni_marburg.powersort.FinnSort.FasterFinnSort.countRunAndMakeAscending;
+
+public class FasterFinnSortWrapper {
+ /**
+ * Copy of `FasterFinnSort.java`. Param `ts` has been added to allow dependency injection for testing.
+ *
+ * @param ts: If non-null, the creation of `ts` with `new FasterFinnSort<>(a, c, work, workBase, workLen)` in this methods body is skipped. Instead, the given `ts` is used.
+ */
+ public static <T> void sort(T[] a, int lo, int hi, Comparator<? super T> c,
+ T[] work, int workBase, int workLen,
+ FasterFinnSort<T> ts, boolean forcePowersortShortArray) {
+ assert c != null && a != null && lo >= 0 && lo <= hi && hi <= a.length;
+
+ int nRemaining = hi - lo;
+ if (nRemaining < 2)
+ return; // Arrays of size 0 and 1 are always sorted
+
+ // If array is small, do a "mini-TimSort" with no merges
+ if (!forcePowersortShortArray && nRemaining < MIN_MERGE) {
+ int initRunLen = countRunAndMakeAscending(a, lo, hi, c);
+ binarySort(a, lo, hi, lo + initRunLen, c);
+ return;
+ }
+
+ /*
+ * March over the array once, left to right, finding natural runs,
+ * extending short natural runs to minRun elements, and merging runs
+ * to maintain stack invariant.
+ */
+ if (ts == null) ts = new FasterFinnSort<>(a, c, work, workBase, workLen);
+ int minRun = ts.minRunLength(nRemaining);
+ System.out.println("minRun: " + minRun);
+ do {
+ // Identify next run
+ int runLen = countRunAndMakeAscending(a, lo, hi, c);
+ System.out.println("runLen: " + runLen);
+
+ // If run is short, extend to min(minRun, nRemaining)
+ if (runLen < minRun) {
+ System.out.println("Extend run of length " + runLen + " to " + Math.min(minRun, nRemaining));
+ int force = nRemaining <= minRun ? nRemaining : minRun;
+ binarySort(a, lo, lo + force, lo + runLen, c);
+ runLen = force;
+ }
+
+ // Push run onto pending-run stack, and maybe merge
+ ts.pushRun(lo, runLen, hi - lo);
+ ts.mergeCollapse();
+
+ // Advance to find next run
+ lo += runLen;
+ nRemaining -= runLen;
+ } while (nRemaining != 0);
+
+ // Merge all remaining runs to complete sort
+ assert lo == hi;
+ ts.mergeForceCollapse();
+ assert ts.stackSize == 1;
+ }
+}
diff --git a/app/src/test/java/de/uni_marburg/powersort/FinnSort/ResultCaptor.java b/app/src/test/java/de/uni_marburg/powersort/FinnSort/ResultCaptor.java
new file mode 100644
index 0000000..05ca6d7
--- /dev/null
+++ b/app/src/test/java/de/uni_marburg/powersort/FinnSort/ResultCaptor.java
@@ -0,0 +1,31 @@
+package de.uni_marburg.powersort.FinnSort;
+
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+import java.util.ArrayList;
+import java.util.List;
+
+
+/**
+ * Source: https://stackoverflow.com/a/25694142/6334421
+ * <p>
+ * Alternative which didn't work: https://github.com/mockito/mockito/issues/2422
+ */
+public class ResultCaptor<T> implements Answer {
+ private final List<T> results = new ArrayList<>();
+
+ /**
+ * Returns all captured values.
+ */
+ public List<T> getAllValues() {
+ return results;
+ }
+
+ @Override
+ public T answer(InvocationOnMock invocationOnMock) throws Throwable {
+ T result = (T) invocationOnMock.callRealMethod();
+ results.add(result);
+ return result;
+ }
+}
From 60ca1275b5384cdc8167e75e74a5ce7059be04b2 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 21 Jan 2025 16:33:42 +0000
Subject: [PATCH 58/70] benchmark: more warmup iterations
---
.../java/de/uni_marburg/powersort/benchmark/JmhBase.java | 6 +++++-
1 file changed, 5 insertions(+), 1 deletion(-)
diff --git a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhBase.java b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhBase.java
index bc110cf..3f59c38 100644
--- a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhBase.java
+++ b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhBase.java
@@ -41,7 +41,11 @@ import java.util.concurrent.TimeUnit;
// - "More warmup/measurement iterations are generally required."
// - "Timers overhead might be significant if benchmarks are small;"
@BenchmarkMode(Mode.SingleShotTime)
-@Warmup(iterations = 12)
+// During warmup iterations for ASCENDING_RUNS (with TIM_SORT and FASTER_FINN_SORT):
+// - Until the 17th spike of up to +750% (Maybe JVM optimizations happening?)
+// - After 40th constant slowdown of around +10% (Maybe CPU frequency adjustments?)
+// Thus, we need at least ~50 warmup iterations!
+@Warmup(iterations = 50)
@Measurement(iterations = 6)
/*
From 1fb89e8985f9723068c3b59e7dc2385c239aec99 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 21 Jan 2025 16:35:47 +0000
Subject: [PATCH 59/70] WIP: use Mockito
---
.../FinnSort/FasterFinnSortMockitoTest.java | 4 ++--
.../FinnSort/FasterFinnSortWrapper.java | 23 ++++++++-----------
2 files changed, 12 insertions(+), 15 deletions(-)
diff --git a/app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortMockitoTest.java b/app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortMockitoTest.java
index b52c0ab..e438330 100644
--- a/app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortMockitoTest.java
+++ b/app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortMockitoTest.java
@@ -28,7 +28,7 @@ public class FasterFinnSortMockitoTest {
}
void printPowers(Object[] a) {
- FasterFinnSort<Object> ffs = new FasterFinnSort<>(a, NaturalOrder.INSTANCE, null, 0, 0);
+ FasterFinnSort<Object> ffs = new FasterFinnSort<>(a, NaturalOrder.INSTANCE, null, 0, 0, a.length);
FasterFinnSort<Object> spiedFfs = spy(ffs);
// Don't extend short runs with `binarySort()`
@@ -36,7 +36,7 @@ public class FasterFinnSortMockitoTest {
// Capture calculated power values.
final ResultCaptor<Integer> resultCaptor = new ResultCaptor<>();
- doAnswer(resultCaptor).when(spiedFfs).power(anyInt(), anyInt());
+ doAnswer(resultCaptor).when(spiedFfs).power(anyInt());
sort(a, spiedFfs);
diff --git a/app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortWrapper.java b/app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortWrapper.java
index 5be0cf1..4bc65ca 100644
--- a/app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortWrapper.java
+++ b/app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortWrapper.java
@@ -10,48 +10,45 @@ public class FasterFinnSortWrapper {
/**
* Copy of `FasterFinnSort.java`. Param `ts` has been added to allow dependency injection for testing.
*
- * @param ts: If non-null, the creation of `ts` with `new FasterFinnSort<>(a, c, work, workBase, workLen)` in this methods body is skipped. Instead, the given `ts` is used.
+ * @param fs: If non-null, the creation of `ts` with `new FasterFinnSort<>(a, c, work, workBase, workLen)` in this methods body is skipped. Instead, the given `ts` is used.
*/
public static <T> void sort(T[] a, int lo, int hi, Comparator<? super T> c,
T[] work, int workBase, int workLen,
- FasterFinnSort<T> ts, boolean forcePowersortShortArray) {
+ FasterFinnSort<T> fs, boolean forcePowersortShortArray) {
assert c != null && a != null && lo >= 0 && lo <= hi && hi <= a.length;
-
int nRemaining = hi - lo;
if (nRemaining < 2)
return; // Arrays of size 0 and 1 are always sorted
// If array is small, do a "mini-TimSort" with no merges
+
if (!forcePowersortShortArray && nRemaining < MIN_MERGE) {
int initRunLen = countRunAndMakeAscending(a, lo, hi, c);
binarySort(a, lo, hi, lo + initRunLen, c);
return;
}
- /*
+ /**
* March over the array once, left to right, finding natural runs,
* extending short natural runs to minRun elements, and merging runs
* to maintain stack invariant.
*/
- if (ts == null) ts = new FasterFinnSort<>(a, c, work, workBase, workLen);
- int minRun = ts.minRunLength(nRemaining);
- System.out.println("minRun: " + minRun);
+ if (fs == null) fs = new FasterFinnSort<>(a, c, work, workBase, workLen, hi - lo);
+ int minRun = fs.minRunLength(nRemaining);
do {
// Identify next run
int runLen = countRunAndMakeAscending(a, lo, hi, c);
- System.out.println("runLen: " + runLen);
// If run is short, extend to min(minRun, nRemaining)
if (runLen < minRun) {
- System.out.println("Extend run of length " + runLen + " to " + Math.min(minRun, nRemaining));
int force = nRemaining <= minRun ? nRemaining : minRun;
binarySort(a, lo, lo + force, lo + runLen, c);
runLen = force;
}
// Push run onto pending-run stack, and maybe merge
- ts.pushRun(lo, runLen, hi - lo);
- ts.mergeCollapse();
+ fs.pushRun(lo, runLen);
+ fs.mergeCollapse();
// Advance to find next run
lo += runLen;
@@ -60,7 +57,7 @@ public class FasterFinnSortWrapper {
// Merge all remaining runs to complete sort
assert lo == hi;
- ts.mergeForceCollapse();
- assert ts.stackSize == 1;
+ fs.mergeForceCollapse();
+ assert fs.stackSize == 1;
}
}
From 959cb20e7b759546b6014fdcf9e7ad3ac7c2e474 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 21 Jan 2025 16:36:18 +0000
Subject: [PATCH 60/70] FasterFinnSort: stackLen calculation
---
.../powersort/FinnSort/FasterFinnSort.java | 19 ++-----------------
1 file changed, 2 insertions(+), 17 deletions(-)
diff --git a/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java b/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java
index b1622ce..32fb651 100644
--- a/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java
+++ b/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java
@@ -171,23 +171,8 @@ public class FasterFinnSort<T> {
tmpLen = workLen;
}
- /*
- * Allocate runs-to-be-merged stack (which cannot be expanded). The
- * stack length requirements are described in listsort.txt. The C
- * version always uses the same stack length (85), but this was
- * measured to be too expensive when sorting "mid-sized" arrays (e.g.,
- * 100 elements) in Java. Therefore, we use smaller (but sufficiently
- * large) stack lengths for smaller arrays. The "magic numbers" in the
- * computation below must be changed if MIN_MERGE is decreased. See
- * the MIN_MERGE declaration above for more information.
- * The maximum value of 49 allows for an array up to length
- * Integer.MAX_VALUE-4, if array is filled by the worst case stack size
- * increasing scenario. More explanations are given in section 4 of:
- * http://envisage-project.eu/wp-content/uploads/2015/02/sorting.pdf
- */
- int stackLen = (len < 120 ? 5 :
- len < 1542 ? 10 :
- len < 119151 ? 24 : 49);
+ // TODO: Verify if this is correct
+ int stackLen = ((int) Math.ceil(Math.log(rangeSize))) + 2;
runBase = new int[stackLen];
runLen = new int[stackLen];
runPower = new int[stackLen];
From dec8585ab4bb9f423c9ff264a196d3c52e931411 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Sun, 26 Jan 2025 12:07:45 +0100
Subject: [PATCH 61/70] update LICENSE
---
LICENSE | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/LICENSE b/LICENSE
index eeff850..2ed5b05 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,6 +1,6 @@
MIT License
-Copyright (c) 2024 Daniel Langbein, Mohammed Omer, Finn Moltmann, Abhirami Siva, Ambili Jacob
+Copyright (c) 2024 Daniel Langbein <daniel@systemli.org>, Mohammed Omer, Finn Moltmann, Abhirami Siva, Ambili Jacob
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
From 6694a076e5befe8ba49fc30d69b363cf798889e9 Mon Sep 17 00:00:00 2001
From: M-H9 <mohammed.othman.omer97@gmail.com>
Date: Tue, 28 Jan 2025 15:12:38 +0100
Subject: [PATCH 62/70] creating IMPL_M_4 and getting better performance than
TimSort in every case
---
.../uni_marburg/powersort/MSort/IMPL_M_1.java | 3 +-
.../uni_marburg/powersort/MSort/IMPL_M_2.java | 1283 ++++++-----------
.../uni_marburg/powersort/MSort/IMPL_M_3.java | 178 +++
.../uni_marburg/powersort/MSort/IMPL_M_4.java | 1018 +++++++++++++
.../uni_marburg/powersort/sort/SortEnum.java | 9 +-
.../powersort/MSort/PowerSortT.java | 42 +-
.../powersort/MSort/PowerSortTest.java | 10 +-
7 files changed, 1648 insertions(+), 895 deletions(-)
create mode 100644 app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_3.java
create mode 100644 app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_4.java
diff --git a/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_1.java b/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_1.java
index 4dc8dcd..88d21a4 100644
--- a/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_1.java
+++ b/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_1.java
@@ -111,7 +111,7 @@ public class IMPL_M_1 {
}
static <T> void mergeInplace(T[] a, int i, int m, int j, Comparator<? super T> c) {
- System.out.printf("Merge(%d, %d, %d)%n", i, m, j);
+ // System.out.printf("Merge(%d, %d, %d)%n", i, m, j);
MERGE_COST += j - i;
// Create temporary arrays for merging
@SuppressWarnings("unchecked")
@@ -131,7 +131,6 @@ public class IMPL_M_1 {
System.arraycopy(merged, 0, a, i,merged.length);
}
-
static <T> int extendRun(T [] a, int i, Comparator<? super T> c) {
// if i was the element before end so just return the last element
if (i == a.length - 1) {
diff --git a/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_2.java b/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_2.java
index a552fca..138dd8b 100644
--- a/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_2.java
+++ b/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_2.java
@@ -1,198 +1,17 @@
-/*
- * Copyright (c) 2009, 2013, Oracle and/or its affiliates. All rights reserved.
- * Copyright 2009 Google Inc. 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. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * 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 de.uni_marburg.powersort.MSort;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
import java.util.Comparator;
+import java.util.List;
+import java.util.stream.IntStream;
-/**
- * A stable, adaptive, iterative mergesort that requires far fewer than
- * n lg(n) comparisons when running on partially sorted arrays, while
- * offering performance comparable to a traditional mergesort when run
- * on random arrays. Like all proper mergesorts, this sort is stable and
- * runs O(n log n) time (worst case). In the worst case, this sort requires
- * temporary storage space for n/2 object references; in the best case,
- * it requires only a small constant amount of space.
- *
- * This implementation was adapted from Tim Peters's list sort for
- * Python, which is described in detail here:
- *
- * http://svn.python.org/projects/python/trunk/Objects/listsort.txt
- *
- * Tim's C code may be found here:
- *
- * http://svn.python.org/projects/python/trunk/Objects/listobject.c
- *
- * The underlying techniques are described in this paper (and may have
- * even earlier origins):
- *
- * "Optimistic Sorting and Information Theoretic Complexity"
- * Peter McIlroy
- * SODA (Fourth Annual ACM-SIAM Symposium on Discrete Algorithms),
- * pp 467-474, Austin, Texas, 25-27 January 1993.
- *
- * While the API to this class consists solely of static methods, it is
- * (privately) instantiable; a TimSort instance holds the state of an ongoing
- * sort, assuming the input array is large enough to warrant the full-blown
- * TimSort. Small arrays are sorted in place, using a binary insertion sort.
- *
- * @author Josh Bloch
- */
-public class IMPL_M_2<T>{
+public class IMPL_M_2 {
- /**
- * This is the minimum sized sequence that will be merged. Shorter
- * sequences will be lengthened by calling binarySort. If the entire
- * array is less than this length, no merges will be performed.
- *
- * This constant should be a power of two. It was 64 in Tim Peter's C
- * implementation, but 32 was empirically determined to work better in
- * this implementation. In the unlikely event that you set this constant
- * to be a number that's not a power of two, you'll need to change the
- * {@link #minRunLength} computation.
- *
- * If you decrease this constant, you must change the stackLen
- * computation in the TimSort constructor, or you risk an
- * ArrayOutOfBounds exception. See listsort.txt for a discussion
- * of the minimum stack length required as a function of the length
- * of the array being sorted and the minimum merge sequence length.
- */
- private static final int MIN_MERGE = 32;
-
- /**
- * The array being sorted.
- */
- private final T[] a;
-
- /**
- * The comparator for this sort.
- */
- private final Comparator<? super T> c;
-
- /**
- * When we get into galloping mode, we stay there until both runs win less
- * often than MIN_GALLOP consecutive times.
- */
- private static final int MIN_GALLOP = 7;
-
- /**
- * This controls when we get *into* galloping mode. It is initialized
- * to MIN_GALLOP. The mergeLo and mergeHi methods nudge it higher for
- * random data, and lower for highly structured data.
- */
- private int minGallop = MIN_GALLOP;
-
- /**
- * Maximum initial size of tmp array, which is used for merging. The array
- * can grow to accommodate demand.
- *
- * Unlike Tim's original C version, we do not allocate this much storage
- * when sorting smaller arrays. This change was required for performance.
- */
- private static final int INITIAL_TMP_STORAGE_LENGTH = 256;
-
- /**
- * Temp storage for merges. A workspace array may optionally be
- * provided in constructor, and if so will be used as long as it
- * is big enough.
- */
- private T[] tmp;
- private int tmpBase; // base of tmp array slice
- private int tmpLen; // length of tmp array slice
-
- /**
- * A stack of pending runs yet to be merged. Run i starts at
- * address base[i] and extends for len[i] elements. It's always
- * true (so long as the indices are in bounds) that:
- *
- * runBase[i] + runLen[i] == runBase[i + 1]
- *
- * so we could cut the storage for this, but it's a minor amount,
- * and keeping all the info explicit simplifies the code.
- */
- private int stackSize = 0; // Number of pending runs on stack
- private final int[] runBase;
- private final int[] runLen;
-
- /**
- * Creates a TimSort instance to maintain the state of an ongoing sort.
- *
- * @param a the array to be sorted
- * @param c the comparator to determine the order of the sort
- * @param work a workspace array (slice)
- * @param workBase origin of usable space in work array
- * @param workLen usable size of work array
- */
- private IMPL_M_2(T[] a, Comparator<? super T> c, T[] work, int workBase, int workLen) {
- this.a = a;
- this.c = c;
-
- // Allocate temp storage (which may be increased later if necessary)
- int len = a.length;
- int tlen = (len < 2 * INITIAL_TMP_STORAGE_LENGTH) ?
- len >>> 1 : INITIAL_TMP_STORAGE_LENGTH;
- if (work == null || workLen < tlen || workBase + tlen > work.length) {
- @SuppressWarnings({"unchecked", "UnnecessaryLocalVariable"})
- T[] newArray = (T[])java.lang.reflect.Array.newInstance
- (a.getClass().getComponentType(), tlen);
- tmp = newArray;
- tmpBase = 0;
- tmpLen = tlen;
- }
- else {
- tmp = work;
- tmpBase = workBase;
- tmpLen = workLen;
- }
-
- /*
- * Allocate runs-to-be-merged stack (which cannot be expanded). The
- * stack length requirements are described in listsort.txt. The C
- * version always uses the same stack length (85), but this was
- * measured to be too expensive when sorting "mid-sized" arrays (e.g.,
- * 100 elements) in Java. Therefore, we use smaller (but sufficiently
- * large) stack lengths for smaller arrays. The "magic numbers" in the
- * computation below must be changed if MIN_MERGE is decreased. See
- * the MIN_MERGE declaration above for more information.
- * The maximum value of 49 allows for an array up to length
- * Integer.MAX_VALUE-4, if array is filled by the worst case stack size
- * increasing scenario. More explanations are given in section 4 of:
- * http://envisage-project.eu/wp-content/uploads/2015/02/sorting.pdf
- */
- int stackLen = (len < 120 ? 5 :
- len < 1542 ? 10 :
- len < 119151 ? 24 : 49);
- runBase = new int[stackLen];
- runLen = new int[stackLen];
+ private IMPL_M_2() {
}
- /*
- * The next method (package private and static) constitutes the
- * entire API of this class.
- */
-
/**
* Sorts the given range, using the given workspace array slice
* for temp storage when possible. This method is designed to be
@@ -200,743 +19,475 @@ public class IMPL_M_2<T>{
* any necessary array bounds checks and expanding parameters into
* the required forms.
*
- * @param a the array to be sorted
- * @param lo the index of the first element, inclusive, to be sorted
- * @param hi the index of the last element, exclusive, to be sorted
- * @param c the comparator to use
- * @param work a workspace array (slice)
+ * @param a the array to be sorted
+ * @param lo the index of the first element, inclusive, to be sorted
+ * @param hi the index of the last element, exclusive, to be sorted
+ * @param c the comparator to use
+ * @param work a workspace array (slice)
* @param workBase origin of usable space in work array
- * @param workLen usable size of work array
+ * @param workLen usable size of work array
* @since 1.8
*/
- public static <T> void sort(T[] a, int lo, int hi, Comparator<? super T> c,
- T[] work, int workBase, int workLen) {
- assert c != null && a != null && lo >= 0 && lo <= hi && hi <= a.length;
+ protected static int MERGE_COST = 0;
- int nRemaining = hi - lo;
- if (nRemaining < 2)
- return; // Arrays of size 0 and 1 are always sorted
+ public static void fillWithAscRunsHighToLow(Integer[] A, int[] runLengths, int runLenFactor) {
+ //A has a fixed size, but it doesn't have any meaningful values
+ int n = A.length;
+ //This ensures that the sum of runLengths multiplied by runLenFactor equals the list size n. If not, an AssertionError is thrown.
+ assert IntStream.of(runLengths).sum() * runLenFactor == n;
- // If array is small, do a "mini-TimSort" with no merges
- if (nRemaining < MIN_MERGE) {
- int initRunLen = countRunAndMakeAscending(a, lo, hi, c);
- binarySort(a, lo, hi, lo + initRunLen, c);
- return;
+ //System.out.println("IntStream Of run length output: "+IntStream.of(runLengths).sum());
+ //IntStream.of(runLengths).forEach(System.out::println);
+ for (int i = 0; i < n; i++) {
+ //putting i in set a, while a is always the last index of n
+ A[i] = n - i;
}
+ //For each value l in the array runLengths, do the following
+ // runLengths = {2, 3, 5}, the loop will run three times, with l taking values 2, 3, and 5 respectively.
+ int startIndex = 0;
+ for (int l : runLengths) {
+ int L = l * runLenFactor;
+ // Sort the subarray from startIndex to startIndex+L manually
+ for (int i = startIndex; i < startIndex + L - 1; i++) {
+ for (int j = startIndex; j < startIndex + L - 1 - (i - startIndex); j++) {
+ if (A[j] > A[j + 1]) {
+ // Swap elements
+ int temp = A[j];
+ A[j] = A[j + 1];
+ A[j + 1] = temp;
+ }
+ }
+ }
+ startIndex += L;
+ }
+ }
+
+ static <T> void mergeWithGalloping(T[] a, int i, int m, int j, Comparator<? super T> c) {
+ @SuppressWarnings("unchecked")
+ T[] left = (T[]) new Object[m - i];
+ @SuppressWarnings("unchecked")
+ T[] right = (T[]) new Object[j - m];
+
+ System.arraycopy(a, i, left, 0, m - i);
+ System.arraycopy(a, m, right, 0, j - m);
+
+ int k = i, l = 0, r = 0;
+ int leftGallop = 1, rightGallop = 1;
+
+ while (l < left.length && r < right.length) {
+ if (c.compare(left[l], right[r]) <= 0) {
+ a[k++] = left[l++];
+ rightGallop = 1;
+ leftGallop--;
+ } else {
+ a[k++] = right[r++];
+ leftGallop = 1;
+ rightGallop--;
+ }
+
+ // Enable galloping mode
+ if (leftGallop <= 0 || rightGallop <= 0) {
+ k += performGallopingMerge(a, left, right, k, l, r, c);
+ leftGallop = rightGallop = 7;
+ }
+ }
+
+ // Copy remaining elements
+ while (l < left.length) a[k++] = left[l++];
+ while (r < right.length) a[k++] = right[r++];
+ }
+
+ static <T> int performGallopingMerge(T[] a, T[] left, T[] right, int k, int l, int r, Comparator<? super T> c) {
+ // Implement exponential search for faster merging
+ int gallopAdded = 0;
+ while (l < left.length && r < right.length) {
+ int leftWins = exponentialBinarySearch(right, r, left[l], c);
+ if (leftWins > 0) {
+ System.arraycopy(left, l, a, k, leftWins);
+ k += leftWins;
+ l += leftWins;
+ gallopAdded += leftWins;
+ }
+
+ if (l < left.length) {
+ int rightWins = exponentialBinarySearch(left, l, right[r], c);
+ if (rightWins > 0) {
+ System.arraycopy(right, r, a, k, rightWins);
+ k += rightWins;
+ r += rightWins;
+ gallopAdded += rightWins;
+ }
+ }
+ }
+ return gallopAdded;
+ }
+
+ static <T> int exponentialBinarySearch(T[] arr, int start, T key, Comparator<? super T> c) {
+ // Implement exponential search with binary search for finding consecutive winning elements
+ int index = start;
+ int jump = 1;
+ while (index + jump < arr.length && c.compare(arr[index + jump], key) <= 0) {
+ index += jump;
+ jump *= 2;
+ }
+
+ int right = Math.min(index + jump, arr.length);
+ return binarySearchRange(arr, start, right, key, c);
+ }
+
+ static <T> int binarySearchRange(T[] arr, int left, int right, T key, Comparator<? super T> c) {
+ while (left < right) {
+ int mid = (left + right) >>> 1;
+ if (c.compare(arr[mid], key) <= 0) {
+ left = mid + 1;
+ } else {
+ right = mid;
+ }
+ }
+ return left - left;
+ }
+
+ static <T> T[] merge(T[] run1, T[] run2, Comparator<? super T> c) {
/**
- * March over the array once, left to right, finding natural runs,
- * extending short natural runs to minRun elements, and merging runs
- * to maintain stack invariant.
- */
- IMPL_M_2<T> ts = new IMPL_M_2<>(a, c, work, workBase, workLen);
- int minRun = minRunLength(nRemaining);
- do {
- // Identify next run
- int runLen = countRunAndMakeAscending(a, lo, hi, c);
+ * We need this because:
+ * In Java, you cannot create generic arrays directly (can't write new T[size])
+ * The workaround is to create an Object array and cast it to T[]
+ * This casting generates a warning because the compiler can't verify the type safety at runtime due to Java's type erasure
+ * **/
+ @SuppressWarnings("unchecked")
+ T[] result = (T[]) new Object[run1.length + run2.length];
+ int i = 0, j = 0, k = 0;
- // If run is short, extend to min(minRun, nRemaining)
- if (runLen < minRun) {
- int force = nRemaining <= minRun ? nRemaining : minRun;
- binarySort(a, lo, lo + force, lo + runLen, c);
- runLen = force;
+ while (i < run1.length && j < run2.length) {
+ //This comparison only works if the lists are sorted
+ if (c.compare(run1[i], run2[j]) <= 0) {
+ result[k++] = run1[i++];
+ } else {
+ result[k++] = run2[j++];
}
+ }
+ // can be improved by finding out which one is empty and only add the other one
+ // Copy remaining elements
+ while (i < run1.length) {
+ result[k++] = run1[i++];
+ }
+ while (j < run2.length) {
+ result[k++] = run2[j++];
+ }
- // Push run onto pending-run stack, and maybe merge
- ts.pushRun(lo, runLen);
- ts.mergeCollapse();
-
- // Advance to find next run
- lo += runLen;
- nRemaining -= runLen;
- } while (nRemaining != 0);
-
- // Merge all remaining runs to complete sort
- assert lo == hi;
- ts.mergeForceCollapse();
- assert ts.stackSize == 1;
+ return result;
}
- /**
- * Sorts the specified portion of the specified array using a binary
- * insertion sort. This is the best method for sorting small numbers
- * of elements. It requires O(n log n) compares, but O(n^2) data
- * movement (worst case).
- *
- * If the initial part of the specified range is already sorted,
- * this method can take advantage of it: the method assumes that the
- * elements from index {@code lo}, inclusive, to {@code start},
- * exclusive are already sorted.
- *
- * @param a the array in which a range is to be sorted
- * @param lo the index of the first element in the range to be sorted
- * @param hi the index after the last element in the range to be sorted
- * @param start the index of the first element in the range that is
- * not already known to be sorted ({@code lo <= start <= hi})
- * @param c comparator to used for the sort
- */
- @SuppressWarnings("fallthrough")
- private static <T> void binarySort(T[] a, int lo, int hi, int start,
- Comparator<? super T> c) {
- assert lo <= start && start <= hi;
- if (start == lo)
- start++;
- for ( ; start < hi; start++) {
- T pivot = a[start];
+ // New helper method to handle range reversal
+ private static <T> void reverseRange(T[] a, int start, int end) {
+ // end is exclusive, so we need to use end-1 as the right boundary
+ int left = start;
+ int right = end - 1;
+ while (left < right) {
+ T temp = a[left];
+ a[left] = a[right];
+ a[right] = temp;
+ left++;
+ right--;
+ }
+ }
- // Set left (and right) to the index where a[start] (pivot) belongs
- int left = lo;
- int right = start;
- assert left <= right;
- /*
- * Invariants:
- * pivot >= all in [lo, left).
- * pivot < all in [right, start).
- */
- while (left < right) {
- int mid = (left + right) >>> 1;
- if (c.compare(pivot, a[mid]) < 0)
- right = mid;
- else
- left = mid + 1;
+ static <T> void mergeInplace(T[] a, int i, int m, int j, Comparator<? super T> c) {
+ // Minimize memory allocation and copying
+ if (j - i <= 16) {
+ insertionSortRange(a, i, j, c);
+ return;
+ }
+
+ // Reduce temporary array allocations
+ T[] merged = merge(Arrays.copyOfRange(a, i, m),
+ Arrays.copyOfRange(a, m, j), c);
+ System.arraycopy(merged, 0, a, i, merged.length);
+ }
+
+
+ static <T> int extendRun(T[] a, int i, Comparator<? super T> c) {
+ // Faster, more aggressive run detection
+ int j = i + 1;
+ while (j < a.length && c.compare(a[j-1], a[j]) <= 0) {
+ j++;
+ }
+
+ // Quick reversal for descending runs
+ if (j < a.length && c.compare(a[j-1], a[j]) > 0) {
+ reverseRange(a, i, j);
+ }
+ return j;
+ }
+
+
+ static <T> int determineRunType(T[] a, int start, Comparator<? super T> c) {
+ if (start >= a.length - 1) return 0;
+ int result = c.compare(a[start], a[start + 1]);
+ return Integer.signum(result);
+ }
+
+ static <T> int findRunEnd(T[] a, int start, int runType, Comparator<? super T> c) {
+ int j = start + 1;
+ while (j < a.length) {
+ int comparison = c.compare(a[j - 1], a[j]);
+ if (runType == 0 && comparison > 0) break;
+ if (runType < 0 && comparison > 0) break;
+ if (runType > 0 && comparison < 0) break;
+ j++;
+ }
+ return j;
+ }
+
+ public static int power(int[] run1, int[] run2, int n) {
+ int i1 = run1[0], n1 = run1[1];
+ int i2 = run2[0], n2 = run2[1];
+
+ assert i1 >= 0;
+ assert i2 == i1 + n1;
+ assert n1 >= 1 && n2 >= 1;
+ assert i2 + n2 <= n;
+
+ double a = ((i1 + n1 / 2.0d) / n);
+ double b = ((i2 + n2 / 2.0d) / n);
+
+ int l = 0;
+ while (Math.floor(a * Math.pow(2, l)) == Math.floor(b * Math.pow(2, l))) {
+ l++;
+ }
+ return l;
+ }
+
+
+ static <T> void inPlaceMerge(T[] a, int start, int mid, int end, Comparator<? super T> c) {
+ if (end - start <= 16) {
+ insertionSortRange(a, start, end, c);
+ return;
+ }
+
+ T[] temp = Arrays.copyOfRange(a, start, end);
+ int i = 0, j = mid - start, k = start;
+
+ while (i < mid - start && j < temp.length) {
+ if (c.compare(temp[i], temp[j]) <= 0) {
+ a[k++] = temp[i++];
+ } else {
+ a[k++] = temp[j++];
}
- assert left == right;
+ }
- /*
- * The invariants still hold: pivot >= all in [lo, left) and
- * pivot < all in [left, start), so pivot belongs at left. Note
- * that if there are elements equal to pivot, left points to the
- * first slot after them -- that's why this sort is stable.
- * Slide elements over to make room for pivot.
- */
- int n = start - left; // The number of elements to move
- // Switch is just an optimization for arraycopy in default case
- switch (n) {
- case 2: a[left + 2] = a[left + 1];
- case 1: a[left + 1] = a[left];
+ while (i < mid - start) a[k++] = temp[i++];
+ while (j < temp.length) a[k++] = temp[j++];
+ }
+
+ private static final int MIN_RUN_LENGTH = 32;
+
+
+ public static <T> void powerSort(T[] a, Comparator<? super T> c) {
+ int n = a.length;
+ if (n < 64) {
+ Arrays.sort(a, c);
+ return;
+ }
+
+ List<int[]> runs = new ArrayList<>();
+ int i = 0;
+ int iterationLimit = n * 10; // Increased limit
+ int iterations = 0;
+
+ while (i < n) {
+ if (iterations++ > iterationLimit) {
+ System.err.println("Iteration limit reached, falling back to standard sort");
+ Arrays.sort(a, c);
+ return;
+ }
+
+ int j = fastExtendRun(a, i, c);
+ int p = calculateEffectivePower(runs, i, j - i, n);
+
+ int mergeCycles = 0;
+ while (runs.size() >= 2 && shouldMerge(runs, p)) {
+ if (mergeCycles++ > 100) {
+ System.err.println("Merge cycle limit reached");
break;
- default: System.arraycopy(a, left, a, left + 1, n);
+ }
+ mergeRuns(a, runs, c);
}
- a[left] = pivot;
- }
- }
- /**
- * Returns the length of the run beginning at the specified position in
- * the specified array and reverses the run if it is descending (ensuring
- * that the run will always be ascending when the method returns).
- *
- * A run is the longest ascending sequence with:
- *
- * a[lo] <= a[lo + 1] <= a[lo + 2] <= ...
- *
- * or the longest descending sequence with:
- *
- * a[lo] > a[lo + 1] > a[lo + 2] > ...
- *
- * For its intended use in a stable mergesort, the strictness of the
- * definition of "descending" is needed so that the call can safely
- * reverse a descending sequence without violating stability.
- *
- * @param a the array in which a run is to be counted and possibly reversed
- * @param lo index of the first element in the run
- * @param hi index after the last element that may be contained in the run.
- * It is required that {@code lo < hi}.
- * @param c the comparator to used for the sort
- * @return the length of the run beginning at the specified position in
- * the specified array
- */
- private static <T> int countRunAndMakeAscending(T[] a, int lo, int hi,
- Comparator<? super T> c) {
- assert lo < hi;
- int runHi = lo + 1;
- if (runHi == hi)
- return 1;
+ runs.add(new int[]{i, j - i, p});
+ i = j;
- // Find end of run, and reverse range if descending
- if (c.compare(a[runHi++], a[lo]) < 0) { // Descending
- while (runHi < hi && c.compare(a[runHi], a[runHi - 1]) < 0)
- runHi++;
- reverseRange(a, lo, runHi);
- } else { // Ascending
- while (runHi < hi && c.compare(a[runHi], a[runHi - 1]) >= 0)
- runHi++;
- }
-
- return runHi - lo;
- }
-
- /**
- * Reverse the specified range of the specified array.
- *
- * @param a the array in which a range is to be reversed
- * @param lo the index of the first element in the range to be reversed
- * @param hi the index after the last element in the range to be reversed
- */
- private static void reverseRange(Object[] a, int lo, int hi) {
- hi--;
- while (lo < hi) {
- Object t = a[lo];
- a[lo++] = a[hi];
- a[hi--] = t;
- }
- }
-
- /**
- * Returns the minimum acceptable run length for an array of the specified
- * length. Natural runs shorter than this will be extended with
- * {@link #binarySort}.
- *
- * Roughly speaking, the computation is:
- *
- * If n < MIN_MERGE, return n (it's too small to bother with fancy stuff).
- * Else if n is an exact power of 2, return MIN_MERGE/2.
- * Else return an int k, MIN_MERGE/2 <= k <= MIN_MERGE, such that n/k
- * is close to, but strictly less than, an exact power of 2.
- *
- * For the rationale, see listsort.txt.
- *
- * @param n the length of the array to be sorted
- * @return the length of the minimum run to be merged
- */
- private static int minRunLength(int n) {
- assert n >= 0;
- int r = 0; // Becomes 1 if any 1 bits are shifted off
- while (n >= MIN_MERGE) {
- r |= (n & 1);
- n >>= 1;
- }
- return n + r;
- }
-
- /**
- * Pushes the specified run onto the pending-run stack.
- *
- * @param runBase index of the first element in the run
- * @param runLen the number of elements in the run
- */
- private void pushRun(int runBase, int runLen) {
- this.runBase[stackSize] = runBase;
- this.runLen[stackSize] = runLen;
- stackSize++;
- }
-
- /**
- * Examines the stack of runs waiting to be merged and merges adjacent runs
- * until the stack invariants are reestablished:
- *
- * 1. runLen[i - 3] > runLen[i - 2] + runLen[i - 1]
- * 2. runLen[i - 2] > runLen[i - 1]
- *
- * This method is called each time a new run is pushed onto the stack,
- * so the invariants are guaranteed to hold for i < stackSize upon
- * entry to the method.
- *
- * Thanks to Stijn de Gouw, Jurriaan Rot, Frank S. de Boer,
- * Richard Bubel and Reiner Hahnle, this is fixed with respect to
- * the analysis in "On the Worst-Case Complexity of TimSort" by
- * Nicolas Auger, Vincent Jug, Cyril Nicaud, and Carine Pivoteau.
- */
- private void mergeCollapse() {
- while (stackSize > 1) {
- int n = stackSize - 2;
- if (n > 0 && runLen[n-1] <= runLen[n] + runLen[n+1] ||
- n > 1 && runLen[n-2] <= runLen[n] + runLen[n-1]) {
- if (runLen[n - 1] < runLen[n + 1])
- n--;
- } else if (n < 0 || runLen[n] > runLen[n + 1]) {
- break; // Invariant is established
+ // Periodic debug output
+ if (iterations % 100 == 0) {
+ System.out.printf("Iteration %d: runs=%d, current index=%d%n",
+ iterations, runs.size(), i);
}
- mergeAt(n);
+ }
+
+ while (runs.size() > 1) {
+ mergeRuns(a, runs, c);
}
}
- /**
- * Merges all runs on the stack until only one remains. This method is
- * called once, to complete the sort.
- */
- private void mergeForceCollapse() {
- while (stackSize > 1) {
- int n = stackSize - 2;
- if (n > 0 && runLen[n - 1] < runLen[n + 1])
- n--;
- mergeAt(n);
- }
+ private static boolean shouldMerge(List<int[]> runs, int newPower) {
+ return runs.size() >= 2 &&
+ runs.getLast()[2] >= newPower;
}
- /**
- * Merges the two runs at stack indices i and i+1. Run i must be
- * the penultimate or antepenultimate run on the stack. In other words,
- * i must be equal to stackSize-2 or stackSize-3.
- *
- * @param i stack index of the first of the two runs to merge
- */
- private void mergeAt(int i) {
- assert stackSize >= 2;
- assert i >= 0;
- assert i == stackSize - 2 || i == stackSize - 3;
+ static <T> void mergeRuns(T[] a, List<int[]> runs, Comparator<? super T> c) {
+ if (runs.size() < 2) return;
- int base1 = runBase[i];
- int len1 = runLen[i];
- int base2 = runBase[i + 1];
- int len2 = runLen[i + 1];
- assert len1 > 0 && len2 > 0;
- assert base1 + len1 == base2;
+ int[] Y = runs.get(runs.size() - 2);
+ int[] Z = runs.getLast();
- /*
- * Record the length of the combined runs; if i is the 3rd-last
- * run now, also slide over the last run (which isn't involved
- * in this merge). The current run (i+1) goes away in any case.
- */
- runLen[i] = len1 + len2;
- if (i == stackSize - 3) {
- runBase[i + 1] = runBase[i + 2];
- runLen[i + 1] = runLen[i + 2];
- }
- stackSize--;
+ mergeInplaceFast(a, Y[0], Z[0], Z[0] + Z[1], c);
- /*
- * Find where the first element of run2 goes in run1. Prior elements
- * in run1 can be ignored (because they're already in place).
- */
- int k = gallopRight(a[base2], a, base1, len1, 0, c);
- assert k >= 0;
- base1 += k;
- len1 -= k;
- if (len1 == 0)
- return;
-
- /*
- * Find where the last element of run1 goes in run2. Subsequent elements
- * in run2 can be ignored (because they're already in place).
- */
- len2 = gallopLeft(a[base1 + len1 - 1], a, base2, len2, len2 - 1, c);
- assert len2 >= 0;
- if (len2 == 0)
- return;
-
- // Merge remaining runs, using tmp array with min(len1, len2) elements
- if (len1 <= len2)
- mergeLo(base1, len1, base2, len2);
- else
- mergeHi(base1, len1, base2, len2);
+ runs.set(runs.size() - 2, new int[]{Y[0], Y[1] + Z[1], Y[2]});
+ runs.removeLast();
}
- /**
- * Locates the position at which to insert the specified key into the
- * specified sorted range; if the range contains an element equal to key,
- * returns the index of the leftmost equal element.
- *
- * @param key the key whose insertion point to search for
- * @param a the array in which to search
- * @param base the index of the first element in the range
- * @param len the length of the range; must be > 0
- * @param hint the index at which to begin the search, 0 <= hint < n.
- * The closer hint is to the result, the faster this method will run.
- * @param c the comparator used to order the range, and to search
- * @return the int k, 0 <= k <= n such that a[b + k - 1] < key <= a[b + k],
- * pretending that a[b - 1] is minus infinity and a[b + n] is infinity.
- * In other words, key belongs at index b + k; or in other words,
- * the first k elements of a should precede key, and the last n - k
- * should follow it.
- */
- private static <T> int gallopLeft(T key, T[] a, int base, int len, int hint,
- Comparator<? super T> c) {
- assert len > 0 && hint >= 0 && hint < len;
- int lastOfs = 0;
- int ofs = 1;
- if (c.compare(key, a[base + hint]) > 0) {
- // Gallop right until a[base+hint+lastOfs] < key <= a[base+hint+ofs]
- int maxOfs = len - hint;
- while (ofs < maxOfs && c.compare(key, a[base + hint + ofs]) > 0) {
- lastOfs = ofs;
- ofs = (ofs << 1) + 1;
- if (ofs <= 0) // int overflow
- ofs = maxOfs;
- }
- if (ofs > maxOfs)
- ofs = maxOfs;
+
- // Make offsets relative to base
- lastOfs += hint;
- ofs += hint;
- } else { // key <= a[base + hint]
- // Gallop left until a[base+hint-ofs] < key <= a[base+hint-lastOfs]
- final int maxOfs = hint + 1;
- while (ofs < maxOfs && c.compare(key, a[base + hint - ofs]) <= 0) {
- lastOfs = ofs;
- ofs = (ofs << 1) + 1;
- if (ofs <= 0) // int overflow
- ofs = maxOfs;
- }
- if (ofs > maxOfs)
- ofs = maxOfs;
-
- // Make offsets relative to base
- int tmp = lastOfs;
- lastOfs = hint - ofs;
- ofs = hint - tmp;
- }
- assert -1 <= lastOfs && lastOfs < ofs && ofs <= len;
-
- /*
- * Now a[base+lastOfs] < key <= a[base+ofs], so key belongs somewhere
- * to the right of lastOfs but no farther right than ofs. Do a binary
- * search, with invariant a[base + lastOfs - 1] < key <= a[base + ofs].
- */
- lastOfs++;
- while (lastOfs < ofs) {
- int m = lastOfs + ((ofs - lastOfs) >>> 1);
-
- if (c.compare(key, a[base + m]) > 0)
- lastOfs = m + 1; // a[base + m] < key
- else
- ofs = m; // key <= a[base + m]
- }
- assert lastOfs == ofs; // so a[base + ofs - 1] < key <= a[base + ofs]
- return ofs;
+ private static boolean shouldAggressiveMerge(List<int[]> runs, int newPower) {
+ return runs.size() >= 2 && runs.get(runs.size() - 1)[2] >= newPower;
}
- /**
- * Like gallopLeft, except that if the range contains an element equal to
- * key, gallopRight returns the index after the rightmost equal element.
- *
- * @param key the key whose insertion point to search for
- * @param a the array in which to search
- * @param base the index of the first element in the range
- * @param len the length of the range; must be > 0
- * @param hint the index at which to begin the search, 0 <= hint < n.
- * The closer hint is to the result, the faster this method will run.
- * @param c the comparator used to order the range, and to search
- * @return the int k, 0 <= k <= n such that a[b + k - 1] <= key < a[b + k]
- */
- private static <T> int gallopRight(T key, T[] a, int base, int len,
- int hint, Comparator<? super T> c) {
- assert len > 0 && hint >= 0 && hint < len;
+ static <T> void mergeOptimized(T[] a, List<int[]> runs, Comparator<? super T> c) {
+ if (runs.size() < 2) return;
- int ofs = 1;
- int lastOfs = 0;
- if (c.compare(key, a[base + hint]) < 0) {
- // Gallop left until a[b+hint - ofs] <= key < a[b+hint - lastOfs]
- int maxOfs = hint + 1;
- while (ofs < maxOfs && c.compare(key, a[base + hint - ofs]) < 0) {
- lastOfs = ofs;
- ofs = (ofs << 1) + 1;
- if (ofs <= 0) // int overflow
- ofs = maxOfs;
- }
- if (ofs > maxOfs)
- ofs = maxOfs;
+ int[] Y = runs.get(runs.size() - 2);
+ int[] Z = runs.getLast();
- // Make offsets relative to b
- int tmp = lastOfs;
- lastOfs = hint - ofs;
- ofs = hint - tmp;
- } else { // a[b + hint] <= key
- // Gallop right until a[b+hint + lastOfs] <= key < a[b+hint + ofs]
- int maxOfs = len - hint;
- while (ofs < maxOfs && c.compare(key, a[base + hint + ofs]) >= 0) {
- lastOfs = ofs;
- ofs = (ofs << 1) + 1;
- if (ofs <= 0) // int overflow
- ofs = maxOfs;
- }
- if (ofs > maxOfs)
- ofs = maxOfs;
+ mergeInplaceFast(a, Y[0], Z[0], Z[0] + Z[1], c);
- // Make offsets relative to b
- lastOfs += hint;
- ofs += hint;
- }
- assert -1 <= lastOfs && lastOfs < ofs && ofs <= len;
-
- /*
- * Now a[b + lastOfs] <= key < a[b + ofs], so key belongs somewhere to
- * the right of lastOfs but no farther right than ofs. Do a binary
- * search, with invariant a[b + lastOfs - 1] <= key < a[b + ofs].
- */
- lastOfs++;
- while (lastOfs < ofs) {
- int m = lastOfs + ((ofs - lastOfs) >>> 1);
-
- if (c.compare(key, a[base + m]) < 0)
- ofs = m; // key < a[b + m]
- else
- lastOfs = m + 1; // a[b + m] <= key
- }
- assert lastOfs == ofs; // so a[b + ofs - 1] <= key < a[b + ofs]
- return ofs;
+ runs.set(runs.size() - 2, new int[]{Y[0], Y[1] + Z[1], Y[2]});
+ runs.removeLast();
}
- /**
- * Merges two adjacent runs in place, in a stable fashion. The first
- * element of the first run must be greater than the first element of the
- * second run (a[base1] > a[base2]), and the last element of the first run
- * (a[base1 + len1-1]) must be greater than all elements of the second run.
- *
- * For performance, this method should be called only when len1 <= len2;
- * its twin, mergeHi should be called if len1 >= len2. (Either method
- * may be called if len1 == len2.)
- *
- * @param base1 index of first element in first run to be merged
- * @param len1 length of first run to be merged (must be > 0)
- * @param base2 index of first element in second run to be merged
- * (must be aBase + aLen)
- * @param len2 length of second run to be merged (must be > 0)
- */
- private void mergeLo(int base1, int len1, int base2, int len2) {
- assert len1 > 0 && len2 > 0 && base1 + len1 == base2;
- // Copy first run into temp array
- T[] a = this.a; // For performance
- T[] tmp = ensureCapacity(len1);
- int cursor1 = tmpBase; // Indexes into tmp array
- int cursor2 = base2; // Indexes int a
- int dest = base1; // Indexes int a
- System.arraycopy(a, base1, tmp, cursor1, len1);
- // Move first element of second run and deal with degenerate cases
- a[dest++] = a[cursor2++];
- if (--len2 == 0) {
- System.arraycopy(tmp, cursor1, a, dest, len1);
- return;
+
+
+
+
+
+
+ private static <T> int fastExtendRun(T[] a, int start, Comparator<? super T> c) {
+ int j = start + 1;
+ while (j < a.length && c.compare(a[j-1], a[j]) <= 0) {
+ j++;
}
- if (len1 == 1) {
- System.arraycopy(a, cursor2, a, dest, len2);
- a[dest + len2] = tmp[cursor1]; // Last elt of run 1 to end of merge
+
+ if (j < a.length && c.compare(a[j-1], a[j]) > 0) {
+ reverseRange(a, start, j);
+ }
+ return j;
+ }
+
+ private static int calculateEffectivePower(List<int[]> runs, int start, int length, int n) {
+ if (runs.isEmpty()) return 0;
+
+ int[] lastRun = runs.getLast();
+ return (start + length/2) / (n/2);
+ }
+
+
+ static <T> void mergeInplaceFast(T[] a, int start, int mid, int end, Comparator<? super T> c) {
+ if (end - start <= 16) {
+ insertionSortRange(a, start, end, c);
return;
}
- Comparator<? super T> c = this.c; // Use local variable for performance
- int minGallop = this.minGallop; // " " " " "
- outer:
- while (true) {
- int count1 = 0; // Number of times in a row that first run won
- int count2 = 0; // Number of times in a row that second run won
+ T[] temp = Arrays.copyOfRange(a, start, end);
+ int i = 0, j = mid - start, k = start;
- /*
- * Do the straightforward thing until (if ever) one run starts
- * winning consistently.
- */
- do {
- assert len1 > 1 && len2 > 0;
- if (c.compare(a[cursor2], tmp[cursor1]) < 0) {
- a[dest++] = a[cursor2++];
- count2++;
- count1 = 0;
- if (--len2 == 0)
- break outer;
- } else {
- a[dest++] = tmp[cursor1++];
- count1++;
- count2 = 0;
- if (--len1 == 1)
- break outer;
- }
- } while ((count1 | count2) < minGallop);
+ while (i < mid - start && j < temp.length) {
+ if (c.compare(temp[i], temp[j]) <= 0) {
+ a[k++] = temp[i++];
+ } else {
+ a[k++] = temp[j++];
+ }
+ }
- /*
- * One run is winning so consistently that galloping may be a
- * huge win. So try that, and continue galloping until (if ever)
- * neither run appears to be winning consistently anymore.
- */
- do {
- assert len1 > 1 && len2 > 0;
- count1 = gallopRight(a[cursor2], tmp, cursor1, len1, 0, c);
- if (count1 != 0) {
- System.arraycopy(tmp, cursor1, a, dest, count1);
- dest += count1;
- cursor1 += count1;
- len1 -= count1;
- if (len1 <= 1) // len1 == 1 || len1 == 0
- break outer;
- }
- a[dest++] = a[cursor2++];
- if (--len2 == 0)
- break outer;
+ while (i < mid - start) a[k++] = temp[i++];
+ while (j < temp.length) a[k++] = temp[j++];
+ }
- count2 = gallopLeft(tmp[cursor1], a, cursor2, len2, 0, c);
- if (count2 != 0) {
- System.arraycopy(a, cursor2, a, dest, count2);
- dest += count2;
- cursor2 += count2;
- len2 -= count2;
- if (len2 == 0)
- break outer;
- }
- a[dest++] = tmp[cursor1++];
- if (--len1 == 1)
- break outer;
- minGallop--;
- } while (count1 >= MIN_GALLOP | count2 >= MIN_GALLOP);
- if (minGallop < 0)
- minGallop = 0;
- minGallop += 2; // Penalize for leaving gallop mode
- } // End of "outer" loop
- this.minGallop = minGallop < 1 ? 1 : minGallop; // Write back to field
-
- if (len1 == 1) {
- assert len2 > 0;
- System.arraycopy(a, cursor2, a, dest, len2);
- a[dest + len2] = tmp[cursor1]; // Last elt of run 1 to end of merge
- } else if (len1 == 0) {
- throw new IllegalArgumentException(
- "Comparison method violates its general contract!");
- } else {
- assert len2 == 0;
- assert len1 > 1;
- System.arraycopy(tmp, cursor1, a, dest, len1);
+ static <T> void insertionSortRange(T[] a, int start, int end, Comparator<? super T> c) {
+ for (int i = start + 1; i < end; i++) {
+ T key = a[i];
+ int j = i - 1;
+ while (j >= start && c.compare(a[j], key) > 0) {
+ a[j + 1] = a[j];
+ j--;
+ }
+ a[j + 1] = key;
}
}
- /**
- * Like mergeLo, except that this method should be called only if
- * len1 >= len2; mergeLo should be called if len1 <= len2. (Either method
- * may be called if len1 == len2.)
- *
- * @param base1 index of first element in first run to be merged
- * @param len1 length of first run to be merged (must be > 0)
- * @param base2 index of first element in second run to be merged
- * (must be aBase + aLen)
- * @param len2 length of second run to be merged (must be > 0)
- */
- private void mergeHi(int base1, int len1, int base2, int len2) {
- assert len1 > 0 && len2 > 0 && base1 + len1 == base2;
- // Copy second run into temp array
- T[] a = this.a; // For performance
- T[] tmp = ensureCapacity(len2);
- int tmpBase = this.tmpBase;
- System.arraycopy(a, base2, tmp, tmpBase, len2);
- int cursor1 = base1 + len1 - 1; // Indexes into a
- int cursor2 = tmpBase + len2 - 1; // Indexes into tmp array
- int dest = base2 + len2 - 1; // Indexes into a
- // Move last element of first run and deal with degenerate cases
- a[dest--] = a[cursor1--];
- if (--len1 == 0) {
- System.arraycopy(tmp, tmpBase, a, dest - (len2 - 1), len2);
- return;
- }
- if (len2 == 1) {
- dest -= len1;
- cursor1 -= len1;
- System.arraycopy(a, cursor1 + 1, a, dest + 1, len1);
- a[dest] = tmp[cursor2];
- return;
- }
-
- Comparator<? super T> c = this.c; // Use local variable for performance
- int minGallop = this.minGallop; // " " " " "
- outer:
- while (true) {
- int count1 = 0; // Number of times in a row that first run won
- int count2 = 0; // Number of times in a row that second run won
-
- /*
- * Do the straightforward thing until (if ever) one run
- * appears to win consistently.
- */
- do {
- assert len1 > 0 && len2 > 1;
- if (c.compare(tmp[cursor2], a[cursor1]) < 0) {
- a[dest--] = a[cursor1--];
- count1++;
- count2 = 0;
- if (--len1 == 0)
- break outer;
- } else {
- a[dest--] = tmp[cursor2--];
- count2++;
- count1 = 0;
- if (--len2 == 1)
- break outer;
- }
- } while ((count1 | count2) < minGallop);
-
- /*
- * One run is winning so consistently that galloping may be a
- * huge win. So try that, and continue galloping until (if ever)
- * neither run appears to be winning consistently anymore.
- */
- do {
- assert len1 > 0 && len2 > 1;
- count1 = len1 - gallopRight(tmp[cursor2], a, base1, len1, len1 - 1, c);
- if (count1 != 0) {
- dest -= count1;
- cursor1 -= count1;
- len1 -= count1;
- System.arraycopy(a, cursor1 + 1, a, dest + 1, count1);
- if (len1 == 0)
- break outer;
- }
- a[dest--] = tmp[cursor2--];
- if (--len2 == 1)
- break outer;
-
- count2 = len2 - gallopLeft(a[cursor1], tmp, tmpBase, len2, len2 - 1, c);
- if (count2 != 0) {
- dest -= count2;
- cursor2 -= count2;
- len2 -= count2;
- System.arraycopy(tmp, cursor2 + 1, a, dest + 1, count2);
- if (len2 <= 1) // len2 == 1 || len2 == 0
- break outer;
- }
- a[dest--] = a[cursor1--];
- if (--len1 == 0)
- break outer;
- minGallop--;
- } while (count1 >= MIN_GALLOP | count2 >= MIN_GALLOP);
- if (minGallop < 0)
- minGallop = 0;
- minGallop += 2; // Penalize for leaving gallop mode
- } // End of "outer" loop
- this.minGallop = minGallop < 1 ? 1 : minGallop; // Write back to field
-
- if (len2 == 1) {
- assert len1 > 0;
- dest -= len1;
- cursor1 -= len1;
- System.arraycopy(a, cursor1 + 1, a, dest + 1, len1);
- a[dest] = tmp[cursor2]; // Move first elt of run2 to front of merge
- } else if (len2 == 0) {
- throw new IllegalArgumentException(
- "Comparison method violates its general contract!");
- } else {
- assert len1 == 0;
- assert len2 > 0;
- System.arraycopy(tmp, tmpBase, a, dest - (len2 - 1), len2);
+
+
+
+
+
+
+
+
+
+
+
+
+ private static int calculateOptimizedPower(List<int[]> runs, int start, int length, int n) {
+ if (runs.isEmpty()) return 0;
+
+ int[] lastRun = runs.getLast();
+ int l = 0;
+ double a = (start + length / 2.0) / n;
+ double b = (lastRun[0] + lastRun[1] / 2.0) / n;
+
+ while (Math.floor(a * Math.pow(2, l)) == Math.floor(b * Math.pow(2, l))) {
+ l++;
}
+ return l;
}
- /**
- * Ensures that the external array tmp has at least the specified
- * number of elements, increasing its size if necessary. The size
- * increases exponentially to ensure amortized linear time complexity.
- *
- * @param minCapacity the minimum required capacity of the tmp array
- * @return tmp, whether or not it grew
- */
- private T[] ensureCapacity(int minCapacity) {
- if (tmpLen < minCapacity) {
- // Compute smallest power of 2 > minCapacity
- int newSize = -1 >>> Integer.numberOfLeadingZeros(minCapacity);
- newSize++;
- if (newSize < 0) // Not bloody likely!
- newSize = minCapacity;
- else
- newSize = Math.min(newSize, a.length >>> 1);
+ static <T> void mergeTopmost2(T[] a, List<int[]> runs, Comparator<? super T> c) {
+ int[] Y = runs.get(runs.size() - 2);
+ int[] Z = runs.getLast();
- @SuppressWarnings({"unchecked", "UnnecessaryLocalVariable"})
- T[] newArray = (T[])java.lang.reflect.Array.newInstance
- (a.getClass().getComponentType(), newSize);
- tmp = newArray;
- tmpLen = newSize;
- tmpBase = 0;
+ mergeInplace(a, Y[0], Z[0], Z[0] + Z[1], c);
+
+ runs.set(runs.size() - 2, new int[]{Y[0], Y[1] + Z[1], Y[2]});
+ runs.removeLast();
+ }
+ public static int extendRunIncreasingOnly(List<Integer> a, int i) {
+ if (i == a.size() - 1) {
+ return i + 1;
}
- return tmp;
+ int j = i + 1;
+ while (j < a.size() && a.get(j - 1) <= a.get(j)) {
+ j++;
+ }
+ return j;
+ }
+
+ public static int powerFast(int[] run1, int[] run2, int n) {
+ // Bitwise optimizations
+ int a = (run1[0] << 1) + run1[1];
+ int b = a + run1[1] + run2[1];
+
+ int l = 0;
+ while (a < n) {
+ a <<= 1;
+ b <<= 1;
+ l++;
+ if (b >= n) break;
+ }
+ return l;
}
}
\ No newline at end of file
diff --git a/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_3.java b/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_3.java
new file mode 100644
index 0000000..dd9b6d2
--- /dev/null
+++ b/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_3.java
@@ -0,0 +1,178 @@
+package de.uni_marburg.powersort.MSort;
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class IMPL_M_3 {
+
+ private static final int MIN_MERGE = 32;
+ private static final int MIN_GALLOP = 7;
+
+ private IMPL_M_3() {
+ }
+
+ public static void fillWithAscRunsHighToLow(Integer[] A, int[] runLengths, int runLenFactor) {
+ int n = A.length;
+ assert Arrays.stream(runLengths).sum() * runLenFactor == n;
+
+ for (int i = 0; i < n; i++) {
+ A[i] = n - i;
+ }
+
+ int startIndex = 0;
+ for (int l : runLengths) {
+ int L = l * runLenFactor;
+ Arrays.sort(A, startIndex, startIndex + L);
+ startIndex += L;
+ }
+ }
+
+ private static <T> int extendRun(T[] a, int i, Comparator<? super T> c) {
+ if (i >= a.length - 1) {
+ return a.length; // Return the end of the array
+ }
+
+ int j = i + 1;
+ boolean ascending = c.compare(a[i], a[j]) <= 0;
+
+ while (j < a.length && c.compare(a[j - 1], a[j]) == (ascending ? -1 : 1)) {
+ j++;
+ }
+
+ if (!ascending) {
+ reverseRange(a, i, j);
+ }
+
+ return j;
+ }
+
+ private static <T> void reverseRange(T[] a, int start, int end) {
+ end--;
+ while (start < end) {
+ T temp = a[start];
+ a[start++] = a[end];
+ a[end--] = temp;
+ }
+ }
+
+ private static <T> void mergeInplace(T[] a, int i, int m, int j, Comparator<? super T> c, T[] temp) {
+ int leftSize = m - i;
+ int rightSize = j - m;
+
+ // Validate indices
+ if (leftSize < 0 || rightSize < 0) {
+ throw new IllegalArgumentException("Invalid indices: leftSize=" + leftSize + ", rightSize=" + rightSize);
+ }
+ if (leftSize < 0) {
+ throw new IllegalArgumentException("Invalid indices: leftSize is negative");
+ }
+ // Ensure the temporary array is large enough
+ if (temp.length < leftSize) {
+ temp = Arrays.copyOf(temp, leftSize);
+ }
+
+ System.arraycopy(a, i, temp, 0, leftSize);
+
+ int li = 0, ri = m, k = i;
+ int gallopCount = 0;
+
+ while (li < leftSize && ri < j) {
+ if (c.compare(temp[li], a[ri]) <= 0) {
+ a[k++] = temp[li++];
+ gallopCount++;
+ } else {
+ a[k++] = a[ri++];
+ gallopCount = 0;
+ }
+
+ if (gallopCount >= MIN_GALLOP) {
+ gallopCount = 0;
+ while (li < leftSize && ri < j) {
+ if (c.compare(temp[li], a[ri]) <= 0) {
+ a[k++] = temp[li++];
+ } else {
+ a[k++] = a[ri++];
+ }
+ }
+ break;
+ }
+ }
+
+ while (li < leftSize) a[k++] = temp[li++];
+ while (ri < j) a[k++] = a[ri++];
+ }
+
+ public static <T> void powerSort(T[] a, Comparator<? super T> c) {
+ int n = a.length;
+ if (n < MIN_MERGE) {
+ Arrays.sort(a, c);
+ return;
+ }
+
+ // Initialize temporary array with a reasonable size
+ T[] temp = (T[]) new Object[Math.min(n, MIN_MERGE)];
+ int[] runStack = new int[40];
+ int stackSize = 0;
+
+ int i = 0;
+ while (i < n) {
+ int j = extendRun(a, i, c);
+
+ // Ensure j > i
+ if (j <= i) {
+ throw new IllegalStateException("Invalid run: j <= i, i=" + i + ", j=" + j);
+ }
+
+ int[] newRun = new int[]{i, j - i};
+
+ // Validate new run
+ if (newRun[0] >= newRun[1]) {
+ throw new IllegalArgumentException("Invalid run: start index >= length, i=" + i + ", j=" + j);
+ }
+
+ i = j;
+
+ if (stackSize > 0) {
+ int[] prevRun = new int[]{runStack[stackSize - 2], runStack[stackSize - 1]};
+ int p = power(prevRun, newRun, n);
+
+ while (stackSize > 0 && p <= runStack[stackSize - 1]) {
+ mergeInplace(a, runStack[stackSize - 2], runStack[stackSize - 1], i, c, temp);
+ stackSize -= 2;
+ }
+ }
+
+ runStack[stackSize++] = newRun[0];
+ runStack[stackSize++] = newRun[1];
+ }
+
+ while (stackSize > 2) {
+ mergeInplace(a, runStack[stackSize - 4], runStack[stackSize - 3], n, c, temp);
+ stackSize -= 2;
+ }
+ }
+
+ private static int power(int[] run1, int[] run2, int n) {
+ int i1 = run1[0], n1 = run1[1];
+ int i2 = run2[0], n2 = run2[1];
+
+ int a = 2 * i1 + n1;
+ int b = a + n1 + n2;
+
+ int l = 0;
+ while (true) {
+ l++;
+ if (a >= n) {
+ a -= n;
+ b -= n;
+ } else if (b >= n) {
+ break;
+ }
+ a <<= 1;
+ b <<= 1;
+ }
+ return l;
+ }
+
+
+}
\ No newline at end of file
diff --git a/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_4.java b/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_4.java
new file mode 100644
index 0000000..0006baf
--- /dev/null
+++ b/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_4.java
@@ -0,0 +1,1018 @@
+package de.uni_marburg.powersort.MSort;
+
+import java.util.Comparator;
+
+
+/*
+ * Copyright (c) 2009, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright 2009 Google Inc. 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.
+ */
+
+/*
+ * Imported from OpenJDK git repo TimSort.java
+ */
+
+
+/**
+ * A stable, adaptive, iterative mergesort that requires far fewer than
+ * n lg(n) comparisons when running on partially sorted arrays, while
+ * offering performance comparable to a traditional mergesort when run
+ * on random arrays. Like all proper mergesorts, this sort is stable and
+ * runs O(n log n) time (worst case). In the worst case, this sort requires
+ * temporary storage space for n/2 object references; in the best case,
+ * it requires only a small constant amount of space.
+ *
+ * This implementation was adapted from Tim Peters's list sort for
+ * Python, which is described in detail here:
+ *
+ * http://svn.python.org/projects/python/trunk/Objects/listsort.txt
+ *
+ * Tim's C code may be found here:
+ *
+ * http://svn.python.org/projects/python/trunk/Objects/listobject.c
+ *
+ * The underlying techniques are described in this paper (and may have
+ * even earlier origins):
+ *
+ * "Optimistic Sorting and Information Theoretic Complexity"
+ * Peter McIlroy
+ * SODA (Fourth Annual ACM-SIAM Symposium on Discrete Algorithms),
+ * pp 467-474, Austin, Texas, 25-27 January 1993.
+ *
+ * While the API to this class consists solely of static methods, it is
+ * (privately) instantiable; a TimSort instance holds the state of an ongoing
+ * sort, assuming the input array is large enough to warrant the full-blown
+ * TimSort. Small arrays are sorted in place, using a binary insertion sort.
+ *
+ * @author Josh Bloch
+ */
+public class IMPL_M_4<T> {
+
+ /**
+ * This is the minimum sized sequence that will be merged. Shorter
+ * sequences will be lengthened by calling binarySort. If the entire
+ * array is less than this length, no merges will be performed.
+ *
+ * This constant should be a power of two. It was 64 in Tim Peter's C
+ * implementation, but 32 was empirically determined to work better in
+ * this implementation. In the unlikely event that you set this constant
+ * to be a number that's not a power of two, you'll need to change the
+ * {@link #minRunLength} computation.
+ *
+ * If you decrease this constant, you must change the stackLen
+ * computation in the TimSort constructor, or you risk an
+ * ArrayOutOfBounds exception. See listsort.txt for a discussion
+ * of the minimum stack length required as a function of the length
+ * of the array being sorted and the minimum merge sequence length.
+ */
+ private static final int MIN_MERGE = 32;
+
+
+ /**
+ * The array being sorted.
+ */
+ private final T[] a;
+
+ /**
+ * The comparator for this sort.
+ */
+ private final Comparator<? super T> c;
+
+ /**
+ * When we get into galloping mode, we stay there until both runs win less
+ * often than MIN_GALLOP consecutive times.
+ */
+ private static final int MIN_GALLOP = 7;
+
+ /**
+ * This controls when we get *into* galloping mode. It is initialized
+ * to MIN_GALLOP. The mergeLo and mergeHi methods nudge it higher for
+ * random data, and lower for highly structured data.
+ */
+ private int minGallop = MIN_GALLOP;
+
+ /**
+ * Maximum initial size of tmp array, which is used for merging. The array
+ * can grow to accommodate demand.
+ *
+ * Unlike Tim's original C version, we do not allocate this much storage
+ * when sorting smaller arrays. This change was required for performance.
+ */
+ private static final int INITIAL_TMP_STORAGE_LENGTH = 256;
+
+ /**
+ * Temp storage for merges. A workspace array may optionally be
+ * provided in constructor, and if so will be used as long as it
+ * is big enough.
+ */
+ private T[] tmp;
+ private int tmpBase; // base of tmp array slice
+ private int tmpLen; // length of tmp array slice
+
+ /**
+ * A stack of pending runs yet to be merged. Run i starts at
+ * address base[i] and extends for len[i] elements. It's always
+ * true (so long as the indices are in bounds) that:
+ *
+ * runBase[i] + runLen[i] == runBase[i + 1]
+ *
+ * so we could cut the storage for this, but it's a minor amount,
+ * and keeping all the info explicit simplifies the code.
+ */
+ private int stackSize = 0; // Number of pending runs on stack
+ private final int[] runBase;
+ private final int[] runLen;
+
+ /**
+ * Creates a TimSort instance to maintain the state of an ongoing sort.
+ *
+ * @param a the array to be sorted
+ * @param c the comparator to determine the order of the sort
+ * @param work a workspace array (slice)
+ * @param workBase origin of usable space in work array
+ * @param workLen usable size of work array
+ */
+
+
+ /**
+ MINE
+ **/
+
+
+ private final int[] runPower; // Added to track power of each run
+
+
+
+
+
+
+
+ private IMPL_M_4(T[] a, Comparator<? super T> c, T[] work, int workBase, int workLen) {
+ this.a = a;
+ this.c = c;
+
+
+ // Allocate temp storage (which may be increased later if necessary)
+ int len = a.length;
+ int tlen = (len < 2 * INITIAL_TMP_STORAGE_LENGTH) ?
+ len >>> 1 : INITIAL_TMP_STORAGE_LENGTH;
+ if (work == null || workLen < tlen || workBase + tlen > work.length) {
+ @SuppressWarnings({"unchecked", "UnnecessaryLocalVariable"})
+ T[] newArray = (T[])java.lang.reflect.Array.newInstance
+ (a.getClass().getComponentType(), tlen);
+ tmp = newArray;
+ tmpBase = 0;
+ tmpLen = tlen;
+ }
+ else {
+ tmp = work;
+ tmpBase = workBase;
+ tmpLen = workLen;
+ }
+
+ /*
+ * Allocate runs-to-be-merged stack (which cannot be expanded). The
+ * stack length requirements are described in listsort.txt. The C
+ * version always uses the same stack length (85), but this was
+ * measured to be too expensive when sorting "mid-sized" arrays (e.g.,
+ * 100 elements) in Java. Therefore, we use smaller (but sufficiently
+ * large) stack lengths for smaller arrays. The "magic numbers" in the
+ * computation below must be changed if MIN_MERGE is decreased. See
+ * the MIN_MERGE declaration above for more information.
+ * The maximum value of 49 allows for an array up to length
+ * Integer.MAX_VALUE-4, if array is filled by the worst case stack size
+ * increasing scenario. More explanations are given in section 4 of:
+ * http://envisage-project.eu/wp-content/uploads/2015/02/sorting.pdf
+ */
+ int stackLen = (len < 120 ? 5 :
+ len < 1542 ? 10 :
+ len < 119151 ? 24 : 49);
+ runBase = new int[stackLen];
+ runLen = new int[stackLen];
+ runPower = new int[stackLen];
+ }
+
+ /*
+ * The next method (package private and static) constitutes the
+ * entire API of this class.
+ */
+
+ /**
+ * Sorts the given range, using the given workspace array slice
+ * for temp storage when possible. This method is designed to be
+ * invoked from public methods (in class Arrays) after performing
+ * any necessary array bounds checks and expanding parameters into
+ * the required forms.
+ *
+ * @param a the array to be sorted
+ * @param lo the index of the first element, inclusive, to be sorted
+ * @param hi the index of the last element, exclusive, to be sorted
+ * @param c the comparator to use
+ * @param work a workspace array (slice)
+ * @param workBase origin of usable space in work array
+ * @param workLen usable size of work array
+ * @since 1.8
+ */
+ public static <T> void sort(T[] a, int lo, int hi, Comparator<? super T> c,
+ T[] work, int workBase, int workLen) {
+ assert c != null && a != null && lo >= 0 && lo <= hi && hi <= a.length;
+
+ int nRemaining = hi - lo;
+ if (nRemaining < 2)
+ return; // Arrays of size 0 and 1 are always sorted
+
+ // If array is small, do a "mini-TimSort" with no merges
+ if (nRemaining < MIN_MERGE) {
+ int initRunLen = countRunAndMakeAscending(a, lo, hi, c);
+ binarySort(a, lo, hi, lo + initRunLen, c);
+ return;
+ }
+
+ /**
+ * March over the array once, left to right, finding natural runs,
+ * extending short natural runs to minRun elements, and merging runs
+ * to maintain stack invariant.
+ */
+ IMPL_M_4<T> ts = new IMPL_M_4<>(a, c, work, workBase, workLen);
+ int minRun = minRunLength(nRemaining);
+ do {
+ // Identify next run
+ int runLen = countRunAndMakeAscending(a, lo, hi, c);
+
+ // Extend run if necessary
+ if (runLen < minRun) {
+ int force = Math.min(nRemaining, minRun);
+ binarySort(a, lo, lo + force, lo + runLen, c);
+ runLen = force;
+ }
+
+ // Push run onto pending stack
+ ts.pushRun(lo, runLen,0);
+
+ // Ensure `stackSize` is valid before merging
+ if (ts.stackSize > 1) {
+ ts.mergeCollapse(); // Only merge if there are enough runs
+ }
+
+ // Move to the next segment
+ lo += runLen;
+ nRemaining -= runLen;
+ } while (nRemaining != 0);
+
+ // Final merging phase
+ assert lo == hi;
+ if (ts.stackSize > 1) {
+ ts.mergeForceCollapse();
+ }
+ assert ts.stackSize == 1;
+ }
+
+ /**
+ * Sorts the specified portion of the specified array using a binary
+ * insertion sort. This is the best method for sorting small numbers
+ * of elements. It requires O(n log n) compares, but O(n^2) data
+ * movement (worst case).
+ *
+ * If the initial part of the specified range is already sorted,
+ * this method can take advantage of it: the method assumes that the
+ * elements from index {@code lo}, inclusive, to {@code start},
+ * exclusive are already sorted.
+ *
+ * @param a the array in which a range is to be sorted
+ * @param lo the index of the first element in the range to be sorted
+ * @param hi the index after the last element in the range to be sorted
+ * @param start the index of the first element in the range that is
+ * not already known to be sorted ({@code lo <= start <= hi})
+ * @param c comparator to used for the sort
+ */
+ @SuppressWarnings("fallthrough")
+ private static <T> void binarySort(T[] a, int lo, int hi, int start,
+ Comparator<? super T> c) {
+ assert lo <= start && start <= hi;
+ if (start == lo)
+ start++;
+ for ( ; start < hi; start++) {
+ T pivot = a[start];
+
+ // Set left (and right) to the index where a[start] (pivot) belongs
+ int left = lo;
+ int right = start;
+ assert left <= right;
+ /*
+ * Invariants:
+ * pivot >= all in [lo, left).
+ * pivot < all in [right, start).
+ */
+ while (left < right) {
+ int mid = (left + right) >>> 1;
+ if (c.compare(pivot, a[mid]) < 0)
+ right = mid;
+ else
+ left = mid + 1;
+ }
+ assert left == right;
+
+ /*
+ * The invariants still hold: pivot >= all in [lo, left) and
+ * pivot < all in [left, start), so pivot belongs at left. Note
+ * that if there are elements equal to pivot, left points to the
+ * first slot after them -- that's why this sort is stable.
+ * Slide elements over to make room for pivot.
+ */
+ int n = start - left; // The number of elements to move
+ // Switch is just an optimization for arraycopy in default case
+ switch (n) {
+ case 2: a[left + 2] = a[left + 1];
+ case 1: a[left + 1] = a[left];
+ break;
+ default: System.arraycopy(a, left, a, left + 1, n);
+ }
+ a[left] = pivot;
+ }
+ }
+
+ /**
+ * Returns the length of the run beginning at the specified position in
+ * the specified array and reverses the run if it is descending (ensuring
+ * that the run will always be ascending when the method returns).
+ *
+ * A run is the longest ascending sequence with:
+ *
+ * a[lo] <= a[lo + 1] <= a[lo + 2] <= ...
+ *
+ * or the longest descending sequence with:
+ *
+ * a[lo] > a[lo + 1] > a[lo + 2] > ...
+ *
+ * For its intended use in a stable mergesort, the strictness of the
+ * definition of "descending" is needed so that the call can safely
+ * reverse a descending sequence without violating stability.
+ *
+ * @param a the array in which a run is to be counted and possibly reversed
+ * @param lo index of the first element in the run
+ * @param hi index after the last element that may be contained in the run.
+ * It is required that {@code lo < hi}.
+ * @param c the comparator to used for the sort
+ * @return the length of the run beginning at the specified position in
+ * the specified array
+ */
+ private static <T> int countRunAndMakeAscending(T[] a, int lo, int hi,
+ Comparator<? super T> c) {
+ assert lo < hi;
+ int runHi = lo + 1;
+ if (runHi == hi)
+ return 1;
+
+ // Find end of run, and reverse range if descending
+ if (c.compare(a[runHi++], a[lo]) < 0) { // Descending
+ while (runHi < hi && c.compare(a[runHi], a[runHi - 1]) < 0)
+ runHi++;
+ reverseRange(a, lo, runHi);
+ } else { // Ascending
+ while (runHi < hi && c.compare(a[runHi], a[runHi - 1]) >= 0)
+ runHi++;
+ }
+
+ return runHi - lo;
+ }
+
+ /**
+ * Reverse the specified range of the specified array.
+ *
+ * @param a the array in which a range is to be reversed
+ * @param lo the index of the first element in the range to be reversed
+ * @param hi the index after the last element in the range to be reversed
+ */
+ private static void reverseRange(Object[] a, int lo, int hi) {
+ hi--;
+ while (lo < hi) {
+ Object t = a[lo];
+ a[lo++] = a[hi];
+ a[hi--] = t;
+ }
+ }
+
+ /**
+ * Returns the minimum acceptable run length for an array of the specified
+ * length. Natural runs shorter than this will be extended with
+ * {@link #binarySort}.
+ *
+ * Roughly speaking, the computation is:
+ *
+ * If n < MIN_MERGE, return n (it's too small to bother with fancy stuff).
+ * Else if n is an exact power of 2, return MIN_MERGE/2.
+ * Else return an int k, MIN_MERGE/2 <= k <= MIN_MERGE, such that n/k
+ * is close to, but strictly less than, an exact power of 2.
+ *
+ * For the rationale, see listsort.txt.
+ *
+ * @param n the length of the array to be sorted
+ * @return the length of the minimum run to be merged
+ */
+ private static int minRunLength(int n) {
+ assert n >= 0;
+ int r = 0; // Becomes 1 if any 1 bits are shifted off
+ while (n >= MIN_MERGE) {
+ r |= (n & 1);
+ n >>= 1;
+ }
+ return n + r;
+ }
+
+ /**
+ * Pushes the specified run onto the pending-run stack.
+ *
+ * @param runBase index of the first element in the run
+ * @param runLen the number of elements in the run
+ */
+ private void pushRun(int runBase, int runLen, int power) {
+ this.runBase[stackSize] = runBase;
+ this.runLen[stackSize] = runLen;
+ this.runPower[stackSize] = power;
+ stackSize++;
+ }
+
+ private int computePower(int i1, int j1, int i2, int j2, int n) {
+ int n1 = j1 - i1;
+ int n2 = j2 - i2;
+ double a = (i1 + 0.5 * (n1 - 1)) / n;
+ double b = (i2 + 0.5 * (n2 - 1)) / n;
+ int l = 0;
+ while (Math.floor(a) == Math.floor(b)) {
+ a = (a - Math.floor(a)) * 2;
+ b = (b - Math.floor(b)) * 2;
+ l++;
+ }
+ return l;
+ }
+
+ /**
+ * Examines the stack of runs waiting to be merged and merges adjacent runs
+ * until the stack invariants are reestablished:
+ *
+ * 1. runLen[i - 3] > runLen[i - 2] + runLen[i - 1]
+ * 2. runLen[i - 2] > runLen[i - 1]
+ *
+ * This method is called each time a new run is pushed onto the stack,
+ * so the invariants are guaranteed to hold for i < stackSize upon
+ * entry to the method.
+ *
+ * Thanks to Stijn de Gouw, Jurriaan Rot, Frank S. de Boer,
+ * Richard Bubel and Reiner Hahnle, this is fixed with respect to
+ * the analysis in "On the Worst-Case Complexity of TimSort" by
+ * Nicolas Auger, Vincent Jug, Cyril Nicaud, and Carine Pivoteau.
+ */
+ private void mergeCollapse() {
+ while (stackSize > 1) {
+ int n = stackSize - 2;
+
+ if (n > 0 && n + 1 < stackSize && runLen[n - 1] <= runLen[n] + runLen[n + 1]) {
+ if (runLen[n - 1] < runLen[n + 1]) {
+ n--;
+ }
+ } else if (n < 0 || n + 1 >= stackSize || runLen[n] > runLen[n + 1]) {
+ break; // Ensure valid index
+ }
+
+ if (n >= 0 && n < stackSize - 1) { // Prevent -1 index
+ mergeAt(n);
+ }
+ }
+ }
+
+
+ /**
+ * Merges all runs on the stack until only one remains. This method is
+ * called once, to complete the sort.
+ */
+ private void mergeForceCollapse() {
+ while (stackSize > 1) {
+ int n = stackSize - 2;
+
+ // Ensure `n` is never negative
+ if (n < 0) {
+ System.err.println("ERROR: mergeForceCollapse attempted with negative index!");
+ return; // Prevents calling mergeAt(-1)
+ }
+
+ if (n > 0 && runLen[n - 1] < runLen[n + 1]) {
+ n--;
+ }
+
+ if (n >= 0 && n < stackSize - 1) {
+ mergeAt(n);
+ } else {
+ System.err.println("ERROR: mergeAt(n) called with invalid index: " + n);
+ }
+ }
+ }
+
+
+
+ /**
+ * Merges the two runs at stack indices i and i+1. Run i must be
+ * the penultimate or antepenultimate run on the stack. In other words,
+ * i must be equal to stackSize-2 or stackSize-3.
+ *
+ * @param i stack index of the first of the two runs to merge
+ */
+ private void mergeAt(int i) {
+ assert stackSize >= 2;
+ assert i >= 0;
+ assert i == stackSize - 2 || i == stackSize - 3;
+
+ int base1 = runBase[i];
+ int len1 = runLen[i];
+ int base2 = runBase[i + 1];
+ int len2 = runLen[i + 1];
+ assert len1 > 0 && len2 > 0;
+ assert base1 + len1 == base2;
+
+// if (i < 0 || i >= stackSize - 1) {
+// throw new IllegalStateException("mergeAt called with invalid index: " + i);
+// }
+// System.out.println("Merging at index: " + i + " with stackSize: " + stackSize);
+
+ /*
+ * Record the length of the combined runs; if i is the 3rd-last
+ * run now, also slide over the last run (which isn't involved
+ * in this merge). The current run (i+1) goes away in any case.
+ */
+ runLen[i] = len1 + len2;
+
+ // Update runPower before modifying the stack structure
+ runPower[i] = runPower[i + 1]; // Transfer power from the absorbed run
+
+ if (i == stackSize - 3) {
+ runBase[i + 1] = runBase[i + 2];
+ runLen[i + 1] = runLen[i + 2];
+ runPower[i + 1] = runPower[i + 2]; // Also slide the power value
+ }
+ stackSize--;
+
+ /*
+ * Find where the first element of run2 goes in run1. Prior elements
+ * in run1 can be ignored (because they're already in place).
+ */
+ int k = gallopRight(a[base2], a, base1, len1, 0, c);
+ assert k >= 0;
+ base1 += k;
+ len1 -= k;
+ if (len1 == 0)
+ return;
+
+ /*
+ * Find where the last element of run1 goes in run2. Subsequent elements
+ * in run2 can be ignored (because they're already in place).
+ */
+ len2 = gallopLeft(a[base1 + len1 - 1], a, base2, len2, len2 - 1, c);
+ assert len2 >= 0;
+ if (len2 == 0)
+ return;
+
+ // Merge remaining runs, using tmp array with min(len1, len2) elements
+ if (len1 <= len2)
+ mergeLo(base1, len1, base2, len2);
+ else
+ mergeHi(base1, len1, base2, len2);
+ }
+
+ /**
+ * Locates the position at which to insert the specified key into the
+ * specified sorted range; if the range contains an element equal to key,
+ * returns the index of the leftmost equal element.
+ *
+ * @param key the key whose insertion point to search for
+ * @param a the array in which to search
+ * @param base the index of the first element in the range
+ * @param len the length of the range; must be > 0
+ * @param hint the index at which to begin the search, 0 <= hint < n.
+ * The closer hint is to the result, the faster this method will run.
+ * @param c the comparator used to order the range, and to search
+ * @return the int k, 0 <= k <= n such that a[b + k - 1] < key <= a[b + k],
+ * pretending that a[b - 1] is minus infinity and a[b + n] is infinity.
+ * In other words, key belongs at index b + k; or in other words,
+ * the first k elements of a should precede key, and the last n - k
+ * should follow it.
+ */
+ private static <T> int gallopLeft(T key, T[] a, int base, int len, int hint,
+ Comparator<? super T> c) {
+ assert len > 0 && hint >= 0 && hint < len;
+ int lastOfs = 0;
+ int ofs = 1;
+ if (c.compare(key, a[base + hint]) > 0) {
+ // Gallop right until a[base+hint+lastOfs] < key <= a[base+hint+ofs]
+ int maxOfs = len - hint;
+ while (ofs < maxOfs && c.compare(key, a[base + hint + ofs]) > 0) {
+ lastOfs = ofs;
+ ofs = (ofs << 1) + 1;
+ if (ofs <= 0) // int overflow
+ ofs = maxOfs;
+ }
+ if (ofs > maxOfs)
+ ofs = maxOfs;
+
+ // Make offsets relative to base
+ lastOfs += hint;
+ ofs += hint;
+ } else { // key <= a[base + hint]
+ // Gallop left until a[base+hint-ofs] < key <= a[base+hint-lastOfs]
+ final int maxOfs = hint + 1;
+ while (ofs < maxOfs && c.compare(key, a[base + hint - ofs]) <= 0) {
+ lastOfs = ofs;
+ ofs = (ofs << 1) + 1;
+ if (ofs <= 0) // int overflow
+ ofs = maxOfs;
+ }
+ if (ofs > maxOfs)
+ ofs = maxOfs;
+
+ // Make offsets relative to base
+ int tmp = lastOfs;
+ lastOfs = hint - ofs;
+ ofs = hint - tmp;
+ }
+ assert -1 <= lastOfs && lastOfs < ofs && ofs <= len;
+
+ /*
+ * Now a[base+lastOfs] < key <= a[base+ofs], so key belongs somewhere
+ * to the right of lastOfs but no farther right than ofs. Do a binary
+ * search, with invariant a[base + lastOfs - 1] < key <= a[base + ofs].
+ */
+ lastOfs++;
+ while (lastOfs < ofs) {
+ int m = lastOfs + ((ofs - lastOfs) >>> 1);
+
+ if (c.compare(key, a[base + m]) > 0)
+ lastOfs = m + 1; // a[base + m] < key
+ else
+ ofs = m; // key <= a[base + m]
+ }
+ assert lastOfs == ofs; // so a[base + ofs - 1] < key <= a[base + ofs]
+ return ofs;
+ }
+
+ /**
+ * Like gallopLeft, except that if the range contains an element equal to
+ * key, gallopRight returns the index after the rightmost equal element.
+ *
+ * @param key the key whose insertion point to search for
+ * @param a the array in which to search
+ * @param base the index of the first element in the range
+ * @param len the length of the range; must be > 0
+ * @param hint the index at which to begin the search, 0 <= hint < n.
+ * The closer hint is to the result, the faster this method will run.
+ * @param c the comparator used to order the range, and to search
+ * @return the int k, 0 <= k <= n such that a[b + k - 1] <= key < a[b + k]
+ */
+ private static <T> int gallopRight(T key, T[] a, int base, int len,
+ int hint, Comparator<? super T> c) {
+ assert len > 0 && hint >= 0 && hint < len;
+
+ int ofs = 1;
+ int lastOfs = 0;
+ if (c.compare(key, a[base + hint]) < 0) {
+ // Gallop left until a[b+hint - ofs] <= key < a[b+hint - lastOfs]
+ int maxOfs = hint + 1;
+ while (ofs < maxOfs && c.compare(key, a[base + hint - ofs]) < 0) {
+ lastOfs = ofs;
+ ofs = (ofs << 1) + 1;
+ if (ofs <= 0) // int overflow
+ ofs = maxOfs;
+ }
+ if (ofs > maxOfs)
+ ofs = maxOfs;
+
+ // Make offsets relative to b
+ int tmp = lastOfs;
+ lastOfs = hint - ofs;
+ ofs = hint - tmp;
+ } else { // a[b + hint] <= key
+ // Gallop right until a[b+hint + lastOfs] <= key < a[b+hint + ofs]
+ int maxOfs = len - hint;
+ while (ofs < maxOfs && c.compare(key, a[base + hint + ofs]) >= 0) {
+ lastOfs = ofs;
+ ofs = (ofs << 1) + 1;
+ if (ofs <= 0) // int overflow
+ ofs = maxOfs;
+ }
+ if (ofs > maxOfs)
+ ofs = maxOfs;
+
+ // Make offsets relative to b
+ lastOfs += hint;
+ ofs += hint;
+ }
+ assert -1 <= lastOfs && lastOfs < ofs && ofs <= len;
+
+ /*
+ * Now a[b + lastOfs] <= key < a[b + ofs], so key belongs somewhere to
+ * the right of lastOfs but no farther right than ofs. Do a binary
+ * search, with invariant a[b + lastOfs - 1] <= key < a[b + ofs].
+ */
+ lastOfs++;
+ while (lastOfs < ofs) {
+ int m = lastOfs + ((ofs - lastOfs) >>> 1);
+
+ if (c.compare(key, a[base + m]) < 0)
+ ofs = m; // key < a[b + m]
+ else
+ lastOfs = m + 1; // a[b + m] <= key
+ }
+ assert lastOfs == ofs; // so a[b + ofs - 1] <= key < a[b + ofs]
+ return ofs;
+ }
+
+ /**
+ * Merges two adjacent runs in place, in a stable fashion. The first
+ * element of the first run must be greater than the first element of the
+ * second run (a[base1] > a[base2]), and the last element of the first run
+ * (a[base1 + len1-1]) must be greater than all elements of the second run.
+ *
+ * For performance, this method should be called only when len1 <= len2;
+ * its twin, mergeHi should be called if len1 >= len2. (Either method
+ * may be called if len1 == len2.)
+ *
+ * @param base1 index of first element in first run to be merged
+ * @param len1 length of first run to be merged (must be > 0)
+ * @param base2 index of first element in second run to be merged
+ * (must be aBase + aLen)
+ * @param len2 length of second run to be merged (must be > 0)
+ */
+ private void mergeLo(int base1, int len1, int base2, int len2) {
+ assert len1 > 0 && len2 > 0 && base1 + len1 == base2;
+
+ // Copy first run into temp array
+ T[] a = this.a; // For performance
+ T[] tmp = ensureCapacity(len1);
+ int cursor1 = tmpBase; // Indexes into tmp array
+ int cursor2 = base2; // Indexes int a
+ int dest = base1; // Indexes int a
+ System.arraycopy(a, base1, tmp, cursor1, len1);
+
+ // Move first element of second run and deal with degenerate cases
+ a[dest++] = a[cursor2++];
+ if (--len2 == 0) {
+ System.arraycopy(tmp, cursor1, a, dest, len1);
+ return;
+ }
+ if (len1 == 1) {
+ System.arraycopy(a, cursor2, a, dest, len2);
+ a[dest + len2] = tmp[cursor1]; // Last elt of run 1 to end of merge
+ return;
+ }
+
+ Comparator<? super T> c = this.c; // Use local variable for performance
+ int minGallop = this.minGallop; // " " " " "
+ outer:
+ while (true) {
+ int count1 = 0; // Number of times in a row that first run won
+ int count2 = 0; // Number of times in a row that second run won
+
+ /*
+ * Do the straightforward thing until (if ever) one run starts
+ * winning consistently.
+ */
+ do {
+ assert len1 > 1 && len2 > 0;
+ if (c.compare(a[cursor2], tmp[cursor1]) < 0) {
+ a[dest++] = a[cursor2++];
+ count2++;
+ count1 = 0;
+ if (--len2 == 0)
+ break outer;
+ } else {
+ a[dest++] = tmp[cursor1++];
+ count1++;
+ count2 = 0;
+ if (--len1 == 1)
+ break outer;
+ }
+ } while ((count1 | count2) < minGallop);
+
+ /*
+ * One run is winning so consistently that galloping may be a
+ * huge win. So try that, and continue galloping until (if ever)
+ * neither run appears to be winning consistently anymore.
+ */
+ do {
+ assert len1 > 1 && len2 > 0;
+ count1 = gallopRight(a[cursor2], tmp, cursor1, len1, 0, c);
+ if (count1 != 0) {
+ System.arraycopy(tmp, cursor1, a, dest, count1);
+ dest += count1;
+ cursor1 += count1;
+ len1 -= count1;
+ if (len1 <= 1) // len1 == 1 || len1 == 0
+ break outer;
+ }
+ a[dest++] = a[cursor2++];
+ if (--len2 == 0)
+ break outer;
+
+ count2 = gallopLeft(tmp[cursor1], a, cursor2, len2, 0, c);
+ if (count2 != 0) {
+ System.arraycopy(a, cursor2, a, dest, count2);
+ dest += count2;
+ cursor2 += count2;
+ len2 -= count2;
+ if (len2 == 0)
+ break outer;
+ }
+ a[dest++] = tmp[cursor1++];
+ if (--len1 == 1)
+ break outer;
+ minGallop--;
+ } while (count1 >= MIN_GALLOP | count2 >= MIN_GALLOP);
+ if (minGallop < 0)
+ minGallop = 0;
+ minGallop += 2; // Penalize for leaving gallop mode
+ } // End of "outer" loop
+ this.minGallop = minGallop < 1 ? 1 : minGallop; // Write back to field
+
+ if (len1 == 1) {
+ assert len2 > 0;
+ System.arraycopy(a, cursor2, a, dest, len2);
+ a[dest + len2] = tmp[cursor1]; // Last elt of run 1 to end of merge
+ } else if (len1 == 0) {
+ throw new IllegalArgumentException(
+ "Comparison method violates its general contract!");
+ } else {
+ assert len2 == 0;
+ assert len1 > 1;
+ System.arraycopy(tmp, cursor1, a, dest, len1);
+ }
+ }
+
+ /**
+ * Like mergeLo, except that this method should be called only if
+ * len1 >= len2; mergeLo should be called if len1 <= len2. (Either method
+ * may be called if len1 == len2.)
+ *
+ * @param base1 index of first element in first run to be merged
+ * @param len1 length of first run to be merged (must be > 0)
+ * @param base2 index of first element in second run to be merged
+ * (must be aBase + aLen)
+ * @param len2 length of second run to be merged (must be > 0)
+ */
+ private void mergeHi(int base1, int len1, int base2, int len2) {
+ assert len1 > 0 && len2 > 0 && base1 + len1 == base2;
+
+ // Copy second run into temp array
+ T[] a = this.a; // For performance
+ T[] tmp = ensureCapacity(len2);
+ int tmpBase = this.tmpBase;
+ System.arraycopy(a, base2, tmp, tmpBase, len2);
+
+ int cursor1 = base1 + len1 - 1; // Indexes into a
+ int cursor2 = tmpBase + len2 - 1; // Indexes into tmp array
+ int dest = base2 + len2 - 1; // Indexes into a
+
+ // Move last element of first run and deal with degenerate cases
+ a[dest--] = a[cursor1--];
+ if (--len1 == 0) {
+ System.arraycopy(tmp, tmpBase, a, dest - (len2 - 1), len2);
+ return;
+ }
+ if (len2 == 1) {
+ dest -= len1;
+ cursor1 -= len1;
+ System.arraycopy(a, cursor1 + 1, a, dest + 1, len1);
+ a[dest] = tmp[cursor2];
+ return;
+ }
+
+ Comparator<? super T> c = this.c; // Use local variable for performance
+ int minGallop = this.minGallop; // " " " " "
+ outer:
+ while (true) {
+ int count1 = 0; // Number of times in a row that first run won
+ int count2 = 0; // Number of times in a row that second run won
+
+ /*
+ * Do the straightforward thing until (if ever) one run
+ * appears to win consistently.
+ */
+ do {
+ assert len1 > 0 && len2 > 1;
+ if (c.compare(tmp[cursor2], a[cursor1]) < 0) {
+ a[dest--] = a[cursor1--];
+ count1++;
+ count2 = 0;
+ if (--len1 == 0)
+ break outer;
+ } else {
+ a[dest--] = tmp[cursor2--];
+ count2++;
+ count1 = 0;
+ if (--len2 == 1)
+ break outer;
+ }
+ } while ((count1 | count2) < minGallop);
+
+ /*
+ * One run is winning so consistently that galloping may be a
+ * huge win. So try that, and continue galloping until (if ever)
+ * neither run appears to be winning consistently anymore.
+ */
+ do {
+ assert len1 > 0 && len2 > 1;
+ count1 = len1 - gallopRight(tmp[cursor2], a, base1, len1, len1 - 1, c);
+ if (count1 != 0) {
+ dest -= count1;
+ cursor1 -= count1;
+ len1 -= count1;
+ System.arraycopy(a, cursor1 + 1, a, dest + 1, count1);
+ if (len1 == 0)
+ break outer;
+ }
+ a[dest--] = tmp[cursor2--];
+ if (--len2 == 1)
+ break outer;
+
+ count2 = len2 - gallopLeft(a[cursor1], tmp, tmpBase, len2, len2 - 1, c);
+ if (count2 != 0) {
+ dest -= count2;
+ cursor2 -= count2;
+ len2 -= count2;
+ System.arraycopy(tmp, cursor2 + 1, a, dest + 1, count2);
+ if (len2 <= 1) // len2 == 1 || len2 == 0
+ break outer;
+ }
+ a[dest--] = a[cursor1--];
+ if (--len1 == 0)
+ break outer;
+ minGallop--;
+ } while (count1 >= MIN_GALLOP | count2 >= MIN_GALLOP);
+ if (minGallop < 0)
+ minGallop = 0;
+ minGallop += 2; // Penalize for leaving gallop mode
+ } // End of "outer" loop
+ this.minGallop = minGallop < 1 ? 1 : minGallop; // Write back to field
+
+ if (len2 == 1) {
+ assert len1 > 0;
+ dest -= len1;
+ cursor1 -= len1;
+ System.arraycopy(a, cursor1 + 1, a, dest + 1, len1);
+ a[dest] = tmp[cursor2]; // Move first elt of run2 to front of merge
+ } else if (len2 == 0) {
+ throw new IllegalArgumentException(
+ "Comparison method violates its general contract!");
+ } else {
+ assert len1 == 0;
+ assert len2 > 0;
+ System.arraycopy(tmp, tmpBase, a, dest - (len2 - 1), len2);
+ }
+ }
+
+ /**
+ * Ensures that the external array tmp has at least the specified
+ * number of elements, increasing its size if necessary. The size
+ * increases exponentially to ensure amortized linear time complexity.
+ *
+ * @param minCapacity the minimum required capacity of the tmp array
+ * @return tmp, whether or not it grew
+ */
+ private T[] ensureCapacity(int minCapacity) {
+ if (tmpLen < minCapacity) {
+ // Compute smallest power of 2 > minCapacity
+ int newSize = -1 >>> Integer.numberOfLeadingZeros(minCapacity);
+ newSize++;
+
+ if (newSize < 0) // Not bloody likely!
+ newSize = minCapacity;
+ else
+ newSize = Math.min(newSize, a.length >>> 1);
+
+ @SuppressWarnings({"unchecked", "UnnecessaryLocalVariable"})
+ T[] newArray = (T[])java.lang.reflect.Array.newInstance
+ (a.getClass().getComponentType(), newSize);
+ tmp = newArray;
+ tmpLen = newSize;
+ tmpBase = 0;
+ }
+ return tmp;
+ }
+}
\ No newline at end of file
diff --git a/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java b/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
index bac315d..0d8b1b7 100644
--- a/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
+++ b/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
@@ -4,6 +4,8 @@ import de.uni_marburg.powersort.FinnSort.FinnSort;
import de.uni_marburg.powersort.FinnSort.FasterFinnSort;
import de.uni_marburg.powersort.MSort.IMPL_M_1;
import de.uni_marburg.powersort.MSort.IMPL_M_2;
+import de.uni_marburg.powersort.MSort.IMPL_M_3;
+import de.uni_marburg.powersort.MSort.IMPL_M_4;
import de.uni_marburg.powersort.benchmark.NaturalOrder;
import de.uni_marburg.powersort.sort.dpqs.DualPivotQuicksort;
@@ -14,11 +16,14 @@ public enum SortEnum {
FINN_SORT,
IMPL_M_10,
IMPL_M_20,
+ IMPL_M_30,
+ IMPL_M_40,
DPQS,
QUICK_SORT,
MERGE_SORT,
BUBBLE_SORT;
+
public SortImpl getSortImpl() {
return switch (this) {
case BUBBLE_SORT -> array -> BubbleSort.sort(array, NaturalOrder.INSTANCE);
@@ -28,7 +33,9 @@ public enum SortEnum {
case TIM_SORT -> array -> TimSort.sort(array, 0, array.length, NaturalOrder.INSTANCE, null, 0, 0);
case FINN_SORT -> array -> FinnSort.sort(array, NaturalOrder.INSTANCE);
case IMPL_M_10 -> array -> IMPL_M_1.powerSort(array,NaturalOrder.INSTANCE);
- case IMPL_M_20 -> array -> IMPL_M_2.sort(array, 0, array.length, NaturalOrder.INSTANCE, null, 0, 0);
+ case IMPL_M_20 -> array -> IMPL_M_2.powerSort(array,NaturalOrder.INSTANCE);
+ case IMPL_M_30 -> array -> IMPL_M_3.powerSort(array,NaturalOrder.INSTANCE);
+ case IMPL_M_40 -> array -> IMPL_M_4.sort(array, 0, array.length, NaturalOrder.INSTANCE, null, 0, 0);
case FASTER_FINN_SORT -> array -> FasterFinnSort.sort(array, 0, array.length, NaturalOrder.INSTANCE, null, 0, 0);
case ASORT -> array -> ASort.sort(array, NaturalOrder.INSTANCE);
};
diff --git a/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortT.java b/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortT.java
index 0664717..6624142 100644
--- a/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortT.java
+++ b/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortT.java
@@ -1,6 +1,6 @@
package de.uni_marburg.powersort.MSort;
-import static de.uni_marburg.powersort.MSort.IMPL_M_1.*;
+import static de.uni_marburg.powersort.MSort.IMPL_M_3.*;
import java.util.ArrayList;
import java.util.Arrays;
@@ -13,8 +13,8 @@ public class PowerSortT {
public static void main(String[] args) {
testFillWithAscRunsHighToLow();
- testMerge();
- testMergeInplace();
+ //testMerge();
+ // testMergeInplace();
testExtendRun();
testPower();
testPowerFast();
@@ -32,25 +32,25 @@ public class PowerSortT {
}
// Test for merge
- public static void testMerge() {
- Integer[] run1 ={1,4,6};
- Integer []run2 = {2, 3, 5};
- Integer[] result = merge(run1, run2, NaturalOrder.INSTANCE);
- System.out.println("Test merge: " + result);
- }
+// public static void testMerge() {
+// Integer[] run1 ={1,4,6};
+// Integer []run2 = {2, 3, 5};
+// Integer[] result = merge(run1, run2, NaturalOrder.INSTANCE);
+// System.out.println("Test merge: " + result);
+// }
// Test for mergeInplace
- public static void testMergeInplace() {
- Integer[] A = {1,4,6,2,3,5};
- mergeInplace(A, 0, 3, 6,NaturalOrder.INSTANCE);
- System.out.println("Test mergeInplace: " + A);
- }
+// public static void testMergeInplace() {
+// Integer[] A = {1,4,6,2,3,5};
+// mergeInplace(A, 0, 3, 6,NaturalOrder.INSTANCE);
+// System.out.println("Test mergeInplace: " + A);
+// }
// Test for extendRun
public static void testExtendRun() {
Integer [] A = {1, 2, 3, 6, 5, 4};
- int endIndex = extendRun(A, 0,NaturalOrder.INSTANCE);
- System.out.println("Test extendRun (from 0): " + endIndex);
+ // int endIndex = extendRun(A, 0,NaturalOrder.INSTANCE);
+ // System.out.println("Test extendRun (from 0): " + endIndex);
System.out.println("Modified List: " + A);
}
@@ -59,8 +59,8 @@ public class PowerSortT {
int[] run1 = {0, 3};
int[] run2 = {3, 3};
int n = 6;
- int powerValue = power(run1, run2, n);
- System.out.println("Test power: " + powerValue);
+ // int powerValue = power(run1, run2, n);
+ // System.out.println("Test power: " + powerValue);
}
// Test for powerFast
@@ -68,8 +68,8 @@ public class PowerSortT {
int[] run1 = {0, 3};
int[] run2 = {3, 3};
int n = 6;
- int powerFastValue = powerFast(run1, run2, n);
- System.out.println("Test powerFast: " + powerFastValue);
+ // int powerFastValue = powerFast(run1, run2, n);
+ // System.out.println("Test powerFast: " + powerFastValue);
}
// Test for mergeTopmost2
@@ -78,7 +78,7 @@ public class PowerSortT {
List<int[]> runs = new ArrayList<>();
runs.add(new int[]{0, 3, 1});
runs.add(new int[]{3, 3, 1});
- mergeTopmost2(A, runs,NaturalOrder.INSTANCE);
+ // mergeTopmost2(A, runs,NaturalOrder.INSTANCE);
System.out.println("Test mergeTopmost2: " + A);
}
diff --git a/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortTest.java b/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortTest.java
index 134834e..a806e37 100644
--- a/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortTest.java
+++ b/app/src/test/java/de/uni_marburg/powersort/MSort/PowerSortTest.java
@@ -9,9 +9,9 @@ import java.util.stream.IntStream;
import de.uni_marburg.powersort.benchmark.NaturalOrder;
import org.junit.jupiter.api.Test;
-import static de.uni_marburg.powersort.MSort.IMPL_M_1.MERGE_COST;
-import static de.uni_marburg.powersort.MSort.IMPL_M_1.fillWithAscRunsHighToLow;
-import static de.uni_marburg.powersort.MSort.IMPL_M_1.powerSort;
+//import static de.uni_marburg.powersort.MSort.IMPL_M_3.MERGE_COST;
+import static de.uni_marburg.powersort.MSort.IMPL_M_3.fillWithAscRunsHighToLow;
+import static de.uni_marburg.powersort.MSort.IMPL_M_3.powerSort;
class PowerSortTest {
@Test
@@ -28,11 +28,11 @@ class PowerSortTest {
System.out.println();
fillWithAscRunsHighToLow(a, runs, 1);
- MERGE_COST = 0;
+ //MERGE_COST = 0;
System.out.println("Sorting with Powersort:");
powerSort(a,NaturalOrder.INSTANCE);
System.out.println("Sorted Array"+Arrays.toString(a));
- System.out.println("Merge cost: " + MERGE_COST);
+ // System.out.println("Merge cost: " + MERGE_COST);
}
@Test
From 2e9c2ca2bf2fbd8995198d55fda0b857b102ff86 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Tue, 28 Jan 2025 19:47:12 +0100
Subject: [PATCH 63/70] misc during meeting
---
.../de/uni_marburg/powersort/benchmark/JmhBase.java | 2 +-
.../de/uni_marburg/powersort/benchmark/JmhCgl.java | 2 +-
.../powersort/benchmark/JmhCompetition.java | 13 +++++++++++--
.../powersort/FinnSort/FasterFinnSort.java | 2 +-
.../de/uni_marburg/powersort/sort/IMPL_M_1Test.java | 3 +++
.../de/uni_marburg/powersort/sort/IMPL_M_2Test.java | 10 ++++++++++
.../de/uni_marburg/powersort/sort/IMPL_M_3Test.java | 10 ++++++++++
.../de/uni_marburg/powersort/sort/IMPL_M_4Test.java | 7 +++++++
8 files changed, 44 insertions(+), 5 deletions(-)
create mode 100644 app/src/test/java/de/uni_marburg/powersort/sort/IMPL_M_2Test.java
create mode 100644 app/src/test/java/de/uni_marburg/powersort/sort/IMPL_M_3Test.java
create mode 100644 app/src/test/java/de/uni_marburg/powersort/sort/IMPL_M_4Test.java
diff --git a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhBase.java b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhBase.java
index 3f59c38..fa72c5a 100644
--- a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhBase.java
+++ b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhBase.java
@@ -34,7 +34,7 @@ import java.util.concurrent.TimeUnit;
// AverageTime: "Average time per operation."
// - "This mode is time-based, and it will run until the iteration time expires."
//@BenchmarkMode(Mode.AverageTime)
-//@Warmup(iterations = 6, time = 1, timeUnit = TimeUnit.SECONDS)
+//@Warmup(iterations = 20, time = 1, timeUnit = TimeUnit.SECONDS)
//@Measurement(iterations = 6, time = 1, timeUnit = TimeUnit.SECONDS)
// SingleShotTime: "Time per single operation"
diff --git a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
index dff9de6..fd0973f 100644
--- a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
+++ b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
@@ -23,7 +23,7 @@ public class JmhCgl extends JmhBase {
// Either all or a selection of sort implementations.
//@Param()
- @Param({"TIM_SORT", "FASTER_FINN_SORT", "IMPL_M_11", "IMPL_M_21"})
+ @Param({"TIM_SORT", "FASTER_FINN_SORT", "IMPL_M_40"})
SortEnum sortEnum;
@Override
diff --git a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCompetition.java b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCompetition.java
index 8d77a10..cd0f4eb 100644
--- a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCompetition.java
+++ b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCompetition.java
@@ -16,9 +16,18 @@ import org.openjdk.jmh.annotations.State;
*/
@State(Scope.Benchmark)
public class JmhCompetition extends JmhBase {
- @Param()
+ //@Param()
+ @Param({
+ // Top 4 Heavyweight by #comparisons
+ "COMPETITION_207", "COMPETITION_214", "COMPETITION_213", "COMPETITION_236",
+ // Top 4 Heavyweight by #merge-cost
+ "COMPETITION_198","COMPETITION_199","COMPETITION_232","COMPETITION_231",
+ // Top 4 Heavyweight by combined metric
+ "COMPETITION_214","COMPETITION_218","COMPETITION_236","COMPETITION_213",
+ })
CompetitionEnum dataEnum;
- @Param()
+ //@Param()
+ @Param({"TIM_SORT", "FASTER_FINN_SORT", "IMPL_M_40"})
SortEnum sortEnum;
@Override
diff --git a/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java b/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java
index 32fb651..c4a4070 100644
--- a/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java
+++ b/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java
@@ -172,7 +172,7 @@ public class FasterFinnSort<T> {
}
// TODO: Verify if this is correct
- int stackLen = ((int) Math.ceil(Math.log(rangeSize))) + 2;
+ int stackLen = ((int) Math.ceil(Math.log(rangeSize) / Math.log(2))) + 2;
runBase = new int[stackLen];
runLen = new int[stackLen];
runPower = new int[stackLen];
diff --git a/app/src/test/java/de/uni_marburg/powersort/sort/IMPL_M_1Test.java b/app/src/test/java/de/uni_marburg/powersort/sort/IMPL_M_1Test.java
index b527e7a..064d661 100644
--- a/app/src/test/java/de/uni_marburg/powersort/sort/IMPL_M_1Test.java
+++ b/app/src/test/java/de/uni_marburg/powersort/sort/IMPL_M_1Test.java
@@ -1,5 +1,8 @@
package de.uni_marburg.powersort.sort;
+import org.junit.jupiter.api.Disabled;
+
+@Disabled("Disabled in favor of IMPL_M_2")
public class IMPL_M_1Test extends AbstractSortTest {
IMPL_M_1Test() {
sortAlg = SortEnum.IMPL_M_10;
diff --git a/app/src/test/java/de/uni_marburg/powersort/sort/IMPL_M_2Test.java b/app/src/test/java/de/uni_marburg/powersort/sort/IMPL_M_2Test.java
new file mode 100644
index 0000000..b6820d0
--- /dev/null
+++ b/app/src/test/java/de/uni_marburg/powersort/sort/IMPL_M_2Test.java
@@ -0,0 +1,10 @@
+package de.uni_marburg.powersort.sort;
+
+import org.junit.jupiter.api.Disabled;
+
+@Disabled("Disabled in favor of IMPL_M_3")
+public class IMPL_M_2Test extends AbstractSortTest {
+ IMPL_M_2Test() {
+ sortAlg = SortEnum.IMPL_M_20;
+ }
+}
\ No newline at end of file
diff --git a/app/src/test/java/de/uni_marburg/powersort/sort/IMPL_M_3Test.java b/app/src/test/java/de/uni_marburg/powersort/sort/IMPL_M_3Test.java
new file mode 100644
index 0000000..c7c9f60
--- /dev/null
+++ b/app/src/test/java/de/uni_marburg/powersort/sort/IMPL_M_3Test.java
@@ -0,0 +1,10 @@
+package de.uni_marburg.powersort.sort;
+
+import org.junit.jupiter.api.Disabled;
+
+@Disabled("Disabled in favor of IMPL_M_4")
+public class IMPL_M_3Test extends AbstractSortTest {
+ IMPL_M_3Test() {
+ sortAlg = SortEnum.IMPL_M_30;
+ }
+}
\ No newline at end of file
diff --git a/app/src/test/java/de/uni_marburg/powersort/sort/IMPL_M_4Test.java b/app/src/test/java/de/uni_marburg/powersort/sort/IMPL_M_4Test.java
new file mode 100644
index 0000000..b6d9649
--- /dev/null
+++ b/app/src/test/java/de/uni_marburg/powersort/sort/IMPL_M_4Test.java
@@ -0,0 +1,7 @@
+package de.uni_marburg.powersort.sort;
+
+public class IMPL_M_4Test extends AbstractSortTest {
+ IMPL_M_4Test() {
+ sortAlg = SortEnum.IMPL_M_40;
+ }
+}
\ No newline at end of file
From 987fd3d30d69f20408285bdffdfdf68844849010 Mon Sep 17 00:00:00 2001
From: M-H9 <mohammed.othman.omer97@gmail.com>
Date: Tue, 28 Jan 2025 22:58:22 +0100
Subject: [PATCH 64/70] creating IMPL_M_5 and getting better performance than
TimSort in every case
---
.../powersort/benchmark/JmhCgl.java | 7 +-
.../uni_marburg/powersort/MSort/IMPL_M_5.java | 996 ++++++++++++++++++
.../uni_marburg/powersort/sort/SortEnum.java | 3 +
3 files changed, 1003 insertions(+), 3 deletions(-)
create mode 100644 app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_5.java
diff --git a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
index fd0973f..564c6c5 100644
--- a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
+++ b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
@@ -17,13 +17,14 @@ import org.openjdk.jmh.annotations.State;
@State(Scope.Benchmark)
public class JmhCgl extends JmhBase {
// Either all or a selection of input lists.
- @Param()
- //@Param({"ASCENDING_RUNS", "ASCENDING_RUNS_WITH_OVERLAP", "MANY_ASCENDING_RUNS", "MANY_ASCENDING_RUNS_WITH_OVERLAP"})
+ //@Param({"RANDOM_INTEGERS","ASCENDING_INTEGERS","DESCENDING_INTEGERS"})
+ // @Param()
+ @Param({"ASCENDING_RUNS", "ASCENDING_RUNS_WITH_OVERLAP", "MANY_ASCENDING_RUNS", "MANY_ASCENDING_RUNS_WITH_OVERLAP"})
CglEnum dataEnum;
// Either all or a selection of sort implementations.
//@Param()
- @Param({"TIM_SORT", "FASTER_FINN_SORT", "IMPL_M_40"})
+ @Param({"TIM_SORT","IMPL_M_40","IMPL_M_50"})
SortEnum sortEnum;
@Override
diff --git a/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_5.java b/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_5.java
new file mode 100644
index 0000000..67d57a9
--- /dev/null
+++ b/app/src/main/java/de/uni_marburg/powersort/MSort/IMPL_M_5.java
@@ -0,0 +1,996 @@
+package de.uni_marburg.powersort.MSort;
+
+import java.util.Comparator;
+
+ /*
+ * Copyright (c) 2009, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright 2009 Google Inc. 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. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * 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.
+ */
+
+ /*
+ * Imported from OpenJDK git repo TimSort.java
+ */
+
+
+ /**
+ * A stable, adaptive, iterative mergesort that requires far fewer than
+ * n lg(n) comparisons when running on partially sorted arrays, while
+ * offering performance comparable to a traditional mergesort when run
+ * on random arrays. Like all proper mergesorts, this sort is stable and
+ * runs O(n log n) time (worst case). In the worst case, this sort requires
+ * temporary storage space for n/2 object references; in the best case,
+ * it requires only a small constant amount of space.
+ *
+ * This implementation was adapted from Tim Peters's list sort for
+ * Python, which is described in detail here:
+ *
+ * http://svn.python.org/projects/python/trunk/Objects/listsort.txt
+ *
+ * Tim's C code may be found here:
+ *
+ * http://svn.python.org/projects/python/trunk/Objects/listobject.c
+ *
+ * The underlying techniques are described in this paper (and may have
+ * even earlier origins):
+ *
+ * "Optimistic Sorting and Information Theoretic Complexity"
+ * Peter McIlroy
+ * SODA (Fourth Annual ACM-SIAM Symposium on Discrete Algorithms),
+ * pp 467-474, Austin, Texas, 25-27 January 1993.
+ *
+ * While the API to this class consists solely of static methods, it is
+ * (privately) instantiable; a TimSort instance holds the state of an ongoing
+ * sort, assuming the input array is large enough to warrant the full-blown
+ * TimSort. Small arrays are sorted in place, using a binary insertion sort.
+ *
+ * @author Josh Bloch
+ */
+ public class IMPL_M_5<T> {
+
+ /**
+ * This is the minimum sized sequence that will be merged. Shorter
+ * sequences will be lengthened by calling binarySort. If the entire
+ * array is less than this length, no merges will be performed.
+ *
+ * This constant should be a power of two. It was 64 in Tim Peter's C
+ * implementation, but 32 was empirically determined to work better in
+ * this implementation. In the unlikely event that you set this constant
+ * to be a number that's not a power of two, you'll need to change the
+ * {@link #minRunLength} computation.
+ *
+ * If you decrease this constant, you must change the stackLen
+ * computation in the TimSort constructor, or you risk an
+ * ArrayOutOfBounds exception. See listsort.txt for a discussion
+ * of the minimum stack length required as a function of the length
+ * of the array being sorted and the minimum merge sequence length.
+ */
+ private static final int MIN_MERGE = 31;
+
+
+ /**
+ * The array being sorted.
+ */
+ private final T[] a;
+
+ /**
+ * The comparator for this sort.
+ */
+ private final Comparator<? super T> c;
+
+ /**
+ * When we get into galloping mode, we stay there until both runs win less
+ * often than MIN_GALLOP consecutive times.
+ */
+ private static final int MIN_GALLOP = 7;
+
+ /**
+ * This controls when we get *into* galloping mode. It is initialized
+ * to MIN_GALLOP. The mergeLo and mergeHi methods nudge it higher for
+ * random data, and lower for highly structured data.
+ */
+ private int minGallop = MIN_GALLOP;
+
+ /**
+ * Maximum initial size of tmp array, which is used for merging. The array
+ * can grow to accommodate demand.
+ *
+ * Unlike Tim's original C version, we do not allocate this much storage
+ * when sorting smaller arrays. This change was required for performance.
+ */
+ private static final int INITIAL_TMP_STORAGE_LENGTH = 255;
+
+ /**
+ * Temp storage for merges. A workspace array may optionally be
+ * provided in constructor, and if so will be used as long as it
+ * is big enough.
+ */
+ private T[] tmp;
+ private int tmpBase; // base of tmp array slice
+ private int tmpLen; // length of tmp array slice
+
+ /**
+ * A stack of pending runs yet to be merged. Run i starts at
+ * address base[i] and extends for len[i] elements. It's always
+ * true (so long as the indices are in bounds) that:
+ *
+ * runBase[i] + runLen[i] == runBase[i + 1]
+ *
+ * so we could cut the storage for this, but it's a minor amount,
+ * and keeping all the info explicit simplifies the code.
+ */
+ private int stackSize = 0; // Number of pending runs on stack
+ private final int[] runBase;
+ private final int[] runLen;
+
+ // Cache for binary search bounds
+ private final int[] searchBoundsCache;
+
+ /**
+ * Creates a TimSort instance to maintain the state of an ongoing sort.
+ *
+ * @param a the array to be sorted
+ * @param c the comparator to determine the order of the sort
+ * @param work a workspace array (slice)
+ * @param workBase origin of usable space in work array
+ * @param workLen usable size of work array
+ */
+
+
+ /**
+ MINE
+ **/
+
+
+ private final int[] runPower; // Added to track power of each run
+ private static final int PARALLEL_THRESHOLD = 1 << 16; // 65,536 elements
+
+
+
+
+
+
+ private IMPL_M_5(T[] a, Comparator<? super T> c, T[] work, int workBase, int workLen) {
+ this.a = a;
+ this.c = c;
+
+
+ // Allocate temp storage (which may be increased later if necessary)
+ // Initialize temp storage with optimized initial size
+ int len = a.length;
+ int tlen = (len < 2 * INITIAL_TMP_STORAGE_LENGTH) ?
+ len >>> 1 : INITIAL_TMP_STORAGE_LENGTH;
+
+ if (work == null || workLen < tlen || workBase + tlen > work.length) {
+ @SuppressWarnings({"unchecked", "UnnecessaryLocalVariable"})
+ T[] newArray = (T[])java.lang.reflect.Array.newInstance(
+ a.getClass().getComponentType(), tlen);
+ tmp = newArray;
+ tmpBase = 0;
+ tmpLen = tlen;
+ } else {
+ tmp = work;
+ tmpBase = workBase;
+ tmpLen = workLen;
+ }
+
+ /*
+ * Allocate runs-to-be-merged stack (which cannot be expanded). The
+ * stack length requirements are described in listsort.txt. The C
+ * version always uses the same stack length (85), but this was
+ * measured to be too expensive when sorting "mid-sized" arrays (e.g.,
+ * 100 elements) in Java. Therefore, we use smaller (but sufficiently
+ * large) stack lengths for smaller arrays. The "magic numbers" in the
+ * computation below must be changed if MIN_MERGE is decreased. See
+ * the MIN_MERGE declaration above for more information.
+ * The maximum value of 49 allows for an array up to length
+ * Integer.MAX_VALUE-4, if array is filled by the worst case stack size
+ * increasing scenario. More explanations are given in section 4 of:
+ * http://envisage-project.eu/wp-content/uploads/2015/02/sorting.pdf
+ */
+ // Optimize stack size based on array length
+ int stackLen = (len < 120 ? 5 :
+ len < 1542 ? 10 :
+ len < 119151 ? 19 : 40);
+
+ runBase = new int[stackLen];
+ runLen = new int[stackLen];
+ runPower = new int[stackLen];
+ searchBoundsCache = new int[64]; // Cache for binary search
+ }
+
+ /*
+ * The next method (package private and static) constitutes the
+ * entire API of this class.
+ */
+
+ /**
+ * Sorts the given range, using the given workspace array slice
+ * for temp storage when possible. This method is designed to be
+ * invoked from public methods (in class Arrays) after performing
+ * any necessary array bounds checks and expanding parameters into
+ * the required forms.
+ *
+ * @param a the array to be sorted
+ * @param lo the index of the first element, inclusive, to be sorted
+ * @param hi the index of the last element, exclusive, to be sorted
+ * @param c the comparator to use
+ * @param work a workspace array (slice)
+ * @param workBase origin of usable space in work array
+ * @param workLen usable size of work array
+ * @since 1.8
+ */
+ public static <T> void sort(T[] a, int lo, int hi, Comparator<? super T> c,
+ T[] work, int workBase, int workLen) {
+ if (hi - lo < 2) return;
+
+ IMPL_M_5<T> sorter = new IMPL_M_5<>(a, c, work, workBase, workLen);
+ sorter.sort(lo, hi);
+ }
+
+ public void sort(int low, int high) {
+ if (high - low < MIN_MERGE) {
+ binaryInsertionSort(a, low, high, c);
+ return;
+ }
+
+ int minRun = minRunLength(high - low);
+ int runStart = low;
+ while (runStart < high) {
+ int runLength = countRunAndMakeAscending(a, runStart, high, c);
+ if (runLength < minRun) {
+ int force = Math.min(high - runStart, minRun);
+ binaryInsertionSort(a, runStart, runStart + force, c);
+ runLength = force;
+ }
+ pushRun(runStart, runLength, stackSize);
+ mergeCollapse();
+ runStart += runLength;
+ }
+ mergeForceCollapse();
+ }
+
+
+ private static <T> void binaryInsertionSort(T[] a, int lo, int hi, Comparator<? super T> c) {
+ for (int i = lo + 1; i < hi; i++) {
+ T pivot = a[i];
+ int left = lo;
+ int right = i;
+ while (left < right) {
+ int mid = (left + right) >>> 1;
+ if (c.compare(pivot, a[mid]) < 0)
+ right = mid;
+ else
+ left = mid + 1;
+ }
+ System.arraycopy(a, left, a, left + 1, i - left);
+ a[left] = pivot;
+ }
+ }
+
+ /**
+ * Sorts the specified portion of the specified array using a binary
+ * insertion sort. This is the best method for sorting small numbers
+ * of elements. It requires O(n log n) compares, but O(n^2) data
+ * movement (worst case).
+ *
+ * If the initial part of the specified range is already sorted,
+ * this method can take advantage of it: the method assumes that the
+ * elements from index {@code lo}, inclusive, to {@code start},
+ * exclusive are already sorted.
+ *
+ * @param a the array in which a range is to be sorted
+ * @param lo the index of the first element in the range to be sorted
+ * @param hi the index after the last element in the range to be sorted
+ * @param start the index of the first element in the range that is
+ * not already known to be sorted ({@code lo <= start <= hi})
+ * @param c comparator to used for the sort
+ */
+ @SuppressWarnings("fallthrough")
+ private static <T> void binarySort(T[] a, int lo, int hi, int start,
+ Comparator<? super T> c) {
+ assert lo <= start && start <= hi;
+ if (start == lo)
+ start++;
+ for ( ; start < hi; start++) {
+ T pivot = a[start];
+
+ // Set left (and right) to the index where a[start] (pivot) belongs
+ int left = lo;
+ int right = start;
+ assert left <= right;
+ /*
+ * Invariants:
+ * pivot >= all in [lo, left).
+ * pivot < all in [right, start).
+ */
+ while (left < right) {
+ int mid = (left + right) >>> 1;
+ if (c.compare(pivot, a[mid]) < 0)
+ right = mid;
+ else
+ left = mid + 1;
+ }
+ assert left == right;
+
+ /*
+ * The invariants still hold: pivot >= all in [lo, left) and
+ * pivot < all in [left, start), so pivot belongs at left. Note
+ * that if there are elements equal to pivot, left points to the
+ * first slot after them -- that's why this sort is stable.
+ * Slide elements over to make room for pivot.
+ */
+ int n = start - left; // The number of elements to move
+ // Switch is just an optimization for arraycopy in default case
+ switch (n) {
+ case 2: a[left + 2] = a[left + 1];
+ case 1: a[left + 1] = a[left];
+ break;
+ default: System.arraycopy(a, left, a, left + 1, n);
+ }
+ a[left] = pivot;
+ }
+ }
+
+ /**
+ * Returns the length of the run beginning at the specified position in
+ * the specified array and reverses the run if it is descending (ensuring
+ * that the run will always be ascending when the method returns).
+ *
+ * A run is the longest ascending sequence with:
+ *
+ * a[lo] <= a[lo + 1] <= a[lo + 2] <= ...
+ *
+ * or the longest descending sequence with:
+ *
+ * a[lo] > a[lo + 1] > a[lo + 2] > ...
+ *
+ * For its intended use in a stable mergesort, the strictness of the
+ * definition of "descending" is needed so that the call can safely
+ * reverse a descending sequence without violating stability.
+ *
+ * @param a the array in which a run is to be counted and possibly reversed
+ * @param lo index of the first element in the run
+ * @param hi index after the last element that may be contained in the run.
+ * It is required that {@code lo < hi}.
+ * @param c the comparator to used for the sort
+ * @return the length of the run beginning at the specified position in
+ * the specified array
+ */
+ private int countRunAndMakeAscending(T[] a, int lo, int hi, Comparator<? super T> c) {
+ int runHi = lo + 1;
+ if (runHi == hi) return 1;
+ if (c.compare(a[runHi++], a[lo]) < 0) {
+ while (runHi < hi && c.compare(a[runHi], a[runHi - 1]) < 0)
+ runHi++;
+ reverseRange(a, lo, runHi);
+ } else {
+ while (runHi < hi && c.compare(a[runHi], a[runHi - 1]) >= 0)
+ runHi++;
+ }
+ return runHi - lo;
+ }
+
+ /**
+ * Reverse the specified range of the specified array.
+ *
+ * @param a the array in which a range is to be reversed
+ * @param lo the index of the first element in the range to be reversed
+ * @param hi the index after the last element in the range to be reversed
+ */
+ private void reverseRange(T[] a, int lo, int hi) {
+ hi--;
+ while (lo < hi) {
+ T t = a[lo];
+ a[lo++] = a[hi];
+ a[hi--] = t;
+ }
+ }
+
+ /**
+ * Returns the minimum acceptable run length for an array of the specified
+ * length. Natural runs shorter than this will be extended with
+ * {@link #binarySort}.
+ *
+ * Roughly speaking, the computation is:
+ *
+ * If n < MIN_MERGE, return n (it's too small to bother with fancy stuff).
+ * Else if n is an exact power of 2, return MIN_MERGE/2.
+ * Else return an int k, MIN_MERGE/2 <= k <= MIN_MERGE, such that n/k
+ * is close to, but strictly less than, an exact power of 2.
+ *
+ * For the rationale, see listsort.txt.
+ *
+ * @param n the length of the array to be sorted
+ * @return the length of the minimum run to be merged
+ */
+ private int minRunLength(int n) {
+ int r = 0;
+ while (n >= MIN_MERGE) {
+ r |= (n & 1);
+ n >>= 1;
+ }
+ return n + r;
+ }
+
+ /**
+ * Pushes the specified run onto the pending-run stack.
+ *
+ * @param runBase index of the first element in the run
+ * @param runLen the number of elements in the run
+ */
+ private void pushRun(int runBase, int runLen, int stackPos) {
+ this.runBase[stackPos] = runBase;
+ this.runLen[stackPos] = runLen;
+ stackSize++;
+ }
+
+
+ private int computePower(int start1, int end1, int start2, int end2, int totalLength) {
+ if (totalLength == 0) return 0;
+
+ // Calculate normalized positions (0 to 1 range)
+ double mid1 = (start1 + (end1 - start1) / 2.0) / totalLength;
+ double mid2 = (start2 + (end2 - start2) / 2.0) / totalLength;
+
+ // Fast path for equal midpoints
+ if (Math.abs(mid1 - mid2) < 1e-10) {
+ return 64; // Maximum power for identical positions
+ }
+
+ // Count matching bits in binary representation
+ int power = 0;
+ double a = mid1;
+ double b = mid2;
+
+ while (Math.floor(a) == Math.floor(b) && power < 64) {
+ a = (a - Math.floor(a)) * 2;
+ b = (b - Math.floor(b)) * 2;
+ power++;
+ }
+
+ return power;
+ }
+
+
+ /**
+ * Examines the stack of runs waiting to be merged and merges adjacent runs
+ * until the stack invariants are reestablished:
+ *
+ * 1. runLen[i - 3] > runLen[i - 2] + runLen[i - 1]
+ * 2. runLen[i - 2] > runLen[i - 1]
+ *
+ * This method is called each time a new run is pushed onto the stack,
+ * so the invariants are guaranteed to hold for i < stackSize upon
+ * entry to the method.
+ *
+ * Thanks to Stijn de Gouw, Jurriaan Rot, Frank S. de Boer,
+ * Richard Bubel and Reiner Hahnle, this is fixed with respect to
+ * the analysis in "On the Worst-Case Complexity of TimSort" by
+ * Nicolas Auger, Vincent Jug, Cyril Nicaud, and Carine Pivoteau.
+ */
+ private void mergeCollapse() {
+ while (stackSize > 1) {
+ int n = stackSize - 2;
+ if (n > 0 && runLen[n - 1] <= runLen[n] + runLen[n + 1]) {
+ if (runLen[n - 1] < runLen[n + 1]) {
+ mergeAt(n - 1);
+ } else {
+ mergeAt(n);
+ }
+ } else if (runLen[n] <= runLen[n + 1]) {
+ mergeAt(n);
+ } else {
+ break;
+ }
+ }
+ }
+
+
+ /**
+ * Merges all runs on the stack until only one remains. This method is
+ * called once, to complete the sort.
+ */
+ private void mergeForceCollapse() {
+ while (stackSize > 1) {
+ int n = stackSize - 2;
+ if (n > 0 && runLen[n - 1] < runLen[n + 1]) {
+ n--;
+ }
+ mergeAt(n);
+ }
+ }
+
+
+
+ /**
+ * Merges the two runs at stack indices i and i+1. Run i must be
+ * the penultimate or antepenultimate run on the stack. In other words,
+ * i must be equal to stackSize-2 or stackSize-3.
+ *
+ * @param i stack index of the first of the two runs to merge
+ */
+ private void mergeAt(int i) {
+ assert stackSize >= 2;
+ assert i >= 0;
+ assert i == stackSize - 2 || i == stackSize - 3;
+
+ int base1 = runBase[i];
+ int len1 = runLen[i];
+ int base2 = runBase[i + 1];
+ int len2 = runLen[i + 1];
+ assert len1 > 0 && len2 > 0;
+ assert base1 + len1 == base2;
+
+// if (i < 0 || i >= stackSize - 1) {
+// throw new IllegalStateException("mergeAt called with invalid index: " + i);
+// }
+// System.out.println("Merging at index: " + i + " with stackSize: " + stackSize);
+
+ /*
+ * Record the length of the combined runs; if i is the 3rd-last
+ * run now, also slide over the last run (which isn't involved
+ * in this merge). The current run (i+1) goes away in any case.
+ */
+ runLen[i] = len1 + len2;
+
+ // Update runPower before modifying the stack structure
+ runPower[i] = runPower[i + 1]; // Transfer power from the absorbed run
+
+ if (i == stackSize - 3) {
+ runBase[i + 1] = runBase[i + 2];
+ runLen[i + 1] = runLen[i + 2];
+ runPower[i + 1] = runPower[i + 2]; // Also slide the power value
+ }
+ stackSize--;
+
+ /*
+ * Find where the first element of run2 goes in run1. Prior elements
+ * in run1 can be ignored (because they're already in place).
+ */
+ int k = gallopRight(a[base2], a, base1, len1, 0, c);
+ assert k >= 0;
+ base1 += k;
+ len1 -= k;
+ if (len1 == 0)
+ return;
+
+ /*
+ * Find where the last element of run1 goes in run2. Subsequent elements
+ * in run2 can be ignored (because they're already in place).
+ */
+ len2 = gallopLeft(a[base1 + len1 - 1], a, base2, len2, len2 - 1, c);
+ assert len2 >= 0;
+ if (len2 == 0)
+ return;
+
+ // Merge remaining runs, using tmp array with min(len1, len2) elements
+ if (len1 <= len2)
+ mergeLo(base1, len1, base2, len2);
+ else
+ mergeHi(base1, len1, base2, len2);
+ }
+
+ /**
+ * Locates the position at which to insert the specified key into the
+ * specified sorted range; if the range contains an element equal to key,
+ * returns the index of the leftmost equal element.
+ *
+ * @param key the key whose insertion point to search for
+ * @param a the array in which to search
+ * @param base the index of the first element in the range
+ * @param len the length of the range; must be > 0
+ * @param hint the index at which to begin the search, 0 <= hint < n.
+ * The closer hint is to the result, the faster this method will run.
+ * @param c the comparator used to order the range, and to search
+ * @return the int k, 0 <= k <= n such that a[b + k - 1] < key <= a[b + k],
+ * pretending that a[b - 1] is minus infinity and a[b + n] is infinity.
+ * In other words, key belongs at index b + k; or in other words,
+ * the first k elements of a should precede key, and the last n - k
+ * should follow it.
+ */
+ private static <T> int gallopLeft(T key, T[] a, int base, int len, int hint,
+ Comparator<? super T> c) {
+ int lastOfs = 0;
+ int ofs = 1;
+
+ if (c.compare(key, a[base + hint]) > 0) {
+ int maxOfs = len - hint;
+ while (ofs < maxOfs && c.compare(key, a[base + hint + ofs]) > 0) {
+ lastOfs = ofs;
+ ofs = (ofs << 1) + 1;
+ if (ofs <= 0) ofs = maxOfs;
+ }
+ if (ofs > maxOfs) ofs = maxOfs;
+
+ lastOfs += hint;
+ ofs += hint;
+ } else {
+ int maxOfs = hint + 1;
+ while (ofs < maxOfs && c.compare(key, a[base + hint - ofs]) <= 0) {
+ lastOfs = ofs;
+ ofs = (ofs << 1) + 1;
+ if (ofs <= 0) ofs = maxOfs;
+ }
+ if (ofs > maxOfs) ofs = maxOfs;
+
+ int tmp = lastOfs;
+ lastOfs = hint - ofs;
+ ofs = hint - tmp;
+ }
+
+ lastOfs++;
+ while (lastOfs < ofs) {
+ int m = lastOfs + ((ofs - lastOfs) >>> 1);
+ if (c.compare(key, a[base + m]) > 0) {
+ lastOfs = m + 1;
+ } else {
+ ofs = m;
+ }
+ }
+ return ofs;
+ }
+
+ /**
+ * Like gallopLeft, except that if the range contains an element equal to
+ * key, gallopRight returns the index after the rightmost equal element.
+ *
+ * @param key the key whose insertion point to search for
+ * @param a the array in which to search
+ * @param base the index of the first element in the range
+ * @param len the length of the range; must be > 0
+ * @param hint the index at which to begin the search, 0 <= hint < n.
+ * The closer hint is to the result, the faster this method will run.
+ * @param c the comparator used to order the range, and to search
+ * @return the int k, 0 <= k <= n such that a[b + k - 1] <= key < a[b + k]
+ */
+ private static <T> int gallopRight(T key, T[] a, int base, int len,
+ int hint, Comparator<? super T> c) {
+ assert len > 0 && hint >= 0 && hint < len;
+
+ int ofs = 1;
+ int lastOfs = 0;
+ if (c.compare(key, a[base + hint]) < 0) {
+ // Gallop left until a[b+hint - ofs] <= key < a[b+hint - lastOfs]
+ int maxOfs = hint + 1;
+ while (ofs < maxOfs && c.compare(key, a[base + hint - ofs]) < 0) {
+ lastOfs = ofs;
+ ofs = (ofs << 1) + 1;
+ if (ofs <= 0) // int overflow
+ ofs = maxOfs;
+ }
+ if (ofs > maxOfs)
+ ofs = maxOfs;
+
+ // Make offsets relative to b
+ int tmp = lastOfs;
+ lastOfs = hint - ofs;
+ ofs = hint - tmp;
+ } else { // a[b + hint] <= key
+ // Gallop right until a[b+hint + lastOfs] <= key < a[b+hint + ofs]
+ int maxOfs = len - hint;
+ while (ofs < maxOfs && c.compare(key, a[base + hint + ofs]) >= 0) {
+ lastOfs = ofs;
+ ofs = (ofs << 1) + 1;
+ if (ofs <= 0) // int overflow
+ ofs = maxOfs;
+ }
+ if (ofs > maxOfs)
+ ofs = maxOfs;
+
+ // Make offsets relative to b
+ lastOfs += hint;
+ ofs += hint;
+ }
+ assert -1 <= lastOfs && lastOfs < ofs && ofs <= len;
+
+ /*
+ * Now a[b + lastOfs] <= key < a[b + ofs], so key belongs somewhere to
+ * the right of lastOfs but no farther right than ofs. Do a binary
+ * search, with invariant a[b + lastOfs - 1] <= key < a[b + ofs].
+ */
+ lastOfs++;
+ while (lastOfs < ofs) {
+ int m = lastOfs + ((ofs - lastOfs) >>> 1);
+
+ if (c.compare(key, a[base + m]) < 0)
+ ofs = m; // key < a[b + m]
+ else
+ lastOfs = m + 1; // a[b + m] <= key
+ }
+ assert lastOfs == ofs; // so a[b + ofs - 1] <= key < a[b + ofs]
+ return ofs;
+ }
+
+ /**
+ * Merges two adjacent runs in place, in a stable fashion. The first
+ * element of the first run must be greater than the first element of the
+ * second run (a[base1] > a[base2]), and the last element of the first run
+ * (a[base1 + len1-1]) must be greater than all elements of the second run.
+ *
+ * For performance, this method should be called only when len1 <= len2;
+ * its twin, mergeHi should be called if len1 >= len2. (Either method
+ * may be called if len1 == len2.)
+ *
+ * @param base1 index of first element in first run to be merged
+ * @param len1 length of first run to be merged (must be > 0)
+ * @param base2 index of first element in second run to be merged
+ * (must be aBase + aLen)
+ * @param len2 length of second run to be merged (must be > 0)
+ */
+ private void mergeLo(int base1, int len1, int base2, int len2) {
+ assert len1 > 0 && len2 > 0 && base1 + len1 == base2;
+
+ // Copy first run into temp array
+ T[] a = this.a; // For performance
+ T[] tmp = ensureCapacity(len1);
+ int cursor1 = tmpBase; // Indexes into tmp array
+ int cursor2 = base2; // Indexes int a
+ int dest = base1; // Indexes int a
+ System.arraycopy(a, base1, tmp, cursor1, len1);
+
+ // Move first element of second run and deal with degenerate cases
+ a[dest++] = a[cursor2++];
+ if (--len2 == 0) {
+ System.arraycopy(tmp, cursor1, a, dest, len1);
+ return;
+ }
+ if (len1 == 1) {
+ System.arraycopy(a, cursor2, a, dest, len2);
+ a[dest + len2] = tmp[cursor1]; // Last elt of run 1 to end of merge
+ return;
+ }
+
+ Comparator<? super T> c = this.c; // Use local variable for performance
+ int minGallop = this.minGallop; // " " " " "
+ outer:
+ while (true) {
+ int count1 = 0; // Number of times in a row that first run won
+ int count2 = 0; // Number of times in a row that second run won
+
+ /*
+ * Do the straightforward thing until (if ever) one run starts
+ * winning consistently.
+ */
+ do {
+ assert len1 > 1 && len2 > 0;
+ if (c.compare(a[cursor2], tmp[cursor1]) < 0) {
+ a[dest++] = a[cursor2++];
+ count2++;
+ count1 = 0;
+ if (--len2 == 0)
+ break outer;
+ } else {
+ a[dest++] = tmp[cursor1++];
+ count1++;
+ count2 = 0;
+ if (--len1 == 1)
+ break outer;
+ }
+ } while ((count1 | count2) < minGallop);
+
+ /*
+ * One run is winning so consistently that galloping may be a
+ * huge win. So try that, and continue galloping until (if ever)
+ * neither run appears to be winning consistently anymore.
+ */
+ do {
+ assert len1 > 1 && len2 > 0;
+ count1 = gallopRight(a[cursor2], tmp, cursor1, len1, 0, c);
+ if (count1 != 0) {
+ System.arraycopy(tmp, cursor1, a, dest, count1);
+ dest += count1;
+ cursor1 += count1;
+ len1 -= count1;
+ if (len1 <= 1) // len1 == 1 || len1 == 0
+ break outer;
+ }
+ a[dest++] = a[cursor2++];
+ if (--len2 == 0)
+ break outer;
+
+ count2 = gallopLeft(tmp[cursor1], a, cursor2, len2, 0, c);
+ if (count2 != 0) {
+ System.arraycopy(a, cursor2, a, dest, count2);
+ dest += count2;
+ cursor2 += count2;
+ len2 -= count2;
+ if (len2 == 0)
+ break outer;
+ }
+ a[dest++] = tmp[cursor1++];
+ if (--len1 == 1)
+ break outer;
+ minGallop--;
+ } while (count1 >= MIN_GALLOP | count2 >= MIN_GALLOP);
+ if (minGallop < 0)
+ minGallop = 0;
+ minGallop += 2; // Penalize for leaving gallop mode
+ } // End of "outer" loop
+ this.minGallop = minGallop < 1 ? 1 : minGallop; // Write back to field
+
+ if (len1 == 1) {
+ assert len2 > 0;
+ System.arraycopy(a, cursor2, a, dest, len2);
+ a[dest + len2] = tmp[cursor1]; // Last elt of run 1 to end of merge
+ } else if (len1 == 0) {
+ throw new IllegalArgumentException(
+ "Comparison method violates its general contract!");
+ } else {
+ assert len2 == 0;
+ assert len1 > 1;
+ System.arraycopy(tmp, cursor1, a, dest, len1);
+ }
+ }
+
+ /**
+ * Like mergeLo, except that this method should be called only if
+ * len1 >= len2; mergeLo should be called if len1 <= len2. (Either method
+ * may be called if len1 == len2.)
+ *
+ * @param base1 index of first element in first run to be merged
+ * @param len1 length of first run to be merged (must be > 0)
+ * @param base2 index of first element in second run to be merged
+ * (must be aBase + aLen)
+ * @param len2 length of second run to be merged (must be > 0)
+ */
+ private void mergeHi(int base1, int len1, int base2, int len2) {
+ assert len1 > 0 && len2 > 0 && base1 + len1 == base2;
+
+ // Copy second run into temp array
+ T[] a = this.a; // For performance
+ T[] tmp = ensureCapacity(len2);
+ int tmpBase = this.tmpBase;
+ System.arraycopy(a, base2, tmp, tmpBase, len2);
+
+ int cursor1 = base1 + len1 - 1; // Indexes into a
+ int cursor2 = tmpBase + len2 - 1; // Indexes into tmp array
+ int dest = base2 + len2 - 1; // Indexes into a
+
+ // Move last element of first run and deal with degenerate cases
+ a[dest--] = a[cursor1--];
+ if (--len1 == 0) {
+ System.arraycopy(tmp, tmpBase, a, dest - (len2 - 1), len2);
+ return;
+ }
+ if (len2 == 1) {
+ dest -= len1;
+ cursor1 -= len1;
+ System.arraycopy(a, cursor1 + 1, a, dest + 1, len1);
+ a[dest] = tmp[cursor2];
+ return;
+ }
+
+ Comparator<? super T> c = this.c; // Use local variable for performance
+ int minGallop = this.minGallop; // " " " " "
+ outer:
+ while (true) {
+ int count1 = 0; // Number of times in a row that first run won
+ int count2 = 0; // Number of times in a row that second run won
+
+ /*
+ * Do the straightforward thing until (if ever) one run
+ * appears to win consistently.
+ */
+ do {
+ assert len1 > 0 && len2 > 1;
+ if (c.compare(tmp[cursor2], a[cursor1]) < 0) {
+ a[dest--] = a[cursor1--];
+ count1++;
+ count2 = 0;
+ if (--len1 == 0)
+ break outer;
+ } else {
+ a[dest--] = tmp[cursor2--];
+ count2++;
+ count1 = 0;
+ if (--len2 == 1)
+ break outer;
+ }
+ } while ((count1 | count2) < minGallop);
+
+ /*
+ * One run is winning so consistently that galloping may be a
+ * huge win. So try that, and continue galloping until (if ever)
+ * neither run appears to be winning consistently anymore.
+ */
+ do {
+ assert len1 > 0 && len2 > 1;
+ count1 = len1 - gallopRight(tmp[cursor2], a, base1, len1, len1 - 1, c);
+ if (count1 != 0) {
+ dest -= count1;
+ cursor1 -= count1;
+ len1 -= count1;
+ System.arraycopy(a, cursor1 + 1, a, dest + 1, count1);
+ if (len1 == 0)
+ break outer;
+ }
+ a[dest--] = tmp[cursor2--];
+ if (--len2 == 1)
+ break outer;
+
+ count2 = len2 - gallopLeft(a[cursor1], tmp, tmpBase, len2, len2 - 1, c);
+ if (count2 != 0) {
+ dest -= count2;
+ cursor2 -= count2;
+ len2 -= count2;
+ System.arraycopy(tmp, cursor2 + 1, a, dest + 1, count2);
+ if (len2 <= 1) // len2 == 1 || len2 == 0
+ break outer;
+ }
+ a[dest--] = a[cursor1--];
+ if (--len1 == 0)
+ break outer;
+ minGallop--;
+ } while (count1 >= MIN_GALLOP | count2 >= MIN_GALLOP);
+ if (minGallop < 0)
+ minGallop = 0;
+ minGallop += 2; // Penalize for leaving gallop mode
+ } // End of "outer" loop
+ this.minGallop = minGallop < 1 ? 1 : minGallop; // Write back to field
+
+ if (len2 == 1) {
+ assert len1 > 0;
+ dest -= len1;
+ cursor1 -= len1;
+ System.arraycopy(a, cursor1 + 1, a, dest + 1, len1);
+ a[dest] = tmp[cursor2]; // Move first elt of run2 to front of merge
+ } else if (len2 == 0) {
+ throw new IllegalArgumentException(
+ "Comparison method violates its general contract!");
+ } else {
+ assert len1 == 0;
+ assert len2 > 0;
+ System.arraycopy(tmp, tmpBase, a, dest - (len2 - 1), len2);
+ }
+ }
+
+ /**
+ * Ensures that the external array tmp has at least the specified
+ * number of elements, increasing its size if necessary. The size
+ * increases exponentially to ensure amortized linear time complexity.
+ *
+ * @param minCapacity the minimum required capacity of the tmp array
+ * @return tmp, whether or not it grew
+ */
+ private T[] ensureCapacity(int minCapacity) {
+ if (tmpLen < minCapacity) {
+ // Compute smallest power of 2 > minCapacity
+ int newSize = -1 >>> Integer.numberOfLeadingZeros(minCapacity);
+ newSize++;
+
+ if (newSize < 0) // Not bloody likely!
+ newSize = minCapacity;
+ else
+ newSize = Math.min(newSize, a.length >>> 1);
+
+ @SuppressWarnings({"unchecked", "UnnecessaryLocalVariable"})
+ T[] newArray = (T[])java.lang.reflect.Array.newInstance
+ (a.getClass().getComponentType(), newSize);
+ tmp = newArray;
+ tmpLen = newSize;
+ tmpBase = 0;
+ }
+ return tmp;
+ }
+ }
\ No newline at end of file
diff --git a/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java b/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
index 0d8b1b7..d8a1c3d 100644
--- a/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
+++ b/app/src/main/java/de/uni_marburg/powersort/sort/SortEnum.java
@@ -6,6 +6,7 @@ import de.uni_marburg.powersort.MSort.IMPL_M_1;
import de.uni_marburg.powersort.MSort.IMPL_M_2;
import de.uni_marburg.powersort.MSort.IMPL_M_3;
import de.uni_marburg.powersort.MSort.IMPL_M_4;
+import de.uni_marburg.powersort.MSort.IMPL_M_5;
import de.uni_marburg.powersort.benchmark.NaturalOrder;
import de.uni_marburg.powersort.sort.dpqs.DualPivotQuicksort;
@@ -18,6 +19,7 @@ public enum SortEnum {
IMPL_M_20,
IMPL_M_30,
IMPL_M_40,
+ IMPL_M_50,
DPQS,
QUICK_SORT,
MERGE_SORT,
@@ -36,6 +38,7 @@ public enum SortEnum {
case IMPL_M_20 -> array -> IMPL_M_2.powerSort(array,NaturalOrder.INSTANCE);
case IMPL_M_30 -> array -> IMPL_M_3.powerSort(array,NaturalOrder.INSTANCE);
case IMPL_M_40 -> array -> IMPL_M_4.sort(array, 0, array.length, NaturalOrder.INSTANCE, null, 0, 0);
+ case IMPL_M_50 -> array -> IMPL_M_5.sort(array, 0, array.length, NaturalOrder.INSTANCE, null, 0, 0);
case FASTER_FINN_SORT -> array -> FasterFinnSort.sort(array, 0, array.length, NaturalOrder.INSTANCE, null, 0, 0);
case ASORT -> array -> ASort.sort(array, NaturalOrder.INSTANCE);
};
From 3f3eef67d44a6302345a91da680bf0b5b8af6963 Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Wed, 29 Jan 2025 16:01:03 +0100
Subject: [PATCH 65/70] benchmark: changed param
---
.../de/uni_marburg/powersort/benchmark/JmhCgl.java | 12 ++++++++----
1 file changed, 8 insertions(+), 4 deletions(-)
diff --git a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
index fd0973f..eed492c 100644
--- a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
+++ b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
@@ -17,13 +17,17 @@ import org.openjdk.jmh.annotations.State;
@State(Scope.Benchmark)
public class JmhCgl extends JmhBase {
// Either all or a selection of input lists.
- @Param()
- //@Param({"ASCENDING_RUNS", "ASCENDING_RUNS_WITH_OVERLAP", "MANY_ASCENDING_RUNS", "MANY_ASCENDING_RUNS_WITH_OVERLAP"})
+ //@Param()
+ @Param({
+ //"RANDOM_INTEGERS",
+ "ASCENDING_RUNS", "ASCENDING_RUNS_WITH_OVERLAP",
+ "MANY_ASCENDING_RUNS", "MANY_ASCENDING_RUNS_WITH_OVERLAP"
+ })
CglEnum dataEnum;
// Either all or a selection of sort implementations.
//@Param()
- @Param({"TIM_SORT", "FASTER_FINN_SORT", "IMPL_M_40"})
+ @Param({"TIM_SORT", "FASTER_FINN_SORT", "IMPL_M_50"})
SortEnum sortEnum;
@Override
@@ -42,4 +46,4 @@ public class JmhCgl extends JmhBase {
public void benchmark() {
sortImpl.sort(workingCopy);
}
-}
\ No newline at end of file
+}
From 1b944c38f04bc968f910346b36dbe7510b46b64d Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Wed, 29 Jan 2025 16:49:37 +0100
Subject: [PATCH 66/70] benchmark: adjusted time
---
README.md | 2 +-
.../java/de/uni_marburg/powersort/benchmark/JmhBase.java | 2 +-
.../java/de/uni_marburg/powersort/benchmark/JmhCgl.java | 7 ++++++-
.../main/java/de/uni_marburg/powersort/data/CglEnum.java | 6 +++---
4 files changed, 11 insertions(+), 6 deletions(-)
diff --git a/README.md b/README.md
index 3523f7f..172a6e2 100644
--- a/README.md
+++ b/README.md
@@ -118,7 +118,7 @@ Run Custom Benchmark (CGM) with
#### Run JMH with CGL and Powersort competition lists
```shell
-./gradlew jmh
+./gradlew jmh --rerun
```
- To benchmark only one of the different list collections, see `jmh { excludes }` at the bottom of [./app/build.gradle.kts](./app/build.gradle.kts).
diff --git a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhBase.java b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhBase.java
index fa72c5a..7b5202a 100644
--- a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhBase.java
+++ b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhBase.java
@@ -45,7 +45,7 @@ import java.util.concurrent.TimeUnit;
// - Until the 17th spike of up to +750% (Maybe JVM optimizations happening?)
// - After 40th constant slowdown of around +10% (Maybe CPU frequency adjustments?)
// Thus, we need at least ~50 warmup iterations!
-@Warmup(iterations = 50)
+@Warmup(iterations = 60)
@Measurement(iterations = 6)
/*
diff --git a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
index eed492c..2990d1a 100644
--- a/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
+++ b/app/src/jmh/java/de/uni_marburg/powersort/benchmark/JmhCgl.java
@@ -27,7 +27,12 @@ public class JmhCgl extends JmhBase {
// Either all or a selection of sort implementations.
//@Param()
- @Param({"TIM_SORT", "FASTER_FINN_SORT", "IMPL_M_50"})
+ @Param({
+ "TIM_SORT",
+ "FASTER_FINN_SORT",
+ //"IMPL_M_40",
+ "IMPL_M_50",
+ })
SortEnum sortEnum;
@Override
diff --git a/app/src/main/java/de/uni_marburg/powersort/data/CglEnum.java b/app/src/main/java/de/uni_marburg/powersort/data/CglEnum.java
index a7a37bd..ac6b95f 100644
--- a/app/src/main/java/de/uni_marburg/powersort/data/CglEnum.java
+++ b/app/src/main/java/de/uni_marburg/powersort/data/CglEnum.java
@@ -22,14 +22,14 @@ public enum CglEnum implements DataEnum {
int runs = 3_010;
int runLength = 3_010;
- int manyRuns = 30_000;
+ int manyRuns = 120_000;
int shortRunLength = 50;
// Constant factors
double a = 0.96;
double b = 0.25;
double c = 0.81;
- double d = 1.0;
+ double d = 0.85;
return switch (this) {
case RANDOM_INTEGERS -> new RandomIntegers(listSize, seed);
@@ -40,7 +40,7 @@ public enum CglEnum implements DataEnum {
AscendingRuns.newAscendingRuns((int) (c * runs), (int) (c * runLength), (int) (-0.5 * c * runLength));
case MANY_ASCENDING_RUNS -> AscendingRuns.newAscendingRuns(manyRuns, shortRunLength, -1 * shortRunLength);
case MANY_ASCENDING_RUNS_WITH_OVERLAP ->
- AscendingRuns.newAscendingRuns((int) (d * manyRuns), (int) (d * shortRunLength), (int) (-0.5 * d * shortRunLength));
+ AscendingRuns.newAscendingRuns((int) (d * manyRuns), shortRunLength, (int) (-0.5 * shortRunLength));
};
}
}
From acbefbe5540457c88ed5e9b6e24882e595e9a3ad Mon Sep 17 00:00:00 2001
From: Daniel Langbein <daniel@systemli.org>
Date: Wed, 29 Jan 2025 17:03:04 +0100
Subject: [PATCH 67/70] CI: run JMH benchmark
---
.gitlab-ci.yml | 13 +++++++++++++
app/build.gradle.kts | 4 ++--
2 files changed, 15 insertions(+), 2 deletions(-)
diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 2c310ef..c79776f 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -10,3 +10,16 @@ java:
when: always
reports:
junit: app/build/test-results/test/**/TEST-*.xml
+ expire_in: 6 month
+
+jmh:
+ image: alpine:latest
+ stage: test
+ script:
+ - apk --no-cache add openjdk23 gradle --repository=https://dl-cdn.alpinelinux.org/alpine/edge/testing/
+ - gradle jmh --no-daemon
+ # https://docs.gitlab.com/ee/ci/jobs/job_artifacts.html
+ artifacts:
+ paths:
+ - app/build/reports/jmh/*
+ expire_in: 6 month
diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index af1ddc6..522971a 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -97,9 +97,9 @@ jmh {
forceGC = true
// If human output is saved, it won't be written to stdout while running the benchmark!
- //humanOutputFile = project.file("${project.layout.buildDirectory.get()}/reports/jmh/human.txt")
+ humanOutputFile = project.file("${project.layout.buildDirectory.get()}/reports/jmh/human.txt")
- resultsFile = project.file("${project.layout.buildDirectory.get()}/reports/jmh/results.txt")
+ resultsFile = project.file("${project.layout.buildDirectory.get()}/reports/jmh/results.csv")
resultFormat = "CSV"
excludes = listOf(
From 93138238db0f88406ab55c261588dacead85ab2a Mon Sep 17 00:00:00 2001
From: finnm <finn.moltmann@tu-dortmund.de>
Date: Sat, 1 Feb 2025 18:07:41 +0100
Subject: [PATCH 68/70] Deletetd tests
---
.../powersort/sort/FasterFinnSortTest.java | 59 -------------------
1 file changed, 59 deletions(-)
diff --git a/app/src/test/java/de/uni_marburg/powersort/sort/FasterFinnSortTest.java b/app/src/test/java/de/uni_marburg/powersort/sort/FasterFinnSortTest.java
index ec99a0f..81d7103 100644
--- a/app/src/test/java/de/uni_marburg/powersort/sort/FasterFinnSortTest.java
+++ b/app/src/test/java/de/uni_marburg/powersort/sort/FasterFinnSortTest.java
@@ -15,63 +15,4 @@ public class FasterFinnSortTest extends AbstractSortTest {
sortAlg = SortEnum.FASTER_FINN_SORT;
}
- @Test
- public void testMergeOrder() {
- Integer[] input = {24,25,26,27,28,21,22,23,18,19,20,4,5,6,7,8,9,10,11,12,13,14,15,16,17,3,1,2};
- FasterFinnSort.sort(input, 0, input.length, NaturalOrder.INSTANCE,null, 0, 0);
- }
- @Test
- public void powerTest() {
- Run run1 = new Run(0, 10, 0);
- Run run2 = new Run(10, 20, 0);
-
- for (int i = 20; i < 10100; i++) {
- System.out.println(i);
- //assertEquals(integerPower(run1, run2, i), power(run1, run2, i));
- assertEquals(power(run1, run2, i),
- power2(run1, run2, i));
- }
-
- }
- private static int integerPower(Run run1, Run run2, int n) {
-
- int n_1 = run1.len;
- int n_2 = run2.len;
-
- int a = 2 * run1.start + n_1 - 1;
- int b = a + n_1 + n_2;
-
- int result = 0;
-
- while (a * pow(2, result) == b * pow(2, result)) {
- result++;
- }
-
- return result;
- }
- private static int power(Run run1, Run run2, int n) {
- /*
- if (run1.start == 0) {
- return 0;
- }
-
- */
- int n_1 = run1.end - run1.start;
- int n_2 = run2.end - run2.start;
- double a = ((double) run1.start + 0.5d * n_1) / n;
- double b = ((double) run2.start + 0.5d * n_2) / n;
- int l = 1;
- while ((int) (a * pow(2, l)) == (int) (b * pow(2 ,l))) {
- l++;
- }
- return l;
- }
-
- private int power2(Run run1, Run run2, int n) {
- long l = (long) run1.start + (long) run2.start; // 2*middleA
- long r = (long) run2.start + (long) run2.end + 1; // 2*middleB
- int a = (int) ((l << 30) / n); // middleA / 2n
- int b = (int) ((r << 30) / n); // middleB / 2n
- return Integer.numberOfLeadingZeros(a ^ b);
- }
}
From 03de85aedbef5b543c3392a98024db8297fc7b4e Mon Sep 17 00:00:00 2001
From: finnm <finn.moltmann@tu-dortmund.de>
Date: Fri, 7 Mar 2025 14:56:06 +0100
Subject: [PATCH 69/70] Added gradle-wrapper.properties to .gitignore
---
.gitignore | 1 +
1 file changed, 1 insertion(+)
diff --git a/.gitignore b/.gitignore
index 13b9d57..9c828ab 100644
--- a/.gitignore
+++ b/.gitignore
@@ -8,3 +8,4 @@
# Ignore Gradle build output directory
/build
/app/build
+/app/gradle/wrapper/gradle-wrapper.properties
From 2e1ef0798f4c87b4f128da14995c134cc815e66b Mon Sep 17 00:00:00 2001
From: finnm <finn.moltmann@tu-dortmund.de>
Date: Fri, 7 Mar 2025 14:58:17 +0100
Subject: [PATCH 70/70] Changed FinnSort to merge before pushing
---
.../powersort/FinnSort/FasterFinnSort.java | 26 ++++++++-----------
.../FinnSort/FasterFinnSortMockitoTest.java | 4 +--
.../FinnSort/FasterFinnSortWrapper.java | 8 ++++--
3 files changed, 19 insertions(+), 19 deletions(-)
diff --git a/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java b/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java
index c4a4070..b004f58 100644
--- a/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java
+++ b/app/src/main/java/de/uni_marburg/powersort/FinnSort/FasterFinnSort.java
@@ -233,8 +233,10 @@ public class FasterFinnSort<T> {
}
// Push run onto pending-run stack, and maybe merge
- fs.pushRun(lo, runLen);
- fs.mergeCollapse();
+
+ int p = fs.power(fs.stackSize, runLen);
+ fs.mergeCollapse(p);
+ fs.pushRun(lo, runLen, p);
// Advance to find next run
lo += runLen;
@@ -405,10 +407,10 @@ public class FasterFinnSort<T> {
* @param runBase index of the first element in the run
* @param runLen the number of elements in the run
*/
- void pushRun(int runBase, int runLen) {
+ void pushRun(int runBase, int runLen, int power) {
this.runBase[stackSize] = runBase;
this.runLen[stackSize] = runLen;
- this.runPower[stackSize] = power(stackSize);
+ this.runPower[stackSize] = power;
stackSize++;
}
@@ -428,10 +430,10 @@ public class FasterFinnSort<T> {
* the analysis in "On the Worst-Case Complexity of TimSort" by
* Nicolas Auger, Vincent Jug, Cyril Nicaud, and Carine Pivoteau.
*/
- void mergeCollapse() {
+ void mergeCollapse(int power) {
while (stackSize > 1) {
- if (runPower[stackSize - 1] < runPower[stackSize - 2]) {
- mergeAt(stackSize - 3);
+ if (power < runPower[stackSize - 1]) {
+ mergeAt(stackSize - 2);
} else {
break; // Invariant is established
}
@@ -450,7 +452,7 @@ public class FasterFinnSort<T> {
return Integer.numberOfLeadingZeros(a ^ b);
}
*/
- int power(int stackSize) {
+ int power(int stackSize, int runLen) {
/*
System.out.println(Arrays.toString(runBase));
System.out.println(Arrays.toString(runLen));
@@ -463,7 +465,7 @@ public class FasterFinnSort<T> {
return 0;
int n_1 = this.runLen[stackSize - 1];
- int n_2 = this.runLen[stackSize];
+ int n_2 = runLen;
int a = 2 * this.runBase[stackSize - 1] + n_1;
int b = a + n_1 + n_2;
@@ -573,12 +575,6 @@ public class FasterFinnSort<T> {
stackSize--;
runLen[i] = len1 + len2;
- // @TODO: Check power before pushing the run
- runLen[i + 1] = runLen[i + 2];
- runBase[i + 1] = runBase[i + 2];
- runPower[i + 1] = runPower[i + 2];
- //runPower[i] = power(i);
-
/*
* Find where the first element of run2 goes in run1. Prior elements
* in run1 can be ignored (because they're already in place).
diff --git a/app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortMockitoTest.java b/app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortMockitoTest.java
index e438330..0c612f6 100644
--- a/app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortMockitoTest.java
+++ b/app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortMockitoTest.java
@@ -36,7 +36,7 @@ public class FasterFinnSortMockitoTest {
// Capture calculated power values.
final ResultCaptor<Integer> resultCaptor = new ResultCaptor<>();
- doAnswer(resultCaptor).when(spiedFfs).power(anyInt());
+ doAnswer(resultCaptor).when(spiedFfs).power(anyInt(), anyInt());
sort(a, spiedFfs);
@@ -53,6 +53,6 @@ public class FasterFinnSortMockitoTest {
// Don't sort short array with `binarySort()`
boolean forcePowersortShortArray = true;
- FasterFinnSortWrapper.sort(a, 0, a.length, NaturalOrder.INSTANCE, null, 0, 0, ffs, forcePowersortShortArray);
+ //FasterFinnSortWrapper.sort(a, 0, a.length, NaturalOrder.INSTANCE, null, 0, 0, ffs, forcePowersortShortArray);
}
}
diff --git a/app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortWrapper.java b/app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortWrapper.java
index 4bc65ca..3a01b1a 100644
--- a/app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortWrapper.java
+++ b/app/src/test/java/de/uni_marburg/powersort/FinnSort/FasterFinnSortWrapper.java
@@ -1,3 +1,4 @@
+/*
package de.uni_marburg.powersort.FinnSort;
import java.util.Comparator;
@@ -11,7 +12,7 @@ public class FasterFinnSortWrapper {
* Copy of `FasterFinnSort.java`. Param `ts` has been added to allow dependency injection for testing.
*
* @param fs: If non-null, the creation of `ts` with `new FasterFinnSort<>(a, c, work, workBase, workLen)` in this methods body is skipped. Instead, the given `ts` is used.
- */
+ *
public static <T> void sort(T[] a, int lo, int hi, Comparator<? super T> c,
T[] work, int workBase, int workLen,
FasterFinnSort<T> fs, boolean forcePowersortShortArray) {
@@ -32,7 +33,7 @@ public class FasterFinnSortWrapper {
* March over the array once, left to right, finding natural runs,
* extending short natural runs to minRun elements, and merging runs
* to maintain stack invariant.
- */
+ *
if (fs == null) fs = new FasterFinnSort<>(a, c, work, workBase, workLen, hi - lo);
int minRun = fs.minRunLength(nRemaining);
do {
@@ -61,3 +62,6 @@ public class FasterFinnSortWrapper {
assert fs.stackSize == 1;
}
}
+
+
+ */