def run(self):
timer = pk.Timer()
for i in range(self.nrepeat):
self.result = pk.parallel_reduce("subview", self.N, self.yAx)
self.timer_result = timer.seconds()
def run() -> None:
parser = argparse.ArgumentParser()
parser.add_argument('iterations', type=int)
parser.add_argument('length', type=int)
parser.add_argument('offset', nargs='?', type=int, default=0)
args = parser.parse_args()
iterations = args.iterations
length = args.length
offset = args.offset
scalar = 3
if iterations < 1:
sys.exit("ERROR: iterations must be >= 1")
if length <= 0:
sys.exit("ERROR: vector length must be positive")
# emulate cpp example
if length <= 0:
sys.exit("ERROR: offset must be nonnegative")
print("Number of iterations = ", iterations)
print("Vector length = ", length)
print("Offset = ", offset)
p = pk.RangePolicy(pk.ExecutionSpace.OpenMP, 0, length)
w = Workload(iterations, length, offset, scalar)
pk.parallel_for(p, w.init_views)
# pk.fence()
timer = pk.Timer()
for i in range(iterations):
pk.parallel_for(p, w.nstream)
# pk.fence()
nstream_time = timer.seconds()
# verify correctness
ar: float = 0
br: float = 2
cr: float = 2
for i in range(iterations):
ar += br + scalar * cr
ar *= length
asum = pk.parallel_reduce(p, w.res_reduce)
# pk.fence()
episilon: float = 1.0e-8
if (abs(ar - asum) / asum > episilon):
print("ERROR: Failed Valication on output array")
else:
avgtime: float = nstream_time / iterations
nbytes: float = 4.0 * length * 4
print("Solution validates")
print("Rate (MB/s): %.2f" % (1.e-6 * nbytes / avgtime))
print("Avg time (ms): %f" % (avgtime / 1.e-3))
def run() -> None:
values: Tuple[int, int, int, int, int, bool] = parse_args()
N: int = values[0]
M: int = values[1]
E: int = values[3]
fill: bool = values[-1]
nrepeat: int = 1000
print(f"Total size S = {N * M} N = {N} M = {M} E = {E}")
w = Workload(N, M, E, fill)
p = pk.TeamPolicy(E, "auto", 32, pk.get_default_space())
timer = pk.Timer()
for i in range(nrepeat):
result = pk.parallel_reduce(p, w.yAx)
timer_result = timer.seconds()
print(f"Computed result for {N} x {M} x {E} is {result}")
solution: float = N * M * E
if result != solution:
pk.printf("Error: result (%lf) != solution (%lf)\n", result, solution)
print(
f"N({N}) M({M}) E({E}) nrepeat({nrepeat}) problem(MB) time({timer_result}) bandwidth(GB/s)"
)
def run() -> None:
values: Tuple[int, int, int, int, int, bool] = parse_args()
N: int = values[0]
M: int = values[1]
nrepeat: int = 100
print(f"Total size S = {N * M} N = {N} M = {M}")
p = pk.RangePolicy(pk.get_default_space(), 0, N)
w = Workload(N, M)
pk.parallel_for(p, w.y_init)
pk.parallel_for(pk.RangePolicy(pk.get_default_space(), 0, M), w.x_init)
pk.parallel_for(p, w.matrix_init)
timer = pk.Timer()
for i in range(nrepeat):
result = pk.parallel_reduce(p, w.yAx)
timer_result = timer.seconds()
print(f"Computed result for {N} x {M} is {result}")
solution = N * M
if result != solution:
pk.printf("Error: result (%lf) != solution (%lf)\n", result, solution)
print(f"N({N}) M({M}) nrepeat({nrepeat}) problem(MB) time({timer_result}) bandwidth(GB/s)")
def run(self):
timer = pk.Timer()
for r in range(self.R):
pk.parallel_for("gather", self.N, self.benchmark)
pk.fence()
self.seconds = timer.seconds()
def run() -> None:
values: Tuple[int, int, int, int, int, bool] = parse_args()
N: int = values[0]
M: int = values[1]
nrepeat: int = 1
print(f"Total size S = {N * M} N = {N} M = {M}")
y = pk.View([N], pk.double)
x = pk.View([M], pk.double)
A = pk.View([N * M], pk.double)
p = pk.RangePolicy(pk.get_default_space(), 0, N)
pk.parallel_for(p, y_init, y=y)
pk.parallel_for(pk.RangePolicy(pk.get_default_space(), 0, M), y_init, y=x)
pk.parallel_for(p, matrix_init, M=M, A=A)
timer = pk.Timer()
for i in range(nrepeat):
result = pk.parallel_reduce(p, yAx, M=M, y=y, x=x, A=A)
timer_result = timer.seconds()
print(f"Computed result for {N} x {M} is {result}")
solution = N * M
if result != solution:
pk.printf("Error: result (%lf) != solution (%lf)\n", result, solution)
print(f"N({N}) M({M}) nrepeat({nrepeat}) problem(MB) time({timer_result}) bandwidth(GB/s)")
def run(self):
pk.parallel_for(self.N, lambda i: i, self.A)
timer = pk.Timer()
self.result = pk.parallel_scan(self.N, self.scan)
self.timer_result = timer.seconds()
def run() -> None:
random.seed(1010101)
indices = 8192
data = 33554432
repeats = 10
space = pk.ExecutionSpace.OpenMP
parser = argparse.ArgumentParser()
parser.add_argument("--indices", type=int)
parser.add_argument("--data", type=int)
parser.add_argument("--repeats", type=int)
parser.add_argument("--atomics", action="store_true")
parser.add_argument("--execution_space", type=str)
args = parser.parse_args()
if args.indices:
indices = args.indices
if args.data:
data = args.data
if args.repeats:
repeats = args.repeats
use_atomics = args.atomics
if args.execution_space:
space = pk.ExecutionSpace(args.execution_space)
pk.set_default_space(space)
w = Benchmark(indices, data, repeats, use_atomics)
range_indices = pk.RangePolicy(pk.get_default_space(), 0, indices)
range_data = pk.RangePolicy(pk.get_default_space(), 0, data)
print("Reports fastest timing per kernel")
print("Creating Views...")
print("Memory Sizes:")
print(f"- Elements: {data} ({1e-6*data*8} MB)")
print(f"- Indices: {indices} ({1e-6*indices*8} MB)")
print(f"- Atomics: {'yes' if use_atomics else 'no'}")
print(f"Benchmark kernels will be performed for {repeats} iterations")
print("Initializing Views...")
pk.parallel_for(range_data, w.init_data)
pk.parallel_for(range_indices, w.init_indices)
print("Starting benchmarking...")
timer = pk.Timer()
for i in range(repeats):
for i in range(indices):
w.indices[i] = random.randrange(data)
if use_atomics:
pk.parallel_for(range_indices, w.run_gups_atomic)
else:
pk.parallel_for(range_indices, w.run_gups)
gupsTime = timer.seconds()
print(f"GUP/s Random: {1e-9 * repeats * indices / gupsTime}")
print(w.data)
def run(self):
timer = pk.Timer()
pk.parallel_for(self.N, self.matrix_init)
for i in range(self.nrepeat):
self.result = pk.parallel_reduce("04", self.N, self.yAx)
self.timer_result = timer.seconds()
def run(self):
timer = pk.Timer()
for i in range(self.nrepeat):
self.result = pk.parallel_reduce("team_policy",
pk.TeamPolicy(self.N, "auto"),
self.yAx)
self.timer_result = timer.seconds()
def run(self):
timer = pk.Timer()
for i in range(self.nrepeat):
self.result = pk.parallel_reduce("team_vector_loop",
pk.TeamPolicy(self.E, "auto", 32),
self.yAx)
self.timer_result = timer.seconds()
def run(self):
pk.parallel_for(N, self.init_y)
pk.parallel_for(M, self.init_x)
pk.parallel_for(pk.MDRangePolicy([0, 0], [self.N, self.M]),
self.init_A)
timer = pk.Timer()
for i in range(self.nrepeat):
self.result = pk.parallel_reduce("mdrange", self.N, self.yAx)
self.timer_result = timer.seconds()
def run(self):
pk.parallel_for(self.N, self.y_init)
# pk.parallel_for(self.N, lambda i : self.y[i] = 1)
pk.parallel_for(self.M, self.x_init)
# pk.parallel_for(self.N, lambda i : self.x[i] = 1)
pk.parallel_for(self.N, self.matrix_init)
timer = pk.Timer()
for i in range(self.nrepeat):
self.result = pk.parallel_reduce("01", self.N, self.yAx)
self.timer_result = timer.seconds()
def run(self):
t: int = tile_size
r: int = radius
pk.parallel_for(pk.MDRangePolicy([0, 0], [n, n], [t, t]), self.init)
pk.fence()
timer = pk.Timer()
for i in range(iterations):
if (i == 1):
pk.fence()
if r == 1:
# star1 stencil
pk.parallel_for(
"stencil", pk.MDRangePolicy([r, r], [n - r, n - r],
[t, t]), self.star1)
elif r == 2:
# star2 stencil
pk.parallel_for(
"stencil", pk.MDRangePolicy([r, r], [n - r, n - r],
[t, t]), self.star2)
else:
# star3 stencil
pk.parallel_for(
"stencil", pk.MDRangePolicy([r, r], [n - r, n - r],
[t, t]), self.star3)
pk.parallel_for(pk.MDRangePolicy([0, 0], [n, n], [t, t]),
self.increment)
pk.fence()
self.stencil_time = timer.seconds()
active_points: int = (n - 2 * r) * (n - 2 * r)
# verify correctness
self.norm = pk.parallel_reduce(
pk.MDRangePolicy([r, r], [n - r, n - r], [t, t]), self.norm_reduce)
pk.fence()
self.norm /= active_points
episilon: float = 1.0e-8
reference_norm: float = 2 * (iterations)
if (abs(self.norm - reference_norm) > episilon):
pk.printf("ERROR: L1 norm != Reference norm err=%.2f\n",
abs(self.norm - reference_norm))
else:
pk.printf("Solution validates\n")
def run() -> None:
values: Tuple[int, int, int, int, int, bool] = parse_args()
N: int = values[0]
M: int = values[1]
fill: bool = values[-1]
nrepeat: int = 100
print(f"Total size S = {N * M} N = {N} M = {M}")
pk.set_default_space(pk.ExecutionSpace.Cuda)
y: pk.View1D = pk.View([N], pk.double)
x: pk.View1D = pk.View([M], pk.double)
A: pk.View2D = pk.View([N, M], pk.double)
p = pk.RangePolicy(pk.get_default_space(), 0, N)
pk.parallel_for(p, y_init, y=y)
pk.parallel_for(pk.RangePolicy(pk.get_default_space(), 0, M), y_init, y=x)
pk.parallel_for(p, matrix_init, M=M, A=A)
# if fill:
# y.fill(1)
# x.fill(1)
# A.fill(1)
# else:
# for i in range(N):
# y[i] = 1
# for i in range(M):
# x[i] = 1
# for j in range(N):
# for i in range(M):
# A[j][i] = 1
timer = pk.Timer()
for i in range(nrepeat):
result = pk.parallel_reduce(p, yAx, M=M, y=y, x=x, A=A)
timer_result = timer.seconds()
print(f"Computed result for {N} x {M} is {result}")
solution: float = N * M
if result != solution:
pk.printf("Error: result (%lf) != solution (%lf)\n", result, solution)
print(
f"N({N}) M({M}) nrepeat({nrepeat}) problem(MB) time({timer_result}) bandwidth(GB/s)"
)
def run() -> None:
values: Tuple[int, int, int, int, int, bool] = parse_args()
N: int = values[0]
M: int = values[1]
E: int = values[3]
fill: bool = values[-1]
nrepeat: int = 1000
print(f"Total size S = {N * M} N = {N} M = {M} E = {E}")
y: pk.View2D = pk.View([E, N], pk.double, layout=pk.Layout.LayoutRight)
x: pk.View2D = pk.View([E, M], pk.double, layout=pk.Layout.LayoutRight)
A: pk.View3D = pk.View([E, N, M], pk.double, layout=pk.Layout.LayoutRight)
if fill:
y.fill(1)
x.fill(1)
A.fill(1)
else:
for e in range(E):
for i in range(N):
y[e][i] = 1
for i in range(M):
x[e][i] = 1
for j in range(N):
for i in range(M):
A[e][j][i] = 1
p = pk.TeamPolicy(E, "auto", 32, pk.get_default_space())
timer = pk.Timer()
for i in range(nrepeat):
result = pk.parallel_reduce(p, yAx, N=N, M=M, y=y, x=x, A=A)
timer_result = timer.seconds()
print(
f"Computed result for {N} x {M} x {E} is {result}")
solution: float = N * M * E
if result != solution:
pk.printf("Error: result (%lf) != solution (%lf)\n",
result, solution)
print(f"N({N}) M({M}) E({E}) nrepeat({nrepeat}) problem(MB) time({timer_result}) bandwidth(GB/s)")
def run(self):
pk.parallel_for(
pk.MDRangePolicy([0, 0], [self.order, self.order],
[self.tile_size, self.tile_size]), self.init)
pk.fence()
timer = pk.Timer()
for i in range(self.iterations):
if self.permute:
pk.parallel_for(
"transpose",
pk.MDRangePolicy([0, 0], [self.order, self.order],
[self.tile_size, self.tile_size],
rank=pk.Rank(2, pk.Iterate.Left,
pk.Iterate.Right)),
self.tranpose)
else:
pk.parallel_for(
"transpose",
pk.MDRangePolicy([0, 0], [self.order, self.order],
[self.tile_size, self.tile_size],
rank=pk.Rank(2, pk.Iterate.Right,
pk.Iterate.Left)),
self.tranpose)
self.transpose_time = timer.seconds()
self.abserr = pk.parallel_reduce(
pk.MDRangePolicy([0, 0], [self.order, self.order],
[self.tile_size, self.tile_size]),
self.abserr_reduce)
pk.printf("%f\n", self.abserr)
episilon: float = 1.0e-8
if (self.abserr > episilon):
pk.printf(
"ERROR: aggregated squared error exceeds threshold %.2f\n",
self.abserr)
else:
pk.printf("Solution validates %2.f\n", self.abserr)
def run(self):
printf("Initializing Views...\n")
pk.parallel_for(self.dataCount, self.init_data)
pk.parallel_for(self.indicesCount, self.init_indices)
printf("Starting benchmarking...\n")
pk.fence()
timer = pk.Timer()
for i in range(self.repeats):
# FIXME: randomize indices
# for i in range(self.indicesCount):
# self.indices[i] = random.randrange(self.dataCount)
if self.use_atomics:
pk.parallel_for("gups", self.indicesCount,
self.run_gups_atomic)
else:
pk.parallel_for("gups", self.indicesCount, self.run_gups)
pk.fence()
self.gupsTime = timer.seconds()
def run(self):
pk.parallel_for(self.array_size, self.init_arrays)
timer = pk.Timer()
for i in range(self.num_times):
pk.parallel_for("babel_stream", self.array_size, self.copy)
pk.fence()
# self.runtimes[0][i] = timer.seconds()
# timer.reset()
pk.parallel_for("babel_stream", self.array_size, self.mul)
pk.fence()
# self.runtimes[1][i] = timer.seconds()
# timer.reset()
pk.parallel_for("babel_stream", self.array_size, self.add)
pk.fence()
pk.parallel_for("babel_stream", self.array_size, self.triad)
pk.fence()
self.sum = pk.parallel_reduce("babel_stream", self.array_size,
self.dot)
self.runtime = timer.seconds()
def run(self):
pk.parallel_for(self.length, self.init)
# pk.parallel_for(self.length, lambda i: 0, self.A)
# pk.parallel_for(self.length, lambda i: 2, self.B)
# pk.parallel_for(self.length, lambda i: 2, self.C)
pk.fence()
timer = pk.Timer()
for i in range(self.iterations):
pk.parallel_for("nstream", self.length, self.nstream)
pk.fence()
self.nstream_time = timer.seconds()
# verify correctness
ar: float = 0
br: float = 2
cr: float = 2
for i in range(self.iterations):
ar += br + self.scalar * cr
ar *= self.length
self.asum = pk.parallel_reduce(self.length,
lambda i, acc: acc + abs(self.A[i]))
pk.fence()
episilon: float = 1.0e-8
if (abs(ar - self.asum) / self.asum > episilon):
pk.printf("ERROR: Failed Valication on output array\n")
else:
avgtime: float = self.nstream_time / self.iterations
nbytes: float = 4.0 * self.length * 4
pk.printf("Solution validates\n")
pk.printf("Rate (MB/s): %.2f\n", 1.e-6 * nbytes / avgtime)
pk.printf("Avg time (ms): %f\n", avgtime / 1.e-3)
space = pk.ExecutionSpace(args.execution_space)
pk.set_default_space(space)
N = args.N
K = args.K
D = args.D
R = args.R
U = args.U
F = args.F
scalar_size = 8
policy = pk.RangePolicy(pk.get_default_space(), 0, N)
w = Benchmark_double_8(N, K, D, R, F)
timer = pk.Timer()
for r in range(R):
pk.parallel_for(policy, w.benchmark)
pk.fence()
seconds = timer.seconds()
num_bytes = 1.0 * N * K * R * (2 * scalar_size + 4) + N * R * scalar_size
flops = 1.0 * N * K * R * (F * 2 * U + 2 * (U - 1))
gather_ops = 1.0 * N * K * R * 2
seconds = seconds
print(
f"SNKDRUF: {scalar_size/4} {N} {K} {D} {R} {U} {F} Time: {seconds} " +
f"Bandwidth: {1.0 * num_bytes / seconds / (1024**3)} GiB/s GFlop/s: {1e-9 * flops / seconds} GGather/s: {1e-9 * gather_ops / seconds}"
)
def run(self, nsteps: int) -> None:
neigh_cutoff: float = self.input.force_cutoff + self.input.neighbor_skin
temp = Temperature(self.comm)
pote = PotE(self.comm)
kine = KinE(self.comm)
force_time: float = 0
comm_time: float = 0
neigh_time: float = 0
other_time: float = 0
last_time: float = 0
timer = pk.Timer()
force_timer = pk.Timer()
comm_timer = pk.Timer()
neigh_timer = pk.Timer()
other_timer = pk.Timer()
for step in range(1, nsteps + 1):
other_timer.reset()
self.integrator.initial_integrate()
other_time += other_timer.seconds()
if step % self.input.comm_exchange_rate == 0 and step > 0:
comm_timer.reset()
self.comm.exchange()
comm_time += comm_timer.seconds()
other_timer.reset()
self.binning.create_binning(neigh_cutoff, neigh_cutoff,
neigh_cutoff, 1, True, False, True)
other_time += other_timer.seconds()
comm_timer.reset()
self.comm.exchange_halo()
comm_time += comm_timer.seconds()
neigh_timer.reset()
self.binning.create_binning(neigh_cutoff, neigh_cutoff,
neigh_cutoff, 1, True, True, False)
if self.neighbor is not None:
self.neighbor.create_neigh_list(self.system, self.binning,
self.force.half_neigh,
False, self.input.fill)
neigh_time += neigh_timer.seconds()
else:
comm_timer.reset()
self.comm.update_halo()
comm_time += comm_timer.seconds()
force_timer.reset()
if self.input.fill:
self.system.f.fill(0)
else:
for i in range(self.system.f.extent(0)):
for j in range(self.system.f.extent(1)):
self.system.f[i][j] = 0.0
self.force.compute(self.system, self.binning, self.neighbor)
force_time += force_timer.seconds()
if self.input.comm_newton:
comm_timer.reset()
self.comm.update_force()
comm_time += comm_timer.seconds()
other_timer.reset()
self.integrator.final_integrate()
if step % self.input.thermo_rate == 0:
T: float = temp.compute(self.system)
PE: float = pote.compute(self.system, self.binning,
self.neighbor,
self.force) / self.system.N
KE: float = kine.compute(self.system) / self.system.N
if self.system.do_print:
if not self.system.print_lammps:
time: float = timer.seconds()
print(
f"{step} {T:.6f} {PE:.6f} {PE + KE:.6f} {timer.seconds():.6f}"
f" {1.0 * self.system.N * self.input.thermo_rate / (time - last_time):e}"
)
last_time = time
else:
time: float = timer.seconds()
print(
f" {step} {T:.6f} {PE:.6f} {PE + KE:.6f} {timer.seconds():.6f}"
)
last_time = time
if self.input.dumpbinaryflag:
self.dump_binary(step)
if self.input.correctnessflag:
self.check_correctness(step)
other_time += other_timer.seconds()
time: float = timer.seconds()
T: float = temp.compute(self.system)
PE: float = pote.compute(self.system, self.binning, self.neighbor,
self.force) / self.system.N
KE: float = kine.compute(self.system) / self.system.N
if self.system.do_print:
if not self.system.print_lammps:
print()
print("#Procs Particles |"
" Time T_Force T_Neigh T_Comm T_Other |"
" Steps/s Atomsteps/s Atomsteps/(proc*s)")
print(
f"{self.comm.num_processes()} {self.system.N} |"
f" {time:.6f} {force_time:.6f} {neigh_time:.6f} {comm_time:.6f} {other_time:.6f} |"
f" {1.0 * nsteps / time:.6f} {1.0 * self.system.N * nsteps / time:e}"
f" {1.0 * self.system.N * nsteps / time / self.comm.num_processes():e} PERFORMANCE"
)
else:
print(f"Loop time of {time} on {self.comm.num_processes()}"
f" procs for {nsteps} with {self.system.N} atoms")
def run(self):
timer = pk.Timer()
pk.parallel_for("bytes_and_flops", pk.TeamPolicy(self.N, self.T),
self.benchmark)
pk.fence()
self.seconds = timer.seconds()
