def _parse_implicit(self, args):
targets = set()
applications = set()
measurements = set()
experiments = set()
targ_ctrl = Target.controller(PROJECT_STORAGE)
app_ctrl = Application.controller(PROJECT_STORAGE)
meas_ctrl = Measurement.controller(PROJECT_STORAGE)
expr_ctrl = Experiment.controller(PROJECT_STORAGE)
for flag in 'impl_experiment', 'impl_project', 'impl_target', 'impl_application', 'impl_measurement':
for name in getattr(args, flag, []):
tar = targ_ctrl.one({"name": name})
app = app_ctrl.one({"name": name})
mes = meas_ctrl.one({"name": name})
expr = expr_ctrl.one({"name": name})
found = {tar, app, mes, expr} - {None}
if len(found) > 1:
self.parser.error(
"'%s' is ambiguous. "
"Please use a command line flag to specify configuration type."
% name)
elif not found:
self.parser.error(
"'%s' is not an experiment, target, application, or measurement."
% name)
elif tar:
targets.add(tar)
elif app:
applications.add(app)
elif mes:
measurements.add(mes)
elif expr:
experiments.add(expr)
return targets, applications, measurements, experiments
def _parse_implicit(self, args):
targets = set()
applications = set()
measurements = set()
experiments = set()
targ_ctrl = Target.controller(PROJECT_STORAGE)
app_ctrl = Application.controller(PROJECT_STORAGE)
meas_ctrl = Measurement.controller(PROJECT_STORAGE)
expr_ctrl = Experiment.controller(PROJECT_STORAGE)
for flag in 'impl_experiment', 'impl_project', 'impl_target', 'impl_application', 'impl_measurement':
for name in getattr(args, flag, []):
tar = targ_ctrl.one({"name": name})
app = app_ctrl.one({"name": name})
mes = meas_ctrl.one({"name": name})
expr = expr_ctrl.one({"name": name})
found = set([tar, app, mes, expr]) - set([None])
if len(found) > 1:
self.parser.error("'%s' is ambiguous. "
"Please use a command line flag to specify configuration type." % name)
elif len(found) == 0:
self.parser.error("'%s' is not an experiment, target, application, or measurement." % name)
elif tar:
targets.add(tar)
elif app:
applications.add(app)
elif mes:
measurements.add(mes)
elif expr:
experiments.add(expr)
return targets, applications, measurements, experiments
def _parse_implicit(self, args, targets, applications, measurements):
targ_ctrl = Target.controller(PROJECT_STORAGE)
app_ctrl = Application.controller(PROJECT_STORAGE)
meas_ctrl = Measurement.controller(PROJECT_STORAGE)
for flag in 'impl_targets', 'impl_applications', 'impl_measurements':
for name in getattr(args, flag, []):
tar = targ_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. Please use --target, --application,"
" or --measurement to specify configuration type" %
name)
elif len(tam) == 0:
self.parser.error(
"'%s' is not a target, application, or measurement" %
name)
elif tar:
targets.add(tar)
elif app:
applications.add(app)
elif mes:
measurements.add(mes)
def main(self, argv):
args = self._parse_args(argv)
proj_ctrl = Project.controller()
proj = proj_ctrl.selected()
targ = Target.controller(proj_ctrl.storage).one({'name': args.target})
if targ is None:
self.parser.error("A target with name %s does not exist." %
args.target)
app = Application.controller(proj_ctrl.storage).one(
{'name': args.application})
if app is None:
self.parser.error("An application with name %s does not exist." %
args.application)
meas = Measurement.controller(proj_ctrl.storage).one(
{'name': args.measurement})
if meas is None:
self.parser.error("A measurement with name %s does not exist." %
args.measurement)
data = {
'name': args.name,
'project': proj.eid,
'target': targ.eid,
'application': app.eid,
'measurement': meas.eid
}
return self._create_record(PROJECT_STORAGE, data)
def assertCompiler(self, role, target_name='targ1'):
from taucmdr.model.target import Target
targ_ctrl = Target.controller(PROJECT_STORAGE)
targ = targ_ctrl.one({'name': target_name})
try:
return targ.populate(role.keyword)['path']
except KeyError:
self.fail("No %s compiler in target '%s'" % (role, target_name))
def assertCompiler(self, role, target_name='targ1'):
from taucmdr.model.target import Target
targ_ctrl = Target.controller(PROJECT_STORAGE)
targ = targ_ctrl.one({'name': target_name})
try:
return targ.populate(role.keyword)['path']
except KeyError:
self.fail("No %s compiler in target '%s'" % (role, target_name))
def test_host_family_pgi(self):
self.reset_project_storage()
stdout, stderr = self.assertCommandReturnValue(0, create_cmd, ['test_targ', '--compilers', 'PGI'])
self.assertIn("Added target", stdout)
self.assertIn("test_targ", stdout)
self.assertFalse(stderr)
from taucmdr.cf.storage.levels import PROJECT_STORAGE
from taucmdr.model.target import Target
ctrl = Target.controller(PROJECT_STORAGE)
test_targ = ctrl.one({'name': 'test_targ'})
path = test_targ.populate(CC.keyword)['path']
self.assertEqual('pgcc', os.path.basename(path), "Target[CC] is '%s', not 'pgcc'" % path)
def test_host_family_pgi(self):
self.reset_project_storage()
stdout, stderr = self.assertCommandReturnValue(
0, create_cmd, ['test_targ', '--compilers', 'PGI'])
self.assertIn("Added target", stdout)
self.assertIn("test_targ", stdout)
self.assertFalse(stderr)
from taucmdr.cf.storage.levels import PROJECT_STORAGE
from taucmdr.model.target import Target
ctrl = Target.controller(PROJECT_STORAGE)
test_targ = ctrl.one({'name': 'test_targ'})
path = test_targ.populate(CC.keyword)['path']
self.assertEqual('pgcc', os.path.basename(path),
"Target[CC] is '%s', not 'pgcc'" % path)
def _populate_project(self, argv, args):
def _safe_execute(cmd, argv):
retval = cmd.main(argv)
if retval != EXIT_SUCCESS:
raise InternalError("return code %s: %s %s" % (retval, cmd, ' '.join(argv)))
# Parse and strip application arguments to avoid ambiguous arguments like '--mpi' in `measurement create`
application_name = args.application_name
application_args, unknown = application_create_cmd.parser.parse_known_args([application_name] + argv)
application_argv = [application_name] + [arg for arg in argv if arg not in unknown]
_safe_execute(application_create_cmd, application_argv)
argv = [arg for arg in argv if arg in unknown]
target_name = args.target_name
_, unknown = target_create_cmd.parser.parse_known_args([target_name] + argv)
target_argv = [target_name] + [arg for arg in argv if arg not in unknown]
_safe_execute(target_create_cmd, target_argv)
targ = Target.controller(PROJECT_STORAGE).one({'name': target_name})
if not targ['binutils_source']:
self.logger.info("GNU binutils unavailable: disabling sampling and compiler-based instrumentation")
args.sample = False
args.compiler_inst = 'never'
measurement_names = []
measurement_args = ['--%s=True' % attr for attr in 'cuda', 'mpi', 'opencl', 'shmem'
if getattr(application_args, attr, False)]
if args.sample:
trace = args.trace if args.profile == 'none' else 'none'
_safe_execute(measurement_create_cmd,
['sample', '--profile', args.profile, '--trace', trace, '--sample=True',
'--source-inst=never', '--compiler-inst=never',
'--link-only=False'] + measurement_args)
measurement_names.append('sample')
if args.profile != 'none':
_safe_execute(measurement_create_cmd,
['profile', '--profile', args.profile, '--trace=none', '--sample=False',
'--source-inst', args.source_inst, '--compiler-inst', args.compiler_inst,
'--link-only=False'] + measurement_args)
measurement_names.append('profile')
if args.trace != 'none':
_safe_execute(measurement_create_cmd,
['trace', '--profile=none', '--trace', args.trace, '--sample=False', '--callpath=0',
'--source-inst', args.source_inst, '--compiler-inst', args.compiler_inst,
'--link-only=False'] + measurement_args)
measurement_names.append('trace')
select_cmd.main(['--target', target_name,
'--application', application_name,
'--measurement', measurement_names[0]])
def main(self, argv):
from taucmdr.cli.commands.project.list import COMMAND as project_list
args = self._parse_args(argv)
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 = self._parse_add_args(args, tar_ctrl, app_ctrl, meas_ctrl, targets, applications, measurements)
removed = self._parse_remove_args(args, tar_ctrl, app_ctrl, meas_ctrl, targets, applications, measurements)
updates['targets'] = list(targets)
updates['applications'] = list(applications)
updates['measurements'] = list(measurements)
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 updates.pop('force_tau_options', False) and [i.lower().strip() for i in force_tau_options] == ['none']:
proj_ctrl.unset(['force_tau_options'], {'name': project_name})
self.logger.info("Removed 'force-tau-options' from project configuration '%s'.", project_name)
else:
updates['force_tau_options'] = force_tau_options
self.logger.info("Added 'force-tau-options' to project configuration '%s'.", project_name)
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
def test_host_family_intel(self):
self.reset_project_storage()
stdout, stderr = self.assertCommandReturnValue(0, create_cmd, ['test_targ', '--compilers', 'Intel'])
self.assertIn("Added target", stdout)
self.assertIn("test_targ", stdout)
self.assertFalse(stderr)
from taucmdr.cf.storage.levels import PROJECT_STORAGE
from taucmdr.model.target import Target
ctrl = Target.controller(PROJECT_STORAGE)
test_targ = ctrl.one({'name': 'test_targ'})
for role, expected in (CC, 'icc'), (CXX, 'icpc'), (FC, 'ifort'):
path = test_targ.populate(role.keyword)['path']
self.assertEqual(os.path.basename(path), expected,
"Target[%s] is '%s', not '%s'" % (role, path, expected))
def test_host_family_intel(self):
self.reset_project_storage()
stdout, stderr = self.assertCommandReturnValue(
0, create_cmd, ['test_targ', '--compilers', 'Intel'])
self.assertIn("Added target", stdout)
self.assertIn("test_targ", stdout)
self.assertFalse(stderr)
from taucmdr.cf.storage.levels import PROJECT_STORAGE
from taucmdr.model.target import Target
ctrl = Target.controller(PROJECT_STORAGE)
test_targ = ctrl.one({'name': 'test_targ'})
for role, expected in (CC, 'icc'), (CXX, 'icpc'), (FC, 'ifort'):
path = test_targ.populate(role.keyword)['path']
self.assertEqual(
os.path.basename(path), expected,
"Target[%s] is '%s', not '%s'" % (role, path, expected))
def main(self, argv):
args = self._parse_args(argv)
proj_ctrl = Project.controller()
proj = proj_ctrl.selected()
targ = Target.controller(proj_ctrl.storage).one({'name': args.target})
if targ is None:
self.parser.error("A target with name %s does not exist." %args.target)
app = Application.controller(proj_ctrl.storage).one({'name': args.application})
if app is None:
self.parser.error("An application with name %s does not exist." %args.application)
meas = Measurement.controller(proj_ctrl.storage).one({'name': args.measurement})
if meas is None:
self.parser.error("A measurement with name %s does not exist." %args.measurement)
data = {'name': args.name,
'project': proj.eid,
'target': targ.eid,
'application': app.eid,
'measurement': meas.eid}
return self._create_record(PROJECT_STORAGE, data)
def main(self, argv):
from taucmdr.cli.commands.project.list import COMMAND as project_list
args = self._parse_args(argv)
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)
updates['name'] = getattr(args, 'new_name', project_name)
targets = set(project['targets'])
applications = set(project['applications'])
measurements = set(project['measurements'])
added = self._parse_add_args(args, tar_ctrl, app_ctrl, meas_ctrl,
targets, applications, measurements)
removed = self._parse_remove_args(args, tar_ctrl, app_ctrl, meas_ctrl,
targets, applications, measurements)
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
def _parse_implicit(self, args, targets, applications, measurements):
targ_ctrl = Target.controller(PROJECT_STORAGE)
app_ctrl = Application.controller(PROJECT_STORAGE)
meas_ctrl = Measurement.controller(PROJECT_STORAGE)
for flag in 'impl_targets', 'impl_applications', 'impl_measurements':
for name in getattr(args, flag, []):
tar = targ_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. Please use --target, --application,"
" or --measurement to specify configuration type" % name)
elif len(tam) == 0:
self.parser.error("'%s' is not a target, application, or measurement" % name)
elif tar:
targets.add(tar)
elif app:
applications.add(app)
elif mes:
measurements.add(mes)
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):
from taucmdr.cli.commands.project.list import COMMAND as project_list
args = self._parse_args(argv)
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)
updates['name'] = getattr(args, 'new_name', project_name)
targets = set(project['targets'])
applications = set(project['applications'])
measurements = set(project['measurements'])
added = self._parse_add_args(args, tar_ctrl, app_ctrl, meas_ctrl, targets, applications, measurements)
removed = self._parse_remove_args(args, tar_ctrl, app_ctrl, meas_ctrl, targets, applications, measurements)
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
def _populate_project(self, args):
# Create default application
application_name = args.application_name
cmd_args = Application.filter_arguments(args)
cmd_args.name = application_name
cmd_args.openmp = bool(args.openmp)
if args.openmp is None:
args.openmp = 'ignore'
self._safe_execute(application_create_cmd, cmd_args)
# Create default target
target_name = args.target_name
cmd_args = Target.filter_arguments(args)
cmd_args.name = target_name
self._safe_execute(target_create_cmd, cmd_args)
# Target was created so let's see if we can use binutils on this target.
targ = Target.controller(PROJECT_STORAGE).one({'name': target_name})
if not targ['binutils_source']:
self.logger.info("GNU binutils unavailable: disabling sampling and compiler-based instrumentation")
args.sample = False
args.compiler_inst = 'never'
# Create default measurements
measurements = []
if args.profile != 'none':
self._create_measurement(
'baseline', args, baseline=True, profile='tau', trace='none',
sample=False, source_inst='never', compiler_inst='never',
mpi=False, cuda=False, opencl=False, openmp='ignore', shmem=False,
track_memory_footprint=False, callsite=False, comm_matrix=False,
heap_usage=False, memory_alloc=False)
if args.sample:
measurements.append(self._create_measurement(
'sample', args, profile=args.profile, trace='none',
sample=True, source_inst='never', compiler_inst='never'))
if args.source_inst != 'never' or args.compiler_inst != 'never':
measurements.append(self._create_measurement(
'profile', args, profile=args.profile, trace='none',
sample=False, source_inst=args.source_inst, compiler_inst=args.compiler_inst))
if args.source_inst != 'never':
measurements.append(self._create_measurement(
'source-inst', args, profile=args.profile, trace='none',
sample=False, source_inst=args.source_inst, compiler_inst='never'))
if args.compiler_inst != 'never':
measurements.append(self._create_measurement(
'compiler-inst', args, profile=args.profile, trace='none',
sample=False, source_inst='never', compiler_inst='always'))
if args.trace != 'none':
if args.source_inst != 'never' or args.compiler_inst != 'never':
measurements.append(self._create_measurement(
'trace', args, profile='none', trace=args.trace, callpath=0,
sample=False, source_inst=args.source_inst, compiler_inst=args.compiler_inst))
try:
measurement_name = measurements[0]
except IndexError:
measurement_name = 'baseline'
# Create default experiment
select_cmd.main(['--target', target_name,
'--application', application_name,
'--measurement', measurement_name])