Add If statement benchmarks

src/benchmarks/micro/runtime/Statements/If.cs

@@ -0,0 +1,195 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using BenchmarkDotNet.Attributes;
+using BenchmarkDotNet.Running;
+using MicroBenchmarks;
+using System.Runtime.CompilerServices;
+
+namespace IfStatements
+{
+ [BenchmarkCategory(Categories.Runtime)]
+ public unsafe class IfStatements
+ {
+ private const int Iterations = 10000;
+ private const int MaxArgsPassed = 4; // Num of args in Consume
+
+ private static int[] inputs;
+
+ private static int s_seed;
+
+ static void InitRand() {
+ s_seed = 7774755;
+ }
+
+ static int Rand(ref int seed) {
+ s_seed = (s_seed * 77 + 13218009) % 3687091;
+ return seed;
+ }
+
+ public IfStatements()
+ {
+ inputs = new int[Iterations + MaxArgsPassed];
+ for (int i = 0; i < inputs.Length; i++) {
+ inputs[i] = Rand(ref s_seed) - 1;
+ }
+ }
+
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ static void Consume(int op1, int op2, int op3, int op4) {
+ return;
+ }
+
+ [Benchmark]
+ public void Single() {
+ for (int i = 0; i < Iterations; i++) {
+ SingleInner(inputs[i]);
+ }
+ }
+
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ public static void SingleInner(int op1) {
+ if (op1 % 2 == 0) {
+ op1 = 5;
+ }
+ Consume(op1, 0, 0, 0);
+ }
+
+ [Benchmark]
+ public void And() {
+ for (int i = 0; i < Iterations; i++) {
+ AndInner(inputs[i], inputs[i+1]);
+ }
+ }
+
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ public static void AndInner(int op1, int op2) {
+ if (op1 % 2 == 0 && op2 % 2 == 0) {
+ op1 = 5;
+ }
+ Consume(op1, op2, 0, 0);
+ }
+
+ [Benchmark]
+ public void AndAnd() {
+ for (int i = 0; i < Iterations; i++) {
+ AndAndInner(inputs[i], inputs[i+1], inputs[i+2]);
+ }
+ }
+
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ public static void AndAndInner(int op1, int op2, int op3) {
+ if (op1 % 2 == 0 && op2 % 2 == 0 && op3 % 2 == 0) {
+ op1 = 5;
+ }
+ Consume(op1, op2, op3, 0);
+ }
+
+ [Benchmark]
+ public void AndAndAnd() {
+ for (int i = 0; i < Iterations; i++) {
+ AndAndAndInner(inputs[i], inputs[i+1], inputs[i+2], inputs[i+3]);
+ }
+ }
+
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ public static void AndAndAndInner(int op1, int op2, int op3, int op4) {
+ if (op1 % 2 == 0 && op2 % 2 == 0 && op3 % 2 == 0 && op4 % 2 == 0) {
+ op1 = 5;
+ }
+ Consume(op1, op2, op3, op4);
+ }
+
+ [Benchmark]
+ public void Or() {
+ for (int i = 0; i < Iterations; i++) {
+ OrInner(inputs[i], inputs[i+1]);
+ }
+ }
+
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ public static void OrInner(int op1, int op2) {
+ if (op1 % 2 == 0 || op2 % 2 == 0) {
+ op1 = 5;
+ }
+ Consume(op1, op2, 0, 0);
+ }
+
+ [Benchmark]
+ public void OrOr() {
+ for (int i = 0; i < Iterations; i++) {
+ OrOrInner(inputs[i], inputs[i+1], inputs[i+2]);
+ }
+ }
+
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ public static void OrOrInner(int op1, int op2, int op3) {
+ if (op1 % 2 == 0 || op2 % 2 == 0 || op3 % 2 == 0) {
+ op1 = 5;
+ }
+ Consume(op1, op2, op3, 0);
+ }
+
+ [Benchmark]
+ public void AndOr() {
+ for (int i = 0; i < Iterations; i++) {
+ AndOrInner(inputs[i], inputs[i+1], inputs[i+2]);
+ }
+ }
+
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ public static void AndOrInner(int op1, int op2, int op3) {
+ if (op1 % 2 == 0 && op2 % 2 == 0 || op3 % 2 == 0) {
+ op1 = 5;
+ }
+ Consume(op1, op2, op3, 0);
+ }
+
+ [Benchmark]
+ public void SingleArray() {
+ for (int i = 0; i < Iterations; i++) {
+ SingleArrayInner(i);
+ }
+ }
+
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ public static void SingleArrayInner(int op1) {
+ if (inputs[op1] % 2 == 0) {
+ op1 = 5;
+ }
+ Consume(op1, 0, 0, 0);
+ }
+
+ [Benchmark]
+ public void AndArray() {
+ for (int i = 0; i < Iterations; i++) {
+ AndArrayInner(i, i+1);
+ }
+ }
+
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ public static void AndArrayInner(int op1, int op2) {
+ if (inputs[op1] % 2 == 0 && inputs[op2] % 2 == 0) {
+ op1 = 5;
+ }
+ Consume(op1, op2, 0, 0);
+ }
+
+ [Benchmark]
+ public void OrArray() {
+ for (int i = 0; i < Iterations; i++) {
+ OrArrayInner(i, i+1);
+ }
+ }
+
+ [MethodImpl(MethodImplOptions.NoInlining)]
+ public static void OrArrayInner(int op1, int op2) {
+ if (inputs[op1] % 2 == 0 || inputs[op2] % 2 == 0) {
+ op1 = 5;
+ }
+ Consume(op1, op2, 0, 0);
+ }
+ }
+}