def work(self): if self.flag == "4": start = time() print("step4 on "+str( charm.myPe())) #self.driver.step4() #self.driver.step6() self.contribute(self.driver.separate_step4(), Reducer.sum, self.future) print("step4: " + str(time() - start)) elif self.flag == '6': start = time() print("step6 on " + str(charm.myPe())) # self.driver.step4() # self.driver.step6() self.contribute(self.driver.separate_step6(), Reducer.sum, self.future) print("step6: " + str(time() - start)) elif self.flag == "3": start = time() #self.flag = 100 print("step3 on "+str( charm.myPe())) result = self.driver.step3() self.contribute(result, Reducer.sum, self.future) print("step3: "+ str(time() - start)) elif self.flag == "5": #print("adjnaskaajsdnkjsanksaksnkajnk") start = time() print("step5 on "+str(charm.myPe())) self.contribute(self.driver.step5(), Reducer.sum, self.future) print("step5: " + str(time() - start)) else: self.contribute(np.zeros(9000000), Reducer.sum, self.future)
def SayGoodbye(self): if charm.myPe() < 10: print('Goodbye from PE', charm.myPe()) # goodbye chares do an empty reduction. after the reduction completes, # the 'done' method of the mainchare will be called. # mainProxy is a global of this module, set previously from the mainchare self.reduce(mainProxy.done)
def start(self): """ Invoke the starter code for test. """ if charm.myPe() == 0: print(self.thisIndex, 'on PE', charm.myPe(), 'before migration') self.toPe = (charm.myPe() + 1) % charm.numPes() self.thisProxy[self.thisIndex].migrate(self.toPe)
def __init__(self, home_pes_future): assert ( not all_created ) # makes sure constructor is only called for creation, not migration self.iteration = 0 self.originalPe = charm.myPe() self.data = numpy.arange(100, dtype='int64') * (self.originalPe + 1) # notify controllers that array elements are created and pass home PE of every element self.contribute(charm.myPe(), Reducer.gather, home_pes_future)
def migrated(self): """ Test method called after migration to assert that the chare has migrated. """ if self.thisIndex == (0, ): print(self.thisIndex, 'migrated to PE', charm.myPe()) assert charm.myPe() == self.toPe self.contribute(None, None, charm.thisProxy[0].exit)
def sum_local_exp(self, f): start = time() if self.flag == "4": print("step4 on processor:" + str(charm.myPe())) self.contribute(self.driver.separate_step4(), Reducer.sum, f) print("step4 time to finish:" + str(time() - start)) elif self.flag == "6": print("step6 on processor:" + str(charm.myPe())) self.contribute(self.driver.separate_step6(), Reducer.sum, f) print("step6 time to finish:" + str(time() - start))
def say(self, msg): """ Helper method which is called by invoking the element proxy. This method is expected to be called on only the PE for which the proxy is created. """ self.count += 1 print("Say", msg, "on PE", charm.myPe()) if self.count == 2: assert charm.myPe() == 2 exit()
def direct_result(self, f): start = time() if self.flag == "3": print("step3 on processor: " + str(charm.myPe())) self.contribute(self.driver.step3(), Reducer.sum, f) print("step3 time to finish:" + str(time() - start)) elif self.flag == "5": print("step5 on processor: " + str(charm.myPe())) self.contribute(self.driver.step5(), Reducer.sum, f) print("step5 time to finish:" + str(time() - start))
def work(self): if self.flag == "4": start = time() print("step4 on " + str(charm.myPe())) self.contribute(self.driver.separate_step4(), Reducer.sum, self.future) print("step4: " + str(time() - start)) elif self.flag == "6": start = time() print("step6 on " + str(charm.myPe())) self.contribute(self.driver.separate_step6(), Reducer.sum, self.future) print("step6: " + str(time() - start)) else: self.contribute(np.zeros(self.total), Reducer.sum, self.future)
def start(self): self.hasMigrated = False self.iteration += 1 if self.iteration == MAX_ITER: self.contribute(None, None, charm.thisProxy[0].exit) else: self.prevPe = charm.myPe() self.AtSync()
def getVal(self, iteration): result = 53 * testGroup[charm.myPe()].getVal(ret=True).get() * self.thisIndex[0] * self.iteration #assert result == 53 * (73 + charm.myPe()) * self.thisIndex[0] * self.iteration self.msgsRcvd += 1 if self.msgsRcvd == numChares: self.msgsRcvd = 0 self.iteration += 1 return result
def calculate(self): print("this piece " + str(self.pos) + " is on processor:" + str(charm.myPe())) st = time() partial_direct_interaction = ro.driver.multicore_step3( self.total_processors, self.pos) self.contribute(partial_direct_interaction, Reducer.sum, self.f) print("time to calculate " + str(self.pos) + "th piece of the direct interaction:" + str(time() - st))
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, mainProxy.start)
def work(self): if self.flag == "467": start = time() print("step467 on processor:"+str( charm.myPe())) self.contribute(self.driver.step4(), Reducer.sum, self.thisProxy[0].collectResult) print("step467 took " + str(time() - start)+" seconds to finish") elif self.flag == "3": start = time() print("step3 on processor:"+str( charm.myPe())) result = self.driver.step3() self.contribute(result, Reducer.sum, self.thisProxy[0].collectResult) print("step3 took "+ str(time() - start)+" seconds to finish") elif self.flag == "5": start = time() print("step5 on processor:"+str(charm.myPe())) self.contribute(self.driver.step5(), Reducer.sum, self.thisProxy[0].collectResult) print("step5 took " + str(time() - start) +" seconds to finish") else: self.contribute(np.zeros(self.total), Reducer.sum, self.thisProxy[0].collectResult)
def __init__(self): self.x = numpy.arange(DATA_LEN, dtype='float64') y = self.x * (self.thisIndex[0] + 1) self.S1 = y.tobytes() self.S2 = array.array('d', y) self.S3 = y self.msgsRcvd = 0 self.contribute(charm.myPe(), Reducer.gather, self.thisProxy.recvLocations)
def work(self): if self.flag == "4": start = time() print("step4 on processor"+str( charm.myPe())) self.contribute(self.driver.multicore_separate_step4(self.total_processors,self.pos), Reducer.sum, self.future) print("step4 time to finish: " + str(time() - start)+" on processor "+str(str(charm.myPe()))) elif self.flag == "3": print("step3 on processor " + str(charm.myPe())) st = time() partial_direct_interaction = self.driver.multicore_step3(self.total_processors, self.pos) self.contribute(partial_direct_interaction, Reducer.sum, self.future) print("time to calculate " + str(self.pos) + "th piece of the direct interaction:" + str(time() - st)) elif self.flag == "6": start = time() print("step6 on processor "+str(charm.myPe())) self.contribute(self.driver.multicore_separate_step6(self.total_processors, self.pos), Reducer.sum, self.future) print("step6 time to finish: " + str(time() - start)+" on processor "+str(str(charm.myPe()))) elif self.flag == "5": start = time() print("step5 on "+str(charm.myPe())) self.contribute(self.driver.step5_with_extent(self.total_processors, self.pos), Reducer.sum, self.future) print("step5 time to finish: " + str(time() - start)+" on processor "+str(str(charm.myPe())))
def start(self): # print('Controller running on PE', charm.myPe()) for i in range(charm.numPes()): assert i == charm.thisProxy[i].myPe(ret=True).get() pe = charm.myPe() - 1 if pe == -1: pe = 0 charm.thisProxy[pe].exec('global MY_GLOBAL; MY_GLOBAL = 7262', __name__, awaitable=True).get() assert charm.thisProxy[pe].eval('MY_GLOBAL', __name__, ret=True).get() == 7262 Group(Test)
def start(self): if self.thisIndex == (0, ) and self.iteration % 20 == 0: print('Iteration ' + str(self.iteration)) self.check() A = numpy.arange(1000, dtype='float64') work = 1000 * int(round(math.log(charm.myPe() + 1) + 1)) # elements in higher PEs do more work for i in range(work): A += 1.33 self.iteration += 1 if self.iteration == MAX_ITER: self.contribute(None, None, charm.thisProxy[0].exit) elif self.iteration % 20 == 0: self.AtSync() else: self.thisProxy[self.thisIndex].start()
def sayHi(self, hello_num): print('Hi[' + str(hello_num) + '] from element', self.thisIndex, 'on PE', charm.myPe()) lastIdx = tuple([size - 1 for size in self.array_dims]) if self.thisIndex == lastIdx: # this is the last index, we are done print('All done') exit() else: # send a hello message to the next element (in row-major order) nextIndex = list(self.thisIndex) num_dims = len(self.array_dims) for i in range(num_dims - 1, -1, -1): nextIndex[i] = (nextIndex[i] + 1) % self.array_dims[i] if nextIndex[i] != 0: break return self.thisProxy[nextIndex].sayHi(hello_num + 1)
def doReduction(self): print('Test element ' + str(self.thisIndex) + ' on PE ' + str(charm.myPe()) + ' is starting its contributions.') # test contributing single int back to Main self.contribute(42, Reducer.sum, mainProxy.done_int) # test contributing list of floats back to main num = [10.1, 13.4] self.contribute(num+[float(self.thisIndex[0])], Reducer.sum, mainProxy.done_float) # test nop reduction to main self.contribute(None, Reducer.nop, mainProxy.done_nop) # test contributing to Test[0] self.contribute(4.2, Reducer.sum, self.thisProxy[0].reductionTarget) # test contributing to Test (broadcast) self.contribute(numpy.array([4.2, 8.4]), Reducer.sum, self.thisProxy.reductionTargetBcast) # test contributing to TestGroup[0] self.contribute(4, Reducer.sum, groupProxy[0].reduceFromArray) # test contributing to TestGroup (broadcast) self.contribute(array.array('i', [0, 8, 3]), Reducer.sum, groupProxy.reduceFromArrayBcast)
def start(self): assert charm.myPe() == 1 N = charm.numPes() * 3 a1 = charm.thisProxy[0].createArray(Test, N, ret=True).get() f = Future() a1.work(f, 5) assert f.get() == N * 5 N = 25 a2 = charm.thisProxy[0].createArray(Test, (5, 5), args=[33], ret=True).get() f = Future() a2.work(f, 6) assert f.get() == N * (6 + 33) exit()
def doReduction(self): print('TestGroup element on PE ' + str(charm.myPe()) + ' is starting its contributions.') # test contributing single int back to Main self.contribute(42, Reducer.sum, mainProxy.done_int) # test contributing list of floats back to Main num = [10.1, 13.4] self.contribute(num + [float(self.thisIndex)], Reducer.sum, mainProxy.done_float) # test nop reduction to main self.contribute(None, Reducer.nop, mainProxy.done_nop) # test contributing to TestArray[0] self.contribute([4.2, 13.1], Reducer.sum, arrayProxy[0].reduceGroupToArray) # test contributing to TestArray (broadcast) self.contribute(-4, Reducer.sum, arrayProxy.reduceGroupToArrayBcast) # test contributing to TestGroup[0] self.contribute([5, 7, -3, 0], Reducer.sum, self.thisProxy[0].reduceGroupToGroup) # test contributing to TestGroup (broadcast) self.contribute(-4.2, Reducer.sum, self.thisProxy.reduceGroupToGroupBcast)
def __init__(self): print('TestGroup ' + str(self.thisIndex) + ' created on PE ' + str(charm.myPe()))
def main(args): print('Charm program started on processor', charm.myPe()) print('Running on', charm.numPes(), 'processors') exit()
def SayHi(self): if charm.myPe() < 10: print('Hello from PE', charm.myPe(), 'on', time.strftime('%c')) # call SayGoodbye method of the goodbye chare on my PE, bye_chares is # a global variable of this module, set previously from the mainchare bye_chares[charm.myPe()].SayGoodbye()
def work2(self, cb): self.contribute(charm.myPe(), Reducer.sum, cb)
def check1(self): assert charm.myPe() == 3 return 68425
def resumeFromSync(self): assert self.migratable == (self.thisIndex[0] % 2 != 0) if not self.migratable: assert charm.myPe() == self.originalPe assert self.hasMigrated == (self.prevPe != charm.myPe()) self.thisProxy[self.thisIndex].start()
def __init__(self): print('Hello from MyChare instance in processor', charm.myPe())
def __init__(self): self.iteration = 0 self.originalPe = charm.myPe() if self.thisIndex[0] % 2 == 0: self.setMigratable(False)