vendor/gonum.org/v1/gonum/internal/asm/c128/bench_test.go

   1 // Copyright ©2016 The Gonum 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 c128
   6
   7 import "testing"
   8
   9 var (
  10         a = complex128(2 + 2i)
  11         x = make([]complex128, 1000000)
  12         y = make([]complex128, 1000000)
  13         z = make([]complex128, 1000000)
  14 )
  15
  16 func init() {
  17         for n := range x {
  18                 x[n] = complex(float64(n), float64(n))
  19                 y[n] = complex(float64(n), float64(n))
  20         }
  21 }
  22
  23 func benchaxpyu(t *testing.B, n int, f func(a complex128, x, y []complex128)) {
  24         x, y := x[:n], y[:n]
  25         for i := 0; i < t.N; i++ {
  26                 f(a, x, y)
  27         }
  28 }
  29
  30 func naiveaxpyu(a complex128, x, y []complex128) {
  31         for i, v := range x {
  32                 y[i] += a * v
  33         }
  34 }
  35
  36 func BenchmarkC128AxpyUnitary1(t *testing.B)     { benchaxpyu(t, 1, AxpyUnitary) }
  37 func BenchmarkC128AxpyUnitary2(t *testing.B)     { benchaxpyu(t, 2, AxpyUnitary) }
  38 func BenchmarkC128AxpyUnitary3(t *testing.B)     { benchaxpyu(t, 3, AxpyUnitary) }
  39 func BenchmarkC128AxpyUnitary4(t *testing.B)     { benchaxpyu(t, 4, AxpyUnitary) }
  40 func BenchmarkC128AxpyUnitary5(t *testing.B)     { benchaxpyu(t, 5, AxpyUnitary) }
  41 func BenchmarkC128AxpyUnitary10(t *testing.B)    { benchaxpyu(t, 10, AxpyUnitary) }
  42 func BenchmarkC128AxpyUnitary100(t *testing.B)   { benchaxpyu(t, 100, AxpyUnitary) }
  43 func BenchmarkC128AxpyUnitary1000(t *testing.B)  { benchaxpyu(t, 1000, AxpyUnitary) }
  44 func BenchmarkC128AxpyUnitary5000(t *testing.B)  { benchaxpyu(t, 5000, AxpyUnitary) }
  45 func BenchmarkC128AxpyUnitary10000(t *testing.B) { benchaxpyu(t, 10000, AxpyUnitary) }
  46 func BenchmarkC128AxpyUnitary50000(t *testing.B) { benchaxpyu(t, 50000, AxpyUnitary) }
  47
  48 func BenchmarkLC128AxpyUnitary1(t *testing.B)     { benchaxpyu(t, 1, naiveaxpyu) }
  49 func BenchmarkLC128AxpyUnitary2(t *testing.B)     { benchaxpyu(t, 2, naiveaxpyu) }
  50 func BenchmarkLC128AxpyUnitary3(t *testing.B)     { benchaxpyu(t, 3, naiveaxpyu) }
  51 func BenchmarkLC128AxpyUnitary4(t *testing.B)     { benchaxpyu(t, 4, naiveaxpyu) }
  52 func BenchmarkLC128AxpyUnitary5(t *testing.B)     { benchaxpyu(t, 5, naiveaxpyu) }
  53 func BenchmarkLC128AxpyUnitary10(t *testing.B)    { benchaxpyu(t, 10, naiveaxpyu) }
  54 func BenchmarkLC128AxpyUnitary100(t *testing.B)   { benchaxpyu(t, 100, naiveaxpyu) }
  55 func BenchmarkLC128AxpyUnitary1000(t *testing.B)  { benchaxpyu(t, 1000, naiveaxpyu) }
  56 func BenchmarkLC128AxpyUnitary5000(t *testing.B)  { benchaxpyu(t, 5000, naiveaxpyu) }
  57 func BenchmarkLC128AxpyUnitary10000(t *testing.B) { benchaxpyu(t, 10000, naiveaxpyu) }
  58 func BenchmarkLC128AxpyUnitary50000(t *testing.B) { benchaxpyu(t, 50000, naiveaxpyu) }
  59
  60 func benchaxpyut(t *testing.B, n int, f func(d []complex128, a complex128, x, y []complex128)) {
  61         x, y, z := x[:n], y[:n], z[:n]
  62         for i := 0; i < t.N; i++ {
  63                 f(z, a, x, y)
  64         }
  65 }
  66
  67 func naiveaxpyut(d []complex128, a complex128, x, y []complex128) {
  68         for i, v := range x {
  69                 d[i] = y[i] + a*v
  70         }
  71 }
  72
  73 func BenchmarkC128AxpyUnitaryTo1(t *testing.B)     { benchaxpyut(t, 1, AxpyUnitaryTo) }
  74 func BenchmarkC128AxpyUnitaryTo2(t *testing.B)     { benchaxpyut(t, 2, AxpyUnitaryTo) }
  75 func BenchmarkC128AxpyUnitaryTo3(t *testing.B)     { benchaxpyut(t, 3, AxpyUnitaryTo) }
  76 func BenchmarkC128AxpyUnitaryTo4(t *testing.B)     { benchaxpyut(t, 4, AxpyUnitaryTo) }
  77 func BenchmarkC128AxpyUnitaryTo5(t *testing.B)     { benchaxpyut(t, 5, AxpyUnitaryTo) }
  78 func BenchmarkC128AxpyUnitaryTo10(t *testing.B)    { benchaxpyut(t, 10, AxpyUnitaryTo) }
  79 func BenchmarkC128AxpyUnitaryTo100(t *testing.B)   { benchaxpyut(t, 100, AxpyUnitaryTo) }
  80 func BenchmarkC128AxpyUnitaryTo1000(t *testing.B)  { benchaxpyut(t, 1000, AxpyUnitaryTo) }
  81 func BenchmarkC128AxpyUnitaryTo5000(t *testing.B)  { benchaxpyut(t, 5000, AxpyUnitaryTo) }
  82 func BenchmarkC128AxpyUnitaryTo10000(t *testing.B) { benchaxpyut(t, 10000, AxpyUnitaryTo) }
  83 func BenchmarkC128AxpyUnitaryTo50000(t *testing.B) { benchaxpyut(t, 50000, AxpyUnitaryTo) }
  84
  85 func BenchmarkLC128AxpyUnitaryTo1(t *testing.B)     { benchaxpyut(t, 1, naiveaxpyut) }
  86 func BenchmarkLC128AxpyUnitaryTo2(t *testing.B)     { benchaxpyut(t, 2, naiveaxpyut) }
  87 func BenchmarkLC128AxpyUnitaryTo3(t *testing.B)     { benchaxpyut(t, 3, naiveaxpyut) }
  88 func BenchmarkLC128AxpyUnitaryTo4(t *testing.B)     { benchaxpyut(t, 4, naiveaxpyut) }
  89 func BenchmarkLC128AxpyUnitaryTo5(t *testing.B)     { benchaxpyut(t, 5, naiveaxpyut) }
  90 func BenchmarkLC128AxpyUnitaryTo10(t *testing.B)    { benchaxpyut(t, 10, naiveaxpyut) }
  91 func BenchmarkLC128AxpyUnitaryTo100(t *testing.B)   { benchaxpyut(t, 100, naiveaxpyut) }
  92 func BenchmarkLC128AxpyUnitaryTo1000(t *testing.B)  { benchaxpyut(t, 1000, naiveaxpyut) }
  93 func BenchmarkLC128AxpyUnitaryTo5000(t *testing.B)  { benchaxpyut(t, 5000, naiveaxpyut) }
  94 func BenchmarkLC128AxpyUnitaryTo10000(t *testing.B) { benchaxpyut(t, 10000, naiveaxpyut) }
  95 func BenchmarkLC128AxpyUnitaryTo50000(t *testing.B) { benchaxpyut(t, 50000, naiveaxpyut) }
  96
  97 func benchaxpyinc(t *testing.B, ln, t_inc int, f func(alpha complex128, x, y []complex128, n, incX, incY, ix, iy uintptr)) {
  98         n, inc := uintptr(ln), uintptr(t_inc)
  99         var idx int
 100         if t_inc < 0 {
 101                 idx = (-ln + 1) * t_inc
 102         }
 103         for i := 0; i < t.N; i++ {
 104                 f(1+1i, x, y, n, inc, inc, uintptr(idx), uintptr(idx))
 105         }
 106 }
 107
 108 func naiveaxpyinc(alpha complex128, x, y []complex128, n, incX, incY, ix, iy uintptr) {
 109         for i := 0; i < int(n); i++ {
 110                 y[iy] += alpha * x[ix]
 111                 ix += incX
 112                 iy += incY
 113         }
 114 }
 115
 116 func BenchmarkC128AxpyIncN1Inc1(b *testing.B) { benchaxpyinc(b, 1, 1, AxpyInc) }
 117
 118 func BenchmarkC128AxpyIncN2Inc1(b *testing.B)  { benchaxpyinc(b, 2, 1, AxpyInc) }
 119 func BenchmarkC128AxpyIncN2Inc2(b *testing.B)  { benchaxpyinc(b, 2, 2, AxpyInc) }
 120 func BenchmarkC128AxpyIncN2Inc4(b *testing.B)  { benchaxpyinc(b, 2, 4, AxpyInc) }
 121 func BenchmarkC128AxpyIncN2Inc10(b *testing.B) { benchaxpyinc(b, 2, 10, AxpyInc) }
 122
 123 func BenchmarkC128AxpyIncN3Inc1(b *testing.B)  { benchaxpyinc(b, 3, 1, AxpyInc) }
 124 func BenchmarkC128AxpyIncN3Inc2(b *testing.B)  { benchaxpyinc(b, 3, 2, AxpyInc) }
 125 func BenchmarkC128AxpyIncN3Inc4(b *testing.B)  { benchaxpyinc(b, 3, 4, AxpyInc) }
 126 func BenchmarkC128AxpyIncN3Inc10(b *testing.B) { benchaxpyinc(b, 3, 10, AxpyInc) }
 127
 128 func BenchmarkC128AxpyIncN4Inc1(b *testing.B)  { benchaxpyinc(b, 4, 1, AxpyInc) }
 129 func BenchmarkC128AxpyIncN4Inc2(b *testing.B)  { benchaxpyinc(b, 4, 2, AxpyInc) }
 130 func BenchmarkC128AxpyIncN4Inc4(b *testing.B)  { benchaxpyinc(b, 4, 4, AxpyInc) }
 131 func BenchmarkC128AxpyIncN4Inc10(b *testing.B) { benchaxpyinc(b, 4, 10, AxpyInc) }
 132
 133 func BenchmarkC128AxpyIncN10Inc1(b *testing.B)  { benchaxpyinc(b, 10, 1, AxpyInc) }
 134 func BenchmarkC128AxpyIncN10Inc2(b *testing.B)  { benchaxpyinc(b, 10, 2, AxpyInc) }
 135 func BenchmarkC128AxpyIncN10Inc4(b *testing.B)  { benchaxpyinc(b, 10, 4, AxpyInc) }
 136 func BenchmarkC128AxpyIncN10Inc10(b *testing.B) { benchaxpyinc(b, 10, 10, AxpyInc) }
 137
 138 func BenchmarkC128AxpyIncN1000Inc1(b *testing.B)  { benchaxpyinc(b, 1000, 1, AxpyInc) }
 139 func BenchmarkC128AxpyIncN1000Inc2(b *testing.B)  { benchaxpyinc(b, 1000, 2, AxpyInc) }
 140 func BenchmarkC128AxpyIncN1000Inc4(b *testing.B)  { benchaxpyinc(b, 1000, 4, AxpyInc) }
 141 func BenchmarkC128AxpyIncN1000Inc10(b *testing.B) { benchaxpyinc(b, 1000, 10, AxpyInc) }
 142
 143 func BenchmarkC128AxpyIncN100000Inc1(b *testing.B)  { benchaxpyinc(b, 100000, 1, AxpyInc) }
 144 func BenchmarkC128AxpyIncN100000Inc2(b *testing.B)  { benchaxpyinc(b, 100000, 2, AxpyInc) }
 145 func BenchmarkC128AxpyIncN100000Inc4(b *testing.B)  { benchaxpyinc(b, 100000, 4, AxpyInc) }
 146 func BenchmarkC128AxpyIncN100000Inc10(b *testing.B) { benchaxpyinc(b, 100000, 10, AxpyInc) }
 147
 148 func BenchmarkC128AxpyIncN100000IncM1(b *testing.B)  { benchaxpyinc(b, 100000, -1, AxpyInc) }
 149 func BenchmarkC128AxpyIncN100000IncM2(b *testing.B)  { benchaxpyinc(b, 100000, -2, AxpyInc) }
 150 func BenchmarkC128AxpyIncN100000IncM4(b *testing.B)  { benchaxpyinc(b, 100000, -4, AxpyInc) }
 151 func BenchmarkC128AxpyIncN100000IncM10(b *testing.B) { benchaxpyinc(b, 100000, -10, AxpyInc) }
 152
 153 func BenchmarkLC128AxpyIncN1Inc1(b *testing.B) { benchaxpyinc(b, 1, 1, naiveaxpyinc) }
 154
 155 func BenchmarkLC128AxpyIncN2Inc1(b *testing.B)  { benchaxpyinc(b, 2, 1, naiveaxpyinc) }
 156 func BenchmarkLC128AxpyIncN2Inc2(b *testing.B)  { benchaxpyinc(b, 2, 2, naiveaxpyinc) }
 157 func BenchmarkLC128AxpyIncN2Inc4(b *testing.B)  { benchaxpyinc(b, 2, 4, naiveaxpyinc) }
 158 func BenchmarkLC128AxpyIncN2Inc10(b *testing.B) { benchaxpyinc(b, 2, 10, naiveaxpyinc) }
 159
 160 func BenchmarkLC128AxpyIncN3Inc1(b *testing.B)  { benchaxpyinc(b, 3, 1, naiveaxpyinc) }
 161 func BenchmarkLC128AxpyIncN3Inc2(b *testing.B)  { benchaxpyinc(b, 3, 2, naiveaxpyinc) }
 162 func BenchmarkLC128AxpyIncN3Inc4(b *testing.B)  { benchaxpyinc(b, 3, 4, naiveaxpyinc) }
 163 func BenchmarkLC128AxpyIncN3Inc10(b *testing.B) { benchaxpyinc(b, 3, 10, naiveaxpyinc) }
 164
 165 func BenchmarkLC128AxpyIncN4Inc1(b *testing.B)  { benchaxpyinc(b, 4, 1, naiveaxpyinc) }
 166 func BenchmarkLC128AxpyIncN4Inc2(b *testing.B)  { benchaxpyinc(b, 4, 2, naiveaxpyinc) }
 167 func BenchmarkLC128AxpyIncN4Inc4(b *testing.B)  { benchaxpyinc(b, 4, 4, naiveaxpyinc) }
 168 func BenchmarkLC128AxpyIncN4Inc10(b *testing.B) { benchaxpyinc(b, 4, 10, naiveaxpyinc) }
 169
 170 func BenchmarkLC128AxpyIncN10Inc1(b *testing.B)  { benchaxpyinc(b, 10, 1, naiveaxpyinc) }
 171 func BenchmarkLC128AxpyIncN10Inc2(b *testing.B)  { benchaxpyinc(b, 10, 2, naiveaxpyinc) }
 172 func BenchmarkLC128AxpyIncN10Inc4(b *testing.B)  { benchaxpyinc(b, 10, 4, naiveaxpyinc) }
 173 func BenchmarkLC128AxpyIncN10Inc10(b *testing.B) { benchaxpyinc(b, 10, 10, naiveaxpyinc) }
 174
 175 func BenchmarkLC128AxpyIncN1000Inc1(b *testing.B)  { benchaxpyinc(b, 1000, 1, naiveaxpyinc) }
 176 func BenchmarkLC128AxpyIncN1000Inc2(b *testing.B)  { benchaxpyinc(b, 1000, 2, naiveaxpyinc) }
 177 func BenchmarkLC128AxpyIncN1000Inc4(b *testing.B)  { benchaxpyinc(b, 1000, 4, naiveaxpyinc) }
 178 func BenchmarkLC128AxpyIncN1000Inc10(b *testing.B) { benchaxpyinc(b, 1000, 10, naiveaxpyinc) }
 179
 180 func BenchmarkLC128AxpyIncN100000Inc1(b *testing.B)  { benchaxpyinc(b, 100000, 1, naiveaxpyinc) }
 181 func BenchmarkLC128AxpyIncN100000Inc2(b *testing.B)  { benchaxpyinc(b, 100000, 2, naiveaxpyinc) }
 182 func BenchmarkLC128AxpyIncN100000Inc4(b *testing.B)  { benchaxpyinc(b, 100000, 4, naiveaxpyinc) }
 183 func BenchmarkLC128AxpyIncN100000Inc10(b *testing.B) { benchaxpyinc(b, 100000, 10, naiveaxpyinc) }
 184
 185 func BenchmarkLC128AxpyIncN100000IncM1(b *testing.B)  { benchaxpyinc(b, 100000, -1, naiveaxpyinc) }
 186 func BenchmarkLC128AxpyIncN100000IncM2(b *testing.B)  { benchaxpyinc(b, 100000, -2, naiveaxpyinc) }
 187 func BenchmarkLC128AxpyIncN100000IncM4(b *testing.B)  { benchaxpyinc(b, 100000, -4, naiveaxpyinc) }
 188 func BenchmarkLC128AxpyIncN100000IncM10(b *testing.B) { benchaxpyinc(b, 100000, -10, naiveaxpyinc) }
 189
 190 func benchaxpyincto(t *testing.B, ln, t_inc int, f func(dst []complex128, incDst, idst uintptr, alpha complex128, x, y []complex128, n, incX, incY, ix, iy uintptr)) {
 191         n, inc := uintptr(ln), uintptr(t_inc)
 192         var idx int
 193         if t_inc < 0 {
 194                 idx = (-ln + 1) * t_inc
 195         }
 196         for i := 0; i < t.N; i++ {
 197                 f(z, inc, uintptr(idx), 1+1i, x, y, n, inc, inc, uintptr(idx), uintptr(idx))
 198         }
 199 }
 200
 201 func naiveaxpyincto(dst []complex128, incDst, idst uintptr, alpha complex128, x, y []complex128, n, incX, incY, ix, iy uintptr) {
 202         for i := 0; i < int(n); i++ {
 203                 dst[idst] = alpha*x[ix] + y[iy]
 204                 ix += incX
 205                 iy += incY
 206                 idst += incDst
 207         }
 208 }
 209
 210 func BenchmarkC128AxpyIncToN1Inc1(b *testing.B) { benchaxpyincto(b, 1, 1, AxpyIncTo) }
 211
 212 func BenchmarkC128AxpyIncToN2Inc1(b *testing.B)  { benchaxpyincto(b, 2, 1, AxpyIncTo) }
 213 func BenchmarkC128AxpyIncToN2Inc2(b *testing.B)  { benchaxpyincto(b, 2, 2, AxpyIncTo) }
 214 func BenchmarkC128AxpyIncToN2Inc4(b *testing.B)  { benchaxpyincto(b, 2, 4, AxpyIncTo) }
 215 func BenchmarkC128AxpyIncToN2Inc10(b *testing.B) { benchaxpyincto(b, 2, 10, AxpyIncTo) }
 216
 217 func BenchmarkC128AxpyIncToN3Inc1(b *testing.B)  { benchaxpyincto(b, 3, 1, AxpyIncTo) }
 218 func BenchmarkC128AxpyIncToN3Inc2(b *testing.B)  { benchaxpyincto(b, 3, 2, AxpyIncTo) }
 219 func BenchmarkC128AxpyIncToN3Inc4(b *testing.B)  { benchaxpyincto(b, 3, 4, AxpyIncTo) }
 220 func BenchmarkC128AxpyIncToN3Inc10(b *testing.B) { benchaxpyincto(b, 3, 10, AxpyIncTo) }
 221
 222 func BenchmarkC128AxpyIncToN4Inc1(b *testing.B)  { benchaxpyincto(b, 4, 1, AxpyIncTo) }
 223 func BenchmarkC128AxpyIncToN4Inc2(b *testing.B)  { benchaxpyincto(b, 4, 2, AxpyIncTo) }
 224 func BenchmarkC128AxpyIncToN4Inc4(b *testing.B)  { benchaxpyincto(b, 4, 4, AxpyIncTo) }
 225 func BenchmarkC128AxpyIncToN4Inc10(b *testing.B) { benchaxpyincto(b, 4, 10, AxpyIncTo) }
 226
 227 func BenchmarkC128AxpyIncToN10Inc1(b *testing.B)  { benchaxpyincto(b, 10, 1, AxpyIncTo) }
 228 func BenchmarkC128AxpyIncToN10Inc2(b *testing.B)  { benchaxpyincto(b, 10, 2, AxpyIncTo) }
 229 func BenchmarkC128AxpyIncToN10Inc4(b *testing.B)  { benchaxpyincto(b, 10, 4, AxpyIncTo) }
 230 func BenchmarkC128AxpyIncToN10Inc10(b *testing.B) { benchaxpyincto(b, 10, 10, AxpyIncTo) }
 231
 232 func BenchmarkC128AxpyIncToN1000Inc1(b *testing.B)  { benchaxpyincto(b, 1000, 1, AxpyIncTo) }
 233 func BenchmarkC128AxpyIncToN1000Inc2(b *testing.B)  { benchaxpyincto(b, 1000, 2, AxpyIncTo) }
 234 func BenchmarkC128AxpyIncToN1000Inc4(b *testing.B)  { benchaxpyincto(b, 1000, 4, AxpyIncTo) }
 235 func BenchmarkC128AxpyIncToN1000Inc10(b *testing.B) { benchaxpyincto(b, 1000, 10, AxpyIncTo) }
 236
 237 func BenchmarkC128AxpyIncToN100000Inc1(b *testing.B)  { benchaxpyincto(b, 100000, 1, AxpyIncTo) }
 238 func BenchmarkC128AxpyIncToN100000Inc2(b *testing.B)  { benchaxpyincto(b, 100000, 2, AxpyIncTo) }
 239 func BenchmarkC128AxpyIncToN100000Inc4(b *testing.B)  { benchaxpyincto(b, 100000, 4, AxpyIncTo) }
 240 func BenchmarkC128AxpyIncToN100000Inc10(b *testing.B) { benchaxpyincto(b, 100000, 10, AxpyIncTo) }
 241
 242 func BenchmarkC128AxpyIncToN100000IncM1(b *testing.B)  { benchaxpyincto(b, 100000, -1, AxpyIncTo) }
 243 func BenchmarkC128AxpyIncToN100000IncM2(b *testing.B)  { benchaxpyincto(b, 100000, -2, AxpyIncTo) }
 244 func BenchmarkC128AxpyIncToN100000IncM4(b *testing.B)  { benchaxpyincto(b, 100000, -4, AxpyIncTo) }
 245 func BenchmarkC128AxpyIncToN100000IncM10(b *testing.B) { benchaxpyincto(b, 100000, -10, AxpyIncTo) }
 246
 247 func BenchmarkLC128AxpyIncToN1Inc1(b *testing.B) { benchaxpyincto(b, 1, 1, naiveaxpyincto) }
 248
 249 func BenchmarkLC128AxpyIncToN2Inc1(b *testing.B)  { benchaxpyincto(b, 2, 1, naiveaxpyincto) }
 250 func BenchmarkLC128AxpyIncToN2Inc2(b *testing.B)  { benchaxpyincto(b, 2, 2, naiveaxpyincto) }
 251 func BenchmarkLC128AxpyIncToN2Inc4(b *testing.B)  { benchaxpyincto(b, 2, 4, naiveaxpyincto) }
 252 func BenchmarkLC128AxpyIncToN2Inc10(b *testing.B) { benchaxpyincto(b, 2, 10, naiveaxpyincto) }
 253
 254 func BenchmarkLC128AxpyIncToN3Inc1(b *testing.B)  { benchaxpyincto(b, 3, 1, naiveaxpyincto) }
 255 func BenchmarkLC128AxpyIncToN3Inc2(b *testing.B)  { benchaxpyincto(b, 3, 2, naiveaxpyincto) }
 256 func BenchmarkLC128AxpyIncToN3Inc4(b *testing.B)  { benchaxpyincto(b, 3, 4, naiveaxpyincto) }
 257 func BenchmarkLC128AxpyIncToN3Inc10(b *testing.B) { benchaxpyincto(b, 3, 10, naiveaxpyincto) }
 258
 259 func BenchmarkLC128AxpyIncToN4Inc1(b *testing.B)  { benchaxpyincto(b, 4, 1, naiveaxpyincto) }
 260 func BenchmarkLC128AxpyIncToN4Inc2(b *testing.B)  { benchaxpyincto(b, 4, 2, naiveaxpyincto) }
 261 func BenchmarkLC128AxpyIncToN4Inc4(b *testing.B)  { benchaxpyincto(b, 4, 4, naiveaxpyincto) }
 262 func BenchmarkLC128AxpyIncToN4Inc10(b *testing.B) { benchaxpyincto(b, 4, 10, naiveaxpyincto) }
 263
 264 func BenchmarkLC128AxpyIncToN10Inc1(b *testing.B)  { benchaxpyincto(b, 10, 1, naiveaxpyincto) }
 265 func BenchmarkLC128AxpyIncToN10Inc2(b *testing.B)  { benchaxpyincto(b, 10, 2, naiveaxpyincto) }
 266 func BenchmarkLC128AxpyIncToN10Inc4(b *testing.B)  { benchaxpyincto(b, 10, 4, naiveaxpyincto) }
 267 func BenchmarkLC128AxpyIncToN10Inc10(b *testing.B) { benchaxpyincto(b, 10, 10, naiveaxpyincto) }
 268
 269 func BenchmarkLC128AxpyIncToN1000Inc1(b *testing.B)  { benchaxpyincto(b, 1000, 1, naiveaxpyincto) }
 270 func BenchmarkLC128AxpyIncToN1000Inc2(b *testing.B)  { benchaxpyincto(b, 1000, 2, naiveaxpyincto) }
 271 func BenchmarkLC128AxpyIncToN1000Inc4(b *testing.B)  { benchaxpyincto(b, 1000, 4, naiveaxpyincto) }
 272 func BenchmarkLC128AxpyIncToN1000Inc10(b *testing.B) { benchaxpyincto(b, 1000, 10, naiveaxpyincto) }
 273
 274 func BenchmarkLC128AxpyIncToN100000Inc1(b *testing.B)  { benchaxpyincto(b, 100000, 1, naiveaxpyincto) }
 275 func BenchmarkLC128AxpyIncToN100000Inc2(b *testing.B)  { benchaxpyincto(b, 100000, 2, naiveaxpyincto) }
 276 func BenchmarkLC128AxpyIncToN100000Inc4(b *testing.B)  { benchaxpyincto(b, 100000, 4, naiveaxpyincto) }
 277 func BenchmarkLC128AxpyIncToN100000Inc10(b *testing.B) { benchaxpyincto(b, 100000, 10, naiveaxpyincto) }
 278
 279 func BenchmarkLC128AxpyIncToN100000IncM1(b *testing.B) { benchaxpyincto(b, 100000, -1, naiveaxpyincto) }
 280 func BenchmarkLC128AxpyIncToN100000IncM2(b *testing.B) { benchaxpyincto(b, 100000, -2, naiveaxpyincto) }
 281 func BenchmarkLC128AxpyIncToN100000IncM4(b *testing.B) { benchaxpyincto(b, 100000, -4, naiveaxpyincto) }
 282 func BenchmarkLC128AxpyIncToN100000IncM10(b *testing.B) {
 283         benchaxpyincto(b, 100000, -10, naiveaxpyincto)
 284 }