bench_test.go

     1  // Copyright 2020 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package test
     6  
     7  import (
     8  	"fmt"
     9  	"testing"
    10  )
    11  
    12  var globl int64
    13  var globl32 int32
    14  
    15  func BenchmarkLoadAdd(b *testing.B) {
    16  	x := make([]int64, 1024)
    17  	y := make([]int64, 1024)
    18  	for i := 0; i < b.N; i++ {
    19  		var s int64
    20  		for i := range x {
    21  			s ^= x[i] + y[i]
    22  		}
    23  		globl = s
    24  	}
    25  }
    26  
    27  // Added for ppc64 extswsli on power9
    28  func BenchmarkExtShift(b *testing.B) {
    29  	x := make([]int32, 1024)
    30  	for i := 0; i < b.N; i++ {
    31  		var s int64
    32  		for i := range x {
    33  			s ^= int64(x[i]+32) * 8
    34  		}
    35  		globl = s
    36  	}
    37  }
    38  
    39  func BenchmarkModify(b *testing.B) {
    40  	a := make([]int64, 1024)
    41  	v := globl
    42  	for i := 0; i < b.N; i++ {
    43  		for j := range a {
    44  			a[j] += v
    45  		}
    46  	}
    47  }
    48  
    49  func BenchmarkMullImm(b *testing.B) {
    50  	x := make([]int32, 1024)
    51  	for i := 0; i < b.N; i++ {
    52  		var s int32
    53  		for i := range x {
    54  			s += x[i] * 100
    55  		}
    56  		globl32 = s
    57  	}
    58  }
    59  
    60  func BenchmarkConstModify(b *testing.B) {
    61  	a := make([]int64, 1024)
    62  	for i := 0; i < b.N; i++ {
    63  		for j := range a {
    64  			a[j] += 3
    65  		}
    66  	}
    67  }
    68  
    69  func BenchmarkBitSet(b *testing.B) {
    70  	const N = 64 * 8
    71  	a := make([]uint64, N/64)
    72  	for i := 0; i < b.N; i++ {
    73  		for j := uint64(0); j < N; j++ {
    74  			a[j/64] |= 1 << (j % 64)
    75  		}
    76  	}
    77  }
    78  
    79  func BenchmarkBitClear(b *testing.B) {
    80  	const N = 64 * 8
    81  	a := make([]uint64, N/64)
    82  	for i := 0; i < b.N; i++ {
    83  		for j := uint64(0); j < N; j++ {
    84  			a[j/64] &^= 1 << (j % 64)
    85  		}
    86  	}
    87  }
    88  
    89  func BenchmarkBitToggle(b *testing.B) {
    90  	const N = 64 * 8
    91  	a := make([]uint64, N/64)
    92  	for i := 0; i < b.N; i++ {
    93  		for j := uint64(0); j < N; j++ {
    94  			a[j/64] ^= 1 << (j % 64)
    95  		}
    96  	}
    97  }
    98  
    99  func BenchmarkBitSetConst(b *testing.B) {
   100  	const N = 64
   101  	a := make([]uint64, N)
   102  	for i := 0; i < b.N; i++ {
   103  		for j := range a {
   104  			a[j] |= 1 << 37
   105  		}
   106  	}
   107  }
   108  
   109  func BenchmarkBitClearConst(b *testing.B) {
   110  	const N = 64
   111  	a := make([]uint64, N)
   112  	for i := 0; i < b.N; i++ {
   113  		for j := range a {
   114  			a[j] &^= 1 << 37
   115  		}
   116  	}
   117  }
   118  
   119  func BenchmarkBitToggleConst(b *testing.B) {
   120  	const N = 64
   121  	a := make([]uint64, N)
   122  	for i := 0; i < b.N; i++ {
   123  		for j := range a {
   124  			a[j] ^= 1 << 37
   125  		}
   126  	}
   127  }
   128  
   129  func BenchmarkMulNeg(b *testing.B) {
   130  	x := make([]int64, 1024)
   131  	for i := 0; i < b.N; i++ {
   132  		var s int64
   133  		for i := range x {
   134  			s = (-x[i]) * 11
   135  		}
   136  		globl = s
   137  	}
   138  }
   139  
   140  func BenchmarkMul2Neg(b *testing.B) {
   141  	x := make([]int64, 1024)
   142  	y := make([]int64, 1024)
   143  	for i := 0; i < b.N; i++ {
   144  		var s int64
   145  		for i := range x {
   146  			s = (-x[i]) * (-y[i])
   147  		}
   148  		globl = s
   149  	}
   150  }
   151  
   152  func BenchmarkSimplifyNegMul(b *testing.B) {
   153  	x := make([]int64, 1024)
   154  	y := make([]int64, 1024)
   155  	b.ResetTimer()
   156  	for i := 0; i < b.N; i++ {
   157  		var s int64
   158  		for i := range x {
   159  			s = -(-x[i] * y[i])
   160  		}
   161  		globl = s
   162  	}
   163  }
   164  
   165  func BenchmarkSimplifyNegDiv(b *testing.B) {
   166  	x := make([]int64, 1024)
   167  	y := make([]int64, 1024)
   168  	for i := range y {
   169  		y[i] = 42
   170  	}
   171  	b.ResetTimer()
   172  	for i := 0; i < b.N; i++ {
   173  		var s int64
   174  		for i := range x {
   175  			s = -(-x[i] / y[i])
   176  		}
   177  		globl = s
   178  	}
   179  }
   180  
   181  var globbool bool
   182  
   183  // containsRight compares strs[i] == str (slice element on left).
   184  //
   185  //go:noinline
   186  func containsRight(strs []string, str string) bool {
   187  	for i := range strs {
   188  		if strs[i] == str {
   189  			return true
   190  		}
   191  	}
   192  	return false
   193  }
   194  
   195  // containsLeft compares str == strs[i] (parameter on left).
   196  //
   197  //go:noinline
   198  func containsLeft(strs []string, str string) bool {
   199  	for i := range strs {
   200  		if str == strs[i] {
   201  			return true
   202  		}
   203  	}
   204  	return false
   205  }
   206  
   207  // BenchmarkStringEqParamOrder tests that the operand order of string
   208  // equality comparisons does not affect performance. See issue #74471.
   209  func BenchmarkStringEqParamOrder(b *testing.B) {
   210  	strs := []string{
   211  		"12312312", "abcsdsfw", "abcdefgh", "qereqwre",
   212  		"gwertdsg", "hellowod", "iamgroot", "theiswer",
   213  		"dg323sdf", "gadsewwe", "g42dg4t3", "4hre2323",
   214  		"23eg4325", "13234234", "32dfgsdg", "23fgre34",
   215  		"43rerrer", "hh2s2443", "hhwesded", "1swdf23d",
   216  		"gwcdrwer", "bfgwertd", "badgwe3g", "lhoejyop",
   217  	}
   218  	target := fmt.Sprintf("%s", "notfound")
   219  	b.Run("ParamRight", func(b *testing.B) {
   220  		for b.Loop() {
   221  			globbool = containsRight(strs, target)
   222  		}
   223  	})
   224  	b.Run("ParamLeft", func(b *testing.B) {
   225  		for b.Loop() {
   226  			globbool = containsLeft(strs, target)
   227  		}
   228  	})
   229  }
   230
View as plain text