def routine(self): log_info(self.logger,"Started") rewrite_loop(self.rule_classes, self.init_goals, self.logger, lambda: self.get_msg, self.send_msgs, self.create_new_worker ,self.location, output_logger=self.output_logger) log_info(self.logger,"Shutting Down")
def rewrite_loop(rule_classes, init_goals, logger, recv_msg_future_func, send_msgs_func, create_new_location_func, location, output_logger=None): fact_stores = new_stores() histories = new_histories() rules = map(lambda rule_class: rule_class(), rule_classes) if location != None: for rule in rules: rule.set_rank( loc_rank(location.value) ) interp_rules = interpret_rules(rules, fact_stores) goals = HeapGoals() matching_funcs = generate_matching_functions(goals, fact_stores, histories, interp_rules, logger, send_msgs_func, create_new_location_func, location=location) for goal in init_goals: goals.push( make_fact_repr(goal) ) recv_msg_func = recv_msg_future_func() current_steps = default_steps current_factor = backoff_factor done = False while not done: current_steps = default_steps ext_fact_repr = recv_msg_func() if ext_fact_repr != None: while ext_fact_repr != None: goals.push(ext_fact_repr) recv_msg_func = recv_msg_future_func() ext_fact_repr = recv_msg_func() current_factor = backoff_factor else: current_steps *= current_factor current_factor *= 2 while current_steps > 0: try: act_fact_repr = goals.pop() matching_funcs[act_fact_repr['sym_id']](act_fact_repr) current_steps -= 1 except IndexError: ext_fact_repr = try_until(recv_msg_func, times=pause_times) if ext_fact_repr != None: goals.push(ext_fact_repr) recv_msg_func = recv_msg_future_func() current_factor = backoff_factor current_steps = 0 else: done = True break log_info(logger,pretty_stores( fact_stores )) if not (output_logger == None): log_info(output_logger,"Location %s:\n%s" % (location.value,pretty_stores(fact_stores,brief=True)) )
def execute_msr(init_goals, rule_classes, use_mpi=True): if not use_mpi: logger = init_logger("msr", log_file="msr.log") log_info(logger,"Started") rewrite_loop(rule_classes, init_goals, logger, (lambda: lambda: None), (lambda _: None), (lambda x: None), None ) log_info(logger,"Shutting Down!") else: comm = MPI.COMM_WORLD rank = comm.Get_rank() # Check rules for dynamic spawning pattern. allow_dynamic_spawning = False for rule_class in rule_classes: rule = rule_class() if rule.req_dynamic_spawning: allow_dynamic_spawning = True break if allow_dynamic_spawning: mp = MSRMasterProcess(rank, init_goals, rule_classes, file_logging=True, output_file="output.log") mp.start() else: logger = init_logger("rank_%s" % rank, log_file="rank_%s.log" % rank) output_logger = init_logger("output", log_file="output.log") log_info(logger,"Started") init_goals = filter_goals_by_rank(init_goals, rank) rewrite_loop(rule_classes, init_goals, logger, receive_fact_future_mpi, send_facts, lambda x: None, lift(loc(rank)), output_logger=output_logger) log_info(logger,"Shutting Down!")
def is_alive(self): ''' procs = self.worker_procs for proc_id in procs: proc = procs[proc_id] if proc.is_alive(): return True ''' if len(self.worker_procs) > 0: return True # debug("Master %s finds all workers Dead!" % self.rank) log_info(self.logger,"All workers Dead!") if self.curr_sleep_limit > 0: return True else: return False
def is_alive(self): ''' procs = self.worker_procs for proc_id in procs: proc = procs[proc_id] if proc.is_alive(): return True ''' if len(self.worker_procs) > 0: return True # debug("Master %s finds all workers Dead!" % self.rank) log_info(self.logger, "All workers Dead!") if self.curr_sleep_limit > 0: return True else: return False
def exec_rhs(): log_info(logger, "Applying rule %s" % rule_id) # sys.stdout.write("Local: ") # for goal in local_goals: # sys.stdout.write("%s, " % goal) # sys.stdout.write("\nExternal: ") # for goal in external_goals: # sys.stdout.write("%s, " % goal) # sys.stdout.write("\n\n") # add_goals(goals, local_goals) (local_goals,external_goals) = partition_goals_by_proc_id(rhs(), loc_proc_id(location.value)) spawn_new_locs() log_info(logger, "Sending internal goals: %s" % map(make_fact_repr_loc,local_goals) ) log_info(logger, "Sending external goals: %s" % map(make_fact_repr_loc,external_goals) ) goals.push_many( map(make_fact_repr,local_goals) ) send_goal_func( map(make_fact_repr_loc,external_goals) )
def spawn_new_locs(): new_locations = exist_locs_func() log_info(logger, "Creating new %s locations: %s" % (len(new_locations),new_locations)) for location in new_locations: proc_id = loc_proc_id( location ) create_new_location_func( proc_id )
def is_alive(self): log_info(self.logger,"Testing liveness: %s" % (self.proc_id,self.proc.is_alive())) return self.proc.is_alive()
def start(self): log_info(self.logger, "Started") master_channel = self.master_channel worker_channels = self.worker_channels self.create_new_worker(str(self.rank)) for _ in range(0,self.init_workers-1): self.create_new_worker() done_something = False recv_future = receive_fact_future_mpi() while self.is_alive(): if not master_channel.empty(): int_msg = master_channel.get() task_type = int_msg['task'] if task_type == DELIVER_MSG: msgs = int_msg['msgs'] log_info(self.logger, "Delivering messages %s" % msgs) for data in msgs: if data['rank'] == self.rank: log_info(self.logger, "Internal message, sending to worker %s" % data['proc_id']) worker_channels[data['proc_id']].put( data ) else: log_info(self.logger, "External message, sending to MPI rank %s" % data['rank']) send_fact( data ) elif task_type == CREATE_WORKER: proc_id = int_msg['proc_id'] log_info(self.logger, "Creating worker %s" % proc_id) worker_channel = Queue() worker_channels[proc_id] = worker_channel p = self.new_worker(self.rank, proc_id, worker_channel, master_channel) p.start() self.worker_procs[proc_id] = p elif task_type == KILL_SELF: proc_id = int_msg['proc_id'] log_info(self.logger, "Killing worker %s" % proc_id) # self.worker_procs[proc_id].terminate() del self.worker_channels[proc_id] del self.worker_procs[proc_id] done_something = True mpi_msg = recv_future() if mpi_msg != None: worker_channels[mpi_msg['proc_id']].put( mpi_msg ) done_something = True recv_future = receive_fact_future_mpi() if done_something: done_something = False self.reset_sleep() else: self.sleep() log_info(self.logger,"Shutting Down")
def sleep(self): log_info(self.logger, "Sleeping: %s" % self.curr_sleep_limit ) time.sleep(self.curr_sleep_length) if self.curr_sleep_limit > 0: self.curr_sleep_length *= self.sleep_factor self.curr_sleep_limit -= 1
def is_alive(self): log_info(self.logger, "Testing liveness: %s" % (self.proc_id, self.proc.is_alive())) return self.proc.is_alive()
def start(self): log_info(self.logger, "Started") master_channel = self.master_channel worker_channels = self.worker_channels self.create_new_worker(str(self.rank)) for _ in range(0, self.init_workers - 1): self.create_new_worker() done_something = False recv_future = receive_fact_future_mpi() while self.is_alive(): if not master_channel.empty(): int_msg = master_channel.get() task_type = int_msg['task'] if task_type == DELIVER_MSG: msgs = int_msg['msgs'] log_info(self.logger, "Delivering messages %s" % msgs) for data in msgs: if data['rank'] == self.rank: log_info( self.logger, "Internal message, sending to worker %s" % data['proc_id']) worker_channels[data['proc_id']].put(data) else: log_info( self.logger, "External message, sending to MPI rank %s" % data['rank']) send_fact(data) elif task_type == CREATE_WORKER: proc_id = int_msg['proc_id'] log_info(self.logger, "Creating worker %s" % proc_id) worker_channel = Queue() worker_channels[proc_id] = worker_channel p = self.new_worker(self.rank, proc_id, worker_channel, master_channel) p.start() self.worker_procs[proc_id] = p elif task_type == KILL_SELF: proc_id = int_msg['proc_id'] log_info(self.logger, "Killing worker %s" % proc_id) # self.worker_procs[proc_id].terminate() del self.worker_channels[proc_id] del self.worker_procs[proc_id] done_something = True mpi_msg = recv_future() if mpi_msg != None: worker_channels[mpi_msg['proc_id']].put(mpi_msg) done_something = True recv_future = receive_fact_future_mpi() if done_something: done_something = False self.reset_sleep() else: self.sleep() log_info(self.logger, "Shutting Down")
def sleep(self): log_info(self.logger, "Sleeping: %s" % self.curr_sleep_limit) time.sleep(self.curr_sleep_length) if self.curr_sleep_limit > 0: self.curr_sleep_length *= self.sleep_factor self.curr_sleep_limit -= 1