< prev index next >

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

Print this page




  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 }
< prev index next >