def main(args): f1 = charm.createFuture() f2 = charm.createFuture() Group(Test, args=[f1, f2]) assert f1.get() == charm.numPes() assert f2.get() == charm.numPes() charm.exit()
def done(self, result): self.count += result self.countReductions += 1 if self.countReductions == 2: assert self.count == (charm.numPes() + charm.numPes() * CHARES_PER_PE) print("Program done") charm.exit()
def main(args): f1 = charm.createFuture() f2 = charm.createFuture() Group(Test, args=[f1]) Array(Test, charm.numPes() * 4, args=[f2]) np.testing.assert_allclose(f1.get(), np.arange(10, dtype='float64') * charm.numPes()) np.testing.assert_allclose( f2.get(), np.arange(10, dtype='float64') * charm.numPes() * 4) charm.exit()
def recvLocations(self, locations): loc = defaultdict(list) for chare_idx, pe in enumerate(locations): loc[pe].append(chare_idx) myPe = charm.myPe() myPos = loc[myPe].index(self.thisIndex[0]) # i-th chare in a PE sends to i-th chare in PE-1 and PE+1 and to itself nb1 = self.thisProxy[loc[(myPe - 1) % charm.numPes()][myPos]] nb2 = self.thisProxy[loc[(myPe + 1) % charm.numPes()][myPos]] self.nbs = [nb1, nb2, self.thisProxy[self.thisIndex]] self.contribute(None, None, ro.mainProxy.start)
def main(args): grpProxy = Group(Test) for i in range(charm.numPes()): data = grpProxy[i].getData(ret=True).get() assert data == i**2, "Blocking call in main failed." print("Test " + str(i) + " sent data: " + str(data)) charm.exit()
def SayHi(self, hiNo): print("Hi[" + str(hiNo) + "] from element " + str(self.thisIndex)) if self.thisIndex + 1 < charm.numPes(): # Pass the hello on: self.thisProxy[self.thisIndex+1].SayHi(hiNo+1) else: ro.mainProxy.done()
def collectStats(self, stat_result): assert self.thisIndex[0] == 0, "Reduction target incorrect!" if stat_result == 0: self.min_future.send(stat_result) elif stat_result == (charm.numPes() * CHARES_PER_PE) - 1: self.max_future.send(stat_result) else: self.sum_future.send(stat_result)
def main(args): if (len(args) != 3) and (len(args) != 7): print(args[0] + " [array_size] [block_size]") print( "OR " + args[0] + " [array_size_X] [array_size_Y] [array_size_Z] [block_size_X] [block_size_Y] [block_size_Z]" ) charm.abort("Incorrect program arguments") if len(args) == 3: ro.arrayDimX = ro.arrayDimY = ro.arrayDimZ = int(args[1]) ro.blockDimX = ro.blockDimY = ro.blockDimZ = int(args[2]) elif len(args) == 7: ro.arrayDimX, ro.arrayDimY, ro.arrayDimZ = [ int(arg) for arg in args[1:4] ] ro.blockDimX, ro.blockDimY, ro.blockDimZ = [ int(arg) for arg in args[4:7] ] if (ro.arrayDimX < ro.blockDimX) or (ro.arrayDimX % ro.blockDimX != 0): charm.abort("array_size_X % block_size_X != 0!") if (ro.arrayDimY < ro.blockDimY) or (ro.arrayDimY % ro.blockDimY != 0): charm.abort("array_size_Y % block_size_Y != 0!") if (ro.arrayDimZ < ro.blockDimZ) or (ro.arrayDimZ % ro.blockDimZ != 0): charm.abort("array_size_Z % block_size_Z != 0!") ro.num_chare_x = ro.arrayDimX // ro.blockDimX ro.num_chare_y = ro.arrayDimY // ro.blockDimY ro.num_chare_z = ro.arrayDimZ // ro.blockDimZ print("\nSTENCIL COMPUTATION WITH BARRIERS\n") print("Running Stencil on " + str(charm.numPes()) + " processors with " + str((ro.num_chare_x, ro.num_chare_y, ro.num_chare_z)) + " chares") print("Array Dimensions: " + str((ro.arrayDimX, ro.arrayDimY, ro.arrayDimZ))) print("Block Dimensions: " + str((ro.blockDimX, ro.blockDimY, ro.blockDimZ))) nb_precomps = Group(NumbaPrecompiler) charm.awaitCreation(nb_precomps) # wait until Numba functions are compiled sim_done = charm.createFuture() array = Array(Stencil, (ro.num_chare_x, ro.num_chare_y, ro.num_chare_z), args=[sim_done]) charm.awaitCreation(array) print("Starting simulation") initTime = time.time() array.start() sim_done.get() # wait until simulation completes totalTime = time.time() - initTime print(MAX_ITER, "iterations completed, total time=", round(totalTime, 3), "secs, time per iteration (ms) =", round(totalTime / MAX_ITER * 1000, 3)) charm.printStats() charm.exit()
def start(self): """ Invoke the starter code for test. """ if charm.myPe() == 0: print("On PE", charm.myPe(), "before migration") self.thisProxy[self.thisIndex].test() self.toPe = (charm.myPe() + 1) % charm.numPes() self.migrate(self.toPe)
def SayHi(self, hellos): hellos.addHello("Hi[" + str(hellos.hiNo) + "] from element " + str(self.thisIndex)) hellos.hiNo += 1 if self.thisIndex + 1 < charm.numPes(): # Pass the hello list on: self.thisProxy[self.thisIndex + 1].SayHi(hellos) else: print("All done " + str(hellos)) charm.exit()
def main(args): testProxy = Array(Test, charm.numPes() * CHARES_PER_PE) sum_f = charm.createFuture() min_f = charm.createFuture() max_f = charm.createFuture() testProxy.getStats((sum_f, min_f, max_f)) print("[Main] Sum: " + str(sum_f.get()) + ", Min: " + str(min_f.get()) + ", Max: " + str(max_f.get())) print("[Main] All done.") charm.exit()
def main(args): numChares = min(charm.numPes() * CHARES_PER_PE, 64) testProxy = Array(Test, numChares) f = charm.createFuture(senders=numChares) testProxy.getData(f) data = f.get() print("[Main] Received data: " + str(data)) assert sorted(data) == list(range(numChares)), "Multi-futures failed!" print("[Main] All done.") charm.exit()
def main(args): if charm.numPes() < 5: print("\nRun this example with at least 5 PEs\n") charm.exit() pool = Chare(Master, onPE=0) # create one Master called 'pool' on PE 0 f1 = charm.createFuture() f2 = charm.createFuture() tasks1 = [1, 2, 3, 4, 5] tasks2 = [1, 3, 5, 7, 9] pool.map_async(f, 2, tasks1, f1) pool.map_async(f, 2, tasks2, f2) print("Final results are", f1.get(), f2.get()) # wait on futures charm.exit()
def main(args): a = Array(Test, charm.numPes()) sleepTimes = [random.uniform(0.5, 1.5) for i in range(charm.numPes())] # for some reason, work() runs on PE 0 before sending the broadcast msgs out # to the other PEs, so I set wait time to 0 on PE 0 sleepTimes[0] = 0.0 t0 = time.time() a.work(sleepTimes, ret=True).get() # wait for broadcast to complete wait_time = time.time() - t0 assert(wait_time >= max(sleepTimes)) print(wait_time, max(sleepTimes)) g = Group(Test) sleepTimes = [random.uniform(0.5, 1.5) for i in range(charm.numPes())] sleepTimes[0] = 0.0 t0 = time.time() g.work(sleepTimes, ret=True).get() # wait for broadcast to complete wait_time = time.time() - t0 assert(wait_time >= max(sleepTimes)) print(wait_time, max(sleepTimes)) charm.exit()
def __init__(self, args): ro.main = self.thisProxy num_chares = min(charm.numPes() * CHARES_PER_PE, MAX_CHARES) assert num_chares % 2 == 0 workers = Array(Worker, num_chares) self.num_responses1 = self.num_responses2 = 0 self.result = 0 for i in range(NUM_ITER): workers.sendVal() self.wait("self.num_responses1 == " + str(num_chares//2)) self.wait("self.num_responses2 == " + str(num_chares//2)) assert(self.result == num_chares * 237) assert(self.num_responses1 == num_chares//2) assert(self.num_responses2 == num_chares//2) self.num_responses1 = self.num_responses2 = 0 self.result = 0 charm.printStats() charm.exit()
def main(args): global allPes_check, evenPes_check print("\nWhole topo tree rooted at PE 0") printWholeTree(0, 0) assert (len(allPes_check) == charm.numPes() and set(allPes_check) == set(range(charm.numPes()))) allPes_check = [] lastPE = charm.numPes() - 1 if lastPE != 0: print("\nWhole topo tree rooted at", lastPE) printWholeTree(lastPE, lastPE) assert (len(allPes_check) == charm.numPes() and set(allPes_check) == set(range(charm.numPes()))) allPes_check = [] print("\nEven numbered PE tree, rooted at PE 0") evenPEs = [pe for pe in range(charm.numPes()) if pe % 2 == 0] printEvenNbTree(evenPEs, 0) assert (len(evenPes_check) == len(evenPEs) and set(evenPes_check) == set(evenPEs)) evenPes_check = [] newRoot = evenPEs[-1] if newRoot != 0: evenPEs.insert( 0, evenPEs.pop()) # move root from back to beginning of list print("\nEven numbered PE tree, rooted at PE", newRoot) printEvenNbTree(evenPEs, newRoot) assert (len(evenPes_check) == len(evenPEs) and set(evenPes_check) == set(evenPEs)) evenPes_check = [] charm.exit()
def main(args): print("Running Hello on " + str(charm.numPes()) + " processors") Group(Hello)[0].SayHi(HelloList(17))
def main(args): # every chare sends to every other so don't want a ton of chares ro.numChares = min(charm.numPes() * 8, 32) ro.testGroup = Group(Test2) Array(Test, ro.numChares)
def main(args): if charm.numPes() < 3: charm.abort("Run program with at least 3 PEs") ro.numParticipants = min(charm.numPes() - 1, 31) Group(Test).run()
def main(args): print("Charm program started on processor", charm.myPe()) print("Running on", charm.numPes(), "processors") charm.exit()
def main(args): if charm.numPes() == 1: charm.abort("Run program with more than 1 PE") array_proxy = Array(Migrate, CHARES_PER_PE * charm.numPes()) array_proxy.start()
def __init__(self): # create a Worker in every processor self.workers = Group(Worker) self.free_procs = set(range(1, charm.numPes())) self.next_job_id = 0 self.jobs = {}
def main(args): ro.num_workers = min(charm.numPes() * 8, MAX_CHARES) controller = Chare(Controller, onPE=0) ro.workers = Array(Worker, ro.num_workers, args=[controller])
def main(args): ro.numChares = min(charm.numPes() * 8, 32) ro.testGroup = Group(Test2) Array(Test, ro.numChares)
def __init__(self, args): Group(Test).work(self.thisProxy) Array(Test, charm.numPes() * CHARES_PER_PE).work(self.thisProxy) self.countReductions = self.count = 0
def SayHi(self): print("Hello from PE", charm.myPe(), "on", time.strftime('%c')) ro.byes[(self.thisIndex + 1) % charm.numPes()].SayGoodbye()
def main(args): if charm.numPes() < 3: charm.abort("Run program with at least 3 PEs") grp_proxy = Group(Test) grp_proxy[0].start()
def __init__(self, args): ro.mainProxy = self.thisProxy ro.testProxy = Array(Test, charm.numPes() * CHARES_PER_PE)
def main(args): ro.controllers = Group(Controller) ro.array = Array(Test, charm.numPes() * 4)
def __init__(self): if isinstance(self.thisIndex, tuple): myIndex = self.thisIndex[0] else: myIndex = self.thisIndex if charm.numPes() <= 20 or myIndex == 0: print("Test", self.thisIndex, "created")