|
|
@@ -0,0 +1,201 @@
|
|
|
+/*
|
|
|
+ * @author Ranides Atterwim <ranides@gmail.com>
|
|
|
+ * @copyright Ranides Atterwim
|
|
|
+ * @license WTFPL
|
|
|
+ * @url http://ranides.net/projects/assira
|
|
|
+ */
|
|
|
+package net.ranides.benchmark;
|
|
|
+
|
|
|
+import java.util.Comparator;
|
|
|
+import java.util.Random;
|
|
|
+import net.ranides.assira.collection.IntComparator;
|
|
|
+import net.ranides.assira.collection.arrays.ArraySort;
|
|
|
+import net.ranides.assira.collection.arrays.IntArraySort;
|
|
|
+import org.openjdk.jmh.annotations.Benchmark;
|
|
|
+
|
|
|
+/**
|
|
|
+ * Benchmark for IntArraySort. We want to compare it with generic "NativeArray".
|
|
|
+ * Results:
|
|
|
+ * 1. IntArray is ~75% faster than NativeArray
|
|
|
+ * 2. IntComparator is 2 times faster than Comparator
|
|
|
+ * 3. Real overhead is very small. Even change from (a-b) to Integer.compare(a,b)
|
|
|
+ * changes results by ~50%. That's great.
|
|
|
+ *
|
|
|
+ *
|
|
|
+ * IntComparator (a,b) -> a-b
|
|
|
+ * QuickSort
|
|
|
+ * IntArray(int) 64 ns 75 %
|
|
|
+ * NativeArray(int) 86 ns 100 %
|
|
|
+ * NativeArray(Integer) 158 ns 183 %
|
|
|
+ *
|
|
|
+ * MergeSort
|
|
|
+ * IntArray(int) 30 ns 81 %
|
|
|
+ * IntArray(natural) 63 ns 170 % Integer#cmp vs (a-b)
|
|
|
+ * NativeArray(int) 37 ns 100 %
|
|
|
+ * NativeArray(Integer) 134 ns 362 %
|
|
|
+ * NativeArray(natural) 110 ns 300 % Integer#cmp vs (a-b)
|
|
|
+ *
|
|
|
+ *
|
|
|
+ * -----------------
|
|
|
+ *
|
|
|
+ *
|
|
|
+ * IntComparator (a,b) -> Integer::compare
|
|
|
+ * QuickSort
|
|
|
+ * IntArray(int) 73 ns 77 %
|
|
|
+ * NativeArray(int) 94 ns 100 %
|
|
|
+ * NativeArray(Integer) 179 ns 190 %
|
|
|
+ *
|
|
|
+ * MergeSort
|
|
|
+ * IntArray(int) 64 ns 94 %
|
|
|
+ * IntArray(natural) 62 ns 91 %
|
|
|
+ * NativeArray(int) 68 ns 100 %
|
|
|
+ * NativeArray(Integer) 208 ns 305 %
|
|
|
+ * NativeArray(natural) 74 ns 108 %
|
|
|
+ *
|
|
|
+ *
|
|
|
+ * -----------------
|
|
|
+ *
|
|
|
+ *
|
|
|
+ * IntComparator (a,b) -> Integer::compare
|
|
|
+ * QuickSort
|
|
|
+ * IntArray(int) 79 ns 79 %
|
|
|
+ * NativeArray(int) 100 ns 100 %
|
|
|
+ * NativeArray(Integer) 170 ns 170 %
|
|
|
+ *
|
|
|
+ * MergeSort
|
|
|
+ * IntArray(int) 65 ns 79 %
|
|
|
+ * IntArray(natural) 67 ns 81 %
|
|
|
+ * NativeArray(int) 82 ns 100 %
|
|
|
+ * NativeArray(Integer) 206 ns 251 %
|
|
|
+ * NativeArray(natural) 82 ns 100 %
|
|
|
+ *
|
|
|
+ *
|
|
|
+ * -----------------
|
|
|
+ *
|
|
|
+ *
|
|
|
+ * QuickSort
|
|
|
+ * IntArray 129/s 77 ns 78 % OK
|
|
|
+ * NativeArray(int) 102/s 98 ns 100 % OK
|
|
|
+ * NativeArray(Integer) 59/s 169 ns 172 % OK
|
|
|
+ *
|
|
|
+ * MergeSort
|
|
|
+ * IntArray 152/s 66 ns 80 % OK
|
|
|
+ * IntArray(natural) 137/s 73 ns 89 % OK
|
|
|
+ * NativeArray(int) 122/s 82 ns 100 % OK
|
|
|
+ * NativeArray_Integer 45/s 222 ns 270 % OK
|
|
|
+ * NativeArray(natural) 142/s 70 ns 85 % ~
|
|
|
+
|
|
|
+ *
|
|
|
+ */
|
|
|
+public class IntArrayBenchmark {
|
|
|
+
|
|
|
+ private static final int REPS = 100;
|
|
|
+
|
|
|
+ int[] array(int size) {
|
|
|
+ Random rand = new Random(777);
|
|
|
+ int[] array = new int[size];
|
|
|
+ for(int i=0; i<size; i++) {
|
|
|
+ array[i] = rand.nextInt();
|
|
|
+ }
|
|
|
+ return array;
|
|
|
+ }
|
|
|
+
|
|
|
+ @Benchmark
|
|
|
+ public int timeRandomize() {
|
|
|
+ int ret = 0;
|
|
|
+ for(int i=0; i<REPS; i++) {
|
|
|
+ int[] array = array(1000);
|
|
|
+ ret += array[0] + array[999];
|
|
|
+ }
|
|
|
+ return ret;
|
|
|
+ }
|
|
|
+
|
|
|
+ @Benchmark
|
|
|
+ public int timeQuickSort_IntArray() {
|
|
|
+ int ret = 0;
|
|
|
+ for(int i=0; i<REPS; i++) {
|
|
|
+ int[] array = array(1000);
|
|
|
+ IntArraySort.quickSort(array, (int a,int b) -> Integer.compare(a, b));
|
|
|
+ ret += array[0] + array[999];
|
|
|
+ }
|
|
|
+ return ret;
|
|
|
+ }
|
|
|
+
|
|
|
+ @Benchmark
|
|
|
+ public int timeQuickSort_NativeArray_int() {
|
|
|
+ int ret = 0;
|
|
|
+ for(int i=0; i<REPS; i++) {
|
|
|
+ int[] array = array(1000);
|
|
|
+ ArraySort.quickSort(array, (IntComparator)Integer::compare);
|
|
|
+ ret += array[0] + array[999];
|
|
|
+ }
|
|
|
+ return ret;
|
|
|
+ }
|
|
|
+
|
|
|
+ @Benchmark
|
|
|
+ public int timeQuickSort_NativeArray_Integer() {
|
|
|
+ int ret = 0;
|
|
|
+ for(int i=0; i<REPS; i++) {
|
|
|
+ int[] array = array(1000);
|
|
|
+ ArraySort.quickSort(array, (Comparator<Integer>)(a,b) -> Integer.compare(a, b));
|
|
|
+ ret += array[0] + array[999];
|
|
|
+ }
|
|
|
+ return ret;
|
|
|
+ }
|
|
|
+
|
|
|
+ @Benchmark
|
|
|
+ public int timeMergeSort_IntArray() {
|
|
|
+ int ret = 0;
|
|
|
+ for(int i=0; i<REPS; i++) {
|
|
|
+ int[] array = array(1000);
|
|
|
+ IntArraySort.mergeSort(array, (int a,int b) -> Integer.compare(a, b));
|
|
|
+ ret += array[0] + array[999];
|
|
|
+ }
|
|
|
+ return ret;
|
|
|
+ }
|
|
|
+
|
|
|
+ @Benchmark
|
|
|
+ public int timeMergeSort_IntArray_NC() {
|
|
|
+ int ret = 0;
|
|
|
+ for(int i=0; i<REPS; i++) {
|
|
|
+ int[] array = array(1000);
|
|
|
+ IntArraySort.mergeSort(array);
|
|
|
+ ret += array[0] + array[999];
|
|
|
+ }
|
|
|
+ return ret;
|
|
|
+ }
|
|
|
+
|
|
|
+ @Benchmark
|
|
|
+ public int timeMergeSort_NativeArray_int() {
|
|
|
+ int ret = 0;
|
|
|
+ for(int i=0; i<REPS; i++) {
|
|
|
+ int[] array = array(1000);
|
|
|
+ ArraySort.mergeSort(array, (IntComparator)(a,b) -> Integer.compare(a, b));
|
|
|
+ ret += array[0] + array[999];
|
|
|
+ }
|
|
|
+ return ret;
|
|
|
+ }
|
|
|
+
|
|
|
+ @Benchmark
|
|
|
+ public int timeMergeSort_NativeArray_Integer() {
|
|
|
+ int ret = 0;
|
|
|
+ for(int i=0; i<REPS; i++) {
|
|
|
+ int[] array = array(1000);
|
|
|
+ ArraySort.mergeSort(array, (Comparator<Integer>)(a,b) -> Integer.compare(a, b));
|
|
|
+ ret += array[0] + array[999];
|
|
|
+ }
|
|
|
+ return ret;
|
|
|
+ }
|
|
|
+
|
|
|
+ @Benchmark
|
|
|
+ public int timeMergeSort_NativeArray_NC() {
|
|
|
+ int ret = 0;
|
|
|
+ for(int i=0; i<REPS; i++) {
|
|
|
+ int[] array = array(1000);
|
|
|
+ ArraySort.mergeSort(array);
|
|
|
+ ret += array[0] + array[999];
|
|
|
+ }
|
|
|
+ return ret;
|
|
|
+ }
|
|
|
+
|
|
|
+}
|
