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()