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 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 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 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 = '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))
