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