Пример #1
0
func TestArrayCopy(test *testing.T) {
	runtime.LockOSThread()
	// fail test on panic, do not crash
	//defer func() {
	//	if err := recover(); err != nil {
	//		test.Error(err)
	//	}
	//}()

	size := []int{4, 8, 16}
	host1, host2 := host.NewArray(3, size), host.NewArray(3, size)
	dev1, dev2 := NewArray(3, size), NewArray(3, size)
	defer dev1.Free()
	defer dev2.Free()

	l1 := host1.List
	for i := range l1 {
		l1[i] = float64(i)
	}

	dev1.CopyFromHost(host1)
	dev2.CopyFromDevice(dev1)
	dev2.CopyToHost(host2)

	l2 := host2.List
	for i := range l1 {
		if l2[i] != float64(i) {
			if !test.Failed() {
				test.Error("expected", i, "got:", l2[i])
			}
		}
	}
}
Пример #2
0
// Set the multiplier of a MASK or the value of a VALUE
func (q *Quant) SetValue(val []float64) {
	//Debug("SetValue", q.name, val)
	//~ checkKinds(q, MASK, VALUE)
	checkComp(q, len(val))
	if q.kind == MASK || q.kind == VALUE {
		for i, v := range val {
			q.multiplier[i] = v
		}
	} else if q.kind == FIELD {
		q.multiplier = ones(q.nComp)
		// use q.Buffer instead?
		tempField := host.NewArray(q.nComp, q.array.Size3D())
		for c := 0; c < q.nComp; c++ {
			for i := 0; i < q.array.Size3D()[X]; i++ {
				for j := 0; j < q.array.Size3D()[Y]; j++ {
					for k := 0; k < q.array.Size3D()[Z]; k++ {
						tempField.Array[c][i][j][k] = float64(val[c])
					}
				}
			}
		}
		q.SetField(tempField)
		// not sure whenever tempBuffer will be destroyed by the GC?
	} else {
		panic(InputErr(q.name + " is not " + MASK.String() + " or " + FIELD.String() + " or " + VALUE.String() + " but " + q.kind.String()))
	}

	q.Verify()
	q.Invalidate() //!
}
Пример #3
0
func genWindow(size []int) *host.Array {
	window := host.NewArray(1, size)
	for i := 0; i < size[0]; i++ {
		val0 := 1.0
		if size[0] > 16 {
			arg0 := float64(i) / float64(size[0]-1)
			val0 = gauss(arg0, 0.4)
		}
		for j := 0; j < size[1]; j++ {
			val1 := 1.0
			if size[1] > 16 {
				arg1 := float64(j) / float64(size[1]-1)
				val1 = gauss(arg1, 0.4)
			}
			for k := 0; k < size[2]; k++ {
				val2 := 1.0
				if size[2] > 16 {
					arg2 := float64(k) / float64(size[2]-1)
					val2 = gauss(arg2, 0.4)
				}
				window.Array[0][i][j][k] = float64(val0 * val1 * val2)
			}
		}

	}
	return window
}
Пример #4
0
// Converts a json vector array to a host.Array.
// Also swaps XYZ - ZYX convention
// TODO: works only for 4D vector arrays
func jsonToHostArray(v interface{}) *host.Array {
	defer func() {
		err := recover()
		if err != nil {
			panic(IOErr(fmt.Sprint("Error parsing json array: ", ShortPrint(v), "\ncause: ", err)))
		}
	}()

	err := false
	// determine array size as {len(v), len(v[0]), len(v[0][0]), ...}
	var size [4]int
	v2 := v
	for i := range size {
		if arr, ok := v2.([]interface{}); ok {
			size[i] = len(arr)
			if size[i] == 0 {
				err = true
				break
			}
			v2 = arr[0]
		} else {
			err = true
			break
		}
	}

	if err {
		panic(IOErr(fmt.Sprint("Array with invalid size:", ShortPrint(v))))
	}

	size3D := size[1:]
	arr := host.NewArray(size[0], []int{size3D[X], size3D[Y], size3D[Z]})
	a := arr.Array
	va := v.([]interface{})
	for c := range a {
		va_c := va[c].([]interface{})
		for i := range a[c] {
			va_ci := va_c[i].([]interface{})
			for j := range a[c][i] {
				va_cij := va_ci[j].([]interface{})
				for k := range a[c][i][j] {
					a[c][i][j][k] = float64(va_cij[k].(float64)) // convert XYZ-ZYX, works only for 3D
				}
			}
		}
	}
	runtime.GC() // a LOT of garbage has been made
	return convertXYZ(arr)
}
Пример #5
0
func BenchmarkReduceSumCPU(b *testing.B) {

	b.StopTimer()

	size := bigsize()
	a := host.NewArray(3, size)
	b.SetBytes(int64(a.Len()) * SIZEOF_FLOAT)
	b.StartTimer()
	for i := 0; i < b.N; i++ {

		var cpusum float64
		for _, num := range a.List {
			cpusum += float64(num)
		}

	}
}
Пример #6
0
// Should init to zeros
func TestArrayInit(test *testing.T) {
	runtime.LockOSThread()
	// fail test on panic, do not crash
	//defer func() {
	//	if err := recover(); err != nil {
	//		test.Error(err)
	//	}
	//}()

	size := []int{4, 8, 16}
	host1 := host.NewArray(3, size)
	dev1 := NewArray(3, size)
	defer dev1.Free()
	fmt.Printf("%+v\n", dev1)

	if dev1.Len() != 3*Prod(size) {
		if !test.Failed() {
			test.Error("Len(): ", dev1.Len(), "expected: ", 3*Prod(size))
		}
	}

	if dev1.PartLen4D() != 3*Prod(size)/NDevice() {
		test.Fail()
	}

	if dev1.PartLen3D() != Prod(size)/NDevice() {
		test.Fail()
	}

	l1 := host1.List
	for i := range l1 {
		l1[i] = float64(i)
	}

	dev1.CopyToHost(host1)
	//host1.CopyFromDevice(dev1)

	for i := range l1 {
		if l1[i] != 0 {
			if !test.Failed() {
				test.Error(l1[i], "!=0")
			}
		}
	}
}
Пример #7
0
// Convert mumax's internal ZYX convention to userspace XYZ.
func convertXYZ(arr *host.Array) *host.Array {
	s := arr.Size3D
	n := arr.NComp()
	a := arr.Array
	transp := host.NewArray(n, []int{s[Z], s[Y], s[X]})
	t := transp.Array
	for c := 0; c < n; c++ {
		for i := 0; i < s[X]; i++ {
			for j := 0; j < s[Y]; j++ {
				for k := 0; k < s[Z]; k++ {
					t[(n-1)-c][k][j][i] = a[c][i][j][k]
				}
			}
		}
	}
	runtime.GC() // a LOT of garbage has been made
	return transp
}
Пример #8
0
// Returns a new host array of size size2, re-sized from the input array by nearest-neighbor interpolation.
func Resample(in *host.Array, size2 []int) *host.Array {
	Assert(len(size2) == 3)

	out := host.NewArray(in.NComp(), size2)
	out_a := out.Array
	in_a := in.Array
	size1 := in.Size3D
	for c := range out_a {
		for i := range out_a[c] {
			i1 := (i * size1[X]) / size2[X]
			for j := range out_a[0][i] {
				j1 := (j * size1[Y]) / size2[Y]
				for k := range out_a[0][i][j] {
					k1 := (k * size1[Z]) / size2[Z]
					out_a[c][i][j][k] = in_a[c][i1][j1][k1]
				}
			}
		}
	}
	return out
}
Пример #9
0
func ReadPNG(fname string) *host.Array {
	in, err := os.Open(fname)
	CheckIO(err)

	img, err2 := png.Decode(in)
	CheckIO(err2)

	width := img.Bounds().Max.X
	height := img.Bounds().Max.Y

	inside := host.NewArray(1, []int{1, height, width})

	for i := 0; i < height; i++ {
		for j := 0; j < width; j++ {
			r, g, b, _ := img.At(j, height-1-i).RGBA()
			if r+g+b < (0xFFFF*3)/2 {
				inside.Array[0][0][i][j] = 1
			}
		}
	}
	return inside
}
Пример #10
0
// Extract real or imaginary parts, copy them from src to dst.
// In the meanwhile, check if the other parts are nearly zero
// and scale the kernel to compensate for unnormalized FFTs.
// real_imag = 0: real parts
// real_imag = 1: imag parts
func extract(src *host.Array) *host.Array {

	sx := src.Size3D[X]/2 + 1 // antisymmetric
	sy := src.Size3D[Y]/2 + 1 // antisymmetric
	sz := src.Size3D[Z] / 2   // only real parts should be stored, the value of the imaginary part should stay below the zero threshould
	dst := host.NewArray(src.NComp(), []int{sx, sy, sz})

	dstArray := dst.Array
	srcArray := src.Array

	// Normally, the FFT'ed kernel is purely real because of symmetry,
	// so we only store the real parts...
	maxImg := float64(0.)
	maxReal := float64(0.)
	for c := range dstArray {
		for k := range dstArray[c] {
			for j := range dstArray[c][k] {
				for i := range dstArray[c][k][j] {
					dstArray[c][k][j][i] = srcArray[c][k][j][2*i]
					if Abs32(srcArray[c][k][j][2*i+1]) > maxImg {
						maxImg = Abs32(srcArray[c][k][j][2*i+1])
					}
					if Abs32(srcArray[c][k][j][2*i+0]) > maxReal {
						maxReal = Abs32(srcArray[c][k][j][2*i+0])
					}
				}
			}
		}
	}
	// ...however, we check that the imaginary parts are nearly zero,
	// just to be sure we did not make a mistake during kernel creation.
	Debug("FFT Kernel max real part", 0, ":", maxReal)
	Debug("FFT Kernel max imag part", 1, ":", maxImg)
	Debug("FFT Kernel max imag/real part=", maxImg/maxReal)
	if maxImg/maxReal > 1e-12 { // TODO: is this reasonable?
		panic(BugF("FFT Kernel max bad/good part=", maxImg/maxReal))
	}
	return dst
}
Пример #11
0
// DEBUG: Make a freshly allocated copy on the host.
func (src *Array) LocalCopy() *host.Array {
	dst := host.NewArray(src.NComp(), src.Size3D())
	src.CopyToHost(dst)
	return dst
}