def main(self, argv):
args = self.parser.parse_args(args=argv)
self.logger.debug("Arguments: %s", args)
store = PROJECT_STORAGE
ctrl = Project(store)
pprint(ctrl.export_records(eids=[proj.eid for proj in ctrl.all()]))
return EXIT_SUCCESS
def main(self, argv):
args = self.parser.parse_args(args=argv)
self.logger.debug('Arguments: %s', args)
subargs = ['--dashboard']
proj_ctrl = Project.controller()
print
try:
proj = proj_ctrl.selected()
except ProjectSelectionError as err:
project_count = proj_ctrl.count()
if project_count > 0:
project_list_cmd.main(subargs)
err.value = "No project configuration selected. There are %d configurations available." % project_count
else:
from tau.cli.commands.project.create import COMMAND as project_create_cmd
err.value = "No project configurations exist."
err.hints = ['Use `%s` to create a new project configuration.' % project_create_cmd]
raise err
else:
project_list_cmd.main(subargs)
target_list_cmd.main([targ['name'] for targ in proj.populate('targets')])
application_list_cmd.main([targ['name'] for targ in proj.populate('applications')])
measurement_list_cmd.main([targ['name'] for targ in proj.populate('measurements')])
self._print_experiments(proj)
print
return EXIT_SUCCESS
def main(self, argv):
args = self.parser.parse_args(args=argv)
self.logger.debug('Arguments: %s', args)
store = STORAGE_LEVELS[getattr(args, arguments.STORAGE_LEVEL_FLAG)[0]]
ctrl = self.model.controller(store)
key_attr = self.model.key_attribute
key = getattr(args, key_attr)
compilers = self.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
try:
ctrl.create(data)
except UniqueAttributeError:
self.parser.error("A %s with %s='%s' already exists" % (self.model_name, key_attr, key))
if ctrl.storage is PROJECT_STORAGE:
from tau.cli.commands.project.edit import COMMAND as project_edit_cmd
proj_ctrl = Project.controller()
try:
proj = proj_ctrl.selected()
except ProjectSelectionError:
self.logger.info("Created a new %s '%s'. Use `%s` to add the new %s to a project.",
self.model_name, key, project_edit_cmd, self.model_name)
else:
project_edit_cmd.main([proj['name'], '--add', key])
else:
self.logger.info("Created a new %s-level %s: '%s'.", ctrl.storage.name, self.model_name, key)
return EXIT_SUCCESS
def _parse_implicit(self, args):
projects = set()
targets = set()
applications = set()
measurements = set()
proj_ctrl = Project.controller()
targ_ctrl = Target.controller(PROJECT_STORAGE)
app_ctrl = Application.controller(PROJECT_STORAGE)
meas_ctrl = Measurement.controller(PROJECT_STORAGE)
for flag in 'impl_project', 'impl_target', 'impl_application', 'impl_measurement':
for name in getattr(args, flag, []):
prj = proj_ctrl.one({"name": name})
tar = targ_ctrl.one({"name": name})
app = app_ctrl.one({"name": name})
mes = meas_ctrl.one({"name": name})
ptam = set([prj, tar, app, mes]) - set([None])
if len(ptam) > 1:
self.parser.error("'%s' is ambiguous. Please use --project, --target, --application,"
" or --measurement to specify configuration type." % name)
elif len(ptam) == 0:
self.parser.error("'%s' is not a project, target, application, or measurement." % name)
elif prj:
projects.add(prj)
elif tar:
targets.add(tar)
elif app:
applications.add(app)
elif mes:
measurements.add(mes)
return projects, targets, applications, measurements
def main(self, argv):
args = self.parser.parse_args(args=argv)
self.logger.debug('Arguments: %s', args)
projects, targets, applications, measurements = self._parse_implicit(args)
proj = self._parse_explicit_project(args, projects)
targ = self._parse_explicit(args, Target, targets, proj, 'targets')
app = self._parse_explicit(args, Application, applications, proj, 'applications')
meas = self._parse_explicit(args, Measurement, measurements, proj, 'measurements')
proj_ctrl = Project.controller()
if not (targ and app and meas):
proj_ctrl.select(proj)
self.logger.info("Selected project '%s'. No experiment.", proj['name'])
else:
self._check_compatibility(proj, targ, app, meas)
expr_ctrl = Experiment.controller()
data = {'project': proj.eid, 'target': targ.eid, 'application': app.eid, 'measurement': meas.eid}
matching = expr_ctrl.search(data)
if not matching:
self.logger.debug('Creating new experiment')
expr = expr_ctrl.create(data)
elif len(matching) > 1:
raise InternalError('More than one experiment with data %r exists!' % data)
else:
self.logger.debug('Reusing existing experiment')
expr = matching[0]
proj_ctrl.select(proj, expr)
populated = expr.populate()
self.logger.info("Selected project '%s' with experiment (%s, %s, %s).",
proj['name'],
populated['target']['name'],
populated['application']['name'],
populated['measurement']['name'])
return EXIT_SUCCESS
def main(self, argv):
args = self.parser.parse_args(args=argv)
self.logger.debug('Arguments: %s', args)
store = STORAGE_LEVELS[getattr(args, arguments.STORAGE_LEVEL_FLAG)[0]]
ctrl = self.model.controller(store)
key_attr = self.model.key_attribute
key = getattr(args, key_attr)
data = {attr: getattr(args, attr) for attr in self.model.attributes if hasattr(args, attr)}
try:
ctrl.create(data)
except UniqueAttributeError:
self.parser.error("A %s with %s='%s' already exists" % (self.model_name, key_attr, key))
if ctrl.storage is PROJECT_STORAGE:
from tau.cli.commands.project.edit import COMMAND as project_edit_cmd
proj_ctrl = Project.controller()
try:
proj = proj_ctrl.selected()
except ProjectSelectionError:
self.logger.info("Created a new %s '%s'. Use `%s` to add the new %s to a project.",
self.model_name, key, project_edit_cmd, self.model_name)
else:
project_edit_cmd.main([proj['name'], '--add', key])
else:
self.logger.info("Created a new %s-level %s: '%s'.", ctrl.storage.name, self.model_name, key)
return EXIT_SUCCESS
def main(self, argv):
args = self.parser.parse_args(args=argv)
self.logger.debug('Arguments: %s', args)
proj_ctrl = Project.controller()
proj = proj_ctrl.selected()
expr = proj.experiment()
return expr.managed_build(args.cmd, args.cmd_args)
def main(self, argv):
args = self.parser.parse_args(args=argv)
self.logger.debug('Arguments: %s', args)
application_cmd = [args.cmd] + args.cmd_args
try:
launcher_cmd = args.launcher
except AttributeError:
launcher_cmd, application_cmd = self._detect_launcher(application_cmd)
proj_ctrl = Project.controller()
proj = proj_ctrl.selected()
expr = proj.experiment()
return expr.managed_run(launcher_cmd, application_cmd)
def main(self, argv):
args = self.parser.parse_args(args=argv)
self.logger.debug('Arguments: %s', args)
if not (args.profile or args.trace or args.sample):
self.parser.error('You must specify at least one measurement.')
proj_ctrl = Project.controller()
try:
proj = proj_ctrl.selected()
except ProjectStorageError:
self.logger.debug("No project found, initializing a new project.")
PROJECT_STORAGE.connect_filesystem()
self._create_project(argv, args)
except ProjectSelectionError as err:
err.value = "The project has been initialized but no project configuration is selected."
raise err
else:
self.logger.info("Selected project: '%s'", proj['name'])
return dashboard_cmd.main([])
def main(self, argv):
args = self.parser.parse_args(args=argv)
self.logger.debug('Arguments: %s', args)
proj_ctrl = Project.controller()
trial_ctrl = Trial.controller(proj_ctrl.storage)
proj = proj_ctrl.selected()
expr = proj.experiment()
try:
number = int(args.number)
except ValueError:
self.parser.error("Invalid trial number: %s" % args.number)
fields = {'experiment': expr.eid, 'number': number}
if not trial_ctrl.exists(fields):
self.parser.error("No trial number %s in the current experiment. "
"See `tau trial list` to see all trial numbers." % number)
trial_ctrl.delete(fields)
self.logger.info('Deleted trial %s', number)
return EXIT_SUCCESS
def _parse_explicit_project(self, args, acc):
proj_ctrl = Project.controller()
try:
name = getattr(args, 'project')
except AttributeError:
pass
else:
found = proj_ctrl.one({"name": name})
if not found:
self.parser.error("There is no project configuration named '%s.'" % name)
else:
acc.add(found)
if len(acc) == 0:
try:
return proj_ctrl.selected()
except ProjectSelectionError:
self.parser.error("No project configuration selected. Please use --project to specify one.")
elif len(acc) > 1:
self.parser.error("Multiple project configurations specified: %s. Please specify at most one." %
', '.join(acc))
elif len(acc) == 1:
return acc.pop()
def main(self, argv):
args = self.parser.parse_args(args=argv)
self.logger.debug('Arguments: %s', args)
proj_ctrl = Project.controller()
proj = proj_ctrl.selected()
expr = proj.experiment()
try:
str_numbers = args.numbers
except AttributeError:
numbers = None
else:
numbers = []
for num in str_numbers:
try:
numbers.append(int(num))
except ValueError:
self.parser.error("Invalid trial number: %s" % num)
try:
tool = args.tool
except AttributeError:
tool = None
return expr.show(trial_numbers=numbers, tool_name=tool)
def main(self, argv):
from tau.cli.commands.project.list import COMMAND as project_list
args = self.parser.parse_args(args=argv)
self.logger.debug('Arguments: %s', args)
tar_ctrl = Target.controller(PROJECT_STORAGE)
app_ctrl = Application.controller(PROJECT_STORAGE)
meas_ctrl = Measurement.controller(PROJECT_STORAGE)
proj_ctrl = Project.controller()
project_name = args.name
project = proj_ctrl.one({'name': project_name})
if not project:
self.parser.error("'%s' is not a project name. Type `%s` to see valid names." %
(project_name, project_list.command))
updates = dict(project.element)
updates['name'] = getattr(args, 'new_name', project_name)
targets = set(project['targets'])
applications = set(project['applications'])
measurements = set(project['measurements'])
added = set()
removed = set()
for attr, ctrl, dest in [('add_targets', tar_ctrl, targets),
('add_applications', app_ctrl, applications),
('add_measurements', meas_ctrl, measurements)]:
names = getattr(args, attr, [])
for name in names:
found = ctrl.one({'name': name})
if not found:
self.parser.error("There is no %s named '%s'" % (ctrl.model.name, name))
dest.add(found.eid)
added.add(found)
for name in set(getattr(args, "add", [])):
tar = tar_ctrl.one({'name': name})
app = app_ctrl.one({'name': name})
mes = meas_ctrl.one({'name': name})
tam = set([tar, app, mes]) - set([None])
if len(tam) > 1:
self.parser.error("'%s' is ambiguous. Use --add-targets, --add-applications,"
" or --add-measurements to specify configuration type" % name)
elif len(tam) == 0:
self.parser.error("'%s' is not a target, application, or measurement" % name)
else:
added.update(tam)
if tar:
targets.add(tar.eid)
elif app:
applications.add(app.eid)
elif mes:
measurements.add(mes.eid)
for attr, ctrl, dest in [('remove_targets', tar_ctrl, targets),
('remove_applications', app_ctrl, applications),
('remove_measurements', meas_ctrl, measurements)]:
names = getattr(args, attr, [])
for name in names:
found = ctrl.one({'name': name})
if not found:
self.parser.error('There is no %s named %r' % (ctrl.model.name, name))
dest.remove(found.eid)
removed.add(found)
for name in set(getattr(args, "remove", [])):
tar = tar_ctrl.one({'name': name})
app = app_ctrl.one({'name': name})
mes = meas_ctrl.one({'name': name})
tam = set([tar, app, mes]) - set([None])
if len(tam) > 1:
self.parser.error("'%s' is ambiguous. Use --remove-targets, --remove-applications,"
" or --remove-measurements to specify configuration type" % name)
elif len(tam) == 0:
self.parser.error("'%s' is not a target, application, or measurement" % name)
else:
removed.update(tam)
if tar:
targets.remove(tar.eid)
elif app:
applications.remove(app.eid)
elif mes:
measurements.remove(mes.eid)
updates['targets'] = list(targets)
updates['applications'] = list(applications)
updates['measurements'] = list(measurements)
proj_ctrl.update(updates, {'name': project_name})
for model in added:
self.logger.info("Added %s '%s' to project configuration '%s'.",
model.name.lower(), model[model.key_attribute], project_name)
for model in removed:
self.logger.info("Removed %s '%s' from project configuration '%s'.",
model.name.lower(), model[model.key_attribute], project_name)
return EXIT_SUCCESS
