8310813: Simplify and modernize equals, hashCode, and compareTo for BigInteger

src/java.base/share/classes/java/math/BigInteger.java

@@ -3951,7 +3951,7 @@ final int compareMagnitude(BigInteger val) {
             return -1;
         if (len1 > len2)
             return 1;
-        int i = ArraysSupport.mismatch(m1, 0, m2, 0, len1);
+        int i = ArraysSupport.mismatch(m1, m2, len1);
         if (i != -1)
             return ((m1[i] & LONG_MASK) < (m2[i] & LONG_MASK)) ? -1 : 1;
         return 0;
@@ -4022,7 +4022,7 @@ public boolean equals(Object x) {
         if (mag.length != xInt.mag.length)
             return false;
 
-        return ArraysSupport.mismatch(mag, 0, xInt.mag, 0, mag.length) == -1;
+        return ArraysSupport.mismatch(mag, xInt.mag, mag.length) == -1;
     }
 
     /**

test/micro/org/openjdk/bench/java/math/BigIntegerCompareTo.java

@@ -24,6 +24,7 @@
 package org.openjdk.bench.java.math;
 
 import java.math.BigInteger;
+import java.util.Arrays;
 import java.util.concurrent.TimeUnit;
 
 import org.openjdk.jmh.annotations.Benchmark;
@@ -37,57 +38,52 @@
 import org.openjdk.jmh.annotations.Setup;
 import org.openjdk.jmh.annotations.State;
 import org.openjdk.jmh.annotations.Warmup;
+import org.openjdk.jmh.infra.Blackhole;
 
 @BenchmarkMode(Mode.AverageTime)
 @OutputTimeUnit(TimeUnit.NANOSECONDS)
 @State(Scope.Thread)
-@Warmup(iterations = 3, time = 1)
-@Measurement(iterations = 3, time = 1)
+@Warmup(iterations = 3, time = 5)
+@Measurement(iterations = 3, time = 5)
 @Fork(value = 3)
 public class BigIntegerCompareTo {
 
-    // The below list was derived from stats gathered from running tests in
-    // the security area, which is the biggest client of BigInteger in JDK.
-    //
-    // Every time bigInteger1.compareTo(bigInteger2) was called, the
-    // Math.min(bigInteger1.bitLength(), bigInteger2.bitLength()) value
-    // was recorded. Recorded values were then sorted by frequency in
-    // descending order. Top 20 of the most frequent values were then picked.
-    @Param({
-              "19",
-              "18",
-              "17",
-              "16",
-               "1",
-              "15",
-              "14",
-               "2",
-              "13",
-               "0",
-              "12",
-            "1536",
-            "1024",
-            "1535",
-            "1023",
-              "11",
-             "512",
-             "256",
-             "255",
-            "1534",
-    })
-    private int nBits;
+    public enum Group {S, M, L}
 
-    private BigInteger x, y;
+    @Param({"S", "M", "L"})
+    private Group group;
+
+    private static final int MAX_LENGTH = Arrays.stream(Group.values())
+            .mapToInt(p -> getNumbersOfBits(p).length)
+            .max()
+            .getAsInt();
+
+    private BigInteger[] numbers;
 
     @Setup
     public void setup() {
-        var p = Shared.createPair(nBits);
-        x = p.x();
-        y = p.y();
+        int[] nBits = getNumbersOfBits(group);
+        numbers = new BigInteger[2 * MAX_LENGTH];
+        for (int i = 0; i < MAX_LENGTH; i++) {
+            var p = Shared.createPair(nBits[i % nBits.length]);
+            numbers[2 * i] = p.x();
+            numbers[2 * i + 1] = p.y();
+        }
+    }
+
+    private static int[] getNumbersOfBits(Group p) {
+        // the below arrays were derived from stats gathered from running tests in
+        // the security area, which is the biggest client of BigInteger in JDK
+        return switch (p) {
+            case S -> new int[]{0, 1, 2, 11, 12, 13, 14, 15, 16, 17, 18, 19};
+            case M -> new int[]{255, 256, 512};
+            case L -> new int[]{1023, 1024, 1534, 1535, 1536};
+        };
     }
 
     @Benchmark
-    public int testCompareTo() {
-        return x.compareTo(y);
+    public void testCompareTo(Blackhole bh) {
+        for (int i = 0; i < numbers.length; i += 2)
+            bh.consume(numbers[i].compareTo(numbers[i + 1]));
     }
 }

test/micro/org/openjdk/bench/java/math/BigIntegerEquals.java

@@ -24,6 +24,7 @@
 package org.openjdk.bench.java.math;
 
 import java.math.BigInteger;
+import java.util.Arrays;
 import java.util.concurrent.TimeUnit;
 
 import org.openjdk.jmh.annotations.Benchmark;
@@ -37,57 +38,52 @@
 import org.openjdk.jmh.annotations.Setup;
 import org.openjdk.jmh.annotations.State;
 import org.openjdk.jmh.annotations.Warmup;
+import org.openjdk.jmh.infra.Blackhole;
 
 @BenchmarkMode(Mode.AverageTime)
 @OutputTimeUnit(TimeUnit.NANOSECONDS)
 @State(Scope.Thread)
-@Warmup(iterations = 3, time = 1)
-@Measurement(iterations = 3, time = 1)
+@Warmup(iterations = 3, time = 5)
+@Measurement(iterations = 3, time = 5)
 @Fork(value = 3)
 public class BigIntegerEquals {
 
-    // The below list was derived from stats gathered from running tests in
-    // the security area, which is the biggest client of BigInteger in JDK.
-    //
-    // Every time bigInteger1.equals(bigInteger2) was called, the
-    // Math.min(bigInteger1.bitLength(), bigInteger2.bitLength()) value
-    // was recorded. Recorded values were then sorted by frequency in
-    // descending order. Top 20 of the most frequent values were then picked.
-    @Param({
-            "256",
-            "255",
-            "521",
-            "384",
-              "1",
-             "46",
-            "252",
-            "446",
-            "448",
-            "383",
-            "520",
-            "254",
-            "130",
-            "445",
-            "129",
-            "447",
-            "519",
-            "251",
-            "382",
-            "253",
-    })
-    private int nBits;
+    public enum Group {S, M, L}
 
-    private BigInteger x, y;
+    @Param({"S", "M", "L"})
+    private Group group;
+
+    private static final int MAX_LENGTH = Arrays.stream(Group.values())
+            .mapToInt(p -> getNumbersOfBits(p).length)
+            .max()
+            .getAsInt();
+
+    private BigInteger[] numbers;
 
     @Setup
     public void setup() {
-        var p = Shared.createPair(nBits);
-        x = p.x();
-        y = p.y();
+        int[] nBits = getNumbersOfBits(group);
+        numbers = new BigInteger[2 * MAX_LENGTH];
+        for (int i = 0; i < MAX_LENGTH; i++) {
+            var p = Shared.createPair(nBits[i % nBits.length]);
+            numbers[2 * i] = p.x();
+            numbers[2 * i + 1] = p.y();
+        }
+    }
+
+    private static int[] getNumbersOfBits(Group p) {
+        // the below arrays were derived from stats gathered from running tests in
+        // the security area, which is the biggest client of BigInteger in JDK
+        return switch (p) {
+            case S -> new int[]{1, 46};
+            case M -> new int[]{129, 130, 251, 252, 253, 254, 255, 256};
+            case L -> new int[]{382, 383, 384, 445, 446, 447, 448, 519, 520, 521};
+        };
     }
 
     @Benchmark
-    public boolean testEquals() {
-        return x.equals(y);
+    public void testEquals(Blackhole bh) {
+        for (int i = 0; i < numbers.length; i += 2)
+            bh.consume(numbers[i].equals(numbers[i + 1]));
     }
 }

test/micro/org/openjdk/bench/java/math/BigIntegerHashCode.java

@@ -24,6 +24,7 @@
 package org.openjdk.bench.java.math;
 
 import java.math.BigInteger;
+import java.util.Arrays;
 import java.util.concurrent.TimeUnit;
 
 import org.openjdk.jmh.annotations.Benchmark;
@@ -37,54 +38,50 @@
 import org.openjdk.jmh.annotations.Setup;
 import org.openjdk.jmh.annotations.State;
 import org.openjdk.jmh.annotations.Warmup;
+import org.openjdk.jmh.infra.Blackhole;
 
 @BenchmarkMode(Mode.AverageTime)
 @OutputTimeUnit(TimeUnit.NANOSECONDS)
 @State(Scope.Thread)
-@Warmup(iterations = 3, time = 1)
-@Measurement(iterations = 3, time = 1)
+@Warmup(iterations = 3, time = 5)
+@Measurement(iterations = 3, time = 5)
 @Fork(value = 3)
 public class BigIntegerHashCode {
 
-    // The below list was derived from stats gathered from running tests in
-    // the security area, which is the biggest client of BigInteger in JDK.
-    //
-    // Every time BigInteger.hashCode() was called, BigInteger.bitLength() of
-    // the receiver was recorded. Recorded values were then sorted by frequency
-    // in descending order. Top 20 of the most frequent value were then picked.
-    @Param({
-             "256",
-             "521",
-            "1024",
-            "2048",
-             "384",
-            "3072",
-            "4096",
-             "512",
-             "768",
-            "5120",
-            "6144",
-            "2049",
-            "1025",
-              "13",
-             "767",
-               "7",
-            "2047",
-             "511",
-               "2",
-              "64",
-    })
-    private int nBits;
+    public enum Group {S, M, L}
 
-    private BigInteger x;
+    @Param({"S", "M", "L"})
+    private Group group;
+
+    private static final int MAX_LENGTH = Arrays.stream(Group.values())
+            .mapToInt(p -> getNumbersOfBits(p).length)
+            .max()
+            .getAsInt();
+
+    private BigInteger[] numbers;
 
     @Setup
     public void setup() {
-        x = Shared.createSingle(nBits);
+        int[] nBits = getNumbersOfBits(group);
+        numbers = new BigInteger[MAX_LENGTH];
+        for (int i = 0; i < MAX_LENGTH; i++) {
+            numbers[i] = Shared.createSingle(nBits[i % nBits.length]);
+        }
+    }
+
+    private static int[] getNumbersOfBits(Group p) {
+        // the below arrays were derived from stats gathered from running tests in
+        // the security area, which is the biggest client of BigInteger in JDK
+        return switch (p) {
+            case S -> new int[]{2, 7, 13, 64};
+            case M -> new int[]{256, 384, 511, 512, 521, 767, 768};
+            case L -> new int[]{1024, 1025, 2047, 2048, 2049, 3072, 4096, 5120, 6144};
+        };
     }
 
     @Benchmark
-    public int testHashCode() {
-        return x.hashCode();
+    public void testHashCode(Blackhole bh) {
+        for (var n : numbers)
+            bh.consume(n.hashCode());
     }
 }

test/micro/org/openjdk/bench/java/math/Shared.java

@@ -99,7 +99,7 @@ public static Pair createPair(int nBits) {
 
     public record Pair(BigInteger x, BigInteger y) {
         public Pair {
-            if (x.signum() != y.signum())
+            if (x.signum() == -y.signum()) // if the pair comprises positive and negative
                 throw new IllegalArgumentException("x.signum()=" + x.signum()
                         + ", y=signum()=" + y.signum());
             if (y.bitLength() - x.bitLength() > 1)