counts = new IdentityHashMap<>();
+ for (ScoreDoc sd : template) {
+ counts.merge(sd, 1, Integer::sum);
+ }
+ for (ScoreDoc sd : result) {
+ Integer c = counts.get(sd);
+ if (c == null) {
+ throw new IllegalStateException(
+ name + " failed: result contains unknown ScoreDoc instance");
+ }
+ if (c == 1) {
+ counts.remove(sd);
+ } else {
+ counts.put(sd, c - 1);
+ }
+ }
+ if (counts.isEmpty() == false) {
+ throw new IllegalStateException(name + " failed: result missing ScoreDoc instances");
+ }
+ }
+
+ /**
+ * setupInvocation performs a shallow copy of the template.
+ *
+ * Note: using Level.Invocation introduces overhead that JMH cannot easily subtract. For very
+ * small sizes (e.g. size=10), this overhead might be comparable to the benchmarked sort itself.
+ * We accept this because each invocation must start with the same unsorted array to ensure
+ * reproducibility across different sorting algorithms.
+ */
+ @Setup(Level.Invocation)
+ public void setupInvocation() {
+ work = new ScoreDoc[size];
+ System.arraycopy(template, 0, work, 0, size);
+ }
+
+ // ---- 1. JDK Arrays.sort with lambda ----
+
+ private ScoreDoc[] runJdkSortLambda(ScoreDoc[] work) {
+ Arrays.sort(work, (a, b) -> Integer.compare(a.doc, b.doc));
+ return work;
+ }
+
+ @Benchmark
+ public void jdkSortLambda(Blackhole bh) {
+ // intentionally inline — tests whether JIT handles inline lambda differently than static
+ // comparator
+ bh.consume(runJdkSortLambda(work));
+ }
+
+ // ---- 2. JDK Arrays.sort with static comparator ----
+
+ private ScoreDoc[] runJdkSortComparator(ScoreDoc[] work) {
+ Arrays.sort(work, BY_DOC_ASC);
+ return work;
+ }
+
+ @Benchmark
+ public void jdkSortComparator(Blackhole bh) {
+ bh.consume(runJdkSortComparator(work));
+ }
+
+ // ---- 3. ArrayUtil.introSort (wraps ArrayIntroSorter) ----
+
+ private ScoreDoc[] runArrayUtilIntroSort(ScoreDoc[] work) {
+ ArrayUtil.introSort(work, BY_DOC_ASC);
+ return work;
+ }
+
+ @Benchmark
+ public void arrayUtilIntroSort(Blackhole bh) {
+ bh.consume(runArrayUtilIntroSort(work));
+ }
+
+ // ---- 4. ArrayUtil.timSort (wraps ArrayTimSorter) ----
+
+ private ScoreDoc[] runArrayUtilTimSort(ScoreDoc[] work) {
+ ArrayUtil.timSort(work, BY_DOC_ASC);
+ return work;
+ }
+
+ @Benchmark
+ public void arrayUtilTimSort(Blackhole bh) {
+ bh.consume(runArrayUtilTimSort(work));
+ }
+
+ // ---- 5. Anonymous IntroSorter ----
+
+ private ScoreDoc[] runIntroSorterAnonymous(ScoreDoc[] work) {
+ final ScoreDoc[] arr = work;
+ new IntroSorter() {
+ ScoreDoc pivot;
+
+ @Override
+ protected void swap(int i, int j) {
+ ScoreDoc tmp = arr[i];
+ arr[i] = arr[j];
+ arr[j] = tmp;
+ }
+
+ @Override
+ protected void setPivot(int i) {
+ pivot = arr[i];
+ }
+
+ @Override
+ protected int comparePivot(int j) {
+ return Integer.compare(pivot.doc, arr[j].doc);
+ }
+
+ @Override
+ protected int compare(int i, int j) {
+ return Integer.compare(arr[i].doc, arr[j].doc);
+ }
+ }.sort(0, arr.length);
+ return arr;
+ }
+
+ @Benchmark
+ public void introSorterAnonymous(Blackhole bh) {
+ bh.consume(runIntroSorterAnonymous(work));
+ }
+
+ // ---- 6. Anonymous TimSorter ----
+
+ private ScoreDoc[] runTimSorterAnonymous(ScoreDoc[] work) {
+ final ScoreDoc[] arr = work;
+ final int len = arr.length;
+ new TimSorter(len / 2) {
+ ScoreDoc[] tmp = new ScoreDoc[len / 2];
+
+ @Override
+ protected void swap(int i, int j) {
+ ScoreDoc t = arr[i];
+ arr[i] = arr[j];
+ arr[j] = t;
+ }
+
+ @Override
+ protected int compare(int i, int j) {
+ return Integer.compare(arr[i].doc, arr[j].doc);
+ }
+
+ @Override
+ protected void copy(int src, int dest) {
+ arr[dest] = arr[src];
+ }
+
+ @Override
+ protected void save(int start, int l) {
+ System.arraycopy(arr, start, tmp, 0, l);
+ }
+
+ @Override
+ protected void restore(int src, int dest) {
+ arr[dest] = tmp[src];
+ }
+
+ @Override
+ protected int compareSaved(int i, int j) {
+ return Integer.compare(tmp[i].doc, arr[j].doc);
+ }
+ }.sort(0, len);
+ return arr;
+ }
+
+ @Benchmark
+ public void timSorterAnonymous(Blackhole bh) {
+ bh.consume(runTimSorterAnonymous(work));
+ }
+
+ // ---- 7. Anonymous InPlaceMergeSorter ----
+
+ private ScoreDoc[] runInPlaceMergeSorterAnonymous(ScoreDoc[] work) {
+ final ScoreDoc[] arr = work;
+ new InPlaceMergeSorter() {
+ @Override
+ protected void swap(int i, int j) {
+ ScoreDoc tmp = arr[i];
+ arr[i] = arr[j];
+ arr[j] = tmp;
+ }
+
+ @Override
+ protected int compare(int i, int j) {
+ return Integer.compare(arr[i].doc, arr[j].doc);
+ }
+ }.sort(0, arr.length);
+ return arr;
+ }
+
+ @Benchmark
+ public void inPlaceMergeSorterAnonymous(Blackhole bh) {
+ bh.consume(runInPlaceMergeSorterAnonymous(work));
+ }
+
+ // ---- 8. JDK Arrays.parallelSort with static comparator ----
+
+ private ScoreDoc[] runJdkParallelSort(ScoreDoc[] work) {
+ Arrays.parallelSort(work, BY_DOC_ASC);
+ return work;
+ }
+
+ @Benchmark
+ public void jdkParallelSort(Blackhole bh) {
+ bh.consume(runJdkParallelSort(work));
+ }
+
+ // ---- 9. Extract doc IDs, sort with JDK Arrays.sort (primitive long[]), reorder ----
+
+ private ScoreDoc[] runJdkSortPrimitiveExtractLong(ScoreDoc[] work) {
+ int len = work.length;
+ // pack (doc, originalIndex) into a long: doc in upper 32, index in lower 32
+ long[] packed = new long[len];
+ for (int i = 0; i < len; i++) {
+ packed[i] = ((long) work[i].doc << 32) | (i & 0xFFFFFFFFL);
+ }
+ Arrays.sort(packed);
+ ScoreDoc[] sorted = new ScoreDoc[len];
+ for (int i = 0; i < len; i++) {
+ sorted[i] = work[(int) packed[i]];
+ }
+ return sorted;
+ }
+
+ @Benchmark
+ public void jdkSortPrimitiveExtractLong(Blackhole bh) {
+ bh.consume(runJdkSortPrimitiveExtractLong(work));
+ }
+
+ // ---- 10. Extract doc IDs, sort with int[] when bits fit, else long[] ----
+
+ // bits needed to represent values in [0, max)
+ private static int bitsNeeded(int max) {
+ return 32 - Integer.numberOfLeadingZeros(max - 1);
+ }
+
+ private ScoreDoc[] runJdkSortPrimitiveExtractAdaptive(ScoreDoc[] work) {
+ int len = work.length;
+ int docBits = bitsNeeded(MAX_DOC);
+ int indexBits = bitsNeeded(len);
+ if (docBits + indexBits <= 31) {
+ // pack into int[]: doc in upper bits, index in lower bits
+ // <= 31 (not 32) because Arrays.sort uses signed comparison,
+ // so bit 31 must stay clear to avoid sign-bit corruption
+ int[] packed = new int[len];
+ for (int i = 0; i < len; i++) {
+ packed[i] = (work[i].doc << indexBits) | i;
+ }
+ Arrays.sort(packed);
+ int indexMask = (1 << indexBits) - 1;
+ ScoreDoc[] sorted = new ScoreDoc[len];
+ for (int i = 0; i < len; i++) {
+ sorted[i] = work[packed[i] & indexMask];
+ }
+ return sorted;
+ } else {
+ // fall back to long[]
+ long[] packed = new long[len];
+ for (int i = 0; i < len; i++) {
+ packed[i] = ((long) work[i].doc << 32) | (i & 0xFFFFFFFFL);
+ }
+ Arrays.sort(packed);
+ ScoreDoc[] sorted = new ScoreDoc[len];
+ for (int i = 0; i < len; i++) {
+ sorted[i] = work[(int) packed[i]];
+ }
+ return sorted;
+ }
+ }
+
+ @Benchmark
+ public void jdkSortPrimitiveExtractAdaptive(Blackhole bh) {
+ /**
+ * Documentation of int vs long paths given MAX_DOC = 5,000,000:
+ *
+ *
+ * - sizes 10, 50, 100 take the int[] path (23 + 7 = 30 <= 31 bits)
+ *
- sizes 500, 1,000, 10,000 take the long[] path (23 + 9 = 32 > 31 bits)
+ *
+ */
+ bh.consume(runJdkSortPrimitiveExtractAdaptive(work));
+ }
+
+ // ---- 11. Extract doc IDs, sort with LSBRadixSorter when bits fit, else JDK long[] ----
+
+ private ScoreDoc[] runLsbRadixSortExtract(ScoreDoc[] work) {
+ int len = work.length;
+ int docBits = bitsNeeded(MAX_DOC);
+ int indexBits = bitsNeeded(len);
+ if (docBits + indexBits <= 32) {
+ int[] packed = new int[len];
+ for (int i = 0; i < len; i++) {
+ packed[i] = (work[i].doc << indexBits) | i;
+ }
+ new LSBRadixSorter().sort(docBits + indexBits, packed, len);
+ int indexMask = (1 << indexBits) - 1;
+ ScoreDoc[] sorted = new ScoreDoc[len];
+ for (int i = 0; i < len; i++) {
+ sorted[i] = work[packed[i] & indexMask];
+ }
+ return sorted;
+ } else {
+ // fallback to long[] + Arrays.sort
+ long[] packed = new long[len];
+ for (int i = 0; i < len; i++) {
+ packed[i] = ((long) work[i].doc << 32) | (i & 0xFFFFFFFFL);
+ }
+ Arrays.sort(packed);
+ ScoreDoc[] sorted = new ScoreDoc[len];
+ for (int i = 0; i < len; i++) {
+ sorted[i] = work[(int) packed[i]];
+ }
+ return sorted;
+ }
+ }
+
+ @Benchmark
+ public void lsbRadixSortExtract(Blackhole bh) {
+ bh.consume(runLsbRadixSortExtract(work));
+ }
+
+ // ---- 12. Extract doc IDs, manual 4-pass radix sort (8-bit) ----
+
+ private ScoreDoc[] runRadixSort2Pass(ScoreDoc[] work) {
+ int len = work.length;
+ int docBits = bitsNeeded(MAX_DOC);
+ int indexBits = bitsNeeded(len);
+ if (docBits + indexBits <= 32) {
+ int[] packed = new int[len];
+ for (int i = 0; i < len; i++) {
+ packed[i] = (work[i].doc << indexBits) | i;
+ }
+
+ int totalBits = docBits + indexBits;
+ int[] bucket = new int[256];
+ int[] workArray = new int[len];
+
+ // up to 4 passes over 8-bit radix, skip unnecessary high passes
+ int passes = (totalBits + 7) >>> 3; // ceil(totalBits / 8)
+ for (int pass = 0; pass < passes; pass++) {
+ int shift = pass * 8;
+ int[] src = (pass % 2 == 0) ? packed : workArray;
+ int[] dst = (pass % 2 == 0) ? workArray : packed;
+
+ // histogram
+ for (int i = 0; i < len; i++) {
+ bucket[(src[i] >>> shift) & 0xFF]++;
+ }
+ // prefix sum
+ for (int i = 1; i < 256; i++) {
+ bucket[i] += bucket[i - 1];
+ }
+ // scatter
+ for (int i = len - 1; i >= 0; i--) {
+ dst[--bucket[(src[i] >>> shift) & 0xFF]] = src[i];
+ }
+
+ Arrays.fill(bucket, 0);
+ }
+
+ // if odd number of passes, result is in workArray
+ int[] sorted_packed = (passes % 2 == 0) ? packed : workArray;
+
+ int indexMask = (1 << indexBits) - 1;
+ ScoreDoc[] sorted = new ScoreDoc[len];
+ for (int i = 0; i < len; i++) {
+ sorted[i] = work[sorted_packed[i] & indexMask];
+ }
+ return sorted;
+ } else {
+ // long fallback
+ long[] packed = new long[len];
+ for (int i = 0; i < len; i++) {
+ packed[i] = ((long) work[i].doc << 32) | (i & 0xFFFFFFFFL);
+ }
+ Arrays.sort(packed);
+ ScoreDoc[] sorted = new ScoreDoc[len];
+ for (int i = 0; i < len; i++) {
+ sorted[i] = work[(int) packed[i]];
+ }
+ return sorted;
+ }
+ }
+
+ @Benchmark
+ public void radixSort2Pass(Blackhole bh) {
+ bh.consume(runRadixSort2Pass(work));
+ }
+}