def __setup_modules(self):
"""
A helper function used by the Application constructor to setup the modules
portion of the Application.
"""
self.__log.debug("Start __setup_modules()")
for mod_node in self.__config_node.get_all_sub_nodes('module'):
mod_config_node = ConfigTree(mod_node)
assert mod_config_node.get_node_name() == mod_node.get('name'), \
'check failed'
new_module = Module(self.__work_dir, self.__module_lib_name,
self.__module_lib_full_parent_dir,
mod_config_node)
# check for a duplicate module before appending a new one
for module in self.__modules:
mod_lib_dir_name = module.library_parent_dir
mod_lib_name = module.library_name
if new_module.name == module.name:
if new_module.get_library_parent_dir() == mod_lib_dir_name:
assert new_module.get_library_name != mod_lib_name, \
"duplicate module; ABORT."
# add module to list
self.__modules.append(new_module)
self.__log.debug("appended module %s", mod_node.get('name'))
self.__log.debug("end __setup_modules()")
def __setup_networks(self):
'''
A helper function used by the Application constructor to setup the networks
portion of the Application.
'''
self.__log.debug('start __setup_networks()')
for net_node in self.__config_node.get_all_sub_nodes("network"):
net_config_node = ConfigTree(net_node)
assert net_config_node.get_node_name() == net_node.get(
'name'), 'check failed'
network = Network(net_config_node)
self.__networks.append(network)
self.__log.debug("appended network %s", net_node.get("name"))
self.__log.debug("end __setup_networks()")
def __setup_simulations(self):
'''
This method is a helper function for the Cortix constructor
whose purpose is to set up the simulations defined by the
Cortix configuration.
'''
for sim in self.__config_tree.get_all_sub_nodes('simulation'):
self.__log.debug("__setup_simulations(): simulation name: %s",
sim.get('name'))
sim_config_tree = ConfigTree(sim)
simulation = Simulation(self.__work_dir, sim_config_tree)
self.__simulations.append(simulation)
def __init__(self, net_config_node=ConfigTree()):
assert isinstance(net_config_node, ConfigTree), \
'-> net_config_node is invalid.'
self.__config_node = net_config_node
self.__name = self.__config_node.get_node_name()
self.__connectivity = list(dict())
self.__slot_names = list()
# cortix communication file for modules
self.__runtime_cortix_comm_file = dict()
# network graph
self.__nx_graph = nx.MultiDiGraph(name=self.__name)
for child in self.__config_node.get_node_children():
(element, tag, attributes, text) = child
if tag == 'connect':
assert text is None, 'non empty text, %r, in %r network: ' \
% (text, self.__name)
tmp = dict()
if tag == 'connect':
for (key, value) in attributes:
assert key not in tmp.keys(), \
'repeated key in attribute of %r network' % self.__name
value = value.strip()
if key == 'fromModuleSlot':
value = value.replace(':', '_')
if key == 'toModuleSlot':
value = value.replace(':', '_')
tmp[key] = value
self.__connectivity.append(tmp)
for (key, val) in tmp.items():
if key == 'fromModuleSlot':
self.__runtime_cortix_comm_file[val] = \
'null-runtime_cortix_comm_file'
if key == 'toModuleSlot':
self.__runtime_cortix_comm_file[val] = \
'null-runtime_cortix_comm_file'
vtx1 = tmp['fromModuleSlot']
vtx2 = tmp['toModuleSlot']
self.__nx_graph.add_edge(vtx1, vtx2,
fromPort=tmp['fromPort'],
toPort=tmp['toPort'])
self.__slot_names = [
name for name in self.__runtime_cortix_comm_file.keys()]
def __init__(self, name=None, config_file="cortix-config.xml"):
assert name is not None, "must give Cortix object a name"
assert isinstance(config_file, str), "-> configFile not a str."
self.__config_file = config_file
# Create a configuration tree
self.__config_tree = ConfigTree(config_file_name=self.__config_file)
# Read this object's name
node = self.__config_tree.get_sub_node("name")
self.__name = node.text.strip()
# check
assert self.__name == name,\
"Cortix object name %r conflicts with cortix-config.xml %r" \
% (self.__name, name)
# Read the work directory name
node = self.__config_tree.get_sub_node("work_dir")
work_dir = node.text.strip()
if work_dir[-1] != '/':
work_dir += '/'
self.__work_dir = work_dir + self.__name + "-wrk/"
# Create the work directory
if os.path.isdir(self.__work_dir):
os.system('rm -rf ' + self.__work_dir)
os.system('mkdir -p ' + self.__work_dir)
# Create the logging facility for each object
node = self.__config_tree.get_sub_node("logger")
logger_name = self.__name
self.__log = logging.getLogger(logger_name)
self.__log.setLevel(logging.NOTSET)
logger_level = node.get("level").strip()
self.__log = set_logger_level(self.__log, logger_name, logger_level)
file_handler = logging.FileHandler(self.__work_dir + "cortix.log")
file_handler.setLevel(logging.NOTSET)
file_handler_level = None
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.NOTSET)
console_handler_level = None
for child in node:
if child.tag == "file_handler":
file_handler_level = child.get("level").strip()
file_handler = set_logger_level(file_handler, logger_name,
file_handler_level)
if child.tag == "console_handler":
console_handler_level = child.get("level").strip()
console_handler = set_logger_level(console_handler,
logger_name,
console_handler_level)
# Formatter added to handlers
formatter = logging.Formatter(
"%(asctime)s - %(name)s - %(levelname)s - %(message)s")
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)
# add handlers to logger
self.__log.addHandler(file_handler)
self.__log.addHandler(console_handler)
self.__log.info("Created Cortix logger: %s", self.__name)
self.__log.debug("Logger level: %s", logger_level)
self.__log.debug("Logger file handler level: %s", file_handler_level)
self.__log.debug("Logger console handler level: %s",
console_handler_level)
self.__log.info("Created Cortix work directory: %s", self.__work_dir)
# Setup simulations (one or more as specified in the config file)
self.__simulations = list()
self.__setup_simulations()
self.__log.info("Created Cortix object %s", self.__name)
class Cortix():
'''
The main Cortix class definition. This class encapsulates the
concepts of simulations, tasks, and modules, for a given application providing
the user with an interface to the simulations.
'''
def __init__(self, name=None, config_file="cortix-config.xml"):
assert name is not None, "must give Cortix object a name"
assert isinstance(config_file, str), "-> configFile not a str."
self.__config_file = config_file
# Create a configuration tree
self.__config_tree = ConfigTree(config_file_name=self.__config_file)
# Read this object's name
node = self.__config_tree.get_sub_node("name")
self.__name = node.text.strip()
# check
assert self.__name == name,\
"Cortix object name %r conflicts with cortix-config.xml %r" \
% (self.__name, name)
# Read the work directory name
node = self.__config_tree.get_sub_node("work_dir")
work_dir = node.text.strip()
if work_dir[-1] != '/':
work_dir += '/'
self.__work_dir = work_dir + self.__name + "-wrk/"
# Create the work directory
if os.path.isdir(self.__work_dir):
os.system('rm -rf ' + self.__work_dir)
os.system('mkdir -p ' + self.__work_dir)
# Create the logging facility for each object
node = self.__config_tree.get_sub_node("logger")
logger_name = self.__name
self.__log = logging.getLogger(logger_name)
self.__log.setLevel(logging.NOTSET)
logger_level = node.get("level").strip()
self.__log = set_logger_level(self.__log, logger_name, logger_level)
file_handler = logging.FileHandler(self.__work_dir + "cortix.log")
file_handler.setLevel(logging.NOTSET)
file_handler_level = None
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.NOTSET)
console_handler_level = None
for child in node:
if child.tag == "file_handler":
file_handler_level = child.get("level").strip()
file_handler = set_logger_level(file_handler, logger_name,
file_handler_level)
if child.tag == "console_handler":
console_handler_level = child.get("level").strip()
console_handler = set_logger_level(console_handler,
logger_name,
console_handler_level)
# Formatter added to handlers
formatter = logging.Formatter(
"%(asctime)s - %(name)s - %(levelname)s - %(message)s")
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)
# add handlers to logger
self.__log.addHandler(file_handler)
self.__log.addHandler(console_handler)
self.__log.info("Created Cortix logger: %s", self.__name)
self.__log.debug("Logger level: %s", logger_level)
self.__log.debug("Logger file handler level: %s", file_handler_level)
self.__log.debug("Logger console handler level: %s",
console_handler_level)
self.__log.info("Created Cortix work directory: %s", self.__work_dir)
# Setup simulations (one or more as specified in the config file)
self.__simulations = list()
self.__setup_simulations()
self.__log.info("Created Cortix object %s", self.__name)
#----------------------- end def __init__():--------------------------------------
def run_simulations(self, task_name=None):
'''
This method runs every simulation
defined by the Cortix object.
At the moment this is done one simulation at a time.
'''
for sim in self.__simulations:
sim.execute(task_name)
#----------------------- end def run_simulations():-------------------------------
#*********************************************************************************
# Private helper functions (internal use: __)
def __setup_simulations(self):
'''
This method is a helper function for the Cortix constructor
whose purpose is to set up the simulations defined by the
Cortix configuration.
'''
for sim in self.__config_tree.get_all_sub_nodes('simulation'):
self.__log.debug("__setup_simulations(): simulation name: %s",
sim.get('name'))
sim_config_tree = ConfigTree(sim)
simulation = Simulation(self.__work_dir, sim_config_tree)
self.__simulations.append(simulation)
#----------------------- end def __setup_simulations():---------------------------
def __del__(self):
self.__log.info("Destroyed Cortix object: %s", self.__name)
def __init__(self, parent_work_dir=None, library_name=None,
library_parent_dir=None, mod_config_node=ConfigTree()):
assert isinstance(
parent_work_dir, str), "-> parent_work_dir is invalid."
# Inherit a configuration tree
assert isinstance(mod_config_node, ConfigTree), \
"-> mod_config_node is invalid."
self.__config_node = mod_config_node
# Read the module name and type
self.__mod_name = self.__config_node.get_node_name()
self.__mod_type = self.__config_node.get_node_type()
# Specify module library with upstream information
self.__library_parent_dir = library_parent_dir
self.__library_name = library_name
self.__executable_name = 'null-executable_name'
self.__executable_path = 'null-executable_path'
self.__input_file_name = 'null-input_file_name'
self.__input_file_path = 'null-input_file_path'
self.__ports = list() # list of (port_name, port_type, port_multiplicity)
# Save config data
for child in self.__config_node.get_node_children():
(elem, tag, attributes, text) = child
text = text.strip()
if self.__mod_type != 'native':
if tag == 'executable_name':
self.__executable_name = text
if tag == 'executable_path':
if text[-1] != '/':
text += '/'
self.__executable_path = text
if tag == 'input_file_name':
self.__input_file_name = text
if tag == 'input_file_path':
if text[-1] != '/':
text += '/'
self.__input_file_path = text
if tag == 'library':
assert len(attributes) == 1, 'only name of library allowed.'
key = attributes[0][0]
assert key == 'name', 'invalid attribute.'
val = attributes[0][1].strip()
self.__library_name = val
node = ConfigTree(elem)
sub_node = node.get_sub_node('parent_dir')
assert sub_node is not None, 'missing parent_dir.'
self.__library_parent_dir = sub_node.text.strip()
if self.__library_parent_dir[-1] == '/':
self.__library_parent_dir.strip('/')
if tag == 'port':
assert len(attributes) == 3, "only <= 3 attributes allowed."
tmp = dict() # store port name and three attributes
for attribute in attributes:
key = attribute[0]
val = attribute[1].strip()
if key == 'type':
assert val == 'use' or val == 'provide' or val == 'input' or \
val == 'output', 'port attribute value invalid.'
tmp['port_name'] = text # port_name
tmp['port_type'] = val # port_type
elif key == 'mode':
file_value = val.split('.')[0]
assert file_value == 'file' or file_value == 'directory',\
'port attribute value invalid.'
tmp['port_mode'] = val
elif key == 'multiplicity':
tmp['port_multiplicity'] = int(val) # port_multiplicity
else:
assert False, 'invalid port attribute. fatal.'
assert len(tmp) == 4
store = (tmp['port_name'], tmp['port_type'], tmp['port_mode'],
tmp['port_multiplicity'])
self.__ports.append(store) # (port_name, port_type, port_mode,
# port_multiplicity)
tmp = None
store = None
def __init__(self, parent_work_dir=None, sim_config_node=ConfigTree()):
assert isinstance(parent_work_dir, str), '-> parentWorkDir invalid.'
# Inherit a configuration tree
assert isinstance(sim_config_node,
ConfigTree), '-> sim_config_node invalid.'
self.__config_node = sim_config_node
# Read the simulation name
self.__name = sim_config_node.get_node_name()
# Create the cortix/simulation work directory
self.__work_dir = parent_work_dir + 'sim_' + self.__name + '/'
os.system('mkdir -p ' + self.__work_dir)
# Create the logging facility for each object
node = sim_config_node.get_sub_node("logger")
logger_name = 'sim:' + self.__name
self.__log = logging.getLogger(logger_name)
self.__log.setLevel(logging.NOTSET)
logger_level = node.get('level').strip()
self.__log = set_logger_level(self.__log, logger_name, logger_level)
file_handler = logging.FileHandler(self.__work_dir + 'sim.log')
file_handler.setLevel(logging.NOTSET)
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.NOTSET)
for child in node:
if child.tag == "file_handler":
file_handler_level = child.get("level").strip()
file_handler = set_logger_level(file_handler, logger_name,
file_handler_level)
if child.tag == 'console_handler':
console_handler_level = child.get('level').strip()
console_handler = set_logger_level(console_handler,
logger_name,
console_handler_level)
# formatter added to handlers
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)
# add handlers to logger
self.__log.addHandler(file_handler)
self.__log.addHandler(console_handler)
self.__log.info("created Simulation logger: %s", self.__name)
self.__log.debug("'logger level: %s", logger_level)
self.__log.debug("logger file handler level: %s", file_handler_level)
self.__log.debug("logger console handler level: %s",
console_handler_level)
for app_node in self.__config_node.get_all_sub_nodes("application"):
app_config_node = ConfigTree(app_node)
assert app_config_node.get_node_name() == app_node.get("name"), \
"check failed"
# Create the application for this simulation
self.__application = Application(self.__work_dir, app_config_node)
self.__log.debug("created application: %s", app_node.get('name'))
# Stores the task(s) created by the execute method
self.__tasks = list()
self.__log.info("created simulation: %s", self.__name)
def __setup_task(self, task_name):
'''
This is a helper function used by the execute() method.
It sets up the set of tasks defined in the Cortix config for a simulation.
'''
self.__log.debug('start __setup_task(%s)', task_name)
task = None
for task_node in self.__config_node.get_all_sub_nodes('task'):
if task_node.get('name') != task_name:
continue
task_config_node = ConfigTree(task_node)
# create task
task = Task(self.__work_dir, task_config_node)
self.__tasks.append(task)
self.__log.debug("appended task: %s", task_node.get("name"))
if task is None:
self.__log.debug('no task to exectute; done here.')
self.__log.debug('end __setup_task(%s)', task_name)
return
networks = self.__application.networks
# create subdirectory with task name
task_name = task.name
task_work_dir = task.work_dir
assert os.path.isdir(
task_work_dir), "directory %r invalid." % task_work_dir
# set the parameters for the task in the cortix param file
task_file = task_work_dir + 'cortix-param.xml'
fout = open(task_file, 'w')
fout.write('<?xml version="1.0" encoding="UTF-8"?>\n')
fout.write('<!-- Written by Simulation::__setup_task() -->\n')
fout.write('<cortix_param>\n')
start_time = task.start_time
start_time_unit = task.start_time_unit
fout.write('<start_time unit="' + start_time_unit + '"' + '>' +
str(start_time) + '</start_time>\n')
evolve_time = task.evolve_time
evolve_time_unit = task.evolve_time_unit
fout.write('<evolve_time unit="' + evolve_time_unit + '"' + '>' +
str(evolve_time) + '</evolve_time>\n')
time_step = task.time_step
time_step_unit = task.time_step_unit
fout.write('<time_step unit="' + time_step_unit + '"' + '>' +
str(time_step) + '</time_step>\n')
fout.write('</cortix_param>')
fout.close()
task.set_runtime_cortix_param_file(task_file)
# Using the tasks and network create the runtime module directories and comm
# files
for net in networks:
if net.name.strip() != task_name.strip():
s = '__setup_task():: net name: ' + \
net.name + ' not equal to task name: ' + task_name + '; ignored.'
self.__log.warn(s)
if net.name.strip() == task_name.strip(
): # net and task names must match
connect = net.connectivity
to_module_to_port_visited = dict()
for con in connect:
# Start with the ports that will function as a provide port or
# input port
to_module_slot = con['toModuleSlot']
to_port = con['toPort']
if to_module_slot not in to_module_to_port_visited.keys():
to_module_to_port_visited[to_module_slot] = list()
to_module_name = '_'.join(to_module_slot.split('_')[:-1])
to_module = self.__application.get_module(to_module_name)
assert to_module is not None, \
'module %r does not exist in application' % to_module_name
assert to_module.has_port_name(to_port), \
'module %r has no port %r.' % (
to_module.name, to_port)
assert to_module.get_port_type(to_port) is not None,\
'network name: %r, module name: %r, to_port: %r port type \
invalid %r' % (net.name, to_module.name, to_port,
type(to_module.get_port_type(to_port)))
to_module_slot_work_dir = task_work_dir + to_module_slot + '/'
if to_module.get_port_type(to_port) != 'input':
assert to_module.get_port_type(to_port) == 'provide', \
'port type %r invalid. Module %r, port %r' \
% (to_module.get_port_type(to_port), to_module.name,
to_port)
# "to" is who receives the "call", hence the provider
to_module_slot_comm_file = to_module_slot_work_dir + \
'cortix-comm.xml'
if not os.path.isdir(to_module_slot_work_dir):
os.system('mkdir -p ' + to_module_slot_work_dir)
if not os.path.isfile(to_module_slot_comm_file):
fout = open(to_module_slot_comm_file, 'w')
fout.write('<?xml version="1.0" encoding="UTF-8"?>\n')
fout.write(
'<!-- Written by Simulation::__setup_task() -->\n')
fout.write('<cortix_comm>\n')
if to_port not in to_module_to_port_visited[
to_module_slot]:
fout = open(to_module_slot_comm_file, 'a')
# this is the cortix info for modules providing data
to_port_mode = to_module.get_port_mode(to_port)
if to_port_mode.split('.')[0] == 'file':
ext = to_port_mode.split('.')[1]
log_str = '<port name="' + to_port + '" type="provide" file="'\
+ to_module_slot_work_dir + to_port + '.' + ext + '"/>\n'
elif to_port_mode == 'directory':
log_str = '<port name="' + to_port +\
'" type="provide" directory="' +\
to_module_slot_work_dir + to_port + '"/>\n'
else:
assert False, 'invalid port mode. fatal.'
fout.write(log_str)
fout.close()
to_module_to_port_visited[to_module_slot].append(
to_port)
debug_str = '__setup_task():: comm module: ' + to_module_slot + \
'; network: ' + task_name + ' ' + log_str
self.__log.debug(debug_str)
# register the cortix-comm file for the network
net.set_runtime_cortix_comm_file(to_module_slot,
to_module_slot_comm_file)
# Now do the ports that will function as use ports or
# output ports
from_module_slot = con['fromModuleSlot']
from_port = con['fromPort']
from_module_name = '_'.join(
from_module_slot.split('_')[:-1])
from_module = self.__application.get_module(
from_module_name)
assert from_module.has_port_name(from_port), \
'module %r has no port %r' % (
from_module_name, from_port)
assert from_module.get_port_type(from_port) is not None, \
'network name: %r, module name: %r, from_port: %r port type invalid %r'\
% (net.name, from_module.name, from_port,
type(from_module.get_port_type(from_port)))
from_module_slot_work_dir = task_work_dir + from_module_slot + '/'
if from_module.get_port_type(from_port) != 'output':
assert from_module.get_port_type(from_port) == 'use', \
'port type %r invalid. Module %r, port %r' % \
(from_module.get_port_type(from_port),
from_module.name, from_port)
# "from" is who makes the "call", hence the user
from_module_slot_comm_file = from_module_slot_work_dir + \
'cortix-comm.xml'
if not os.path.isdir(from_module_slot_work_dir):
os.system('mkdir -p ' + from_module_slot_work_dir)
if not os.path.isfile(from_module_slot_comm_file):
fout = open(from_module_slot_comm_file, 'w')
fout.write(
'<?xml version="1.0" encoding="UTF-8"?>\n')
fout.write(
'<!-- Written by Simulation::__setup_task() -->\n'
)
fout.write('<cortix_comm>\n')
fout.close() # is this right?
fout = open(from_module_slot_comm_file, 'a')
# this is the cortix info for modules using data
assert from_module.get_port_type(from_port) == 'use', \
'from_port must be use type.'
to_port_mode = to_module.get_port_mode(to_port)
if to_port_mode.split('.')[0] == 'file':
ext = to_port_mode.split('.')[1]
log_str = '<port name="' + from_port + \
'" type="use" file="' + \
to_module_slot_work_dir + to_port + '.' + ext + \
'"/>\n'
elif to_port_mode == 'directory':
log_str = '<port name="' + from_port + \
'" type="use" directory="' + \
to_module_slot_work_dir + to_port + '"/>\n'
else:
assert False, 'invalid port mode. fatal.'
fout.write(log_str)
fout.close()
debug_str = '__setup_task():: comm module: ' + \
from_module_slot + '; network: ' + task_name + \
' ' + log_str
self.__log.debug(debug_str)
# register the cortix-comm file for the network
net.set_runtime_cortix_comm_file(from_module_slot,
from_module_slot_comm_file)
# finish forming the XML documents for port types
for net in networks:
for slot_name in net.slot_names:
comm_file = net.get_runtime_cortix_comm_file(slot_name)
if comm_file == 'null-runtime_cortix_comm_file':
if net.name != task_name:
s = '__setup_task():: comm file for ' + slot_name + \
' in network ' + net.name + ' is ' + comm_file
self.__log.warn(s)
continue
else:
assert False, 'FATAL ERROR building the comm file for module %r'%\
slot_name
fout = open(comm_file, 'a')
fout.write('</cortix_comm>')
fout.close()
self.__log.debug('end __setup_task(%s)', task_name)
def __init__(self, parent_work_dir=None, task_config_node=ConfigTree()):
assert isinstance(parent_work_dir, str), '-> parent_work_dir invalid.'
# Inherit a configuration tree
assert isinstance(task_config_node, ConfigTree), \
'-> task_config_node not a ConfigTree: %r.' % type(task_config_node)
self.__config_node = task_config_node
# Read the task name
self.__name = self.__config_node.get_node_name()
# Set the work directory (previously created)
assert os.path.isdir(parent_work_dir), 'work directory not available.'
self.__work_dir = parent_work_dir + 'task_' + self.__name + '/'
os.system('mkdir -p ' + self.__work_dir)
# Create the logging facility for the object
node = task_config_node.get_sub_node('logger')
logger_name = 'task:'+self.__name
self.__log = logging.getLogger(logger_name)
self.__log.setLevel(logging.NOTSET)
logger_level = node.get('level').strip()
self.__log = set_logger_level(self.__log, logger_name, logger_level)
file_handle = logging.FileHandler(self.__work_dir + 'task.log')
file_handle.setLevel(logging.NOTSET)
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.NOTSET)
for child in node:
if child.tag == 'file_handler':
# file handler
file_handle_level = child.get('level').strip()
file_handle = set_logger_level(file_handle, logger_name,
file_handle_level)
if child.tag == 'console_handler':
# console handler
console_handle_level = child.get('level').strip()
console_handler = set_logger_level(console_handler,
logger_name, console_handle_level)
# formatter added to handlers
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
file_handle.setFormatter(formatter)
console_handler.setFormatter(formatter)
# add handlers to logger
self.__log.addHandler(file_handle)
self.__log.addHandler(console_handler)
self.__log.info('created logger: %s', self.__name)
self.__log.debug('logger level: %s', logger_level)
self.__log.debug('logger file handler level: %s', file_handle_level)
self.__log.debug(
'logger console handler level: %s',
console_handle_level)
self.__start_time = self.__evolve_time = self.__time_step = 0.0
self.__start_time_unit = 'null-start_time_unit'
self.__evolve_time_unit = 'null-evolve_time_unit'
self.__time_step_unit = 'null-time_step_unit'
self.__runtime_cortix_param_file = 'null-runtime_cortix_param_file'
self.__log.debug('start __init__()')
for child in self.__config_node.get_node_children():
(elem, tag, items, text) = child
if tag == 'start_time':
for (key, value) in items:
if key == 'unit':
self.__start_time_unit = value
self.__start_time = float(text.strip())
if tag == 'evolve_time':
for (key, value) in items:
if key == 'unit':
self.__evolve_time_unit = value
self.__evolve_time = float(text.strip())
if tag == 'time_step':
for (key, value) in items:
if key == 'unit':
self.__time_step_unit = value
self.__time_step = float(text.strip())
if self.__start_time_unit == 'null-start_time_unit':
self.__start_time_unit = self.__evolve_time_unit
assert self.__evolve_time_unit != 'null-evolve_time_unit', \
'invalid time unit = %r' % (self.__evolve_time_unit)
self.__log.debug('start_time value = %s', str(self.__start_time))
self.__log.debug('start_time unit = %s', str(self.__start_time_unit))
self.__log.debug('evolve_time value = %s', str(self.__evolve_time))
self.__log.debug('evolve_time unit = %s', str(self.__evolve_time_unit))
self.__log.debug('end __init__()')
self.__log.info('created task: %s', self.__name)
def __init__(self, app_work_dir=None, app_config_node=ConfigTree()):
assert isinstance(app_work_dir, str), '-> app_work_dir is invalid'
# Inherit a configuration tree
assert isinstance(app_config_node,
ConfigTree), "-> app_config_node invalid"
assert isinstance(app_config_node.get_node_tag(),
str), "empty xml tree."
self.__config_node = app_config_node
# Read the application name
self.__name = self.__config_node.get_node_name()
# Set the work directory (previously created)
self.__work_dir = app_work_dir
assert os.path.isdir(app_work_dir), "Work directory not available."
# Set the module library for the whole application
node = app_config_node.get_sub_node('module_library')
self.__module_lib_name = node.get('name').strip()
sub_node = ConfigTree(node)
assert sub_node.get_node_tag() == 'module_library', 'FATAL.'
for child in sub_node.get_node_children():
(elem, tag, attributes, text) = child
if tag == 'parent_dir':
self.__module_lib_full_parent_dir = text.strip()
if self.__module_lib_full_parent_dir[-1] == '/':
self.__module_lib_full_parent_dir.strip('/')
# add library full path to python module search
sys.path.insert(1, self.__module_lib_full_parent_dir)
# Create the logging facility for the singleton object
node = app_config_node.get_sub_node("logger")
logger_name = 'app:' + self.__name # prefix to avoid clash of loggers
self.__log = logging.getLogger(logger_name)
self.__log.setLevel(logging.NOTSET)
logger_level = node.get('level').strip()
self.__log = set_logger_level(self.__log, logger_name, logger_level)
file_handler = logging.FileHandler(self.__work_dir + 'app.log')
file_handler.setLevel(logging.NOTSET)
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.NOTSET)
for child in node:
if child.tag == 'file_handler':
# file handler
file_handler_level = child.get('level').strip()
file_handler = set_logger_level(file_handler, logger_name,
file_handler_level)
if child.tag == 'console_handler':
# console handler
console_handler_level = child.get('level').strip()
console_handler = set_logger_level(console_handler,
logger_name,
console_handler_level)
# formatter added to handlers
formatter = logging.Formatter(
'%(asctime)s - %(name)s - %(levelname)s - %(message)s')
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)
# add handlers to logger
self.__log.addHandler(file_handler)
self.__log.addHandler(console_handler)
self.__log.info('Created Application logger: %s', self.__name)
self.__log.debug('logger level: %s', logger_level)
self.__log.debug('logger file handler level: %s', file_handler_level)
self.__log.debug('logger console handler level: %s',
console_handler_level)
self.__modules = list()
self.__setup_modules()
self.__networks = list()
self.__setup_networks()
self.__log.info('Created application: %s', self.__name)