mirror of
https://github.com/gonum/gonum.git
synced 2025-10-05 15:16:59 +08:00
1686 lines
37 KiB
Go
1686 lines
37 KiB
Go
// Code generated by "go run github.com/gonum/blas/testblas/benchautogen/autogen_bench_level1double.go"; DO NOT EDIT.
|
|
|
|
// Copyright 2014 The Gonum Authors. All rights reserved.
|
|
// Use of this code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file
|
|
|
|
package native
|
|
|
|
import (
|
|
"math/rand"
|
|
"testing"
|
|
|
|
"gonum.org/v1/gonum/blas"
|
|
)
|
|
|
|
const (
|
|
posInc1 = 5
|
|
posInc2 = 3
|
|
negInc1 = -3
|
|
negInc2 = -4
|
|
SMALL_SLICE = 10
|
|
MEDIUM_SLICE = 1000
|
|
LARGE_SLICE = 100000
|
|
HUGE_SLICE = 10000000
|
|
)
|
|
|
|
func randomSlice(l, idx int) []float64 {
|
|
if idx < 0 {
|
|
idx = -idx
|
|
}
|
|
s := make([]float64, l*idx)
|
|
for i := range s {
|
|
s[i] = rand.Float64()
|
|
}
|
|
return s
|
|
}
|
|
|
|
func benchmarkDdot(b *testing.B, n int, x []float64, incX int, y []float64, incY int) {
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
impl.Ddot(n, x, incX, y, incY)
|
|
}
|
|
}
|
|
|
|
func BenchmarkDdotSmallBothUnitary(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDdot(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDdotSmallIncUni(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDdot(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDdotSmallUniInc(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDdot(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDdotSmallBothInc(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDdot(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDdotMediumBothUnitary(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDdot(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDdotMediumIncUni(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDdot(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDdotMediumUniInc(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDdot(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDdotMediumBothInc(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDdot(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDdotLargeBothUnitary(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDdot(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDdotLargeIncUni(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDdot(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDdotLargeUniInc(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDdot(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDdotLargeBothInc(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDdot(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDdotHugeBothUnitary(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDdot(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDdotHugeIncUni(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDdot(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDdotHugeUniInc(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDdot(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDdotHugeBothInc(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDdot(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
/* ------------------ */
|
|
func benchmarkDnrm2(b *testing.B, n int, x []float64, incX int) {
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
impl.Dnrm2(n, x, incX)
|
|
}
|
|
}
|
|
|
|
func BenchmarkDnrm2SmallUnitaryInc(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
|
|
benchmarkDnrm2(b, n, x, incX)
|
|
}
|
|
|
|
func BenchmarkDnrm2SmallPosInc(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
|
|
benchmarkDnrm2(b, n, x, incX)
|
|
}
|
|
|
|
func BenchmarkDnrm2MediumUnitaryInc(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
|
|
benchmarkDnrm2(b, n, x, incX)
|
|
}
|
|
|
|
func BenchmarkDnrm2MediumPosInc(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
|
|
benchmarkDnrm2(b, n, x, incX)
|
|
}
|
|
|
|
func BenchmarkDnrm2LargeUnitaryInc(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
|
|
benchmarkDnrm2(b, n, x, incX)
|
|
}
|
|
|
|
func BenchmarkDnrm2LargePosInc(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
|
|
benchmarkDnrm2(b, n, x, incX)
|
|
}
|
|
|
|
func BenchmarkDnrm2HugeUnitaryInc(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
|
|
benchmarkDnrm2(b, n, x, incX)
|
|
}
|
|
|
|
func BenchmarkDnrm2HugePosInc(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
|
|
benchmarkDnrm2(b, n, x, incX)
|
|
}
|
|
|
|
/* ------------------ */
|
|
func benchmarkDasum(b *testing.B, n int, x []float64, incX int) {
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
impl.Dasum(n, x, incX)
|
|
}
|
|
}
|
|
|
|
func BenchmarkDasumSmallUnitaryInc(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
|
|
benchmarkDasum(b, n, x, incX)
|
|
}
|
|
|
|
func BenchmarkDasumSmallPosInc(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
|
|
benchmarkDasum(b, n, x, incX)
|
|
}
|
|
|
|
func BenchmarkDasumMediumUnitaryInc(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
|
|
benchmarkDasum(b, n, x, incX)
|
|
}
|
|
|
|
func BenchmarkDasumMediumPosInc(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
|
|
benchmarkDasum(b, n, x, incX)
|
|
}
|
|
|
|
func BenchmarkDasumLargeUnitaryInc(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
|
|
benchmarkDasum(b, n, x, incX)
|
|
}
|
|
|
|
func BenchmarkDasumLargePosInc(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
|
|
benchmarkDasum(b, n, x, incX)
|
|
}
|
|
|
|
func BenchmarkDasumHugeUnitaryInc(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
|
|
benchmarkDasum(b, n, x, incX)
|
|
}
|
|
|
|
func BenchmarkDasumHugePosInc(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
|
|
benchmarkDasum(b, n, x, incX)
|
|
}
|
|
|
|
/* ------------------ */
|
|
func benchmarkIdamax(b *testing.B, n int, x []float64, incX int) {
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
impl.Idamax(n, x, incX)
|
|
}
|
|
}
|
|
|
|
func BenchmarkIdamaxSmallUnitaryInc(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
|
|
benchmarkIdamax(b, n, x, incX)
|
|
}
|
|
|
|
func BenchmarkIdamaxSmallPosInc(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
|
|
benchmarkIdamax(b, n, x, incX)
|
|
}
|
|
|
|
func BenchmarkIdamaxMediumUnitaryInc(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
|
|
benchmarkIdamax(b, n, x, incX)
|
|
}
|
|
|
|
func BenchmarkIdamaxMediumPosInc(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
|
|
benchmarkIdamax(b, n, x, incX)
|
|
}
|
|
|
|
func BenchmarkIdamaxLargeUnitaryInc(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
|
|
benchmarkIdamax(b, n, x, incX)
|
|
}
|
|
|
|
func BenchmarkIdamaxLargePosInc(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
|
|
benchmarkIdamax(b, n, x, incX)
|
|
}
|
|
|
|
func BenchmarkIdamaxHugeUnitaryInc(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
|
|
benchmarkIdamax(b, n, x, incX)
|
|
}
|
|
|
|
func BenchmarkIdamaxHugePosInc(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
|
|
benchmarkIdamax(b, n, x, incX)
|
|
}
|
|
|
|
/* ------------------ */
|
|
func benchmarkDswap(b *testing.B, n int, x []float64, incX int, y []float64, incY int) {
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
impl.Dswap(n, x, incX, y, incY)
|
|
}
|
|
}
|
|
|
|
func BenchmarkDswapSmallBothUnitary(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDswap(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDswapSmallIncUni(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDswap(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDswapSmallUniInc(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDswap(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDswapSmallBothInc(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDswap(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDswapMediumBothUnitary(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDswap(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDswapMediumIncUni(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDswap(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDswapMediumUniInc(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDswap(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDswapMediumBothInc(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDswap(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDswapLargeBothUnitary(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDswap(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDswapLargeIncUni(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDswap(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDswapLargeUniInc(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDswap(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDswapLargeBothInc(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDswap(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDswapHugeBothUnitary(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDswap(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDswapHugeIncUni(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDswap(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDswapHugeUniInc(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDswap(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDswapHugeBothInc(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDswap(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
/* ------------------ */
|
|
func benchmarkDcopy(b *testing.B, n int, x []float64, incX int, y []float64, incY int) {
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
impl.Dcopy(n, x, incX, y, incY)
|
|
}
|
|
}
|
|
|
|
func BenchmarkDcopySmallBothUnitary(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDcopy(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDcopySmallIncUni(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDcopy(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDcopySmallUniInc(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDcopy(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDcopySmallBothInc(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDcopy(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDcopyMediumBothUnitary(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDcopy(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDcopyMediumIncUni(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDcopy(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDcopyMediumUniInc(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDcopy(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDcopyMediumBothInc(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDcopy(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDcopyLargeBothUnitary(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDcopy(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDcopyLargeIncUni(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDcopy(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDcopyLargeUniInc(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDcopy(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDcopyLargeBothInc(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDcopy(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDcopyHugeBothUnitary(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDcopy(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDcopyHugeIncUni(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDcopy(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDcopyHugeUniInc(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDcopy(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDcopyHugeBothInc(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
|
|
benchmarkDcopy(b, n, x, incX, y, incY)
|
|
}
|
|
|
|
/* ------------------ */
|
|
func benchmarkDaxpy(b *testing.B, n int, alpha float64, x []float64, incX int, y []float64, incY int) {
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
impl.Daxpy(n, alpha, x, incX, y, incY)
|
|
}
|
|
}
|
|
|
|
func BenchmarkDaxpySmallBothUnitary(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
alpha := 2.4
|
|
benchmarkDaxpy(b, n, alpha, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDaxpySmallIncUni(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
alpha := 2.4
|
|
benchmarkDaxpy(b, n, alpha, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDaxpySmallUniInc(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
alpha := 2.4
|
|
benchmarkDaxpy(b, n, alpha, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDaxpySmallBothInc(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
alpha := 2.4
|
|
benchmarkDaxpy(b, n, alpha, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDaxpyMediumBothUnitary(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
alpha := 2.4
|
|
benchmarkDaxpy(b, n, alpha, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDaxpyMediumIncUni(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
alpha := 2.4
|
|
benchmarkDaxpy(b, n, alpha, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDaxpyMediumUniInc(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
alpha := 2.4
|
|
benchmarkDaxpy(b, n, alpha, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDaxpyMediumBothInc(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
alpha := 2.4
|
|
benchmarkDaxpy(b, n, alpha, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDaxpyLargeBothUnitary(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
alpha := 2.4
|
|
benchmarkDaxpy(b, n, alpha, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDaxpyLargeIncUni(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
alpha := 2.4
|
|
benchmarkDaxpy(b, n, alpha, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDaxpyLargeUniInc(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
alpha := 2.4
|
|
benchmarkDaxpy(b, n, alpha, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDaxpyLargeBothInc(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
alpha := 2.4
|
|
benchmarkDaxpy(b, n, alpha, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDaxpyHugeBothUnitary(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
alpha := 2.4
|
|
benchmarkDaxpy(b, n, alpha, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDaxpyHugeIncUni(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
alpha := 2.4
|
|
benchmarkDaxpy(b, n, alpha, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDaxpyHugeUniInc(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
alpha := 2.4
|
|
benchmarkDaxpy(b, n, alpha, x, incX, y, incY)
|
|
}
|
|
|
|
func BenchmarkDaxpyHugeBothInc(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
alpha := 2.4
|
|
benchmarkDaxpy(b, n, alpha, x, incX, y, incY)
|
|
}
|
|
|
|
/* ------------------ */
|
|
func benchmarkDrot(b *testing.B, n int, x []float64, incX int, y []float64, incY int, c, s float64) {
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
impl.Drot(n, x, incX, y, incY, c, s)
|
|
}
|
|
}
|
|
|
|
func BenchmarkDrotSmallBothUnitary(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
c := 0.89725836967
|
|
s := 0.44150585279
|
|
benchmarkDrot(b, n, x, incX, y, incY, c, s)
|
|
}
|
|
|
|
func BenchmarkDrotSmallIncUni(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
c := 0.89725836967
|
|
s := 0.44150585279
|
|
benchmarkDrot(b, n, x, incX, y, incY, c, s)
|
|
}
|
|
|
|
func BenchmarkDrotSmallUniInc(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
c := 0.89725836967
|
|
s := 0.44150585279
|
|
benchmarkDrot(b, n, x, incX, y, incY, c, s)
|
|
}
|
|
|
|
func BenchmarkDrotSmallBothInc(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
c := 0.89725836967
|
|
s := 0.44150585279
|
|
benchmarkDrot(b, n, x, incX, y, incY, c, s)
|
|
}
|
|
|
|
func BenchmarkDrotMediumBothUnitary(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
c := 0.89725836967
|
|
s := 0.44150585279
|
|
benchmarkDrot(b, n, x, incX, y, incY, c, s)
|
|
}
|
|
|
|
func BenchmarkDrotMediumIncUni(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
c := 0.89725836967
|
|
s := 0.44150585279
|
|
benchmarkDrot(b, n, x, incX, y, incY, c, s)
|
|
}
|
|
|
|
func BenchmarkDrotMediumUniInc(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
c := 0.89725836967
|
|
s := 0.44150585279
|
|
benchmarkDrot(b, n, x, incX, y, incY, c, s)
|
|
}
|
|
|
|
func BenchmarkDrotMediumBothInc(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
c := 0.89725836967
|
|
s := 0.44150585279
|
|
benchmarkDrot(b, n, x, incX, y, incY, c, s)
|
|
}
|
|
|
|
func BenchmarkDrotLargeBothUnitary(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
c := 0.89725836967
|
|
s := 0.44150585279
|
|
benchmarkDrot(b, n, x, incX, y, incY, c, s)
|
|
}
|
|
|
|
func BenchmarkDrotLargeIncUni(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
c := 0.89725836967
|
|
s := 0.44150585279
|
|
benchmarkDrot(b, n, x, incX, y, incY, c, s)
|
|
}
|
|
|
|
func BenchmarkDrotLargeUniInc(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
c := 0.89725836967
|
|
s := 0.44150585279
|
|
benchmarkDrot(b, n, x, incX, y, incY, c, s)
|
|
}
|
|
|
|
func BenchmarkDrotLargeBothInc(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
c := 0.89725836967
|
|
s := 0.44150585279
|
|
benchmarkDrot(b, n, x, incX, y, incY, c, s)
|
|
}
|
|
|
|
func BenchmarkDrotHugeBothUnitary(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
c := 0.89725836967
|
|
s := 0.44150585279
|
|
benchmarkDrot(b, n, x, incX, y, incY, c, s)
|
|
}
|
|
|
|
func BenchmarkDrotHugeIncUni(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
c := 0.89725836967
|
|
s := 0.44150585279
|
|
benchmarkDrot(b, n, x, incX, y, incY, c, s)
|
|
}
|
|
|
|
func BenchmarkDrotHugeUniInc(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
c := 0.89725836967
|
|
s := 0.44150585279
|
|
benchmarkDrot(b, n, x, incX, y, incY, c, s)
|
|
}
|
|
|
|
func BenchmarkDrotHugeBothInc(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
c := 0.89725836967
|
|
s := 0.44150585279
|
|
benchmarkDrot(b, n, x, incX, y, incY, c, s)
|
|
}
|
|
|
|
/* ------------------ */
|
|
func benchmarkDrotmOffDia(b *testing.B, n int, x []float64, incX int, y []float64, incY int, p blas.DrotmParams) {
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
impl.Drotm(n, x, incX, y, incY, p)
|
|
}
|
|
}
|
|
|
|
func BenchmarkDrotmOffDiaSmallBothUnitary(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{0, -0.625, 0.9375, 0}}
|
|
benchmarkDrotmOffDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmOffDiaSmallIncUni(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{0, -0.625, 0.9375, 0}}
|
|
benchmarkDrotmOffDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmOffDiaSmallUniInc(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{0, -0.625, 0.9375, 0}}
|
|
benchmarkDrotmOffDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmOffDiaSmallBothInc(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{0, -0.625, 0.9375, 0}}
|
|
benchmarkDrotmOffDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmOffDiaMediumBothUnitary(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{0, -0.625, 0.9375, 0}}
|
|
benchmarkDrotmOffDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmOffDiaMediumIncUni(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{0, -0.625, 0.9375, 0}}
|
|
benchmarkDrotmOffDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmOffDiaMediumUniInc(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{0, -0.625, 0.9375, 0}}
|
|
benchmarkDrotmOffDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmOffDiaMediumBothInc(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{0, -0.625, 0.9375, 0}}
|
|
benchmarkDrotmOffDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmOffDiaLargeBothUnitary(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{0, -0.625, 0.9375, 0}}
|
|
benchmarkDrotmOffDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmOffDiaLargeIncUni(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{0, -0.625, 0.9375, 0}}
|
|
benchmarkDrotmOffDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmOffDiaLargeUniInc(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{0, -0.625, 0.9375, 0}}
|
|
benchmarkDrotmOffDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmOffDiaLargeBothInc(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{0, -0.625, 0.9375, 0}}
|
|
benchmarkDrotmOffDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmOffDiaHugeBothUnitary(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{0, -0.625, 0.9375, 0}}
|
|
benchmarkDrotmOffDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmOffDiaHugeIncUni(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{0, -0.625, 0.9375, 0}}
|
|
benchmarkDrotmOffDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmOffDiaHugeUniInc(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{0, -0.625, 0.9375, 0}}
|
|
benchmarkDrotmOffDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmOffDiaHugeBothInc(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{0, -0.625, 0.9375, 0}}
|
|
benchmarkDrotmOffDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
/* ------------------ */
|
|
func benchmarkDrotmDia(b *testing.B, n int, x []float64, incX int, y []float64, incY int, p blas.DrotmParams) {
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
impl.Drotm(n, x, incX, y, incY, p)
|
|
}
|
|
}
|
|
|
|
func BenchmarkDrotmDiaSmallBothUnitary(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{5.0 / 12, 0, 0, 0.625}}
|
|
benchmarkDrotmDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmDiaSmallIncUni(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{5.0 / 12, 0, 0, 0.625}}
|
|
benchmarkDrotmDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmDiaSmallUniInc(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{5.0 / 12, 0, 0, 0.625}}
|
|
benchmarkDrotmDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmDiaSmallBothInc(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{5.0 / 12, 0, 0, 0.625}}
|
|
benchmarkDrotmDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmDiaMediumBothUnitary(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{5.0 / 12, 0, 0, 0.625}}
|
|
benchmarkDrotmDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmDiaMediumIncUni(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{5.0 / 12, 0, 0, 0.625}}
|
|
benchmarkDrotmDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmDiaMediumUniInc(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{5.0 / 12, 0, 0, 0.625}}
|
|
benchmarkDrotmDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmDiaMediumBothInc(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{5.0 / 12, 0, 0, 0.625}}
|
|
benchmarkDrotmDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmDiaLargeBothUnitary(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{5.0 / 12, 0, 0, 0.625}}
|
|
benchmarkDrotmDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmDiaLargeIncUni(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{5.0 / 12, 0, 0, 0.625}}
|
|
benchmarkDrotmDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmDiaLargeUniInc(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{5.0 / 12, 0, 0, 0.625}}
|
|
benchmarkDrotmDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmDiaLargeBothInc(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{5.0 / 12, 0, 0, 0.625}}
|
|
benchmarkDrotmDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmDiaHugeBothUnitary(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{5.0 / 12, 0, 0, 0.625}}
|
|
benchmarkDrotmDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmDiaHugeIncUni(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{5.0 / 12, 0, 0, 0.625}}
|
|
benchmarkDrotmDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmDiaHugeUniInc(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{5.0 / 12, 0, 0, 0.625}}
|
|
benchmarkDrotmDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmDiaHugeBothInc(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{5.0 / 12, 0, 0, 0.625}}
|
|
benchmarkDrotmDia(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
/* ------------------ */
|
|
func benchmarkDrotmResc(b *testing.B, n int, x []float64, incX int, y []float64, incY int, p blas.DrotmParams) {
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
impl.Drotm(n, x, incX, y, incY, p)
|
|
}
|
|
}
|
|
|
|
func BenchmarkDrotmRescSmallBothUnitary(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{4096, -3584, 1792, 4096}}
|
|
benchmarkDrotmResc(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmRescSmallIncUni(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{4096, -3584, 1792, 4096}}
|
|
benchmarkDrotmResc(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmRescSmallUniInc(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{4096, -3584, 1792, 4096}}
|
|
benchmarkDrotmResc(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmRescSmallBothInc(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{4096, -3584, 1792, 4096}}
|
|
benchmarkDrotmResc(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmRescMediumBothUnitary(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{4096, -3584, 1792, 4096}}
|
|
benchmarkDrotmResc(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmRescMediumIncUni(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{4096, -3584, 1792, 4096}}
|
|
benchmarkDrotmResc(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmRescMediumUniInc(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{4096, -3584, 1792, 4096}}
|
|
benchmarkDrotmResc(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmRescMediumBothInc(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{4096, -3584, 1792, 4096}}
|
|
benchmarkDrotmResc(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmRescLargeBothUnitary(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{4096, -3584, 1792, 4096}}
|
|
benchmarkDrotmResc(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmRescLargeIncUni(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{4096, -3584, 1792, 4096}}
|
|
benchmarkDrotmResc(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmRescLargeUniInc(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{4096, -3584, 1792, 4096}}
|
|
benchmarkDrotmResc(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmRescLargeBothInc(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{4096, -3584, 1792, 4096}}
|
|
benchmarkDrotmResc(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmRescHugeBothUnitary(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{4096, -3584, 1792, 4096}}
|
|
benchmarkDrotmResc(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmRescHugeIncUni(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := 1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{4096, -3584, 1792, 4096}}
|
|
benchmarkDrotmResc(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmRescHugeUniInc(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{4096, -3584, 1792, 4096}}
|
|
benchmarkDrotmResc(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
func BenchmarkDrotmRescHugeBothInc(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
incY := negInc1
|
|
y := randomSlice(n, incY)
|
|
p := blas.DrotmParams{Flag: blas.OffDiagonal, H: [4]float64{4096, -3584, 1792, 4096}}
|
|
benchmarkDrotmResc(b, n, x, incX, y, incY, p)
|
|
}
|
|
|
|
/* ------------------ */
|
|
func benchmarkDscal(b *testing.B, n int, alpha float64, x []float64, incX int) {
|
|
b.ResetTimer()
|
|
for i := 0; i < b.N; i++ {
|
|
impl.Dscal(n, alpha, x, incX)
|
|
}
|
|
}
|
|
|
|
func BenchmarkDscalSmallUnitaryInc(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
alpha := 2.4
|
|
benchmarkDscal(b, n, alpha, x, incX)
|
|
}
|
|
|
|
func BenchmarkDscalSmallPosInc(b *testing.B) {
|
|
n := SMALL_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
alpha := 2.4
|
|
benchmarkDscal(b, n, alpha, x, incX)
|
|
}
|
|
|
|
func BenchmarkDscalMediumUnitaryInc(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
alpha := 2.4
|
|
benchmarkDscal(b, n, alpha, x, incX)
|
|
}
|
|
|
|
func BenchmarkDscalMediumPosInc(b *testing.B) {
|
|
n := MEDIUM_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
alpha := 2.4
|
|
benchmarkDscal(b, n, alpha, x, incX)
|
|
}
|
|
|
|
func BenchmarkDscalLargeUnitaryInc(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
alpha := 2.4
|
|
benchmarkDscal(b, n, alpha, x, incX)
|
|
}
|
|
|
|
func BenchmarkDscalLargePosInc(b *testing.B) {
|
|
n := LARGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
alpha := 2.4
|
|
benchmarkDscal(b, n, alpha, x, incX)
|
|
}
|
|
|
|
func BenchmarkDscalHugeUnitaryInc(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := 1
|
|
x := randomSlice(n, incX)
|
|
alpha := 2.4
|
|
benchmarkDscal(b, n, alpha, x, incX)
|
|
}
|
|
|
|
func BenchmarkDscalHugePosInc(b *testing.B) {
|
|
n := HUGE_SLICE
|
|
incX := posInc1
|
|
x := randomSlice(n, incX)
|
|
alpha := 2.4
|
|
benchmarkDscal(b, n, alpha, x, incX)
|
|
}
|
|
|
|
/* ------------------ */
|