package/gonum
1
0
Fork 0
mirror of https://github.com/gonum/gonum.git synced 2025-10-23 23:23:15 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

asm/f32: Remove GC calls, renaming fom PR comments

Browse Source
This commit is contained in:
Chad Kunde
2016-06-26 15:06:25 -07:00
parent 4b6ac24240
commit 3e070aadf3
2 changed files with 46 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
asm/f32/bench_test.go
View File

@@ -4,10 +4,7 @@
package f32 package f32
import ( import "testing"
"runtime"
"testing"
)
var ( var (
a = float32(2) a = float32(2)
@@ -25,13 +22,9 @@ func init() {
func benchaxpyu(t *testing.B, n int, f func(a float32, x, y []float32)) { func benchaxpyu(t *testing.B, n int, f func(a float32, x, y []float32)) {
x, y := x[:n], y[:n] x, y := x[:n], y[:n]
t.ResetTimer()
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
f(a, x, y) f(a, x, y)
} }
t.StopTimer()
runtime.GC()
} }
func naiveaxpyu(a float32, x, y []float32) { func naiveaxpyu(a float32, x, y []float32) {
@@ -66,13 +59,9 @@ func BenchmarkLF32AxpyUnitary50000(t *testing.B) { benchaxpyu(t, 50000, naiveaxp
func benchaxpyut(t *testing.B, n int, f func(d []float32, a float32, x, y []float32)) { func benchaxpyut(t *testing.B, n int, f func(d []float32, a float32, x, y []float32)) {
x, y, z := x[:n], y[:n], z[:n] x, y, z := x[:n], y[:n], z[:n]
t.ResetTimer()
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
f(z, a, x, y) f(z, a, x, y)
} }
t.StopTimer()
runtime.GC()
} }
func naiveaxpyut(d []float32, a float32, x, y []float32) { func naiveaxpyut(d []float32, a float32, x, y []float32) {
@@ -111,13 +100,9 @@ func benchaxpyinc(t *testing.B, ln, t_inc int, f func(alpha float32, x, y []floa
if t_inc < 0 { if t_inc < 0 {
idx = (-ln + 1) * t_inc idx = (-ln + 1) * t_inc
} }
t.ResetTimer()
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
f(1, x, y, n, inc, inc, uintptr(idx), uintptr(idx)) f(1, x, y, n, inc, inc, uintptr(idx), uintptr(idx))
} }
t.StopTimer()
runtime.GC()
} }
func naiveaxpyinc(alpha float32, x, y []float32, n, incX, incY, ix, iy uintptr) { func naiveaxpyinc(alpha float32, x, y []float32, n, incX, incY, ix, iy uintptr) {
@@ -208,13 +193,9 @@ func benchaxpyincto(t *testing.B, ln, t_inc int, f func(dst []float32, incDst, i
if t_inc < 0 { if t_inc < 0 {
idx = (-ln + 1) * t_inc idx = (-ln + 1) * t_inc
} }
t.ResetTimer()
for i := 0; i < t.N; i++ { for i := 0; i < t.N; i++ {
f(z, inc, uintptr(idx), 1, x, y, n, inc, inc, uintptr(idx), uintptr(idx)) f(z, inc, uintptr(idx), 1, x, y, n, inc, inc, uintptr(idx), uintptr(idx))
} }
t.StopTimer()
runtime.GC()
} }
func naiveaxpyincto(dst []float32, incDst, idst uintptr, alpha float32, x, y []float32, n, incX, incY, ix, iy uintptr) { func naiveaxpyincto(dst []float32, incDst, idst uintptr, alpha float32, x, y []float32, n, incX, incY, ix, iy uintptr) {

89
asm/f32/stubs_test.go
View File

@@ -81,7 +81,7 @@ func guardVector(v []float32, g float32, g_ln int) (guarded []float32) {
return guarded return guarded
} }
func validGuard(v []float32, g float32, g_ln int) bool { func isValidGuard(v []float32, g float32, g_ln int) bool {
for i := 0; i < g_ln; i++ { for i := 0; i < g_ln; i++ {
if v[i] != g || v[len(v)-1-i] != g { if v[i] != g || v[len(v)-1-i] != g {
return false return false
@@ -96,46 +96,48 @@ func same(x, y float32) bool {
} }
func TestAxpyUnitary(t *testing.T) { func TestAxpyUnitary(t *testing.T) {
var x_gd, y_gd float32 = 1, 1
for j, v := range tests { for j, v := range tests {
g_ln := 4 + j%2 xg_ln, yg_ln := 4+j%2, 4+j%3
v.x, v.y = guardVector(v.x, 1, g_ln), guardVector(v.y, 1, g_ln) v.x, v.y = guardVector(v.x, x_gd, xg_ln), guardVector(v.y, y_gd, yg_ln)
x, y := v.x[g_ln:len(v.x)-g_ln], v.y[g_ln:len(v.y)-g_ln] x, y := v.x[xg_ln:len(v.x)-xg_ln], v.y[yg_ln:len(v.y)-yg_ln]
AxpyUnitary(v.a, x, y) AxpyUnitary(v.a, x, y)
for i := range v.ex { for i := range v.ex {
if !same(y[i], v.ex[i]) { if !same(y[i], v.ex[i]) {
t.Error("Test", j, "Unexpected result at", i, "Got:", int(y[i]), "Expected:", v.ex[i]) t.Errorf("Test %d Unexpected result at %d Got: %v Expected: %v", j, i, y[i], v.ex[i])
} }
} }
if !validGuard(v.x, 1, g_ln) { if !isValidGuard(v.x, x_gd, xg_ln) {
t.Error("Test", j, "Guard violated in x vector", v.x[:g_ln], v.x[len(v.x)-g_ln:]) t.Errorf("Test %d Guard violated in x vector %v %v", j, v.x[:xg_ln], v.x[len(v.x)-xg_ln:])
} }
if !validGuard(v.y, 1, g_ln) { if !isValidGuard(v.y, y_gd, yg_ln) {
t.Error("Test", j, "Guard violated in y vector", v.y[:g_ln], v.y[len(v.x)-g_ln:]) t.Errorf("Test %d Guard violated in y vector %v %v", j, v.y[:yg_ln], v.y[len(v.y)-yg_ln:])
} }
} }
} }
func TestAxpyUnitaryTo(t *testing.T) { func TestAxpyUnitaryTo(t *testing.T) {
var x_gd, y_gd, dst_gd float32 = 1, 1, 0
for j, v := range tests { for j, v := range tests {
g_ln := 4 + j%2 xg_ln, yg_ln := 4+j%2, 4+j%3
v.x, v.y = guardVector(v.x, 1, g_ln), guardVector(v.y, 1, g_ln) v.x, v.y = guardVector(v.x, x_gd, xg_ln), guardVector(v.y, y_gd, yg_ln)
v.dst = guardVector(v.dst, 0, g_ln) v.dst = guardVector(v.dst, dst_gd, xg_ln)
x, y := v.x[g_ln:len(v.x)-g_ln], v.y[g_ln:len(v.y)-g_ln] x, y := v.x[xg_ln:len(v.x)-xg_ln], v.y[yg_ln:len(v.y)-yg_ln]
dst := v.dst[g_ln : len(v.dst)-g_ln] dst := v.dst[xg_ln : len(v.dst)-xg_ln]
AxpyUnitaryTo(dst, v.a, x, y) AxpyUnitaryTo(dst, v.a, x, y)
for i := range v.ex { for i := range v.ex {
if !same(v.ex[i], dst[i]) { if !same(v.ex[i], dst[i]) {
t.Error("Test", j, "Unexpected result at", i, "Got:", dst[i], "Expected:", v.ex[i]) t.Errorf("Test %d Unexpected result at %d Got: %v Expected: %v", j, i, dst[i], v.ex[i])
} }
} }
if !validGuard(v.x, 1, g_ln) { if !isValidGuard(v.x, x_gd, xg_ln) {
t.Error("Test", j, "Guard violated in x vector", v.x[:g_ln], v.x[len(v.x)-g_ln:]) t.Errorf("Test %d Guard violated in x vector %v %v", j, v.x[:xg_ln], v.x[len(v.x)-xg_ln:])
} }
if !validGuard(v.y, 1, g_ln) { if !isValidGuard(v.y, y_gd, yg_ln) {
t.Error("Test", j, "Guard violated in y vector", v.y[:g_ln], v.y[len(v.x)-g_ln:]) t.Errorf("Test %d Guard violated in y vector %v %v", j, v.y[:yg_ln], v.y[len(v.y)-yg_ln:])
} }
if !validGuard(v.dst, 0, g_ln) { if !isValidGuard(v.dst, dst_gd, xg_ln) {
t.Error("Test", j, "Guard violated in x vector", v.x[:g_ln], v.x[len(v.x)-g_ln:]) t.Errorf("Test %d Guard violated in dst vector %v %v", j, v.dst[:xg_ln], v.dst[len(v.dst)-xg_ln:])
} }
} }
} }
@@ -158,7 +160,7 @@ func guardIncVector(v []float32, g float32, incV uintptr, g_ln int) (guarded []f
return guarded return guarded
} }
func validIncGuard(t *testing.T, v []float32, g float32, incV uintptr, g_ln int) { func checkValidIncGuard(t *testing.T, v []float32, g float32, incV uintptr, g_ln int) {
inc := int(incV) inc := int(incV)
s_ln := len(v) - 2*g_ln s_ln := len(v) - 2*g_ln
for i := range v { for i := range v {
@@ -166,51 +168,50 @@ func validIncGuard(t *testing.T, v []float32, g float32, incV uintptr, g_ln int)
case same(v[i], g): case same(v[i], g):
// Correct value // Correct value
case i < g_ln: case i < g_ln:
t.Error("Front guard violated at", i, v[:g_ln]) t.Errorf("Front guard violated at %d %v", i, v[:g_ln])
case i > g_ln+s_ln: case i > g_ln+s_ln:
t.Error("Back guard violated at", i-g_ln-s_ln, v[g_ln+s_ln:]) t.Errorf("Back guard violated at %d %v", i-g_ln-s_ln, v[g_ln+s_ln:])
case (i-g_ln)%inc == 0 && (i-g_ln)/inc < len(v): case (i-g_ln)%inc == 0 && (i-g_ln)/inc < len(v):
// Ignore input values
default: default:
t.Error("Internal guard violated at", i-g_ln, v[g_ln:g_ln+s_ln]) t.Errorf("Internal guard violated at %d %v", i-g_ln, v[g_ln:g_ln+s_ln])
} }
} }
} }
func TestAxpyInc(t *testing.T) { func TestAxpyInc(t *testing.T) {
var x_gd, y_gd float32 = 1, 1
for j, v := range tests { for j, v := range tests {
g_ln := 4 + j%2 xg_ln, yg_ln := 4+j%2, 4+j%3
v.x, v.y = guardIncVector(v.x, 1, v.incX, g_ln), guardIncVector(v.y, 1, v.incY, g_ln) v.x, v.y = guardIncVector(v.x, x_gd, uintptr(v.incX), xg_ln), guardIncVector(v.y, y_gd, uintptr(v.incY), yg_ln)
x, y := v.x[g_ln:len(v.x)-g_ln], v.y[g_ln:len(v.y)-g_ln] x, y := v.x[xg_ln:len(v.x)-xg_ln], v.y[yg_ln:len(v.y)-yg_ln]
AxpyInc(v.a, x, y, uintptr(len(v.ex)), v.incX, v.incY, v.ix, v.iy) AxpyInc(v.a, x, y, uintptr(len(v.ex)), v.incX, v.incY, v.ix, v.iy)
for i := range v.ex { for i := range v.ex {
if !same(y[i*int(v.incY)], v.ex[i]) { if !same(y[i*int(v.incY)], v.ex[i]) {
t.Error("Test", j, "Unexpected result at", i, "Got:", y[i*int(v.incY)], "Expected:", v.ex[i]) t.Errorf("Test %d Unexpected result at %d Got: %v Expected: %v", j, i, y[i*int(v.incY)], v.ex[i])
t.Error("Result:", y)
t.Error("Expect:", v.ex)
} }
} }
validIncGuard(t, v.x, 1, v.incX, g_ln) checkValidIncGuard(t, v.x, x_gd, uintptr(v.incX), xg_ln)
validIncGuard(t, v.y, 1, v.incY, g_ln) checkValidIncGuard(t, v.y, y_gd, uintptr(v.incY), yg_ln)
} }
} }
func TestAxpyIncTo(t *testing.T) { func TestAxpyIncTo(t *testing.T) {
var x_gd, y_gd, dst_gd float32 = 1, 1, 0
for j, v := range tests { for j, v := range tests {
g_ln := 4 + j%2 xg_ln, yg_ln := 4+j%2, 4+j%3
v.x, v.y = guardIncVector(v.x, 1, v.incX, g_ln), guardIncVector(v.y, 1, v.incY, g_ln) v.x, v.y = guardIncVector(v.x, x_gd, uintptr(v.incX), xg_ln), guardIncVector(v.y, y_gd, uintptr(v.incY), yg_ln)
v.dst = guardIncVector(v.dst, 0, v.incDst, g_ln) v.dst = guardIncVector(v.dst, dst_gd, uintptr(v.incDst), xg_ln)
x, y := v.x[g_ln:len(v.x)-g_ln], v.y[g_ln:len(v.y)-g_ln] x, y := v.x[xg_ln:len(v.x)-xg_ln], v.y[yg_ln:len(v.y)-yg_ln]
dst := v.dst[g_ln : len(v.dst)-g_ln] dst := v.dst[xg_ln : len(v.dst)-xg_ln]
AxpyIncTo(dst, v.incDst, v.idst, v.a, x, y, uintptr(len(v.ex)), v.incX, v.incY, v.ix, v.iy) AxpyIncTo(dst, v.incDst, v.idst, v.a, x, y, uintptr(len(v.ex)), v.incX, v.incY, v.ix, v.iy)
for i := range v.ex { for i := range v.ex {
if !same(dst[i*int(v.incDst)], v.ex[i]) { if !same(dst[i*int(v.incDst)], v.ex[i]) {
t.Error("Test", j, "Unexpected result at", i, "Got:", dst[i*int(v.incDst)], "Expected:", v.ex[i]) t.Errorf("Test %d Unexpected result at %d Got: %v Expected: %v", j, i, dst[i*int(v.incDst)], v.ex[i])
t.Error(v.dst)
t.Error(v.ex)
} }
} }
validIncGuard(t, v.x, 1, v.incX, g_ln) checkValidIncGuard(t, v.x, x_gd, uintptr(v.incX), xg_ln)
validIncGuard(t, v.y, 1, v.incY, g_ln) checkValidIncGuard(t, v.y, y_gd, uintptr(v.incY), yg_ln)
validIncGuard(t, v.dst, 0, v.incDst, g_ln) checkValidIncGuard(t, v.dst, dst_gd, uintptr(v.incDst), xg_ln)
} }
} }