28
29 import org.openjdk.jmh.annotations.Benchmark;
30 import org.openjdk.jmh.annotations.BenchmarkMode;
31 import org.openjdk.jmh.annotations.Mode;
32 import org.openjdk.jmh.annotations.OperationsPerInvocation;
33 import org.openjdk.jmh.annotations.OutputTimeUnit;
34 import org.openjdk.jmh.annotations.Scope;
35 import org.openjdk.jmh.annotations.Setup;
36 import org.openjdk.jmh.annotations.State;
37 import org.openjdk.jmh.infra.Blackhole;
38
39 import java.math.BigInteger;
40 import java.util.Random;
41 import java.util.concurrent.TimeUnit;
42
43 @BenchmarkMode(Mode.AverageTime)
44 @OutputTimeUnit(TimeUnit.NANOSECONDS)
45 @State(Scope.Thread)
46 public class BigIntegers {
47
48 private BigInteger[] hugeArray, largeArray, smallArray;
49 public String[] dummyStringArray;
50 public Object[] dummyArr;
51 private static final int TESTSIZE = 1000;
52
53 @Setup
54 public void setup() {
55 Random r = new Random(1123);
56
57 hugeArray = new BigInteger[TESTSIZE]; /*
58 * Huge numbers larger than
59 * MAX_LONG
60 */
61 largeArray = new BigInteger[TESTSIZE]; /*
62 * Large numbers less than
63 * MAX_LONG but larger than
64 * MAX_INT
65 */
66 smallArray = new BigInteger[TESTSIZE]; /*
67 * Small number less than
68 * MAX_INT
69 */
70
71 dummyStringArray = new String[TESTSIZE];
72 dummyArr = new Object[TESTSIZE];
73
74 for (int i = 0; i < TESTSIZE; i++) {
75 int value = Math.abs(r.nextInt());
76
77 hugeArray[i] = new BigInteger("" + ((long) value + (long) Integer.MAX_VALUE)
78 + ((long) value + (long) Integer.MAX_VALUE));
79 largeArray[i] = new BigInteger("" + ((long) value + (long) Integer.MAX_VALUE));
80 smallArray[i] = new BigInteger("" + ((long) value / 1000));
81 }
82 }
83
84 /** Test BigInteger.toString() with huge numbers larger than MAX_LONG */
85 @Benchmark
86 @OperationsPerInvocation(TESTSIZE)
87 public void testHugeToString(Blackhole bh) {
88 for (BigInteger s : hugeArray) {
89 bh.consume(s.toString());
90 }
91 }
92
93 /** Test BigInteger.toString() with large numbers less than MAX_LONG but larger than MAX_INT */
94 @Benchmark
95 @OperationsPerInvocation(TESTSIZE)
96 public void testLargeToString(Blackhole bh) {
97 for (BigInteger s : largeArray) {
98 bh.consume(s.toString());
99 }
100 }
117 if (tmp == null) {
118 tmp = s;
119 continue;
120 }
121 tmp = tmp.multiply(s);
122 }
123 bh.consume(tmp);
124 }
125
126 /** Invokes the multiply method of BigInteger with various different values. */
127 @Benchmark
128 @OperationsPerInvocation(TESTSIZE)
129 public void testAdd(Blackhole bh) {
130 BigInteger tmp = null;
131 for (BigInteger s : hugeArray) {
132 if (tmp == null) {
133 tmp = s;
134 continue;
135 }
136 tmp = tmp.add(s);
137 }
138 bh.consume(tmp);
139 }
140 }
|
28
29 import org.openjdk.jmh.annotations.Benchmark;
30 import org.openjdk.jmh.annotations.BenchmarkMode;
31 import org.openjdk.jmh.annotations.Mode;
32 import org.openjdk.jmh.annotations.OperationsPerInvocation;
33 import org.openjdk.jmh.annotations.OutputTimeUnit;
34 import org.openjdk.jmh.annotations.Scope;
35 import org.openjdk.jmh.annotations.Setup;
36 import org.openjdk.jmh.annotations.State;
37 import org.openjdk.jmh.infra.Blackhole;
38
39 import java.math.BigInteger;
40 import java.util.Random;
41 import java.util.concurrent.TimeUnit;
42
43 @BenchmarkMode(Mode.AverageTime)
44 @OutputTimeUnit(TimeUnit.NANOSECONDS)
45 @State(Scope.Thread)
46 public class BigIntegers {
47
48 private BigInteger[] hugeArray, largeArray, smallArray, shiftArray;
49 public String[] dummyStringArray;
50 public Object[] dummyArr;
51 private static final int TESTSIZE = 1000;
52
53 @Setup
54 public void setup() {
55 Random r = new Random(1123);
56 int numbits = r.nextInt(16384);
57
58 hugeArray = new BigInteger[TESTSIZE]; /*
59 * Huge numbers larger than
60 * MAX_LONG
61 */
62 largeArray = new BigInteger[TESTSIZE]; /*
63 * Large numbers less than
64 * MAX_LONG but larger than
65 * MAX_INT
66 */
67 smallArray = new BigInteger[TESTSIZE]; /*
68 * Small number less than
69 * MAX_INT
70 */
71 shiftArray = new BigInteger[TESTSIZE]; /*
72 * Each array entry size is max 16k bits
73 */
74
75 dummyStringArray = new String[TESTSIZE];
76 dummyArr = new Object[TESTSIZE];
77
78 for (int i = 0; i < TESTSIZE; i++) {
79 int value = Math.abs(r.nextInt());
80
81 hugeArray[i] = new BigInteger("" + ((long) value + (long) Integer.MAX_VALUE)
82 + ((long) value + (long) Integer.MAX_VALUE));
83 largeArray[i] = new BigInteger("" + ((long) value + (long) Integer.MAX_VALUE));
84 smallArray[i] = new BigInteger("" + ((long) value / 1000));
85 shiftArray[i] = new BigInteger(numbits, r);
86 }
87 }
88
89 /** Test BigInteger.toString() with huge numbers larger than MAX_LONG */
90 @Benchmark
91 @OperationsPerInvocation(TESTSIZE)
92 public void testHugeToString(Blackhole bh) {
93 for (BigInteger s : hugeArray) {
94 bh.consume(s.toString());
95 }
96 }
97
98 /** Test BigInteger.toString() with large numbers less than MAX_LONG but larger than MAX_INT */
99 @Benchmark
100 @OperationsPerInvocation(TESTSIZE)
101 public void testLargeToString(Blackhole bh) {
102 for (BigInteger s : largeArray) {
103 bh.consume(s.toString());
104 }
105 }
122 if (tmp == null) {
123 tmp = s;
124 continue;
125 }
126 tmp = tmp.multiply(s);
127 }
128 bh.consume(tmp);
129 }
130
131 /** Invokes the multiply method of BigInteger with various different values. */
132 @Benchmark
133 @OperationsPerInvocation(TESTSIZE)
134 public void testAdd(Blackhole bh) {
135 BigInteger tmp = null;
136 for (BigInteger s : hugeArray) {
137 if (tmp == null) {
138 tmp = s;
139 continue;
140 }
141 tmp = tmp.add(s);
142 }
143 bh.consume(tmp);
144 }
145
146 /** Invokes the shiftLeft method of BigInteger with different values. */
147 @Benchmark
148 @OperationsPerInvocation(TESTSIZE)
149 public void testLeftShift(Blackhole bh) {
150 Random rand = new Random();
151 int shift = rand.nextInt(30) + 1;
152 BigInteger tmp = null;
153 for (BigInteger s : shiftArray) {
154 if (tmp == null) {
155 tmp = s;
156 continue;
157 }
158 tmp = tmp.shiftLeft(shift);
159 }
160 bh.consume(tmp);
161 }
162
163 /** Invokes the shiftRight method of BigInteger with different values. */
164 @Benchmark
165 @OperationsPerInvocation(TESTSIZE)
166 public void testRightShift(Blackhole bh) {
167 Random rand = new Random();
168 int shift = rand.nextInt(30) + 1;
169 BigInteger tmp = null;
170 for (BigInteger s : shiftArray) {
171 if (tmp == null) {
172 tmp = s;
173 continue;
174 }
175 tmp = tmp.shiftRight(shift);
176 }
177 bh.consume(tmp);
178 }
179 }
|