Fixed Engine stuff. Also Go 1.14 fixed (#61)

* Fixed Engine stuff. Also Go 1.14 fixed

* Fixed Travis (Gonum only supports the two most recent versions of Go)

.travis.yml

@@ -5,10 +5,8 @@ branches:
   only:
     - master
 go:
-  - 1.10.x
-  - 1.11.x
-  - 1.12.x
   - 1.13.x
+  - 1.14.x
   - tip
 
 env:

consopt.go

@@ -140,6 +140,7 @@ func FromScalar(x interface{}, argMask ...[]bool) ConsOpt {
 // Memory must be manually managed by the caller.
 // Tensors called with this construction option will not be returned to any pool - rather, all references to the pointers will be null'd.
 // Use with caution.
+//go:nocheckptr
 func FromMemory(ptr uintptr, memsize uintptr) ConsOpt {
 	f := func(t Tensor) {
 		switch tt := t.(type) {

defaultengine_linalg.go

@@ -355,7 +355,7 @@ func (e StdEng) SVD(a Tensor, uv, full bool) (s, u, v Tensor, err error) {
 
 	// extract values
 	var um, vm mat.Dense
-	s = recycledDense(Float64, Shape{MinInt(t.Shape()[0], t.Shape()[1])})
+	s = recycledDense(Float64, Shape{MinInt(t.Shape()[0], t.Shape()[1])}, WithEngine(e))
 	svd.Values(s.Data().([]float64))
 	if uv {
 		svd.UTo(&um)

defaultengine_matop_misc.go

@@ -33,7 +33,7 @@ func (StdEng) denseRepeat(t DenseTensor, axis int, repeats []int) (retVal DenseT
 		axis = 0
 	}
 
-	d := recycledDense(t.Dtype(), newShape)
+	d := recycledDense(t.Dtype(), newShape, WithEngine(StdEng{}))
 
 	var outers int
 	if t.IsScalar() {
@@ -155,7 +155,7 @@ func (e StdEng) denseConcat(a DenseTensor, axis int, Ts []DenseTensor) (DenseTen
 		return nil, errors.Wrap(err, "Unable to find new shape that results from concatenation")
 	}
 
-	retVal := recycledDense(a.Dtype(), newShape)
+	retVal := recycledDense(a.Dtype(), newShape, WithEngine(e))
 	if isMasked {
 		retVal.makeMask()
 	}

dense_linalg.go

@@ -88,7 +88,7 @@ func (t *Dense) MatVecMul(other Tensor, opts ...FuncOpt) (retVal *Dense, err err
 	}
 
 	if retVal == nil {
-		retVal = recycledDense(t.t, expectedShape)
+		retVal = recycledDense(t.t, expectedShape, WithEngine(t.e))
 		if t.o.IsColMajor() {
 			AsFortran(nil)(retVal)
 		}
@@ -137,7 +137,7 @@ func (t *Dense) MatMul(other Tensor, opts ...FuncOpt) (retVal *Dense, err error)
 	}
 
 	if retVal == nil {
-		retVal = recycledDense(t.t, expectedShape)
+		retVal = recycledDense(t.t, expectedShape, WithEngine(t.e))
 		if t.o.IsColMajor() {
 			AsFortran(nil)(retVal)
 		}
@@ -176,7 +176,7 @@ func (t *Dense) Outer(other Tensor, opts ...FuncOpt) (retVal *Dense, err error)
 	}
 
 	if retVal == nil {
-		retVal = recycledDense(t.t, expectedShape)
+		retVal = recycledDense(t.t, expectedShape, WithEngine(t.e))
 		if t.o.IsColMajor() {
 			AsFortran(nil)(retVal)
 		}

dense_matop.go

@@ -73,7 +73,7 @@ func (t *Dense) SafeT(axes ...int) (retVal *Dense, err error) {
 		}
 	}
 
-	retVal = recycledDense(t.t, Shape{t.len()})
+	retVal = recycledDense(t.t, Shape{t.len()}, WithEngine(t.e))
 	copyDense(retVal, t)
 
 	retVal.e = t.e

dense_test.go

@@ -5,7 +5,6 @@ import (
 	"testing"
 	"testing/quick"
 	"time"
-	"unsafe"
 
 	"github.com/stretchr/testify/assert"
 )
@@ -90,24 +89,6 @@ func TestFromScalar(t *testing.T) {
 	assert.Equal(t, []float64{3.14}, data)
 }
 
-func TestFromMemory(t *testing.T) {
-	// dummy memory - this could be an externally malloc'd memory, or a mmap'ed file.
-	// but here we're just gonna let Go manage memory.
-	s := make([]float64, 100)
-	ptr := uintptr(unsafe.Pointer(&s[0]))
-	size := uintptr(100 * 8)
-
-	T := New(Of(Float32), WithShape(50, 4), FromMemory(ptr, size))
-	if len(T.Float32s()) != 200 {
-		t.Error("expected 200 Float32s")
-	}
-	assert.Equal(t, make([]float32, 200), T.Data())
-	assert.True(t, T.IsManuallyManaged(), "Unamanged %v |%v | q: %v", ManuallyManaged, T.flag, (T.flag>>ManuallyManaged)&MemoryFlag(1))
-
-	fail := func() { New(FromMemory(ptr, size), Of(Float32)) }
-	assert.Panics(t, fail, "Expected bad New() call to panic")
-}
-
 func Test_recycledDense(t *testing.T) {
 	T := recycledDense(Float64, ScalarShape())
 	assert.Equal(t, float64(0), T.Data())

dense_views.go

@@ -9,7 +9,7 @@ func (t *Dense) Materialize() Tensor {
 		return t
 	}
 
-	retVal := recycledDense(t.t, t.shape.Clone())
+	retVal := recycledDense(t.t, t.shape.Clone(), WithEngine(t.e))
 	copyDenseIter(retVal, t, nil, nil)
 	retVal.e = t.e
 	retVal.oe = t.oe

known_race_test.go

@@ -0,0 +1,33 @@
+// +build !race
+
+package tensor
+
+import (
+	"testing"
+	"unsafe"
+
+	"github.com/stretchr/testify/assert"
+)
+
+// This test will fail the `go test -race`.
+//
+// This is because FromMemory() will use uintptr in a way that is incorrect according to the checkptr directive of Go 1.14+
+//
+// Though it's incorrect, it's the only way to use heterogenous, readable memory (i.e. CUDA).
+func TestFromMemory(t *testing.T) {
+	// dummy memory - this could be an externally malloc'd memory, or a mmap'ed file.
+	// but here we're just gonna let Go manage memory.
+	s := make([]float64, 100)
+	ptr := uintptr(unsafe.Pointer(&s[0]))
+	size := uintptr(100 * 8)
+
+	T := New(Of(Float32), WithShape(50, 4), FromMemory(ptr, size))
+	if len(T.Float32s()) != 200 {
+		t.Error("expected 200 Float32s")
+	}
+	assert.Equal(t, make([]float32, 200), T.Data())
+	assert.True(t, T.IsManuallyManaged(), "Unamanged %v |%v | q: %v", ManuallyManaged, T.flag, (T.flag>>ManuallyManaged)&MemoryFlag(1))
+
+	fail := func() { New(FromMemory(ptr, size), Of(Float32)) }
+	assert.Panics(t, fail, "Expected bad New() call to panic")
+}

sparse.go

@@ -331,7 +331,7 @@ func (t *CS) Dense() *Dense {
 		// use
 	}
 
-	d := recycledDense(t.t, t.Shape().Clone())
+	d := recycledDense(t.t, t.Shape().Clone(), WithEngine(t.e))
 	if t.o.IsColMajor() {
 		for i := 0; i < len(t.indptr)-1; i++ {
 			for j := t.indptr[i]; j < t.indptr[i+1]; j++ {