def __init__(self, per_node_behavior, java_behavior):
"""Initialize."""
nodes = list(asys.nodes())
current_rank = asys.current_rank()
current_node = [
node for node in nodes if current_rank in asys.node_ranks(node)
]
current_node = current_node[0]
current_node_index = nodes.index(current_node)
os.environ["CURRENT_NODE"] = str(current_node_index)
self.per_node_behavior = per_node_behavior
self.java_behavior = java_behavior
self.seed = int(os.environ["SEED"])
self.tick_time = int(os.environ["TICK_TIME"])
self.attr_names = os.environ["VISUAL_ATTRIBUTES"].strip().split(",")
self.disease_model = DiseaseModel(os.environ["DISEASE_MODEL_FILE"])
self.visit_schema = make_visit_schema(self.attr_names)
self.visit_output_schema = make_visit_output_schema(self.attr_names)
self.state_schema = make_state_schema()
self.empty_visit_df = self.visit_schema.empty_table().to_pandas()
self.empty_visit_output_df = self.visit_output_schema.empty_table(
).to_pandas()
self.empty_state_df = self.state_schema.empty_table().to_pandas()
lid_part_file = os.environ["LID_PARTITION"]
pid_part_file = os.environ["PID_PARTITION"]
lid_part_df = pd.read_csv(lid_part_file)
pid_part_df = pd.read_csv(pid_part_file)
self.lid_rank = {}
for lid, node, cpu in lid_part_df.itertuples(index=False, name=None):
self.lid_rank[lid] = node_rank(node, cpu)
self.pid_prog_rank = {}
self.pid_behav_rank = {}
for pid, node, cpu in pid_part_df.itertuples(index=False, name=None):
self.pid_prog_rank[pid] = node_rank(node, cpu)
if per_node_behavior:
self.pid_behav_rank[pid] = node_rank(node, 0)
else:
self.pid_behav_rank[pid] = node_rank(node, cpu)
if per_node_behavior:
self.behav_ranks = [
asys.node_ranks(node)[0] for node in asys.nodes()
]
else:
self.behav_ranks = asys.ranks()
def pong(self):
self.workers_done += 1
if self.workers_done == len(xa.ranks()):
self.end = time()
print("n_ranks: %d" % len(xa.ranks()))
print("n_nodes: %d" % len(xa.nodes()))
runtime = (self.end - self.start)
print("runtime: %e" % runtime)
xa.stop()
def maybe_stop(self):
if self.num_consumer_done == len(xa.ranks()):
self.end = time()
print("n_sent: %d" % self.objects_sent)
print("n_received: %d" % self.objects_received)
print("n_ranks: %d" % len(xa.ranks()))
print("n_nodes: %d" % len(xa.nodes()))
runtime = (self.end - self.start)
print("runtime: %e" % runtime)
xa.stop()
def __init__(self):
"""Initialize."""
self.num_ticks = int(os.environ["NUM_TICKS"])
self.output_file = os.environ["OUTPUT_FILE"]
self.per_node_behavior = bool(
int(os.environ.get("PER_NODE_BEHAVIOR", "0")))
self.java_behavior = int(os.environ.get("JAVA_BEHAVIOR", "0"))
if self.java_behavior:
self.per_node_behavior = True
self.epicurve_parts = []
self.cur_tick = 0
self.tick_epicurve = []
if self.per_node_behavior:
self.behav_ranks = [
asys.node_ranks(node)[0] for node in asys.nodes()
]
else:
self.behav_ranks = asys.ranks()
def store_flush_done(self, store_name, rank, flush_time):
"""Log that the store flush for the given store was completed.
Parameters
----------
store_name : str
Name of the state store
rank : int
The rank on which the store was running
flush_time : float
Number of seconds taken by the flush operation.
"""
if __debug__:
LOG.debug("The store %s on rank %d has completed flush",
store_name, rank)
assert self.num_store_flush_done[store_name] < len(asys.nodes())
self.num_store_flush_done[store_name] += 1
self.store_rank_flush_time[store_name, rank] = flush_time
self._try_start_step(starting=False)
def _try_start_step(self, starting):
if not starting:
n_nodes = len(asys.nodes())
nsfd_str = [(name, num, n_nodes)
for name, num in self.num_store_flush_done.items()]
nsfd_str = ["%s=%d/%d" % tup for tup in nsfd_str]
nsfd_str = ",".join(nsfd_str)
LOG.log(
INFO_FINE,
"Can start step? (FCD=%s,%s)",
self.flag_coordinator_done,
nsfd_str,
)
if not self.flag_coordinator_done:
return
for store_name in self.store_names:
if self.num_store_flush_done[store_name] < n_nodes:
return
if not starting:
self.round_end_time = perf_counter()
self._write_summary()
timestep_generator = asys.local_actor(self.timestep_generator_aid)
self.timestep = timestep_generator.get_next_timestep()
if self.timestep is None:
LOG.info("Simulation finished.")
asys.stop()
return
self.round_start_time = perf_counter()
self.round_end_time = None
LOG.info("Starting timestep %f", self.timestep.step)
self.population_proxy.create_agents(self.timestep)
self.coordinator_proxy.step(self.timestep)
self.every_runner_proxy.step(self.timestep)
self._prepare_for_next_step()
def node_rank(node, cpu):
"""Get the rank of a cpu given node and cpu index."""
n = asys.nodes()[node]
r = asys.node_ranks(n)[cpu]
return r