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)