1 /*
   2  * Copyright (c) 2014 Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 package org.openjdk.bench.vm.compiler;
  26 
  27 import org.openjdk.jmh.annotations.Benchmark;
  28 import org.openjdk.jmh.annotations.BenchmarkMode;
  29 import org.openjdk.jmh.annotations.Mode;
  30 import org.openjdk.jmh.annotations.OutputTimeUnit;
  31 import org.openjdk.jmh.annotations.Param;
  32 import org.openjdk.jmh.annotations.Scope;
  33 import org.openjdk.jmh.annotations.Setup;
  34 import org.openjdk.jmh.annotations.State;
  35 
  36 import java.util.concurrent.TimeUnit;
  37 
  38 /**
  39  * Tests speed of multiplication calculations with constants.
  40  */
  41 @BenchmarkMode(Mode.AverageTime)
  42 @OutputTimeUnit(TimeUnit.NANOSECONDS)
  43 @State(Scope.Thread)
  44 public class Multiplication {
  45 
  46     @Param("500")
  47     private int arraySize;
  48 
  49     private long[] longArraySmall, longArrayBig;
  50 
  51     @Setup
  52     public void setupSubclass() {
  53         longArraySmall = new long[arraySize];
  54         longArrayBig = new long[arraySize];
  55 
  56         /*
  57          * small values always have higher 32 bits cleared. big values always
  58          * have higher 32 bits set.
  59          */
  60         for (int i = 0; i < arraySize; i++) {
  61             longArraySmall[i] = 100L * i + i;
  62             longArrayBig[i] = ((100L * i + i) << 32) + 4543 + i * 4;
  63         }
  64     }
  65 
  66     /* helper for small constant benchmarks. */
  67     private static long smallConstantHelper(long[] values) {
  68         long sum = 0;
  69         for (long value : values) {
  70             sum += value * 453543L;
  71         }
  72         return sum;
  73     }
  74 
  75     /* helper for big constant benchmarks. */
  76     private static long bigConstantHelper(long[] values) {
  77         long sum = 0;
  78         for (long value : values) {
  79             sum += value * 4554345533543L;
  80         }
  81         return sum;
  82     }
  83 
  84     /**
  85      * Test multiplications of longs. One of the operands is a small constant and the other is a variable that always is
  86      * small.
  87      */
  88     @Benchmark
  89     public long testLongSmallVariableSmallConstantMul() {
  90         return smallConstantHelper(longArraySmall);
  91     }
  92 
  93     /**
  94      * Test multiplications of longs. One of the operands is a big constant and the other is a variable that always is
  95      * small.
  96      */
  97     @Benchmark
  98     public long testLongSmallVariableBigConstantMul() {
  99         return bigConstantHelper(longArraySmall);
 100     }
 101 
 102     /**
 103      * Test multiplications of longs. One of the operands is a small constant and the other is a variable that always is
 104      * big.
 105      */
 106     @Benchmark
 107     public long testLongBigVariableSmallConstantMul() {
 108         return smallConstantHelper(longArrayBig);
 109     }
 110 
 111     /**
 112      * Test multiplications of longs. One of the operands is a big constant and the other is a variable that always is
 113      * big.
 114      */
 115     @Benchmark
 116     public long testLongBigVariableBigConstantMul() {
 117         return bigConstantHelper(longArrayBig);
 118     }
 119 
 120 }