1 files changed, 272 insertions, 0 deletions
diff --git a/src/main/java/org/linaro/benchmarks/micro/intrinsics/Intrinsics.java b/src/main/java/org/linaro/benchmarks/micro/intrinsics/Intrinsics.java
new file mode 100644
index 0000000..f43d977
--- /dev/null
+++ b/src/main/java/org/linaro/benchmarks/micro/intrinsics/Intrinsics.java
@@ -0,0 +1,272 @@
+/*
+ * 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]);
+    }
+  }
+}