path: root/src/main/java/org/linaro/benchmarks/micro/intrinsics/Intrinsics.java

/*
 * Copyright (c) 2015, ARM Limited. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */

package org.linaro.benchmarks.micro.intrinsics;

import java.lang.System;
import java.util.EnumMap;
import java.util.Map;
import java.util.Random;
import org.openjdk.jmh.annotations.*;
import java.util.concurrent.TimeUnit;

@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Benchmark)

public class Intrinsics {

  /* Invoke each intrinsic in question the same no. of times */
  private static final int NUM_INVOKES = 128;

  /* Random pool size.
   * Use a power of two to make the modulo operations below fast. */
  private static final int NUM_RANDS = 1024;

  /* Pre-allocated pool of random integers from [0, Integer.MAX_VALUE) */
  private static final int[] rand = new int[NUM_RANDS];

  static {
    // Allocate a pool of random integers to use in benchmarks that
    // want to try and force branch mispredicts without the overhead
    // of calling random.nextInt in times code. Same seed every time.
    Random random = new Random(42L);
    for (int i = 0; i < NUM_RANDS; i++) {
      rand[i] = random.nextInt(Integer.MAX_VALUE);
    }
  }

  /**
   * NumberOfLeadingZeros.
   **/

  private static int[] resultsNumberOfLeadingZerosInteger = new int[NUM_INVOKES];
  private static int[] resultsNumberOfLeadingZerosLong = new int[NUM_INVOKES];
  private static int[] resultsNumberOfLeadingZerosIntegerRandom = new int[NUM_INVOKES];
  private static int[] resultsNumberOfLeadingZerosLongRandom = new int[NUM_INVOKES];

  @Benchmark
  public void jmhTimeNumberOfLeadingZerosInteger() {
    for (int i = 0; i < NUM_INVOKES; ++i) {
      resultsNumberOfLeadingZerosInteger[i] =
        Integer.numberOfLeadingZeros(0x80000000 >>> i);
    }
  }

  @Benchmark
  public void jmhTimeNumberOfLeadingZerosLong() {
    for (int i = 0; i < NUM_INVOKES; ++i) {
      resultsNumberOfLeadingZerosLong[i] =
        Long.numberOfLeadingZeros(0x8000000000000000L >>> i);
    }
  }

  @Benchmark
  public void jmhTimeNumberOfLeadingZerosIntegerRandom() {
    for (int i = 0; i < NUM_INVOKES; ++i) {
      resultsNumberOfLeadingZerosIntegerRandom[i] =
        Integer.numberOfLeadingZeros(rand[i % NUM_RANDS] >>> rand[i % NUM_RANDS]);
    }
  }

  @Benchmark
  public void jmhTimeNumberOfLeadingZerosLongRandom() {
    for (int i = 0; i < NUM_INVOKES; ++i) {
      resultsNumberOfLeadingZerosLongRandom[i] =
        Long.numberOfLeadingZeros(1 << (rand[i % NUM_RANDS] % Long.SIZE));
    }
  }

  /**
   * NumberOfTrailingZeros.
   **/

  private static int[] resultsNumberOfTrailingZerosInteger = new int[NUM_INVOKES];
  private static int[] resultsNumberOfTrailingZerosLong = new int[NUM_INVOKES];
  private static int[] resultsNumberOfTrailingZerosIntegerRandom = new int[NUM_INVOKES];
  private static int[] resultsNumberOfTrailingZerosLongRandom = new int[NUM_INVOKES];

  @Benchmark
  public void jmhTimeNumberOfTrailingZerosInteger() {
    for (int i = 0; i < NUM_INVOKES; ++i) {
      resultsNumberOfTrailingZerosInteger[i] =
        Integer.numberOfTrailingZeros(0x80000000 >>> i);
    }
  }

  @Benchmark
  public void jmhTimeNumberOfTrailingZerosLong() {
    for (int i = 0; i < NUM_INVOKES; ++i) {
      resultsNumberOfTrailingZerosLong[i] =
        Long.numberOfTrailingZeros(0x8000000000000000L >>> i);
    }
  }

  @Benchmark
  public void jmhTimeNumberOfTrailingZerosIntegerRandom() {
    for (int i = 0; i < NUM_INVOKES; ++i) {
      resultsNumberOfTrailingZerosIntegerRandom[i] =
        Integer.numberOfTrailingZeros(rand[i % NUM_RANDS] >>> rand[i % NUM_RANDS]);
    }
  }

  @Benchmark
  public void jmhTimeNumberOfTrailingZerosLongRandom() {
    for (int i = 0; i < NUM_INVOKES; ++i) {
      resultsNumberOfTrailingZerosLongRandom[i] =
        Long.numberOfTrailingZeros(1 << (rand[i % NUM_RANDS] % Long.SIZE));
    }
  }

  /**
   * BitCount.
   **/

  // both Integer and Long's bitCount() return int type.
  private static int[] resultsBitCountInteger = new int[NUM_INVOKES];
  private static int[] resultsBitCountLong = new int[NUM_INVOKES];
  private static int[] resultsBitCountIntegerRandom = new int[NUM_INVOKES];
  private static int[] resultsBitCountLongRandom = new int[NUM_INVOKES];

