def __init__( self, coordinator_aid, runner_aid, population_aid, timestep_generator_aid, store_names, summary_writer_aid=None, ): """Initialize.""" self.coordinator_proxy = asys.ActorProxy(asys.MASTER_RANK, coordinator_aid) self.every_runner_proxy = asys.ActorProxy(asys.EVERY_RANK, runner_aid) self.population_proxy = asys.ActorProxy(asys.MASTER_RANK, population_aid) self.timestep_generator_aid = timestep_generator_aid self.summary_writer_aid = summary_writer_aid self.store_names = store_names self.timestep = None self.round_start_time = None self.round_end_time = None # Step variables self.flag_coordinator_done = None self.num_store_flush_done = None self.store_rank_flush_time = None self._prepare_for_next_step()
def __init__(self, store_proxies, coordinator_aid, runner_aid): """Initialize the runner. Parameters ---------- store_proxies : dict [str -> ActorProxy] Actor proxy objects to stores coordinator_aid : str ID of the coordinator actor runner_aid : str ID of the runner actors """ self.local_agents = {} self.store_proxies = store_proxies self.coordinator_proxy = asys.ActorProxy(asys.MASTER_RANK, coordinator_aid) self.every_runner_proxy = asys.ActorProxy(asys.EVERY_RANK, runner_aid) self.runner_proxies = [ asys.ActorProxy(rank, runner_aid) for rank in asys.ranks() ] # Step variables self.timestep = None self.flag_create_agent_done = None self.flag_move_agents_done = None self.num_receive_agent_done = None self._prepare_for_next_step()
def main(self): source_rank = 0 sink_rank = 1 shape = (100, 100) source = xa.ActorProxy(source_rank, "source") sink = xa.ActorProxy(sink_rank, "sink") workers = {r: xa.ActorProxy(r, "worker") for r in xa.ranks() if r > 1} n = len(workers) source.create_actor_(Source, n, shape, workers) sink.create_actor_(Sink, n) for worker in workers.values(): worker.create_actor_(Worker, source, sink)
def end_tick(self, epicurve_part): """Receive the end tick message.""" LOG.debug("MainActor: Received end_tick") self.epicurve_parts.append(epicurve_part) # Check if tick ended if len(self.epicurve_parts) < len(self.behav_ranks): return row = [sum(xs) for xs in zip(*self.epicurve_parts)] self.tick_epicurve.append(row) self.cur_tick += 1 self.epicurve_parts = [] # Check if sim should still be running if self.cur_tick < self.num_ticks: LOG.info("MainActor: Starting tick %d", self.cur_tick) for rank in self.behav_ranks: asys.ActorProxy(rank, BEHAV_AID).start_tick() return # Sim has now ended LOG.info("Writing epicurve to output file.") columns = get_config().disease_model.model_dict["states"] epi_df = pd.DataFrame(self.tick_epicurve, columns=columns) epi_df.to_csv(self.output_file, index=False) asys.stop()
def run_behavior_model(self): """Run the behavior model for relevant agents.""" config = get_config() disease_model = config.disease_model visit_output_df = [ unserialize_df(batch) for batch in self.visit_output_batches if batch is not None ] if visit_output_df: visit_output_df = pd.concat(visit_output_df, axis=0) else: visit_output_df = get_config().empty_visit_output_df new_state_df = [ unserialize_df(batch) for batch in self.new_state_batches if batch is not None ] if new_state_df: new_state_df = pd.concat(new_state_df, axis=0) else: new_state_df = get_config().empty_state_df self.behavior_model.run_behavior_model(new_state_df, visit_output_df) LOG.debug("BehaviorActor: Sening epicurve row to main") state_count = new_state_df.groupby("current_state").agg({ "pid": len }).pid epirow = [state_count.get(i, 0) for i in range(disease_model.n_states)] asys.ActorProxy(asys.MASTER_RANK, MAIN_AID).end_tick(epirow) self.visit_output_batches = [] self.new_state_batches = []
def __init__(self): self.start = None self.end = None self.objects_sent = 0 self.objects_received = 0 self.num_consumer_done = 0 self.producer = xa.ActorProxy(xa.MASTER_RANK, "producer")
def __init__(self): self.main_actor = xa.ActorProxy(MASTER_RANK, "main") self.prog_start = perf_counter() self.start_time = None self.end_time = None self.num_messages = 0
def main(self): # Create a greeter on very rank. greeter_id = "greeter" for rank in xa.ranks(): xa.create_actor(rank, greeter_id, Greeter) # Send the greeters the greet message. every_greeter = xa.ActorProxy(xa.EVERY_RANK, greeter_id) every_greeter.greet("world", send_immediate=True) # We are done now. xa.stop()
def __init__(self, balancer, simulator_aid, runner_aid, summary_writer_aid=None): """Initialize. Parameters ---------- balancer: LoadBalancer The agent load balancer simulator_aid : str The ID of the simulator actor runner_aid : str The ID of the runner actors summary_writer_aid : str The ID of the local summary writer actor """ self.balancer = balancer self.simulator_proxy = asys.ActorProxy(asys.MASTER_RANK, simulator_aid) self.runner_proxies = [ asys.ActorProxy(rank, runner_aid) for rank in asys.ranks() ] self.every_runner_proxy = asys.ActorProxy(asys.EVERY_RANK, runner_aid) self.summary_writer_aid = summary_writer_aid self.num_agents_created = 0 self.num_agents_died = 0 # Step variables self.timestep = None self.agent_constructor = None self.flag_create_agent_done = None self.num_agent_step_profile_done = None self.rank_step_time = None self.rank_memory_usage = None self.rank_n_updates = None self.agent_step_time = None self.agent_memory_usage = None self.agent_n_updates = None self.balancing_time = None self._prepare_for_next_step()
def __init__(self, store_name, simulator_aid): """Initialize. Parameters ---------- store_name : str Name of the current state store simulator_aid : str Proxy of the simulator actor """ self.store_name = store_name self.simulator_proxy = asys.ActorProxy(asys.MASTER_RANK, simulator_aid) logger_name = "%s.%s" % (self.__class__.__name__, self.store_name) self.log = asys.getLogger(logger_name) self.num_handle_update_done = 0
def main(self): """Run the simulation.""" for rank in asys.ranks(): asys.create_actor( rank, CONFIG_AID, ConfigActor, per_node_behavior=self.per_node_behavior, java_behavior=self.java_behavior, ) asys.create_actor(rank, LOC_AID, LocationActor) asys.create_actor(rank, PROG_AID, ProgressionActor) for rank in self.behav_ranks: asys.create_actor(rank, BEHAV_AID, BehaviorActor) LOG.info("MainActor: Starting tick %d", self.cur_tick) for rank in self.behav_ranks: asys.ActorProxy(rank, BEHAV_AID).start_tick()
def __init__(self): self.main = xa.ActorProxy(xa.MASTER_RANK, "main") self.consumer = [ xa.ActorProxy(rank, "consumer") for rank in xa.ranks() ] self.every_consumer = xa.ActorProxy(xa.EVERY_RANK, "consumer")
def __init__(self): self.objects_received = 0 self.main = xa.ActorProxy(xa.MASTER_RANK, "main")
def __init__(self): self.worker = xa.ActorProxy(WORKER_RANK, "worker")
def __init__(self): self.main_actor = xa.ActorProxy(MASTER_RANK, "main")
def __init__(self): self.worker = xa.ActorProxy(WORKER_RANK, "worker") self.prog_start = perf_counter() self.ping_start = None self.timings = []
def __init__(self): self.start = None self.end = None self.workers_done = 0 self.every_worker = xa.ActorProxy(xa.EVERY_RANK, "worker")