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