def initialize(self): if not self.target.has('cpuidle'): return self._retrieve_device_idle_info() common_idle_states = self._get_common_idle_values() idle_state_val = IdleStateValue(common_idle_states) if common_idle_states: param_name = 'idle_states' self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=idle_state_val, setter=self.set_idle_state, setter_params={'core': None}, description=""" The idle states to be set for all cores """) for name in unique(self.target.platform.core_names): cpu = resolve_cpus(name, self.target)[0] idle_state_val = IdleStateValue(self.supported_idle_states.get(cpu)) param_name = '{}_idle_states'.format(name) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=idle_state_val, setter=self.set_idle_state, setter_params={'core': name}, description=""" The idle states to be set for {} cores """.format(name)) for cpu_no in range(self.target.number_of_cpus): idle_state_val = IdleStateValue(self.supported_idle_states.get(cpu_no)) param_name = 'cpu{}_idle_states'.format(cpu_no) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=idle_state_val, setter=self.set_idle_state, setter_params={'core': cpu_no}, description=""" The idle states to be set for cpu{} """.format(cpu_no)) if self.target.has('bl'): for cluster in ['big', 'little']: cpu = resolve_cpus(cluster, self.target)[0] idle_state_val = IdleStateValue(self.supported_idle_states.get(cpu)) param_name = '{}_idle_states'.format(cluster) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=idle_state_val, setter=self.set_idle_state, setter_params={'core': cluster}, description=""" The idle states to be set for the {} cores """.format(cluster))
def get_data(self, outfile): # pylint: disable=R0914 tempdir = tempfile.mkdtemp(prefix='daq-raw-') self.execute('get_data', output_directory=tempdir) raw_file_map = {} for entry in os.listdir(tempdir): site = os.path.splitext(entry)[0] path = os.path.join(tempdir, entry) raw_file_map[site] = path self._raw_files.append(path) active_sites = unique([c.site for c in self.active_channels]) file_handles = [] try: site_readers = {} for site in active_sites: try: site_file = raw_file_map[site] fh = open(site_file, 'rb') site_readers[site] = csv.reader(fh) file_handles.append(fh) except KeyError: message = 'Could not get DAQ trace for {}; Obtained traces are in {}' raise HostError(message.format(site, tempdir)) # The first row is the headers channel_order = [] for site, reader in site_readers.iteritems(): channel_order.extend( ['{}_{}'.format(site, kind) for kind in reader.next()]) def _read_next_rows(): parts = [] for reader in site_readers.itervalues(): try: parts.extend(reader.next()) except StopIteration: parts.extend([None, None]) return list(chain(parts)) with open(outfile, 'wb') as wfh: field_names = [c.label for c in self.active_channels] writer = csv.writer(wfh) writer.writerow(field_names) raw_row = _read_next_rows() while any(raw_row): row = [ raw_row[channel_order.index(f)] for f in field_names ] writer.writerow(row) raw_row = _read_next_rows() return MeasurementsCsv(outfile, self.active_channels, self.sample_rate_hz) finally: for fh in file_handles: fh.close()
def get_data(self, outfile): # pylint: disable=R0914 self.tempdir = tempfile.mkdtemp(prefix='daq-raw-') self.daq_client.get_data(self.tempdir) raw_file_map = {} for entry in os.listdir(self.tempdir): site = os.path.splitext(entry)[0] path = os.path.join(self.tempdir, entry) raw_file_map[site] = path self._raw_files.append(path) active_sites = unique([c.site for c in self.active_channels]) file_handles = [] try: site_readers = {} for site in active_sites: try: site_file = raw_file_map[site] reader, fh = create_reader(site_file) site_readers[site] = reader file_handles.append(fh) except KeyError: if not site.startswith("Time"): message = 'Could not get DAQ trace for {}; Obtained traces are in {}' raise HostError(message.format(site, self.tempdir)) # The first row is the headers channel_order = ['Time_time'] for site, reader in site_readers.items(): channel_order.extend( ['{}_{}'.format(site, kind) for kind in next(reader)]) def _read_rows(): row_iter = zip_longest(*site_readers.values(), fillvalue=(None, None)) for raw_row in row_iter: raw_row = list(chain.from_iterable(raw_row)) raw_row.insert(0, _read_rows.row_time_s) yield raw_row _read_rows.row_time_s += 1.0 / self.sample_rate_hz _read_rows.row_time_s = self.target_boottime_clock_at_start with csvwriter(outfile) as writer: field_names = [c.label for c in self.active_channels] writer.writerow(field_names) for raw_row in _read_rows(): row = [ raw_row[channel_order.index(f)] for f in field_names ] writer.writerow(row) return MeasurementsCsv(outfile, self.active_channels, self.sample_rate_hz) finally: for fh in file_handles: fh.close()
def get_data(self, outfile): # pylint: disable=R0914 tempdir = tempfile.mkdtemp(prefix='daq-raw-') self.execute('get_data', output_directory=tempdir) raw_file_map = {} for entry in os.listdir(tempdir): site = os.path.splitext(entry)[0] path = os.path.join(tempdir, entry) raw_file_map[site] = path self._raw_files.append(path) active_sites = unique([c.site for c in self.active_channels]) file_handles = [] try: site_readers = {} for site in active_sites: try: site_file = raw_file_map[site] fh = open(site_file, 'rb') site_readers[site] = csv.reader(fh) file_handles.append(fh) except KeyError: message = 'Could not get DAQ trace for {}; Obtained traces are in {}' raise HostError(message.format(site, tempdir)) # The first row is the headers channel_order = [] for site, reader in site_readers.iteritems(): channel_order.extend(['{}_{}'.format(site, kind) for kind in reader.next()]) def _read_next_rows(): parts = [] for reader in site_readers.itervalues(): try: parts.extend(reader.next()) except StopIteration: parts.extend([None, None]) return list(chain(parts)) with open(outfile, 'wb') as wfh: field_names = [c.label for c in self.active_channels] writer = csv.writer(wfh) writer.writerow(field_names) raw_row = _read_next_rows() while any(raw_row): row = [raw_row[channel_order.index(f)] for f in field_names] writer.writerow(row) raw_row = _read_next_rows() return MeasurementsCsv(outfile, self.active_channels, self.sample_rate_hz) finally: for fh in file_handles: fh.close()
def initialize(self): if not self.target.has('hotplug'): return param_name = 'num_cores' self._runtime_params[param_name] = \ RuntimeParameter(param_name, kind=int, constraint=lambda x: 0 <= x <= self.target.number_of_cpus, description=""" The number of cpu cores to be online """, setter=self.set_num_cores, setter_params={'core': None}) for name in unique(self.target.platform.core_names): param_name = 'num_{}_cores'.format(name) self._runtime_params[param_name] = \ RuntimeParameter(param_name, kind=int, constraint=lambda x, name=name: 0 <= x <= len(self.target.core_cpus(name)), description=""" The number of {} cores to be online """.format(name), setter=self.set_num_cores, setter_params={'core': name}) for cpu_no in range(self.target.number_of_cpus): param_name = 'cpu{}_online'.format(cpu_no) self._runtime_params[param_name] = \ RuntimeParameter(param_name, kind=bool, description=""" Specify whether cpu{} should be online """.format(cpu_no), setter=self.set_num_cores, setter_params={'core': cpu_no}) if self.target.has('bl'): for cluster in ['big', 'little']: param_name = 'num_{}_cores'.format(cluster) self._runtime_params[param_name] = \ RuntimeParameter(param_name, kind=int, constraint=lambda x, c=cluster: 0 <= x <= len(resolve_cpus(c, self.target)), description=""" The number of cores on the {} cluster to be online """.format(cluster), setter=self.set_num_cores, setter_params={'core': cluster})
def merge_sequencies(s1, s2): return type(s2)(unique(chain(s1, s2)))
def core_names(self): return unique(self.target.core_names)
def initialize(self): # pylint: disable=too-many-statements if not self.target.has('cpufreq'): return self._retrive_cpufreq_info() _, common_freqs, common_gov = self._get_common_values() # Add common parameters if available. freq_val = FreqValue(common_freqs) param_name = 'frequency' self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=freq_val, setter=self.set_frequency, setter_params={'core': None}, description=""" The desired frequency for all cores """) param_name = 'max_frequency' self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=freq_val, setter=self.set_max_frequency, setter_params={'core': None}, description=""" The maximum frequency for all cores """) param_name = 'min_frequency' self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=freq_val, setter=self.set_min_frequency, setter_params={'core': None}, description=""" The minimum frequency for all cores """) if common_gov: param_name = 'governor' self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=str, allowed_values=common_gov, setter=self.set_governor, setter_params={'core': None}, description=""" The governor to be set for all cores """) param_name = 'gov_tunables' self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=dict, merge=True, setter=self.set_governor_tunables, setter_params={'core': None}, aliases=['governor_tunables'], description=""" The governor tunables to be set for all cores """) # Add core name parameters for name in unique(self.target.platform.core_names): cpu = resolve_unique_domain_cpus(name, self.target)[0] freq_val = FreqValue(self.supported_cpu_freqs.get(cpu)) avail_govs = self.supported_cpu_governors.get(cpu) param_name = '{}_frequency'.format(name) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=freq_val, setter=self.set_frequency, setter_params={'core': name}, description=""" The desired frequency for the {} cores """.format(name)) param_name = '{}_max_frequency'.format(name) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=freq_val, setter=self.set_max_frequency, setter_params={'core': name}, description=""" The maximum frequency for the {} cores """.format(name)) param_name = '{}_min_frequency'.format(name) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=freq_val, setter=self.set_min_frequency, setter_params={'core': name}, description=""" The minimum frequency for the {} cores """.format(name)) param_name = '{}_governor'.format(name) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=str, allowed_values=avail_govs, setter=self.set_governor, setter_params={'core': name}, description=""" The governor to be set for the {} cores """.format(name)) param_name = '{}_gov_tunables'.format(name) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=dict, setter=self.set_governor_tunables, setter_params={'core': name}, merge=True, description=""" The governor tunables to be set for the {} cores """.format(name)) # Add cpuX parameters. for cpu_no in range(self.target.number_of_cpus): freq_val = FreqValue(self.supported_cpu_freqs.get(cpu_no)) avail_govs = self.supported_cpu_governors.get(cpu_no) param_name = 'cpu{}_frequency'.format(cpu_no) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=freq_val, setter=self.set_frequency, setter_params={'core': cpu_no}, description=""" The desired frequency for cpu{} """.format(cpu_no)) param_name = 'cpu{}_max_frequency'.format(cpu_no) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=freq_val, setter=self.set_max_frequency, setter_params={'core': cpu_no}, description=""" The maximum frequency for cpu{} """.format(cpu_no)) param_name = 'cpu{}_min_frequency'.format(cpu_no) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=freq_val, setter=self.set_min_frequency, setter_params={'core': cpu_no}, description=""" The minimum frequency for cpu{} """.format(cpu_no)) param_name = 'cpu{}_governor'.format(cpu_no) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=str, allowed_values=avail_govs, setter=self.set_governor, setter_params={'core': cpu_no}, description=""" The governor to be set for cpu{} """.format(cpu_no)) param_name = 'cpu{}_gov_tunables'.format(cpu_no) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=dict, setter=self.set_governor_tunables, setter_params={'core': cpu_no}, merge=True, description=""" The governor tunables to be set for cpu{} """.format(cpu_no)) # Add big.little cores if present on device. if self.target.has('bl'): for cluster in ['big', 'little']: cpu = resolve_unique_domain_cpus(cluster, self.target)[0] freq_val = FreqValue(self.supported_cpu_freqs.get(cpu)) avail_govs = self.supported_cpu_governors.get(cpu) param_name = '{}_frequency'.format(cluster) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=freq_val, setter=self.set_frequency, setter_params={'core': cluster}, description=""" The desired frequency for the {} cluster """.format(cluster)) param_name = '{}_max_frequency'.format(cluster) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=freq_val, setter=self.set_max_frequency, setter_params={'core': cluster}, description=""" The maximum frequency for the {} cluster """.format(cluster)) param_name = '{}_min_frequency'.format(cluster) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=freq_val, setter=self.set_min_frequency, setter_params={'core': cluster}, description=""" The minimum frequency for the {} cluster """.format(cluster)) param_name = '{}_governor'.format(cluster) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=str, allowed_values=avail_govs, setter=self.set_governor, setter_params={'core': cluster}, description=""" The governor to be set for the {} cores """.format(cluster)) param_name = '{}_gov_tunables'.format(cluster) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=dict, setter=self.set_governor_tunables, setter_params={'core': cluster}, merge=True, description=""" The governor tunables to be set for the {} cores """.format(cluster))
def initialize(self): # pylint: disable=too-many-statements if not self.target.has('cpufreq'): return self._retrive_cpufreq_info() _, common_freqs, common_gov = self._get_common_values() # Add common parameters if available. freq_val = FreqValue(common_freqs) param_name = 'frequency' self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=freq_val, setter=self.set_frequency, setter_params={'core': None}, description=""" The desired frequency for all cores """) param_name = 'max_frequency' self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=freq_val, setter=self.set_max_frequency, setter_params={'core': None}, description=""" The maximum frequency for all cores """) param_name = 'min_frequency' self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=freq_val, setter=self.set_min_frequency, setter_params={'core': None}, description=""" The minimum frequency for all cores """) if common_gov: param_name = 'governor' self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=str, allowed_values=common_gov, setter=self.set_governor, setter_params={'core': None}, description=""" The governor to be set for all cores """) param_name = 'governor_tunables' self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=dict, merge=True, setter=self.set_governor_tunables, setter_params={'core': None}, description=""" The governor tunables to be set for all cores """) # Add core name parameters for name in unique(self.target.platform.core_names): cpu = resolve_unique_domain_cpus(name, self.target)[0] freq_val = FreqValue(self.supported_cpu_freqs.get(cpu)) avail_govs = self.supported_cpu_governors.get(cpu) param_name = '{}_frequency'.format(name) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=freq_val, setter=self.set_frequency, setter_params={'core': name}, description=""" The desired frequency for the {} cores """.format(name)) param_name = '{}_max_frequency'.format(name) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=freq_val, setter=self.set_max_frequency, setter_params={'core': name}, description=""" The maximum frequency for the {} cores """.format(name)) param_name = '{}_min_frequency'.format(name) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=freq_val, setter=self.set_min_frequency, setter_params={'core': name}, description=""" The minimum frequency for the {} cores """.format(name)) param_name = '{}_governor'.format(name) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=str, allowed_values=avail_govs, setter=self.set_governor, setter_params={'core': name}, description=""" The governor to be set for the {} cores """.format(name)) param_name = '{}_gov_tunables'.format(name) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=dict, setter=self.set_governor_tunables, setter_params={'core': name}, merge=True, description=""" The governor tunables to be set for the {} cores """.format(name)) # Add cpuX parameters. for cpu_no in range(self.target.number_of_cpus): freq_val = FreqValue(self.supported_cpu_freqs.get(cpu_no)) avail_govs = self.supported_cpu_governors.get(cpu_no) param_name = 'cpu{}_frequency'.format(cpu_no) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=freq_val, setter=self.set_frequency, setter_params={'core': cpu_no}, description=""" The desired frequency for cpu{} """.format(cpu_no)) param_name = 'cpu{}_max_frequency'.format(cpu_no) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=freq_val, setter=self.set_max_frequency, setter_params={'core': cpu_no}, description=""" The maximum frequency for cpu{} """.format(cpu_no)) param_name = 'cpu{}_min_frequency'.format(cpu_no) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=freq_val, setter=self.set_min_frequency, setter_params={'core': cpu_no}, description=""" The minimum frequency for cpu{} """.format(cpu_no)) param_name = 'cpu{}_governor'.format(cpu_no) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=str, allowed_values=avail_govs, setter=self.set_governor, setter_params={'core': cpu_no}, description=""" The governor to be set for cpu{} """.format(cpu_no)) param_name = 'cpu{}_gov_tunables'.format(cpu_no) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=dict, setter=self.set_governor_tunables, setter_params={'core': cpu_no}, merge=True, description=""" The governor tunables to be set for cpu{} """.format(cpu_no)) # Add big.little cores if present on device. if self.target.has('bl'): for cluster in ['big', 'little']: cpu = resolve_unique_domain_cpus(cluster, self.target)[0] freq_val = FreqValue(self.supported_cpu_freqs.get(cpu)) avail_govs = self.supported_cpu_governors.get(cpu) param_name = '{}_frequency'.format(cluster) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=freq_val, setter=self.set_frequency, setter_params={'core': cluster}, description=""" The desired frequency for the {} cluster """.format(cluster)) param_name = '{}_max_frequency'.format(cluster) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=freq_val, setter=self.set_max_frequency, setter_params={'core': cluster}, description=""" The maximum frequency for the {} cluster """.format(cluster)) param_name = '{}_min_frequency'.format(cluster) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=freq_val, setter=self.set_min_frequency, setter_params={'core': cluster}, description=""" The minimum frequency for the {} cluster """.format(cluster)) param_name = '{}_governor'.format(cluster) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=str, allowed_values=avail_govs, setter=self.set_governor, setter_params={'core': cluster}, description=""" The governor to be set for the {} cores """.format(cluster)) param_name = '{}_gov_tunables'.format(cluster) self._runtime_params[param_name] = \ RuntimeParameter( param_name, kind=dict, setter=self.set_governor_tunables, setter_params={'core': cluster}, merge=True, description=""" The governor tunables to be set for the {} cores """.format(cluster))