# Rank inner product
nbytes = (one[0].global_bytes() + two[0].global_bytes()) * N * n * n
for use_accelerator, compute_name, access in [
(False, "host", access_host),
(True, "accelerator", access_accelerator),
]:
# Time
dt = 0.0
cgpt.timer_begin()
for it in range(N + Nwarmup):
access(one)
access(two)
if it >= Nwarmup:
dt -= g.time()
ip = g.rank_inner_product(one, two, use_accelerator)
if it >= Nwarmup:
dt += g.time()
# Report
GBPerSec = nbytes / dt / 1e9
cgpt_t = g.timer("rip")
cgpt_t += cgpt.timer_end()
g.message(
f"""{N} rank_inner_product
Object type : {tp.__name__}
Block : {n} x {n}
Data resides in : {access.__name__[7:]}
Performed on : {compute_name}
Time to complete : {dt:.2f} s
Effective memory bandwidth : {GBPerSec:.2f} GB/s
g.copy(new, src)
# cshift into a new lattice dst
dst = g.cshift(src, 0, 1)
# dst[x] = src[x+1] -> src[0] == dst[15]
assert abs(dst[15, 0, 0, 0] - complex(2, 1)) < 1e-6
################################################################################
# Test multi inner_product
################################################################################
for grid in [grid_dp, grid_sp]:
for dtype in [g.vspincolor, lambda grid: g.vcomplex(grid, 12), g.complex]:
left = [dtype(grid) for i in range(2)]
right = [dtype(grid) for i in range(3)]
rng.cnormal([left, right])
host_result = g.rank_inner_product(left, right, False)
acc_result = g.rank_inner_product(left, right, True)
eps = np.linalg.norm(host_result - acc_result) / np.linalg.norm(host_result)
g.message(f"Test multi inner product host<>accelerator: {eps}")
assert eps < 1e-13
for i in range(2):
for j in range(3):
host_result_individual = g.rank_inner_product(left[i], right[j], False)
acc_result_individual = g.rank_inner_product(left[i], right[j], True)
eps = abs(host_result_individual - host_result[i, j]) / abs(
host_result[i, j]
)
assert eps < 1e-13
eps = abs(acc_result_individual - acc_result[i, j]) / abs(
acc_result[i, j]
)
g.default.pop_verbose()
# outer product and inner product of tensors
lhs = g.vcolor([rng.cnormal() for i in range(3)])
rhs = g.vcolor([rng.cnormal() for i in range(3)])
outer = lhs * g.adj(rhs)
inner = g.adj(lhs) * rhs
inner_comp = 0.0
for i in range(3):
inner_comp += lhs.array.conjugate()[i] * rhs.array[i]
for j in range(3):
assert abs(outer.array[i, j] -
lhs.array[i] * rhs.array.conjugate()[j]) < 1e-14
assert abs(inner_comp - inner) < 1e-14
assert abs(inner_comp - g.rank_inner_product(lhs, rhs)) < 1e-14
# TODO: the following is already implemented for vcomplex but should
# be implemented for all vectors
# cwise = lhs * rhs
# inner product for vcomplex
lhs = g.vcomplex([1.0] * 10 + [2] * 10 + [3] * 10 + [4] * 10, 40)
rhs = g.vcomplex([5.0] * 10 + [6] * 10 + [7] * 10 + [8] * 10, 40)
inner = g.adj(lhs) * rhs
inner_comp = 0.0
for i in range(40):
inner_comp += lhs.array.conjugate()[i] * rhs.array[i]
assert abs(inner_comp - inner) < 1e-14
assert inner.real == 700.0
