def bitmask(value): if isinstance(value, basestring): value = ranges_to_list(value) if isiterable(value): value = list_to_mask(value) if not isinstance(value, int): raise ValueError(value) return value
def run(self, cpus=None, cgroup=None, background=False, as_root=False, timeout=None): """ Execute the workload on the configured target. :param cpus: CPUs on which to restrict the workload execution (taskset) :type cpus: list(int) :param cgroup: cgroup in which to run the workload :type cgroup: str :param background: Whether to run the workload in background or not :type background: bool :param as_root: Whether to run the workload as root or not :type as_root: bool :param timeout: Timeout in seconds for the workload execution. :type timeout: int :raise devlib.exception.TimeoutError: When the specified ``timeout`` is hit. The standard output will be saved into a file in ``self.res_dir`` """ logger = self.get_logger() if not self.command: raise RuntimeError("Workload does not specify any command to execute") _command = self.command target = self.target if cpus: taskset_bin = target.which('taskset') if not taskset_bin: raise RuntimeError("Could not find 'taskset' executable on the target") cpumask = list_to_mask(cpus) taskset_cmd = '{} {}'.format(quote(taskset_bin), quote('0x{:x}'.format(cpumask))) _command = '{} {}'.format(taskset_cmd, _command) if cgroup: _command = target.cgroups.run_into_cmd(cgroup, _command) _command = 'cd {} && {}'.format(quote(self.run_dir), _command) logger.info("Execution start: {}".format(_command)) if background: target.background(_command, as_root=as_root) else: self.output = target.execute(_command, as_root=as_root, timeout=timeout) logger.info("Execution complete") logfile = ArtifactPath.join(self.res_dir, 'output.log') logger.debug('Saving stdout to {}...'.format(logfile)) with open(logfile, 'w') as ofile: ofile.write(self.output)
def _basic_run(self, **kwargs): """ Basic run function to be used in subclasses' implementation of ``_run()``. By default, it will use the settings saved in ``_settings`` attribute by :class:`Workload`'s ``__init__``, but they can all be overridden manually with keyword arguments if that is really necessary. """ logger = self.get_logger() target = self.target settings = { **self._settings, **kwargs } as_root = settings.get('as_root') timeout = settings.get('timeout') command = settings.get('command') cpus = settings.get('cpus') cgroup = settings.get('cgroup') if command is None: raise ValueError('command must not be None') # Log the "clean" unmodified command. If the user wants the details, # debug log from devlib will provide it logger.info(f"Execution start: {command}") if cpus: target.install_tools(['taskset']) cpumask = list_to_mask(cpus) taskset_cmd = f"taskset {quote(f'0x{cpumask:x}')}" command = f'{taskset_cmd} {command}' if cgroup: command = target.cgroups.run_into_cmd(cgroup, command) command = f'cd {quote(self.run_dir)} && {command}' bg = target.background(command, as_root=as_root, timeout=timeout) return bg
def _matching_masks(self, cpus): df = self.trace.df_event('thermal_power_cpu_limit') global_mask = list_to_mask(cpus) cpumasks = df['cpus'].unique().tolist() return [m for m in cpumasks if m & global_mask]
def _matchingMasks(self, cpus): df = self._dfg_trace_event('thermal_power_cpu_limit') global_mask = list_to_mask(cpus) cpumasks = df['cpus'].unique().tolist() return [m for m in cpumasks if m & global_mask]