def test_cholesky():
A = dummy_matrix()
B = dummy_matrix()
C = dummy_matrix(num_dims=3)
program = lpcompile(CHOLESKY)(A, B, C, 313, 0)
assert (find_starters(program, input_matrices=["I"])) == [(0, {})]
assert len(find_terminators(program, output_matrices=["O"])) == 49141
def test_qr():
A = dummy_matrix(num_dims=2)
V = dummy_matrix(num_dims=2)
T = dummy_matrix(num_dims=2)
R = dummy_matrix(num_dims=2)
S = dummy_matrix(num_dims=4)
t = time.time()
program = lpcompile(QR)(A, V, T, R, S, 16, 0)
#states = walk_program(program)
#idx = np.random.choice(len(states), len(states) - 1, replace=False)[0]
#states = states[idx:idx+1]
states = [(8, {'j': 1, 'level': 0, 'k': 6, 'i': 1})]
print(states)
times = []
print("number of states", len(states))
actual = time.time()
for p_idx, loop_vars in states:
r_call_abstract_with_scope = program[p_idx]
current_node = (p_idx, loop_vars)
scope = r_call_abstract_with_scope.scope.copy()
children = find_children(program, p_idx, loop_vars)
for p_idx_child, child_vars in children:
child_parents = find_parents(program, p_idx_child, child_vars)
assert current_node in child_parents
e = time.time()
times.append(e - actual)
print("mean find children and parents", np.mean(times))
print("full time ", e - t)
print("std time find children and parents", np.std(times))
def test_tsqr():
A = dummy_matrix(num_dims=1)
V = dummy_matrix(num_dims=2)
T = dummy_matrix(num_dims=2)
R = dummy_matrix(num_dims=2)
program = lpcompile(TSQR)(A, V, T, R, 16)
verify_program(program)
def test_qr():
A = dummy_matrix(num_dims=2)
V = dummy_matrix(num_dims=2)
T = dummy_matrix(num_dims=2)
R = dummy_matrix(num_dims=2)
S = dummy_matrix(num_dims=4)
program = lpcompile(QR)(A, V, T, R, S, 4, 0)
verify_program(program)
def test_gemm():
A = dummy_matrix(num_dims=2)
B = dummy_matrix(num_dims=2)
M = 4
N = 4
K = 4
Temp = dummy_matrix(num_dims=4)
Out = dummy_matrix(num_dims=3)
program = lpcompile(GEMM)(A, B, M, N, K, Temp, Out)
verify_program(program)
def test_qr():
A = dummy_matrix(num_dims=2)
V = dummy_matrix(num_dims=2)
T = dummy_matrix(num_dims=2)
R = dummy_matrix(num_dims=2)
S = dummy_matrix(num_dims=4)
M = 256
program = lpcompile(QR)(A, V, T, R, S, M, 0)
assert len(find_starters(program, input_matrices=["I"])) == M
assert len(find_terminators(program, output_matrices=["Rs"])) == 129920
def test_gemm():
A = dummy_matrix(num_dims=2)
B = dummy_matrix(num_dims=2)
M = 4
N = 4
K = 4
Temp = dummy_matrix(num_dims=4)
Out = dummy_matrix(num_dims=3)
program = lpcompile(GEMM)(A, B, M, N, K, Temp, Out)
assert len(find_starters(program, input_matrices=["A", "B"])) == M * N * K
assert len(find_terminators(program, output_matrices=["Out"])) == M * N
def test_bdfac():
A = dummy_matrix(num_dims=2)
V = dummy_matrix(num_dims=3)
T = dummy_matrix(num_dims=3)
R = dummy_matrix(num_dims=4)
S = dummy_matrix(num_dims=4)
VR = dummy_matrix(num_dims=3)
TR = dummy_matrix(num_dims=3)
L = dummy_matrix(num_dims=4)
SR = dummy_matrix(num_dims=4)
program = lpcompile(BDFAC)(A, V, T, R, S, VR, TR, SR, L, 256, 0)
t = time.time()
print(find_children(program, 15, {'j': 2, 'k': 2, 'i': 1, 'level': 1}))
e = time.time()
print(e - t)
def test_types_simple_2(self):
parser, type_checker, f3_ast = compiler.lpcompile(F3)
tree = astor.dump_tree(f3_ast)
assert type_checker.decl_types['c'] == frontend.ConstFloatType
assert type_checker.decl_types['d'] == frontend.ConstFloatType
assert type_checker.decl_types['e'] == frontend.ConstIntType
def test_types_simple(self):
parser, type_checker, f2_ast = compiler.lpcompile(F2)
tree = astor.dump_tree(f2_ast)
assert type_checker.decl_types['a'] == frontend.ConstFloatType
assert type_checker.decl_types['b'] == frontend.ConstIntType
def test_types_for_loop_nested_if_statment(self):
parser, type_checker, f_ast = compiler.lpcompile(F9)
assert type_checker.decl_types['z'] == frontend.LinearIntType
assert type_checker.decl_types['i'] == frontend.LinearIntType
def test_types_if_statement_no_err(self):
parser, type_checker, f_ast = compiler.lpcompile(F7_no_err)
assert type_checker.decl_types['f'] == frontend.ConstFloatType
assert type_checker.decl_types['d'] == frontend.ConstFloatType
def test_types_if_statement_err(self):
try:
parser, type_checker, f_ast = compiler.lpcompile(F7_err)
except exceptions.LambdaPackParsingException:
pass
def test_cholesky():
A = dummy_matrix()
B = dummy_matrix()
C = dummy_matrix(num_dims=3)
program = lpcompile(CHOLESKY)(A, B, C, 8, 0)
verify_program(program)
def test_simple_nonlinear():
A = dummy_matrix()
B = dummy_matrix()
program = lpcompile(SimpleTestNonLinear)(A, B, int(8))
verify_program(program)
def test_simple_linear_2():
A = dummy_matrix()
B = dummy_matrix()
program = lpcompile(SimpleTestLinear2)(A, B, int(8))
verify_program(program)
def test_types_compound_expr_3(self):
parser, type_checker, f_ast = compiler.lpcompile(F6)
assert type_checker.return_node_type == frontend.ConstFloatType
X_sharded.shape[0]), shard_sizes=(shard_size*b_fac, shard_size), write_header=False, safe=False)
T_sharded = BigMatrix("tsqr_test_T", shape=(num_tree_levels*shard_size*b_fac,
X_sharded.shape[0]), shard_sizes=(shard_size*b_fac, shard_size), write_header=False, safe=False)
I = BigMatrix("I", shape=(N, N), shard_sizes=(
shard_size, shard_size), write_header=True, safe=False)
Vs = BigMatrix("Vs", shape=(num_tree_levels, N, N), shard_sizes=(
1, shard_size, shard_size), write_header=True, safe=False)
Ts = BigMatrix("Ts", shape=(num_tree_levels, N, N), shard_sizes=(
1, shard_size, shard_size), write_header=True, safe=False)
Rs = BigMatrix("Rs", shape=(num_tree_levels, N, N), shard_sizes=(
1, shard_size, shard_size), write_header=True, safe=False)
Ss = BigMatrix("Ss", shape=(N, N, N, num_tree_levels*shard_size), shard_sizes=(shard_size,
shard_size, shard_size, shard_size), write_header=True, parent_fn=parent_fn, safe=False)
#tsqr = frontend.lpcompile(TSQR_BinTree)
N_blocks = X_sharded.num_blocks(0)
program_compiled_linear = compiler.lpcompile(SimpleTestLinear)(Vs, Ts)
program_compiled_nonlinear = compiler.lpcompile(
SimpleTestNonLinear)(Vs, Ts, 100)
program_compiled_QR = compiler.lpcompile(QR)(I, Vs, Ts, Rs, Ss, 16, 0)
start = timer()
#print("children linear", compiler.find_children(program_compiled_linear[0], program_compiled_linear, level=0, j=4, i=3))
#print("children nonlinear", compiler.find_children(program_compiled_nonlinear[0], program_compiled_nonlinear, level=1, k=8, i=0))
#print("children qr", compiler.find_children(program_compiled_QR[1], program_compiled_QR, i=0, j=0, level=0))
print("children", compiler.find_children(
program_compiled_QR[9], program_compiled_QR, k=2, j=3, i=1))
print("parents", compiler.find_parents(
program_compiled_QR[6], program_compiled_QR, i=2, j=3))
#print("parents", compiler.find_parents(program_compiled_QR[2], program_compiled_QR, i=0, j=0, level=2))
end = timer()
print(end - start)