  @Benchmark
  public void jmhTimeBitCountInteger() {
    for (int i = 0; i < NUM_INVOKES; ++i) {
      resultsBitCountInteger[i] = Integer.bitCount(0x1234abcd);
    }
  }

  @Benchmark
  public void jmhTimeBitCountLong() {
    for (int i = 0; i < NUM_INVOKES; ++i) {
      resultsBitCountLong[i] = Long.bitCount(0x1234abcd1234abcdL);
    }
  }

  @Benchmark
  public void jmhTimeBitCountIntegerRandom() {
    for (int i = 0; i < NUM_INVOKES; ++i) {
      resultsBitCountIntegerRandom[i] = Integer.bitCount(rand[i % NUM_RANDS]);
    }
  }

  @Benchmark
  public void jmhTimeBitCountLongRandom() {
    for (int i = 0; i < NUM_INVOKES; ++i) {
      resultsBitCountLongRandom[i] =
        Long.bitCount((long)rand[i % NUM_RANDS] << 32 + rand[i % NUM_RANDS]);
    }
  }

  /**
   * RotateRight.
   **/

  private static int[] resultsRotateRightInteger = new int[NUM_INVOKES];
  private static int[] resultsRotateRightIntegerConstant = new int[NUM_INVOKES];
  private static long[] resultsRotateRightLong = new long[NUM_INVOKES];
  private static long[] resultsRotateRightLongConstant = new long[NUM_INVOKES];

  @Benchmark
  public void jmhTimeRotateRightInteger() {
    for (int i = 0; i < NUM_INVOKES; ++i) {
      resultsRotateRightInteger[i] = Integer.rotateRight(0xFF0000DD, i);
    }
  }

  @Benchmark
  public void jmhTimeRotateRightIntegerConstant() {
    for (int i = 0; i < NUM_INVOKES; ++i) {
      resultsRotateRightIntegerConstant[i] = Integer.rotateRight(0xFF0000DD, 16);
    }
  }

  @Benchmark
  public void jmhTimeRotateRightLong() {
    for (int i = 0; i < NUM_INVOKES; ++i) {
      resultsRotateRightLong[i] = Long.rotateRight(0xBBAAAADDFF0000DDL, i);
    }
  }

  @Benchmark
  public void jmhTimeRotateRightLongConstant() {
    for (int i = 0; i < NUM_INVOKES; ++i) {
      resultsRotateRightLongConstant[i] = Long.rotateRight(0xBBAAAADDFF0000DDL, 48);
    }
  }

  /**
   * RotateLeft.
   **/

  private static int[] resultsRotateLeftInteger = new int[NUM_INVOKES];
  private static int[] resultsRotateLeftIntegerConstant = new int[NUM_INVOKES];
  private static long[] resultsRotateLeftLong = new long[NUM_INVOKES];
  private static long[] resultsRotateLeftLongConstant = new long[NUM_INVOKES];

  @Benchmark
  public void jmhTimeRotateLeftInteger() {
    for (int i = 0; i < NUM_INVOKES; ++i) {
      resultsRotateLeftInteger[i] = Integer.rotateLeft(0xFF0000DD, i);
    }
  }

  @Benchmark
  public void jmhTimeRotateLeftIntegerConstant() {
    for (int i = 0; i < NUM_INVOKES; ++i) {
      resultsRotateLeftIntegerConstant[i] = Integer.rotateLeft(0xFF0000DD, 16);
    }
  }

  @Benchmark
  public void jmhTimeRotateLeftLong() {
    for (int i = 0; i < NUM_INVOKES; ++i) {
      resultsRotateLeftLong[i] = Long.rotateLeft(0xBBAAAADDFF0000DDL, i);
    }
  }

  @Benchmark
  public void jmhTimeRotateLeftLongConstant() {
    for (int i = 0; i < NUM_INVOKES; ++i) {
      resultsRotateLeftLongConstant[i] = Long.rotateLeft(0xBBAAAADDFF0000DDL, 48);
    }
  }

  /**
   * RotateRandom.
   **/

  private static int[] resultsRotateRandomInteger = new int[NUM_INVOKES];
  private static long[] resultsRotateRandomLong = new long[NUM_INVOKES];

  @Benchmark
  public void jmhTimeRotateRandomInteger() {
    for (int i = 0; i < NUM_INVOKES; ++i) {
      resultsRotateRandomInteger[i] = (rand[i % NUM_RANDS] % 2 > 0)
        ? Integer.rotateLeft(0xFF0000DD, rand[i % NUM_RANDS])
        : Integer.rotateRight(0xFF0000DD, rand[i % NUM_RANDS]);
    }
  }

  @Benchmark
  public void jmhTimeRotateRandomLong() {
    for (int i = 0; i < NUM_INVOKES; ++i) {
      resultsRotateRandomLong[i] = (rand[i % NUM_RANDS] % 2 > 0)
        ? Long.rotateLeft(0xBBAAAADDFF0000DDL, rand[i % NUM_RANDS])
        : Long.rotateRight(0xBBAAAADDFF0000DDL, rand[i % NUM_RANDS]);
    }
  }
}