def fini(self,state): etime,edate = tl.datetime() state['etime'] = etime state['edate'] = edate state['radio'].off() tl.log(1,self.fmsg,state['name'],edate) return True
def sinit(state,screen): tl.log(5,'started curses interface...') curses.noecho() curses.cbreak() screen.nodelay(True) curses.curs_set(False) screen.keypad(True) curses.start_color() curses.init_pair(1, curses.COLOR_BLACK, curses.COLOR_GREEN) curses.init_pair(2, curses.COLOR_WHITE, curses.COLOR_BLACK) screen.bkgd(curses.color_pair(2)) screen.refresh() bplex = buffplex(screen) windows = bplex.init() topy,topx = bplex.center_view(windows[0]) #current_selected = 0 #last = 1 #top_textbox = windows[0] state['topy'] = topy state['topx'] = topx state['screen'] = screen state['windows'] = windows state['current'] = 0 state['last'] = 1 state['delay'] = 0.01 state['buffplex'] = bplex return True
def rchan(self,n): if not n in self.channels: tl.log(3,'channel does not exist',n) return cx = self.priority.index(n) ch = self.channels[self.priority[cx]] del self.channels[self.priority.pop(cx)]
def set_stage(state): tl.log(5,'current stage',state['activestage']) m = 'desired active stage?' actstg = state['radio'].above.recv('prompt',m) state['activestage'] = actstg tl.log(5,'current stage',state['activestage']) return True
def work(self,state): n,r = state['name'],state['radio'] qu,cy = state['queue'],state['cycle'] while qu: qcnt = len(qu) if cy: # IF THE SLAVES ARE DISPATCHERS, THEY SHOULD BE # IMMEDIATELY ADDED BACK INTO THE CYCLE # ONLY SEND ENQUEUEEND TO DISPATCHERS... jb,sn = qu.pop(0),cy.pop(0) r.sendto(sn,'enqueue',jb,'enqueueend') else: tl.log(0,self.nineq_msg,qcnt,n) if not self.nonidlework(state): tl.log(3,self.niwk_fail_msg) return False break if len(cy) == len(r.below): state['queue_scheme'] = 'active' r.above.schm = 'active' else: qcnt = len(qu) tl.log(0,self.nieq_msg,qcnt,n) if not self.nonidlework(state): tl.log(3,self.niwk_fail_msg) return False if not self.unload(state): tl.log(3,self.unld_fail_msg) return False return True
def deploy(self,state): jx = self.priority(state) todeploy = self.queue[jx] e,zs,ax,al = self.tickets[self.active] pplan = e.postprocess_plan cplan = e.cartographer_plan cplan._move_to(ax) e._run_params_to_location() traj_cnt,targ_cnt,capt_cnt,ptargets = e._run_init(ax) dshape = (traj_cnt,targ_cnt,capt_cnt) target_traj_cnt = traj_cnt traj_cnt,dshape = cplan._metamap_remaining(ax,traj_cnt,dshape) lstr = cplan._print_friendly_pspace_location(ax) tl.log(1,'lstr',lstr) if not traj_cnt == 0: simu = e.module.simulation seed = e.module._set_seed sarg = e.module.sim_args subj = ( ax,(sarg[0],sarg[2:], e._seed(),dshape,ptargets)) else:subj = (ax,None) ax += 1 self.results.append(None) self.queue.insert(0,(jx,subj)) self.tickets[self.active] = (e,zs,ax,al) if ax == al:self.queue.pop(-1) self.deployed.append(jx) return jx,subj
def abuff(self,name): if name in self.buffs: tl.log(4,'buff already exists',name) return self.buffnames.append(name) self.buffcount += 1 self.buffs[name] = buff()
def encycle(state): r,l = state['radio'],state['last'] stage = state['stagemap'][l] fres = r.channels[l].recv('active') if not stage.inform(state,fres): tl.log(4,'inform stage failure') return False return True
def achan(self,n,c,a): if n in self.channels: tl.log(4,'channel already exists',n) return newchan = ch.channel(c,a) self.channels[n] = newchan self.priority.append(n) return newchan
def echo(self,state): r = state['radio'] if r.above.schm == 'prompt':schm = 'prompt' else:schm = 'active' echomsg = r.above.recv(schm,'echo msg?') r.sendbelow('echo',echomsg) n,h = state['name'],state['host'] tl.log(5,'controller echo',n,h,echomsg) return True
def work(self, state, jx=0): if state["queue"]: jid, job = state["queue"].pop(jx) state["results"][jx] = (jid, state["work"](state, job)) else: if not self.unload(state): tl.log(3, "grunt unload failure") return False return True
def cycle(state): m,s = state['shake'],state['pinfo'] r,v = state['radio'],state['verb'] if v:tl.log(0,'ghostclient cycling',m) r.connect(s,'passive',m,v = v) r.sendto(s,m) r.disconnect(s,v = v) if v:tl.log(0,'ghostclient cycled',m) return True
def admin(service, root=0): assert MPI.COMM_WORLD.Get_size() == 1 brain() host = MPI.Get_processor_name() tl.log(0, "host began serving service", host, service) port, info = tl.serve(service) ad.control(service, port, info) tl.unserve(service, port, info) tl.log(0, "host ceased serving service", host, service)
def encycle(state): r,l,c = state['radio'],state['last'],state['cycle'] jres = r.channels[l].recv('active') if not jres: tl.log(0,'received null result') return True state['results'].extend(jres) if not l in c:c.append(l) return True
def init(self,state): stime,sdate = tl.datetime() state['stime'] = stime state['sdate'] = sdate state['host'] = MPI.Get_processor_name() state['name'] = self.name state['controller'] = self tl.log(1,self.imsg,self.name,sdate,stime) return True
def test_work(state): actstg = state['activestage'] subqueue = [] for x in range(5): subqueue.append((actstg,'hello from user!%i' % (x))) frd = state['istream'] frd.send('enqueue',subqueue) tl.log(5,'test work',subqueue) return True
def recv(self,a,p = None): if a == 'prompt': if p is None:p = '' i = tl.prompt(self.pmsg % p) else: f,r = self.freq,self.root if a == 'active':i = tl.pollrecv(f,r) elif a == 'passive':i = tl.passrecv(f,r) else:tl.log(3,amsg,a) return i
def disconnect(self,n,v = True): if n in self.below: self.channels[n].send('quit','quit') self.below.remove(n) if v:tl.log(1,'disconnected from slave',n) else: tl.detach(self.channels[n].freq,v = v) self.adjacent.remove(n) if v:tl.log(1,'disconnected from peer',n) self.rchan(n)
def help(self,state,w = 50): cs,hlp = self.commands,cStringIO.StringIO() hlp.write('\n'+'#'*w+'\n\tchannel help...\n'+'#'*w) hlp.write('\n input options:') for c in cs: if cs[c][0] is None:continue hlp.write('\n %30s : %10s' % (cs[c][0],c)) hlp.write('\n'+'#'*w+'\n\tend help.......\n'+'#'*w) tl.log(5,hlp.getvalue()) return True
def execprotocol(state): pr,pi = state['radio'].channels['above'].recv('active') state['proto'],state['pinfo'] = pr,pi if pr in state['protos']: tl.log(0,'slave executing protocol',pr) promod,profunc = state['protos'][pr] promod = importlib.import_module(promod) promod.__dict__[profunc](state) else:tl.log(0,'slave unfamiliar with protocol',pr) return True
def proc(self,state,i): if not type(i) == type(''): self.ambig(state,i) else: if i in self.commands: if not self.commands[i][1](state): return False if state['verb'] and not i == 'pass': tl.log(0,self.smsg,i) else:self.ambig(state,i) return True
def tear_network(state): if not check_network(state,'tear_network','tear'):return True if state['tearwait']: for sgn in state['stagemap']: stage = state['stagemap'][sgn] while not stage.finished(state): tl.log(0,'tear_network is waiting for stage',sgn) time.sleep(1.0) state['last'] = sgn state['radio'].channels[sgn](state,'passive') state['radio'].disband(sgn) else:state['radio'].disband(state['stagemap'].keys()) state['graph'].state = 'down' return True
def form(self,state): defmcfg = state['controller'].smngr.get('defaultmcfg') defmpath = tl.datpath(os.path.join('mcfgdata',defmcfg)) if not os.path.exists(defmpath): mfile = tl.prompt('\n\n\tmcfg filename? :: >> ') else:mfile = defmcfg mpath = tl.datpath(os.path.join('mcfgdata',mfile)) if not os.path.exists(mpath): lmsg = 'mcfgstage.form()->mcfg file not found: %s' logging.warning(lmsg,mfile) return [] state['stageform'] = {} state['stageform']['mpath'] = mpath with open(mpath) as mh:mstr = mh.read() tl.log(2,'INPUT MCFGSTRING',mstr) return [(self.name,mstr)]
def brain(): localmemdir = os.path.join(os.getcwd(), "memory") if os.path.exists(localmemdir): tl.log(1, "memory entact") else: tl.log(1, "memory directory not found") tl.log(1, "default memory being constructed...") defmemdir = tl.respath("defaultmemory") shutil.copytree(defmemdir, localmemdir) tl.log(1, "default memory constructed locally")
def run_mjob(state,job): ax,job = job if job is None:return ax,None f,args,drseed,dshape,ptargets = job rgen = random.Random() rgen.seed(drseed) dppath = os.path.join(tl.inmem('data'),'mcfgdata') lfu.user_data_pool_path = dppath loc_pool = dba.batch_node( metapool = True,rnum = drseed, dshape = dshape,targets = ptargets) tl.log(1,'running pspace location',ax) for x in range(dshape[0]): pseed = rgen.randint(0,sys.maxint) r = f(pseed,*args) loc_pool._trajectory(r) loc_pool._stow(v = False) loc_pool._sanitize() return ax,loc_pool
def init(self,state): state['nonidle_delay'] = 1.0 state['queue'],state['results'] = [],[] state['queue_scheme'] = 'active' i,r = state['pinfo'],state['radio'] state['work'] = i.root[1][1] tl.log(1,'dispatch deploying slaves') sport = MPI.Open_port(MPI.INFO_NULL) below = i.below(i.root) varis = [] for cv in below: schan = r.spawn(cv[1][0],sport) schan.acmd('idle',encycle,'') cprot,ginfo = i.proto(cv,**state) tl.log(4,'GINFO',ginfo) schan.send('proto',(cprot,ginfo)) state['cycle'] = r.below[:] chcnt = len(state['cycle']) tl.log(1,'dispatch deployed slaves',chcnt) cinit = cn.controller.init(self,state) abv = state['radio'].above abv.acmd('enqueue',enqueue,'') return cinit
def enqueue(self,state,job): tl.log(5,'MCFG ENQUEUE',job[:20]) dppath = os.path.join(tl.inmem('data'),'mcfgdata') lfu.user_data_pool_path = dppath ensem = self.emnger._add_ensemble(module = 'gillespiem') ensem._parse_mcfg(mcfgstring = job) ensem.output_plan.targeted = ensem.run_params['plot_targets'][:] ensem.output_plan._target_settables() ensem.cartographer_plan._move_to(0) ensem._run_params_to_location_prepoolinit() cplan = ensem.cartographer_plan pplan = ensem.postprocess_plan meta = cplan.maintain_pspmap arc = cplan.trajectory if pplan.use_plan:zs = pplan._init_processes(arc) self.tickets[job] = (ensem,zs,0,len(arc)) self.active = job jx = len(self.queue) self.queue.append((jx,job)) self.results.append(None) state['lastenqueuetime'] = time.time() state['statbuff'] = os.path.join(dppath,self.name+'.buff') self.update_statbuff(state,' 0.0 percent complete')
def work(self,state): if state['state'] == 'open': tl.log(0,'server accepting clients...') sp,si = state['service'] cchan,shake = state['radio'].accept(sp,si,'passive') if shake == 'ghost':state['radio'].disconnect(shake,False) elif shake == 'monitor':tl.log(5,'server accepted monitor',shake) #elif shake == 'halt': # state['state'] = 'closed' # state['radio'].disconnect(shake) else: #clientinstructions = { # 'enqueue' : ('order work',orderwork), # 'stage' : ('order a new stage',orderstage)} tl.log(5,'server accepted client',shake) return True
def run(self,comm = None,port = None,state = None): if state is None: radio = rd.splitter('above',comm,'prompt') state = {'radio':radio,'port':port,'verb':True} else:radio = state['radio'] if not self.init(state): tl.log(3,'controller init failure') raise ValueError while True: if not radio(state):break if self.work(state):pass else: tl.log(3,'controller work failure') break if not self.fini(state): tl.log(3,'controller fini failure') raise ValueError
def client(service): host = MPI.Get_processor_name() tl.log(0, "host ceased serving service", host, service) cl.control(service) tl.log(0, "host ceased serving service", host, service)