"""
Interface to the config_machines.xml file. This class inherits from GenericXML.py
"""
from CIME.XML.standard_module_setup import *
from CIME.XML.generic_xml import GenericXML
from CIME.XML.files import Files
from CIME.utils import convert_to_unknown_type, get_cime_config
import socket
logger = logging.getLogger(__name__)
[docs]class Machines(GenericXML):
def __init__(self, infile=None, files=None, machine=None):
"""
initialize an object
if a filename is provided it will be used,
otherwise if a files object is provided it will be used
otherwise create a files object from default values
"""
self.machine_node = None
self.machine = None
self.machines_dir = None
schema = None
if files is None:
files = Files()
if infile is None:
infile = files.get_value("MACHINES_SPEC_FILE")
schema = files.get_schema("MACHINES_SPEC_FILE")
logger.debug("Verifying using schema {}".format(schema))
self.machines_dir = os.path.dirname(infile)
GenericXML.__init__(self, infile, schema)
# Append the contents of $HOME/.cime/config_machines.xml if it exists
# This could cause problems if node matchs are repeated when only one is expected
local_infile = os.path.join(os.environ.get("HOME"),".cime","config_machines.xml")
logger.debug("Infile: {}".format(local_infile))
if os.path.exists(local_infile):
GenericXML.read(self, local_infile, schema)
if machine is None:
if "CIME_MACHINE" in os.environ:
machine = os.environ["CIME_MACHINE"]
else:
cime_config = get_cime_config()
if cime_config.has_option("main", "machine"):
machine = cime_config.get("main", "machine")
if machine is None:
machine = self.probe_machine_name()
expect(machine is not None, "Could not initialize machine object from {} or {}".format(infile, local_infile))
self.set_machine(machine)
[docs] def get_child(self, name=None, attributes=None, root=None, err_msg=None):
if root is None:
root = self.machine_node
return super(Machines, self).get_child(name, attributes, root, err_msg)
[docs] def get_machines_dir(self):
"""
Return the directory of the machines file
"""
return self.machines_dir
[docs] def get_machine_name(self):
"""
Return the name of the machine
"""
return self.machine
[docs] def get_node_names(self):
"""
Return the names of all the child nodes for the target machine
"""
nodes = self.get_children(root=self.machine_node)
node_names = []
for node in nodes:
node_names.append(self.name(node))
return node_names
[docs] def get_first_child_nodes(self, nodename):
"""
Return the names of all the child nodes for the target machine
"""
nodes = self.get_children(nodename, root=self.machine_node)
return nodes
[docs] def list_available_machines(self):
"""
Return a list of machines defined for a given CIME_MODEL
"""
machines = []
nodes = self.get_children("machine")
for node in nodes:
mach = self.get(node, "MACH")
machines.append(mach)
return machines
[docs] def probe_machine_name(self, warn=True):
"""
Find a matching regular expression for hostname
in the NODENAME_REGEX field in the file. First match wins.
"""
names_not_found = []
nametomatch = socket.getfqdn()
machine = self._probe_machine_name_one_guess(nametomatch)
if machine is None:
names_not_found.append(nametomatch)
nametomatch = socket.gethostname()
machine = self._probe_machine_name_one_guess(nametomatch)
if machine is None:
names_not_found.append(nametomatch)
names_not_found_quoted = ["'" + name + "'" for name in names_not_found]
names_not_found_str = ' or '.join(names_not_found_quoted)
if warn:
logger.warning("Could not find machine match for {}".format(names_not_found_str))
return machine
def _probe_machine_name_one_guess(self, nametomatch):
"""
Find a matching regular expression for nametomatch in the NODENAME_REGEX
field in the file. First match wins. Returns None if no match is found.
"""
machine = None
nodes = self.get_children("machine")
for node in nodes:
machtocheck = self.get(node, "MACH")
logger.debug("machine is " + machtocheck)
regex_str_node = self.get_optional_child("NODENAME_REGEX", root=node)
regex_str = machtocheck if regex_str_node is None else self.text(regex_str_node)
if regex_str is not None:
logger.debug("machine regex string is " + regex_str)
regex = re.compile(regex_str)
if regex.match(nametomatch):
logger.debug("Found machine: {} matches {}".format(machtocheck, nametomatch))
machine = machtocheck
break
return machine
[docs] def set_machine(self, machine):
"""
Sets the machine block in the Machines object
>>> machobj = Machines(machine="melvin")
>>> machobj.get_machine_name()
'melvin'
>>> machobj.set_machine("trump")
Traceback (most recent call last):
...
SystemExit: ERROR: No machine trump found
"""
if machine == "Query":
self.machine = machine
elif self.machine != machine or self.machine_node is None:
self.machine_node = super(Machines,self).get_child("machine", {"MACH" : machine}, err_msg="No machine {} found".format(machine))
self.machine = machine
return machine
#pylint: disable=arguments-differ
[docs] def get_value(self, name, attributes=None, resolved=True, subgroup=None):
"""
Get Value of fields in the config_machines.xml file
"""
expect(self.machine_node is not None, "Machine object has no machine defined")
expect(subgroup is None, "This class does not support subgroups")
value = None
# COMPILER and MPILIB are special, if called without arguments they get the default value from the
# COMPILERS and MPILIBS lists in the file.
if name == "COMPILER":
value = self.get_default_compiler()
elif name == "MPILIB":
value = self.get_default_MPIlib(attributes)
else:
node = self.get_optional_child(name, root=self.machine_node, attributes=attributes)
if node is not None:
value = self.text(node)
if value is None:
# if all else fails
#pylint: disable=assignment-from-none
value = GenericXML.get_value(self, name)
if resolved:
if value is not None:
value = self.get_resolved_value(value)
elif name in os.environ:
value = os.environ[name]
value = convert_to_unknown_type(value)
return value
[docs] def get_field_from_list(self, listname, reqval=None, attributes=None):
"""
Some of the fields have lists of valid values in the xml, parse these
lists and return the first value if reqval is not provided and reqval
if it is a valid setting for the machine
"""
expect(self.machine_node is not None, "Machine object has no machine defined")
supported_values = self.get_value(listname, attributes=attributes)
# if no match with attributes, try without
if supported_values is None:
supported_values = self.get_value(listname, attributes=None)
expect(supported_values is not None,
"No list found for " + listname + " on machine " + self.machine)
supported_values = supported_values.split(",") #pylint: disable=no-member
if reqval is None or reqval == "UNSET":
return supported_values[0]
for val in supported_values:
if val == reqval:
return reqval
return None
[docs] def get_default_compiler(self):
"""
Get the compiler to use from the list of COMPILERS
"""
cime_config = get_cime_config()
if cime_config.has_option('main','COMPILER'):
value = cime_config.get('main', 'COMPILER')
expect(self.is_valid_compiler(value), "User-selected compiler {} is not supported on machine {}".format(value, self.machine))
else:
value = self.get_field_from_list("COMPILERS")
return value
[docs] def get_default_MPIlib(self, attributes=None):
"""
Get the MPILIB to use from the list of MPILIBS
"""
return self.get_field_from_list("MPILIBS", attributes=attributes)
[docs] def is_valid_compiler(self,compiler):
"""
Check the compiler is valid for the current machine
>>> machobj = Machines(machine="edison")
>>> machobj.get_default_compiler()
'intel'
>>> machobj.is_valid_compiler("gnu")
True
>>> machobj.is_valid_compiler("nag")
False
"""
return self.get_field_from_list("COMPILERS", reqval=compiler) is not None
[docs] def is_valid_MPIlib(self, mpilib, attributes=None):
"""
Check the MPILIB is valid for the current machine
>>> machobj = Machines(machine="edison")
>>> machobj.is_valid_MPIlib("mpi-serial")
True
>>> machobj.is_valid_MPIlib("fake-mpi")
False
"""
return mpilib == "mpi-serial" or \
self.get_field_from_list("MPILIBS", reqval=mpilib, attributes=attributes) is not None
[docs] def has_batch_system(self):
"""
Return if this machine has a batch system
>>> machobj = Machines(machine="edison")
>>> machobj.has_batch_system()
True
>>> machobj.set_machine("melvin")
'melvin'
>>> machobj.has_batch_system()
False
"""
result = False
batch_system = self.get_optional_child("BATCH_SYSTEM", root=self.machine_node)
if batch_system is not None:
result = (self.text(batch_system) is not None and self.text(batch_system) != "none")
logger.debug("Machine {} has batch: {}".format(self.machine, result))
return result
[docs] def get_suffix(self, suffix_type):
node = self.get_optional_child("default_run_suffix")
if node is not None:
suffix_node = self.get_optional_child(suffix_type, root=node)
if suffix_node is not None:
return self.text(suffix_node)
return None
[docs] def set_value(self, vid, value, subgroup=None, ignore_type=True):
tmproot = self.root
self.root = self.machine_node
#pylint: disable=assignment-from-no-return
result = super(Machines, self).set_value(vid, value, subgroup=subgroup,
ignore_type=ignore_type)
self.root = tmproot
return result
[docs] def print_values(self):
# write out machines
machines = self.get_children("machine")
logger.info("Machines")
for machine in machines:
name = self.get(machine, "MACH")
desc = self.get_child("DESC", root=machine)
os_ = self.get_child("OS", root=machine)
compilers = self.get_child("COMPILERS", root=machine)
max_tasks_per_node = self.get_child("MAX_TASKS_PER_NODE", root=machine)
max_mpitasks_per_node = self.get_child("MAX_MPITASKS_PER_NODE", root=machine)
print( " {} : {} ".format(name , self.text(desc)))
print( " os ", self.text(os_))
print( " compilers ",self.text(compilers))
if max_mpitasks_per_node is not None:
print(" pes/node ",self.text(max_mpitasks_per_node))
if max_tasks_per_node is not None:
print(" max_tasks/node ",self.text(max_tasks_per_node))
[docs] def return_values(self):
# return a dictionary of machine info
machines = self.get_children("machine")
mach_dict = dict()
logger.debug("Machines return values")
for machine in machines:
name = self.get(machine, "MACH")
desc = self.get_child("DESC", root=machine)
mach_dict[(name,"description")] = self.text(desc)
os_ = self.get_child("OS", root=machine)
mach_dict[(name,"os")] = self.text(os_)
compilers = self.get_child("COMPILERS", root=machine)
mach_dict[(name,"compilers")] = self.text(compilers)
max_tasks_per_node = self.get_child("MAX_TASKS_PER_NODE", root=machine)
mach_dict[(name,"max_tasks_per_node")] = self.text(max_tasks_per_node)
max_mpitasks_per_node = self.get_child("MAX_MPITASKS_PER_NODE", root=machine)
mach_dict[(name,"max_mpitasks_per_node")] = self.text(max_mpitasks_per_node)
return mach_dict