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 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_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)