A[:, :] = 1
x[:] = 1
y[:] = 0
# Regression
regression = np.matmul(np.transpose(A), x) + y
#############################################
# Run DaCe program
if args["specialize"]:
gemv(A=A, x=x, y=x)
else:
gemv(A=A, M=M, x=x, y=y)
residual = np.linalg.norm(y - regression) / dace.eval(N * M)
print("Residual:", residual)
diff = np.abs(y - regression)
wrong_elements = np.transpose(np.nonzero(diff >= 0.01))
highest_diff = np.max(diff)
print("==== Program end ====")
if residual >= 0.01 or highest_diff >= 0.01:
print("Verification failed!")
print("Residual: {}".format(residual))
print("Incorrect elements: {} / {}".format(wrong_elements.shape[0],
dace.eval(N * M)))
print("Highest difference: {}".format(highest_diff))
print("** Result:\n", y)
print("** Reference:\n", regression)
print("Type \"debug\" to enter debugger, "
dace.reduce(lambda a, b: a + b, tmp, C, axis=2, identity=0)
if __name__ == "__main__":
M.set(50)
N.set(20)
K.set(5)
print('Matrix multiplication %dx%dx%d' % (M.get(), N.get(), K.get()))
# Initialize arrays: Randomize A and B, zero C
A[:] = np.random.rand(M.get(), N.get()).astype(dace.float64.type)
B[:] = np.random.rand(N.get(), K.get()).astype(dace.float64.type)
C[:] = dace.float64(0)
D[:] = dace.float64(0)
A_regression = np.ndarray([M.get(), N.get()], dtype=np.float64)
B_regression = np.ndarray([N.get(), K.get()], dtype=np.float64)
C_regression = np.ndarray([M.get(), K.get()], dtype=np.float64)
A_regression[:] = A[:]
B_regression[:] = B[:]
C_regression[:] = C[:]
mapreduce_test_4(A, B, C, D)
np.dot(A_regression, B_regression, C_regression)
diff = np.linalg.norm(C_regression - C) / float(dace.eval(M * K))
print("Difference:", diff)
exit(0 if diff <= 1e-5 else 1)
G_row = dp.ndarray([V + 1], dtype=vtype)
G_col = dp.ndarray([E], dtype=vtype)
G_row[:] = M.indptr
G_col[:] = M.indices
# Regression
result = nx.shortest_path(graph, source=srcnode)
result = [
len(result[v]) - 1 if v in result else INFINITY
for v in range(V.get())
]
regression = True
print('Data loaded')
print('Breadth-First Search E=%d, V=%d' % (dp.eval(E), dp.eval(V)))
# Allocate output arrays
depth = dp.ndarray([V], vtype)
depth[:] = vtype(INFINITY)
sdfg(G_row=G_row, G_col=G_col, depth=depth, srcnode=srcnode, E=E, V=V)
if regression:
print('Comparing results...')
diff = np.linalg.norm(depth - result) / float(dp.eval(V))
print("Difference:", diff)
exit(1 if diff >= 1e-5 else 0)
if args['outfile'] is not None:
print('Saving results...')
N.set(args["N"])
print('Scalar-vector multiplication %d' % (N.get()))
# Initialize arrays: Randomize A and X, zero Y
A = dace.float64(np.random.rand())
X = np.random.rand(N.get()).astype(np.float64)
Y = np.random.rand(N.get()).astype(np.float64)
A_regression = np.float64()
X_regression = np.ndarray([N.get()], dtype=np.float64)
Y_regression = np.ndarray([N.get()], dtype=np.float64)
A_regression = A
X_regression[:] = X[:]
Y_regression[:] = Y[:]
axpy(A, X, Y)
c_axpy = sp.linalg.blas.get_blas_funcs('axpy',
arrays=(X_regression, Y_regression))
if dace.Config.get_bool('profiling'):
dace.timethis('axpy', 'BLAS', dace.eval(2 * N), c_axpy, X_regression,
Y_regression, N.get(), A_regression)
else:
c_axpy(X_regression, Y_regression, N.get(), A_regression)
diff = np.linalg.norm(Y_regression - Y) / float(dace.eval(N))
print("Difference:", diff)
print("==== Program end ====")
exit(0 if diff <= 1e-5 else 1)
print('Matrix addition %dx%d' % (M.get(), N.get()))
# Initialize arrays: Randomize A and B, zero C
A[:] = np.random.rand(M.get(), N.get()).astype(dace.float64.type)
B[:] = np.random.rand(M.get(), N.get()).astype(dace.float64.type)
C[:] = dace.float64(0)
A_regression = np.ndarray([M.get(), N.get()], dtype=np.float64)
B_regression = np.ndarray([M.get(), N.get()], dtype=np.float64)
C_regression = np.ndarray([M.get(), N.get()], dtype=np.float64)
A_regression[:] = A[:]
B_regression[:] = B[:]
C_regression[:] = C[:]
if args["compile-only"]:
dace.compile(mat_add, A, B, C)
else:
mat_add(A, B, C)
if dace.Config.get_bool('profiling'):
dace.timethis('mat_add', contender, dace.eval(2 * N * N * N),
np.dot, A_regression, B_regression, C_regression)
else:
np.add(A_regression, B_regression, C_regression)
diff = np.linalg.norm(C_regression - C) / float(dace.eval(M * N))
print("Difference:", diff)
print("==== Program end ====")
exit(0 if diff <= 1e-5 else 1)
dace.memlet.Memlet.simple(arrays[-2], '4,1,2,1:N-1:2'))
# Copy 9: 2d array to a 3d array with an offset
arrays.append(
state.add_array('A_' + str(len(arrays)), [40, 40], dace.float32))
arrays.append(
state.add_array('A_' + str(len(arrays)), [3, 40, 40], dace.float32))
state.add_edge(
arrays[-2], None, arrays[-1], None,
dace.memlet.Memlet.simple(
arrays[-2], '20:40, 10:30', other_subset_str='2, 10:30, 20:40'))
sdfg.draw_to_file()
array_data = [
np.random.rand(*[dace.eval(s) for s in a.desc(sdfg).shape]).astype(
a.desc(sdfg).dtype.type) for a in arrays
]
args = {anode.label: adata for anode, adata in zip(arrays, array_data)}
args['N'] = N.get()
sdfg(**args)
N = N.get()
diffs = [
np.linalg.norm(array_data[1] - array_data[0][5:10, N - 7:N]) / 5.0 *
7.0,
np.linalg.norm(array_data[3] - array_data[2][4, 1, 1:, 2]) / (N - 1),
np.linalg.norm(array_data[5] - array_data[4]) / 2.0 * 3 * 4 * 5 * 6,
np.linalg.norm(array_data[7] - array_data[6][4, 1, 2, 1:]) / (N - 1),
def makendrange(*args):
result = []
for i in range(0, len(args), 2):
result.append((dace.eval(args[i]), dace.eval(args[i + 1] - 1), 1))
return result
if args["specialize"]:
jacobi(A=A)
else:
jacobi(A=A, H=H, T=T)
# Regression
kernel = np.array([[0, 0.2, 0], [0.2, 0.2, 0.2], [0, 0.2, 0]],
dtype=np.float32)
for i in range(T.get()):
regression = ndimage.convolve(regression,
kernel,
mode='constant',
cval=0.0)
residual = np.linalg.norm(A[2:H.get() - 2, 2:W.get() - 2] -
regression) / dace.eval(H * W)
print("Residual:", residual)
diff = np.abs(A[2:H.get() - 2, 2:W.get() - 2] - regression)
wrong_elements = np.transpose(np.nonzero(diff >= 0.01))
highest_diff = np.max(diff)
print("==== Program end ====")
if residual >= 0.01 or highest_diff >= 0.01:
print("Verification failed!")
print("Residual: {}".format(residual))
print("Incorrect elements: {} / {}".format(wrong_elements.shape[0],
H.get() * W.get()))
print("Highest difference: {}".format(highest_diff))
print("** Result:\n", A[:min(6, H.get()), :min(6, W.get())])
print("** Reference:\n",
regression[:min(4, H.get()), :min(4, W.get())])
dace.reduce(lambda a, b: a + b, tmp, sum)
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("W", type=int, nargs="?", default=128)
parser.add_argument("H", type=int, nargs="?", default=128)
args = vars(parser.parse_args())
A = dace.ndarray([H, W], dtype=dace.float32)
B = dace.ndarray([H, W], dtype=dace.float32)
res = dace.ndarray([1], dtype=dace.float32)
W.set(args["W"])
H.set(args["H"])
print('Map-Reduce Test %dx%d' % (W.get(), H.get()))
A[:] = np.random.rand(H.get(), W.get()).astype(dace.float32.type)
B[:] = dace.float32(0)
res[:] = dace.float32(0)
mapreduce_test(A, B, res)
diff = np.linalg.norm(5 * A - B) / float(dace.eval(H * W))
diff_res = abs((np.sum(B) - res[0])).view(type=np.ndarray)
print("Difference:", diff, diff_res)
print("==== Program end ====")
exit(0 if diff <= 1e-5 and diff_res <= 1 else 1)
# 4D kernel with 5D block
N.set(12)
M.set(3)
K.set(14)
L.set(15)
X.set(1)
Y.set(2)
Z.set(3)
W.set(4)
U.set(5)
dims = tuple(s.get() for s in (N, M, K, L, X, Y, Z, W, U))
outdims = tuple(s.get() for s in (N, M, K, L))
print('High-dimensional GPU kernel test', dims)
A = np.random.randint(10, size=dims).astype(np.uint64)
B = np.zeros(outdims, dtype=np.uint64)
B_regression = np.zeros(outdims, dtype=np.uint64)
# Equivalent python code
for i, j, k, l in dace.ndrange(
makendrange(5, N - 5, 0, M, 7, K - 1, 0, L)):
for a, b, c, d, e in dace.ndrange(
makendrange(0, X, 0, Y, 1, Z, 2, W - 2, 0, U)):
B_regression[i, j, k, l] += A[i, j, k, l, a, b, c, d, e]
highdim(A, B)
diff = np.linalg.norm(B_regression - B) / dace.eval(N * M * K * L)
print('Difference:', diff)
exit(0 if diff <= 1e-5 else 1)
kernel[2, 0] * input[2, 0] + kernel[2, 1] * input[2, 1] +
kernel[2, 2] * input[2, 2])
if __name__ == "__main__":
print("==== Program start ====")
print('Conv2D %dx%d' % (N.get(), N.get()))
A = dace.ndarray([N, N], dtype=dace.float32)
B = dace.ndarray([N, N], dtype=dace.float32)
# Initialize arrays: Randomize A, zero B
A[:] = dace.float32(0)
B[:] = dace.float32(0)
A[1:N.get() - 1, 1:N.get() - 1] = np.random.rand(dace.eval(N - 2),
dace.eval(N - 2)).astype(
dace.float32.type)
regression = np.ndarray([N.get() - 2, N.get() - 2], dtype=np.float32)
regression[:] = A[1:N.get() - 1, 1:N.get() - 1]
#print(A.view(type=np.ndarray))
#############################################
# Run DaCe program
sdfg = stencil3x3.to_sdfg()
sdfg.add_constants({'kernel': KERNEL})
sdfg(A=A, B=B, N=N)
# Regression
b = a
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("W", type=int, nargs="?", default=64)
parser.add_argument("H", type=int, nargs="?", default=64)
args = vars(parser.parse_args())
A = dace.ndarray([H, W], dtype=dace.float32)
B = dace.ndarray([H, W], dtype=dace.float32)
W.set(args["W"])
H.set(args["H"])
print('Transpose %dx%d' % (W.get(), H.get()))
A[:] = np.random.rand(H.get(), W.get()).astype(dace.float32.type)
B[:] = dace.float32(0)
transpose(A, B)
if dace.Config.get_bool('profiling'):
dace.timethis('transpose', 'numpy', dace.eval(H * W), np.transpose, A)
diff = np.linalg.norm(np.transpose(A) - B) / float(dace.eval(H * W))
print("Difference:", diff)
print("==== Program end ====")
exit(0 if diff <= 1e-5 else 1)
# Initialize arrays: Randomize A and X, zero Y
A = dace.float64(np.random.rand())
X[:] = np.random.rand(N.get()).astype(dace.float64.type)
Y[:] = np.random.rand(N.get()).astype(dace.float64.type)
A_regression = np.float64()
X_regression = np.ndarray([N.get()], dtype=np.float64)
Y_regression = np.ndarray([N.get()], dtype=np.float64)
A_regression = A
X_regression[:] = X[:]
Y_regression[:] = Y[:]
if args["compile-only"]:
dace.compile(axpy, A, X, Y)
else:
axpy(A, X, Y)
c_axpy = sp.linalg.blas.get_blas_funcs('axpy',
arrays=(X_regression,
Y_regression))
if dace.Config.get_bool('profiling'):
dace.timethis('axpy', contender, dace.eval(2 * N), c_axpy,
X_regression, Y_regression, N.get(), A_regression)
else:
c_axpy(X_regression, Y_regression, N.get(), A_regression)
diff = np.linalg.norm(Y_regression - Y) / float(dace.eval(N))
print("Difference:", diff)
print("==== Program end ====")
exit(0 if diff <= 1e-5 else 1)
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("W", type=int, nargs="?", default=128)
parser.add_argument("H", type=int, nargs="?", default=128)
parser.add_argument("TH", type=int, nargs="?", default=16)
parser.add_argument("TW", type=int, nargs="?", default=16)
args = vars(parser.parse_args())
A = dace.ndarray([H, W], dtype=dace.float32)
B = dace.ndarray([H, W], dtype=dace.float32)
W.set(args["W"])
H.set(args["H"])
TW.set(args["TW"])
TH.set(args["TH"])
print('Transpose (Tiled) %dx%d (tile size: %dx%d)' %
(W.get(), H.get(), TW.get(), TH.get()))
A[:] = np.random.rand(H.get(), W.get()).astype(dace.float32.type)
B[:] = dace.float32(0)
transpose_tiled(A, B, TW, TH)
diff = np.linalg.norm(np.transpose(A) - B) / float(dace.eval(H * W))
print("Difference:", diff)
print("==== Program end ====")
exit(0 if diff <= 1e-5 else 1)
import numpy as np
import dace
M, N, K = (dace.symbol(name) for name in ['M', 'N', 'K'])
@dace.program
def copy3d(A: dace.float32[M, N, K], B: dace.float32[M, N, K]):
for i in parrange(M):
for j, k in dace.map[0:N, 0:K]:
with dace.tasklet:
a << A[i, j, k]
b >> B[i, j, k]
b = a
if __name__ == '__main__':
[sym.set(24) for sym in [M, N, K]]
A = np.random.rand(M.get(), N.get(), K.get()).astype(np.float32)
B = np.random.rand(M.get(), N.get(), K.get()).astype(np.float32)
copy3d(A, B)
diff = np.linalg.norm(B - A) / dace.eval(M * N)
print('Difference:', diff)
exit(1 if diff >= 1e-5 else 0)
def init():
inp << A[i, j]
out >> B[i, j]
out = inp
for k in range(4):
@dp.tasklet
def do():
inp << A[i, j]
oin << B[i, j]
out >> B[i, j]
out = oin * inp
if __name__ == '__main__':
print('Nested SDFG test (Python syntax)')
# Externals (parameters, symbols)
N.set(64)
input = np.random.rand(N.get(), N.get()).astype(dp.float32.type)
output = np.zeros((N.get(), N.get()), dp.float32.type)
sdfg = sdfg_with_children.to_sdfg()
sdfg(A=input, B=output, N=N)
diff = np.linalg.norm(output - np.power(input, 5)) / dp.eval(N * N)
print("Difference:", diff)
print("==== Program end ====")
exit(0 if diff <= 1e-5 else 1)
C[:] = dace.float64(0)
A_regression = np.ndarray([M.get(), N.get()], dtype=np.float64)
B_regression = np.ndarray([N.get(), K.get()], dtype=np.float64)
C_regression = np.ndarray([M.get(), K.get()], dtype=np.float64)
A_regression[:] = A[:]
B_regression[:] = B[:]
C_regression[:] = C[:]
if args["sdfg"] is not None:
sdfg = dace.SDFG.from_file(args["sdfg"])
gemmfunc = dace.compile(sdfg)
else:
gemmfunc = dace.compile(gemm, A, B, C)
if not args["compile-only"]:
gemmfunc(A, B, C)
if dace.Config.get_bool('profiling'):
dace.timethis('gemm', contender, dace.eval(2 * N * N * N), np.dot,
A_regression, B_regression, C_regression)
else:
np.dot(A_regression, B_regression, C_regression)
#print(C.view(type=np.ndarray))
diff = np.linalg.norm(C_regression - C) / float(dace.eval(M * K))
print("Difference:", diff)
print("==== Program end ====")
exit(0 if diff <= 1e-5 else 1)
parser.add_argument("H", type=int, nargs="?", default=12)
parser.add_argument("MAXITER", type=int, nargs="?", default=30)
args = vars(parser.parse_args())
W.set(args["W"])
H.set(args["H"])
MAXITER.set(args["MAXITER"])
print('Jacobi 5-point Stencil %dx%d (%d steps)' %
(W.get(), H.get(), MAXITER.get()))
A = dace.ndarray([H, W], dtype=dace.float32)
# Initialize arrays: Randomize A, zero B
A[:] = dace.float32(0)
A[1:H.get() - 1, 1:W.get() - 1] = np.random.rand(dace.eval(H - 2),
dace.eval(W - 2)).astype(
dace.float32.type)
regression = np.ndarray([H.get() - 2, W.get() - 2], dtype=np.float32)
regression[:] = A[1:H.get() - 1, 1:W.get() - 1]
#print(A.view(type=np.ndarray))
#############################################
# Run DaCe program
jacobi(A, MAXITER)
# Regression
kernel = np.array([[0, 0.2, 0], [0.2, 0.2, 0.2], [0, 0.2, 0]],
dtype=np.float32)
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("W", type=int, nargs="?", default=32)
parser.add_argument("H", type=int, nargs="?", default=32)
args = vars(parser.parse_args())
A = dace.ndarray([H, W], dtype=dace.uint8)
hist = dace.ndarray([BINS], dtype=dace.uint32)
W.set(args["W"])
H.set(args["H"])
print('Histogram (dec) %dx%d' % (W.get(), H.get()))
A[:] = np.random.randint(0, 256,
(H.get(), W.get())).astype(dace.uint8.type)
hist[:] = dace.uint32(0)
histogram(A, hist)
if dace.Config.get_bool('profiling'):
dace.timethis('histogram', 'numpy', dace.eval(H * W), np.histogram, A,
BINS)
diff = np.linalg.norm(np.histogram(A, bins=BINS)[0] - hist)
print("Difference:", diff)
print("==== Program end ====")
exit(0 if diff <= 1e-5 else 1)
parser = argparse.ArgumentParser()
parser.add_argument("M", type=int, nargs="?", default=24)
parser.add_argument("K", type=int, nargs="?", default=24)
parser.add_argument("N", type=int, nargs="?", default=24)
args = vars(parser.parse_args())
M.set(args["M"])
K.set(args["K"])
N.set(args["N"])
print('Matrix multiplication %dx%dx%d' % (M.get(), K.get(), N.get()))
# Initialize arrays: Randomize A and B, zero C
A = np.random.rand(M.get(), K.get()).astype(np.float64)
B = np.random.rand(K.get(), N.get()).astype(np.float64)
C = np.zeros([M.get(), N.get()], dtype=np.float64)
C_regression = np.zeros_like(C)
gemm(A, B, C)
if dace.Config.get_bool('profiling'):
dace.timethis('gemm', 'numpy', dace.eval(2 * M * K * N), np.dot, A, B,
C_regression)
else:
np.dot(A, B, C_regression)
diff = np.linalg.norm(C_regression - C) / float(dace.eval(M * N))
print("Difference:", diff)
print("==== Program end ====")
exit(0 if diff <= 1e-5 else 1)
dict(i=irange, j=jrange),
dict(a=Memlet.simple(Atrans, 'i-1,j')),
'b = math.exp(a)',
dict(b=Memlet.simple(B, 'i,j')))
state.add_edge(Atrans, None, me, None, Memlet.simple(Atrans, fullrange))
state.add_edge(mx, None, B, None, Memlet.simple(B, fullrange))
##########################################################################
code_nonspec = spec_sdfg.generate_code(specialize=False)
if 'Dynamic' not in code_nonspec[0].code:
print('ERROR: Constants were needlessly specialized')
exit(1)
code_spec = spec_sdfg.generate_code(specialize=True)
if 'Dynamic' in code_spec[0].code:
print('ERROR: Constants were not properly specialized')
exit(2)
spec_sdfg.draw_to_file()
func = dp.compile(spec_sdfg, specialize=True)
func(A=input, B=output, N=N, M=M)
diff = np.linalg.norm(
np.exp(input[1:dp.eval(N - 1), 0:dp.eval(M)]) -
output[1:-1, :]) / dp.eval(N)
print("Difference:", diff)
print("==== Program end ====")
exit(0 if diff <= 1e-5 else 3)
