def main(self, argv):
args = self._parse_args(argv)
store = arguments.parse_storage_flag(args)[0]
data = {
attr: getattr(args, attr)
for attr in self.model.attributes if hasattr(args, attr)
}
meas_name = args.name
try:
force_tau_options = args.force_tau_options
except AttributeError:
pass
else:
# Unset force_tau_options if it was already set and --force-tau-options=none
if data.pop('force_tau_options', False) and [
i.lower().strip() for i in force_tau_options
] == ['none']:
meas_ctrl = Measurement.controller(store)
meas_ctrl.unset(['force_tau_options'], {'name': meas_name})
self.logger.info(
"Removed 'force-tau-options' from measurement '%s'.",
meas_name)
else:
data['force_tau_options'] = force_tau_options
self.logger.info(
"Added 'force-tau-options' to measurement '%s'.",
meas_name)
key_attr = self.model.key_attribute
try:
data[key_attr] = args.new_key
except AttributeError:
pass
key = getattr(args, key_attr)
return self._update_record(store, data, key)
def main(self, argv):
args = self._parse_args(argv)
store = arguments.parse_storage_flag(args)[0]
keys = getattr(args, self.model.key_attribute)
for key in keys:
self._delete_record(store, key)
return EXIT_SUCCESS
def main(self, argv):
args = self._parse_args(argv)
store = arguments.parse_storage_flag(args)[0]
data = {attr: getattr(args, attr) for attr in self.model.attributes if hasattr(args, attr)}
meas_name = args.name
try:
force_tau_options = args.force_tau_options
except AttributeError:
pass
else:
# Unset force_tau_options if it was already set and --force-tau-options=none
if data.pop('force_tau_options', False) and [i.lower().strip() for i in force_tau_options] == ['none']:
meas_ctrl = Measurement.controller(store)
meas_ctrl.unset(['force_tau_options'], {'name': meas_name})
self.logger.info("Removed 'force-tau-options' from measurement '%s'.", meas_name)
else:
data['force_tau_options'] = force_tau_options
self.logger.info("Added 'force-tau-options' to measurement '%s'.", meas_name)
key_attr = self.model.key_attribute
try:
data[key_attr] = args.new_key
except AttributeError:
pass
key = getattr(args, key_attr)
return self._update_record(store, data, key)
def main(self, argv):
args = self._parse_args(argv)
store = arguments.parse_storage_flag(args)[0]
data = {
attr: getattr(args, attr)
for attr in self.model.attributes if hasattr(args, attr)
}
# Translate names to eids
proj_ctrl = Project.controller()
for model in Target, Application, Measurement:
attr = model.name.lower()
if attr in data:
record = model.controller(proj_ctrl.storage).one(
{'name': data[attr]})
if record is None:
self.parser.error("Invalid %s: %s" % (attr, data[attr]))
data[attr] = record.eid
key_attr = self.model.key_attribute
try:
data[key_attr] = args.new_key
except AttributeError:
pass
key = getattr(args, key_attr)
return self._update_record(store, data, key)
def main(self, argv):
args = self._parse_args(argv)
store = arguments.parse_storage_flag(args)[0]
data = {
attr: getattr(args, attr)
for attr in self.model.attributes if hasattr(args, attr)
}
return self._create_record(store, data)
def main(self, argv):
args = self._parse_args(argv)
store = arguments.parse_storage_flag(args)[0]
data = {attr: getattr(args, attr) for attr in self.model.attributes if hasattr(args, attr)}
# Set callpath depth to 0 unless the user specified a non-default callpath depth on the command line
if data.get('trace', 'none') != 'none' and data['callpath'] == self.model.attributes['callpath']['default']:
data['callpath'] = 0
return self._create_record(store, data)
def main(self, argv):
args = self._parse_args(argv)
store = arguments.parse_storage_flag(args)[0]
data = {attr: getattr(args, attr) for attr in self.model.attributes if hasattr(args, attr)}
# Set callpath depth to 0 unless the user specified a non-default callpath depth on the command line
if data.get('trace', 'none') != 'none' and data['callpath'] == self.model.attributes['callpath']['default']:
data['callpath'] = 0
return self._create_record(store, data)
def main(self, argv):
"""Command program entry point.
Args:
argv (list): Command line arguments.
Returns:
int: Process return code: non-zero if a problem occurred, 0 otherwise
"""
args = self._parse_args(argv)
style_args = ['--' + args.style] if hasattr(args, 'style') else []
levels = arguments.parse_storage_flag(args)
keys = getattr(args, 'keys', [])
single = (len(keys) == 1 and len(levels) == 1)
if single:
proj_name = keys[0]
self.title_fmt = "Project Configuration (%(storage_path)s)"
target_list_cmd.title_fmt = "Targets in project '%s'" % proj_name
application_list_cmd.title_fmt = "Applications in project '%s'" % proj_name
measurement_list_cmd.title_fmt = "Measurements in project '%s'" % proj_name
experiment_list_cmd.title_fmt = "Experiments in project '%s'" % proj_name
retval = super(ProjectListCommand, self).main(argv)
if single:
storage = levels[0]
ctrl = Project.controller(storage)
proj = ctrl.one({'name': keys[0]}, context=False)
for cmd, prop in ((target_list_cmd, 'targets'),
(application_list_cmd, 'applications'),
(measurement_list_cmd, 'measurements'),
(experiment_list_cmd, 'experiments')):
primary_key = proj.attributes[prop]['collection'].key_attribute
records = proj.populate(prop, context=False)
if records:
cmd.main([record[primary_key] for record in records] +
['-p'] + [proj['name']] + style_args)
else:
label = util.color_text('%s: No %s' % (proj['name'], prop),
color='red',
attrs=['bold'])
print "%s. Use `%s` to view available %s.\n" % (label,
cmd, prop)
try:
expr = proj.experiment()
if not isinstance(expr, NoneType):
print util.color_text("Selected Experiment: ",
'cyan') + expr['name']
except ExperimentSelectionError:
print(
util.color_text('No selected experiment: ', 'red') +
'Use `%s` to create or select an experiment.' % select_cmd)
return retval
def main(self, argv):
args = self._parse_args(argv)
store = arguments.parse_storage_flag(args)[0]
data = {attr: getattr(args, attr) for attr in self.model.attributes if hasattr(args, attr)}
key_attr = self.model.key_attribute
try:
data[key_attr] = getattr(args, 'copy_%s' % key_attr)
except AttributeError:
pass
key = getattr(args, key_attr)
return self._copy_record(store, data, key)
def main(self, argv):
"""Command program entry point.
Args:
argv (list): Command line arguments.
Returns:
int: Process return code: non-zero if a problem occurred, 0 otherwise
"""
args = self._parse_args(argv)
style_args = ['--' + args.style] if hasattr(args, 'style') else []
levels = arguments.parse_storage_flag(args)
keys = getattr(args, 'keys', [])
single = (len(keys) == 1 and len(levels) == 1)
if single:
proj_name = keys[0]
self.title_fmt = "Project Configuration (%(storage_path)s)"
target_list_cmd.title_fmt = "Targets in project '%s'" % proj_name
application_list_cmd.title_fmt = "Applications in project '%s'" % proj_name
measurement_list_cmd.title_fmt = "Measurements in project '%s'" % proj_name
experiment_list_cmd.title_fmt = "Experiments in project '%s'" % proj_name
retval = super(ProjectListCommand, self).main(argv)
if single:
storage = levels[0]
ctrl = Project.controller(storage)
proj = ctrl.one({'name': keys[0]})
for cmd, prop in ((target_list_cmd, 'targets'),
(application_list_cmd, 'applications'),
(measurement_list_cmd, 'measurements'),
(experiment_list_cmd, 'experiments')):
primary_key = proj.attributes[prop]['collection'].key_attribute
records = proj.populate(prop)
if records:
cmd.main([record[primary_key] for record in records] + style_args)
else:
label = util.color_text('%s: No %s' % (proj['name'], prop), color='red', attrs=['bold'])
print "%s. Use `%s` to view available %s.\n" % (label, cmd, prop)
if proj.get('force_tau_options', False):
self.logger.warning("Project '%s' will add '%s' to TAU_OPTIONS without error checking.",
proj['name'], ' '.join(proj['force_tau_options']))
try:
expr = proj.experiment()
except ExperimentSelectionError:
print (util.color_text('No selected experiment: ', 'red') +
'Use `%s` to create or select an experiment.' % select_cmd)
else:
print util.color_text("Selected Experiment: ", 'cyan') + expr['name']
return retval
def main(self, argv):
args = self._parse_args(argv)
store = arguments.parse_storage_flag(args)[0]
data = {
attr: getattr(args, attr)
for attr in self.model.attributes if hasattr(args, attr)
}
key_attr = self.model.key_attribute
try:
data[key_attr] = getattr(args, 'copy_%s' % key_attr)
except AttributeError:
pass
key = getattr(args, key_attr)
return self._copy_record(store, data, key)
def main(self, argv):
TauInstallation.check_env_compat()
args = self._parse_args(argv)
store = arguments.parse_storage_flag(args)[0]
if hasattr(args, "forced_makefile"):
self._parse_tau_makefile(args)
self.logger.debug('Arguments after parsing TAU Makefile: %s', args)
compilers = self.parse_compiler_flags(args)
data = {attr: getattr(args, attr) for attr in self.model.attributes if hasattr(args, attr)}
for comp in compilers.itervalues():
record = Compiler.controller(store).register(comp)
data[comp.info.role.keyword] = record.eid
return super(TargetCreateCommand, self)._create_record(store, data)
def main(self, argv):
args = self._parse_args(argv)
store = arguments.parse_storage_flag(args)[0]
compilers = target_create_cmd.parse_compiler_flags(args)
data = {attr: getattr(args, attr) for attr in self.model.attributes if hasattr(args, attr)}
for keyword, comp in compilers.iteritems():
self.logger.debug("%s=%s (%s)", keyword, comp.absolute_path, comp.info.short_descr)
record = Compiler.controller(store).register(comp)
data[comp.info.role.keyword] = record.eid
key_attr = self.model.key_attribute
try:
data[key_attr] = getattr(args, 'copy_%s' % key_attr)
except AttributeError:
pass
key = getattr(args, key_attr)
return self._copy_record(store, data, key)
def main(self, argv):
TauInstallation.check_env_compat()
args = self._parse_args(argv)
store = arguments.parse_storage_flag(args)[0]
compilers = target_create_cmd.parse_compiler_flags(args)
data = {attr: getattr(args, attr) for attr in self.model.attributes if hasattr(args, attr)}
for keyword, comp in compilers.iteritems():
self.logger.debug("%s=%s (%s)", keyword, comp.absolute_path, comp.info.short_descr)
record = Compiler.controller(store).register(comp)
data[comp.info.role.keyword] = record.eid
key_attr = self.model.key_attribute
try:
data[key_attr] = getattr(args, 'copy_%s' % key_attr)
except AttributeError:
pass
key = getattr(args, key_attr)
return self._copy_record(store, data, key)
def main(self, argv):
TauInstallation.check_env_compat()
args = self._parse_args(argv)
store = arguments.parse_storage_flag(args)[0]
if hasattr(args, "forced_makefile"):
self._parse_tau_makefile(args)
self.logger.debug('Arguments after parsing TAU Makefile: %s', args)
compilers = self.parse_compiler_flags(args)
data = {
attr: getattr(args, attr)
for attr in self.model.attributes if hasattr(args, attr)
}
for comp in compilers.itervalues():
record = Compiler.controller(store).register(comp)
data[comp.info.role.keyword] = record.eid
return super(TargetCreateCommand, self)._create_record(store, data)
def main(self, argv):
args = self._parse_args(argv)
store = arguments.parse_storage_flag(args)[0]
data = {attr: getattr(args, attr) for attr in self.model.attributes if hasattr(args, attr)}
proj_ctrl = Project.controller()
for model in Target, Application, Measurement:
attr = model.name.lower()
if attr in data:
record = model.controller(proj_ctrl.storage).one({'name': data[attr]})
data[attr] = record.eid
key_attr = self.model.key_attribute
try:
data[key_attr] = args.new_key
except AttributeError:
pass
key = getattr(args, key_attr)
return self._update_record(store, data, key)
def main(self, argv):
TauInstallation.check_env_compat()
args = self._parse_args(argv)
store = arguments.parse_storage_flag(args)[0]
compilers = target_create_cmd.parse_compiler_flags(args)
self.logger.debug('Arguments after parsing compiler flags: %s', args)
data = {attr: getattr(args, attr) for attr in self.model.attributes if hasattr(args, attr)}
for keyword, comp in compilers.iteritems():
self.logger.debug("%s=%s (%s)", keyword, comp.absolute_path, comp.info.short_descr)
record = Compiler.controller(store).register(comp)
data[comp.info.role.keyword] = record.eid
key_attr = self.model.key_attribute
try:
data[key_attr] = args.new_key
except AttributeError:
pass
key = getattr(args, key_attr)
return self._update_record(store, data, key)
def main(self, argv):
args = self._parse_args(argv)
keys = getattr(args, 'keys', None)
style = getattr(args, 'style', None) or self.default_style
storage_levels = arguments.parse_storage_flag(args)
context = True
if args.project:
matching = Project.controller().one({'name': args.project})
if matching:
LOGGER.debug("Using project %s", matching.eid)
context = [('project', matching.eid),
('projects', matching.eid)]
else:
LOGGER.debug("Project %s not found", args.project)
return self._list_records([l.name for l in storage_levels],
keys,
style,
context=context)
def main(self, argv):
args = self._parse_args(argv)
storage = arguments.parse_storage_flag(args)[0]
targ_name = args.target_name
targ = Target.controller(storage).one({'name': targ_name})
if not targ:
self.parser.error("No %s-level target named '%s'." % (storage.name, targ_name))
if args.all:
args.systems = self._measurement_systems
args.modifiers = True
parts = []
if 'CUPTI' in args.systems:
parts.extend(self._format_cupti_metrics(targ))
if 'PAPI_PRESET' in args.systems:
parts.extend(self._format_papi_metrics(targ, 'PRESET', args.modifiers))
if 'PAPI_NATIVE' in args.systems:
parts.extend(self._format_papi_metrics(targ, 'NATIVE', args.modifiers))
if 'TAU' in args.systems:
parts.extend(self._format_tau_metrics(targ))
print '\n'.join(parts)
return EXIT_SUCCESS
def main(self, argv):
args = self._parse_args(argv)
store = arguments.parse_storage_flag(args)[0]
key = getattr(args, self.model.key_attribute)
return self._delete_record(store, key)
def main(self, argv):
args = self._parse_args(argv)
keys = getattr(args, 'keys', None)
style = getattr(args, 'style', None) or self.default_style
storage_levels = arguments.parse_storage_flag(args)
return self._list_records(storage_levels, keys, style)
def main(self, argv):
args = self._parse_args(argv)
store = arguments.parse_storage_flag(args)[0]
key = getattr(args, self.model.key_attribute)
return self._delete_record(store, key)
def main(self, argv):
args = self._parse_args(argv)
store = arguments.parse_storage_flag(args)[0]
data = {attr: getattr(args, attr) for attr in self.model.attributes if hasattr(args, attr)}
return self._create_record(store, data)
def main(self, argv):
args = self._parse_args(argv)
keys = getattr(args, 'keys', None)
style = getattr(args, 'style', None) or self.default_style
storage_levels = arguments.parse_storage_flag(args)
return self._list_records(storage_levels, keys, style)
