basic vector primitives

Author: unixpickle

creator32.go

@@ -0,0 +1,44 @@
+package cudavec
+
+import "github.com/unixpickle/anyvec"
+
+// A Creator32 is an anyvec.Creator for vectors using
+// float32 numerics and []float32 slice types.
+type Creator32 struct {
+	Handle *Handle
+}
+
+// MakeNumeric creates a float32.
+func (c *Creator32) MakeNumeric(x float64) anyvec.Numeric {
+	return float32(x)
+}
+
+// MakeNumericList creates a []float32.
+func (c *Creator32) MakeNumericList(x []float64) anyvec.NumericList {
+	res := make([]float32, len(x))
+	for i, k := range x {
+		res[i] = float32(k)
+	}
+	return res
+}
+
+// MakeVector creates a zero'd out anyvec.Vector.
+func (c *Creator32) MakeVector(size int) anyvec.Vector {
+	panic("nyi")
+}
+
+// MakeVectorData creates an anyvec.Vector with the
+// specified contents.
+func (c *Creator32) MakeVectorData(dObj anyvec.NumericList) anyvec.Vector {
+	panic("nyi")
+}
+
+// Concat concatenates vectors.
+func (c *Creator32) Concat(v ...anyvec.Vector) anyvec.Vector {
+	panic("nyi")
+}
+
+// MakeMapper creates a mapper.
+func (c *Creator32) MakeMapper(inSize int, table []int) anyvec.Mapper {
+	panic("nyi")
+}

vector32.go

@@ -0,0 +1,83 @@
+package cudavec
+
+import (
+	"github.com/unixpickle/anyvec"
+	"github.com/unixpickle/cuda"
+)
+
+type vector32 struct {
+	creator *Creator32
+	size    int
+
+	// May be nil for lazy evaluations.
+	buffer cuda.Buffer
+}
+
+func (v *vector32) Creator() anyvec.Creator {
+	return v.creator
+}
+
+func (v *vector32) Len() int {
+	return v.size
+}
+
+func (v *vector32) Data() anyvec.NumericList {
+	res := make([]float32, v.Len())
+	v.runSync(func() error {
+		if v.buffer != nil {
+			return cuda.ReadBuffer(res, v.buffer)
+		}
+		return nil
+	})
+	return res
+}
+
+func (v *vector32) SetData(d anyvec.NumericList) {
+	slice := d.([]float32)
+	if len(slice) > v.Len() {
+		panic("index out of bounds")
+	}
+	v.runSync(func() error {
+		if err := v.lazyInit(len(slice) < v.Len()); err != nil {
+			return err
+		}
+		return cuda.WriteBuffer(v.buffer, slice)
+	})
+}
+
+func (v *vector32) Scale(s anyvec.Numeric) {
+	v.run(func() error {
+		if v.buffer == nil {
+			return nil
+		}
+		return v.creator.Handle.blas.Sscal(v.Len(), s.(float32), v.buffer, 1)
+	})
+}
+
+func (v *vector32) run(f func() error) <-chan error {
+	return v.creator.Handle.context.Run(func() error {
+		if err := f(); err != nil {
+			panic(err)
+		}
+		return nil
+	})
+}
+
+func (v *vector32) runSync(f func() error) {
+	<-v.run(f)
+}
+
+func (v *vector32) lazyInit(clear bool) error {
+	if v.buffer != nil {
+		return nil
+	}
+	var err error
+	v.buffer, err = cuda.AllocBuffer(v.creator.Handle.allocator, uintptr(v.Len())*4)
+	if err != nil {
+		return err
+	}
+	if clear {
+		return cuda.ClearBuffer(v.buffer)
+	}
+	return nil
+}