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 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 test_resolve_cpu(self):
# Set up a mock target
mock = Mock()
mock.big_core = "A72"
mock.little_core = "A53"
mock.core_names = ['A72', 'A72', 'A53', 'A53']
mock.number_of_cpus = 4
def mock_core_cpus(core):
return [i for i, c in enumerate(mock.core_names) if c == core]
def mock_online_cpus():
return [0, 1, 2]
def mock_offline_cpus():
return [3]
def mock_related_cpus(core):
if core in [0, 1]:
return [0, 1]
elif core in [2, 3]:
return [2, 3]
mock.list_online_cpus = mock_online_cpus
mock.list_offline_cpus = mock_offline_cpus
mock.core_cpus = mock_core_cpus
mock.core_cpus = mock_core_cpus
mock.cpufreq.get_related_cpus = mock_related_cpus
# Check retrieving cpus from a given prefix
assert_equal(resolve_cpus('A72', mock), [0, 1])
assert_equal(resolve_cpus('A53', mock), [2, 3])
assert_equal(resolve_cpus('big', mock), [0, 1])
assert_equal(resolve_cpus('little', mock), [2, 3])
assert_equal(resolve_cpus('', mock), [0, 1, 2, 3])
assert_equal(resolve_cpus('cpu0', mock), [0])
assert_equal(resolve_cpus('cpu3', mock), [3])
# Check get unique domain cpus
assert_equal(resolve_unique_domain_cpus('A72', mock), [0])
assert_equal(resolve_unique_domain_cpus('A53', mock), [2])
assert_equal(resolve_unique_domain_cpus('big', mock), [0])
assert_equal(resolve_unique_domain_cpus('little', mock), [2])
assert_equal(resolve_unique_domain_cpus('', mock), [0, 2])
assert_equal(resolve_unique_domain_cpus('cpu0', mock), [0])
assert_equal(resolve_unique_domain_cpus('cpu3', mock), [2])
def set_num_cores(obj, value, core):
cpus = resolve_cpus(core, obj.target)
max_cores = len(cpus)
value = integer(value)
if value > max_cores:
msg = 'Cannot set number of {}\'s to {}; max is {}'
raise ValueError(msg.format(core, value, max_cores))
msg = 'CPU{} Hotplugging already configured'
# Set cpus to be enabled
for cpu in cpus[:value]:
if cpu in obj.num_cores:
raise ConfigError(msg.format(cpu))
obj.num_cores[cpu] = True
# Set the remaining cpus to be disabled.
for cpu in cpus[value:]:
if cpu in obj.num_cores:
raise ConfigError(msg.format(cpu))
obj.num_cores[cpu] = False
def set_num_cores(obj, value, core):
cpus = resolve_cpus(core, obj.target)
max_cores = len(cpus)
value = integer(value)
if value > max_cores:
msg = 'Cannot set number of {}\'s to {}; max is {}'
raise ValueError(msg.format(core, value, max_cores))
msg = 'CPU{} Hotplugging already configured'
# Set cpus to be enabled
for cpu in cpus[:value]:
if cpu in obj.num_cores:
raise ConfigError(msg.format(cpu))
obj.num_cores[cpu] = True
# Set the remaining cpus to be disabled.
for cpu in cpus[value:]:
if cpu in obj.num_cores:
raise ConfigError(msg.format(cpu))
obj.num_cores[cpu] = False
def test_resolve_cpu(self):
# Set up a mock target
mock = Mock()
mock.big_core = "A72"
mock.little_core = "A53"
mock.core_names = ['A72', 'A72', 'A53', 'A53']
mock.number_of_cpus = 4
def mock_core_cpus(core):
return [i for i, c in enumerate(mock.core_names) if c == core]
def mock_online_cpus():
return [0, 1, 2]
def mock_offline_cpus():
return [3]
def mock_related_cpus(core):
if core in [0, 1]:
return [0, 1]
elif core in [2, 3]:
return [2, 3]
mock.list_online_cpus = mock_online_cpus
mock.list_offline_cpus = mock_offline_cpus
mock.core_cpus = mock_core_cpus
mock.core_cpus = mock_core_cpus
mock.cpufreq.get_related_cpus = mock_related_cpus
# Check retrieving cpus from a given prefix
assert_equal(resolve_cpus('A72', mock), [0, 1])
assert_equal(resolve_cpus('A53', mock), [2, 3])
assert_equal(resolve_cpus('big', mock), [0, 1])
assert_equal(resolve_cpus('little', mock), [2, 3])
assert_equal(resolve_cpus('', mock), [0, 1, 2, 3])
assert_equal(resolve_cpus('cpu0', mock), [0])
assert_equal(resolve_cpus('cpu3', mock), [3])
# Check get unique domain cpus
assert_equal(resolve_unique_domain_cpus('A72', mock), [0])
assert_equal(resolve_unique_domain_cpus('A53', mock), [2])
assert_equal(resolve_unique_domain_cpus('big', mock), [0])
assert_equal(resolve_unique_domain_cpus('little', mock), [2])
assert_equal(resolve_unique_domain_cpus('', mock), [0, 2])
assert_equal(resolve_unique_domain_cpus('cpu0', mock), [0])
assert_equal(resolve_unique_domain_cpus('cpu3', mock), [2])
def set_idle_state(obj, value, core):
cpus = resolve_cpus(core, obj.target)
for cpu in cpus:
obj.config[cpu] = []
for state in value:
obj.config[cpu].append(state)
def set_idle_state(obj, value, core):
cpus = resolve_cpus(core, obj.target)
for cpu in cpus:
obj.config[cpu] = []
for state in value:
obj.config[cpu].append(state)
