sascha/workload-automation
1
0
Fork 0
mirror of https://github.com/ARM-software/workload-automation.git synced 2025-09-02 03:12:34 +01:00
Code Issues Releases Wiki Activity

Integerated new target stuff into execution so far

Browse Source
This commit is contained in:
Sergei Trofimov
2017-03-07 15:17:23 +00:00
parent 42539bbe0d
commit d9458c8767
9 changed files with 170 additions and 147 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
wa/framework/target/descriptor.py
View File

@@ -24,6 +24,33 @@ def get_target_descriptions(loader=pluginloader):
return targets.values()
def instantiate_target(tdesc, params):
target_params = {p.name: p for p in tdesc.target_params}
platform_params = {p.name: p for p in tdesc.platform_params}
conn_params = {p.name: p for p in tdesc.conn_params}
tp, pp, cp = {}, {}, {}
for name, value in params.iteritems():
if name in target_params:
tp[name] = value
elif name in platform_params:
pp[name] = value
elif name in conn_params:
cp[name] = value
else:
msg = 'Unexpected parameter for {}: {}'
raise ValueError(msg.format(tdesc.name, name))
tp['platform'] = (tdesc.platform or Platform)(**pp)
if cp:
tp['connection_settings'] = cp
if tdesc.connection:
tp['conn_cls'] = tdesc.connection
return tdesc.target(**tp)
class TargetDescription(object):
def __init__(self, name, source, description=None, target=None, platform=None,
@@ -86,6 +113,18 @@ COMMON_TARGET_PARAMS = [
Please see ``devlab`` documentation for information on the available
modules.
'''),
Parameter('load_default_modules', kind=bool, default=True,
description='''
A number of modules (e.g. for working with the cpufreq subsystem) are
loaded by default when a Target is instantiated. Setting this to
``True`` would suppress that, ensuring that only the base Target
interface is initialized.
You may want to set this if there is a problem with one or more default
modules on your platform (e.g. your device is unrooted and cpufreq is
not accessible to unprivileged users), or if Target initialization is
taking too long for your platform.
'''),
]
COMMON_PLATFORM_PARAMS = [

8
wa/framework/target/info.py
View File

@@ -1,6 +1,7 @@
from devlib import AndroidTarget
from devlib.exception import TargetError
from devlib.target import KernelConfig, KernelVersion, Cpuinfo
from devlib.utils.android import AndroidProperties
class TargetInfo(object):
@@ -21,8 +22,9 @@ class TargetInfo(object):
if pod["target"] == "AndroidTarget":
instance.screen_resolution = pod['screen_resolution']
instance.prop = pod['prop']
instance.prop = pod['android_id']
instance.prop = AndroidProperties('')
instance.prop._properties = pod['prop']
instance.android_id = pod['android_id']
return instance
@@ -72,7 +74,7 @@ class TargetInfo(object):
if self.target == "AndroidTarget":
pod['screen_resolution'] = self.screen_resolution
pod['prop'] = self.prop
pod['prop'] = self.prop._properties
pod['android_id'] = self.android_id
return pod

103
wa/framework/target/manager.py
View File

@@ -9,6 +9,8 @@ import sys
from wa.framework import signal
from wa.framework.exception import WorkerThreadError, ConfigError
from wa.framework.plugin import Parameter
from wa.framework.target.descriptor import (get_target_descriptions,
instantiate_target)
from wa.framework.target.info import TargetInfo
from wa.framework.target.runtime_config import (SysfileValuesRuntimeConfig,
HotplugRuntimeConfig,
@@ -41,54 +43,29 @@ class TargetManager(object):
"""),
]
DEVICE_MAPPING = {'test' : {'platform_name':'generic',
'target_name': 'android'},
'other': {'platform_name':'test',
'target_name': 'linux'},
}
runtime_config_cls = [
# order matters
SysfileValuesRuntimeConfig,
HotplugRuntimeConfig,
CpufreqRuntimeConfig,
CpuidleRuntimeConfig,
]
# order matters
SysfileValuesRuntimeConfig,
HotplugRuntimeConfig,
CpufreqRuntimeConfig,
CpuidleRuntimeConfig,
]
def __init__(self, name, parameters):
self.name = name
self.target_name = name
self.target = None
self.assistant = None
self.target_name = None
self.platform_name = None
self.parameters = parameters
self.disconnect = parameters.get('disconnect')
self.info = TargetInfo()
# Determine platform and target based on passed name
self._parse_name()
# Create target
self._get_target()
# Create an assistant to perform target specific configuration
self._get_assistant()
self._init_target()
self._init_assistant()
### HERE FOR TESTING, WILL BE CALLED EXTERNALLY ###
# Connect to device and retrieve details.
# self.initialize()
# self.add_parameters()
# self.validate_parameters()
# self.set_parameters()
def initialize(self):
self.runtime_configs = [cls(self.target) for cls in self.runtime_config_cls]
# if self.parameters:
# self.logger.info('Connecting to the device')
with signal.wrap('TARGET_CONNECT'):
self.target.connect()
# self.info.load(self.target)
# info_file = os.path.join(self.context.info_directory, 'target.json')
# with open(info_file, 'w') as wfh:
# json.dump(self.info.to_pod(), wfh)
def finalize(self):
# self.logger.info('Disconnecting from the device')
@@ -108,10 +85,16 @@ class TargetManager(object):
if any(parameter in name for parameter in cfg.supported_parameters):
cfg.add(name, self.parameters.pop(name))
def validate_parameters(self):
def get_target_info(self):
return TargetInfo(self.target)
def validate_runtime_parameters(self, params):
for cfg in self.runtime_configs:
cfg.validate()
def merge_runtime_parameters(self, params):
pass
def set_parameters(self):
for cfg in self.runtime_configs:
cfg.set()
@@ -120,47 +103,23 @@ class TargetManager(object):
for cfg in self.runtime_configs:
cfg.clear()
def _parse_name(self):
# Try and get platform and target
self.name = identifier(self.name.replace('-', '_'))
if '_' in self.name:
self.platform_name, self.target_name = self.name.split('_', 1)
elif self.name in self.DEVICE_MAPPING:
self.platform_name = self.DEVICE_MAPPING[self.name]['platform_name']
self.target_name = self.DEVICE_MAPPING[self.name]['target_name']
else:
raise ConfigError('Unknown Device Specified {}'.format(self.name))
def _init_target(self):
target_map = {td.name: td for td in get_target_descriptions()}
if self.target_name not in target_map:
raise ValueError('Unknown Target: {}'.format(self.target_name))
tdesc = target_map[self.target_name]
self.target = instantiate_target(tdesc, self.parameters)
self.target.setup()
def _get_target(self):
# Create a corresponding target and target-assistant
if self.target_name == 'android':
self.target = AndroidTarget()
elif self.target_name == 'linux':
self.target = LinuxTarget() # pylint: disable=redefined-variable-type
elif self.target_name == 'localLinux':
self.target = LocalLinuxTarget()
else:
raise ConfigError('Unknown Target Specified {}'.format(self.target_name))
def _get_assistant(self):
# Create a corresponding target and target-assistant to help with platformy stuff?
if self.target_name == 'android':
def _init_assistant(self):
# Create a corresponding target and target-assistant to help with
# platformy stuff?
if self.target.os == 'android':
self.assistant = AndroidAssistant(self.target)
elif self.target_name in ['linux', 'localLinux']:
elif self.target.os == 'linux':
self.assistant = LinuxAssistant(self.target) # pylint: disable=redefined-variable-type
else:
raise ConfigError('Unknown Target Specified {}'.format(self.target_name))
# def validate_runtime_parameters(self, parameters):
# for name, value in parameters.iteritems():
# self.add_parameter(name, value)
# self.validate_parameters()
# def set_runtime_parameters(self, parameters):
# # self.clear()
# for name, value in parameters.iteritems():
# self.add_parameter(name, value)
# self.set_parameters()
raise ValueError('Unknown Target OS: {}'.format(self.target.os))
class LinuxAssistant(object):

37
wa/framework/target/runtime_config.py
View File

@@ -15,8 +15,6 @@ class RuntimeConfig(Plugin):
parameters = [
]
# class RuntimeConfig(object):
@property
def supported_parameters(self):
raise NotImplementedError()
@@ -25,8 +23,8 @@ class RuntimeConfig(Plugin):
def core_names(self):
return unique(self.target.core_names)
def __init__(self, target):
super(RuntimeConfig, self).__init__()
def __init__(self, target, **kwargs):
super(RuntimeConfig, self).__init__(**kwargs)
self.target = target
def initialize(self, context):
@@ -47,6 +45,9 @@ class RuntimeConfig(Plugin):
class HotplugRuntimeConfig(RuntimeConfig):
##### NOTE: Currently if initialized with cores hotplugged, this will fail when trying to hotplug back in
name = 'rt-hotplug'
@property
def supported_parameters(self):
params = ['cores']
@@ -93,6 +94,8 @@ class HotplugRuntimeConfig(RuntimeConfig):
class SysfileValuesRuntimeConfig(RuntimeConfig):
name = 'rt-sysfiles'
@property
def supported_parameters(self):
return ['sysfile_values']
@@ -132,6 +135,8 @@ class SysfileValuesRuntimeConfig(RuntimeConfig):
class CpufreqRuntimeConfig(RuntimeConfig):
name = 'rt-cpufreq'
@property
def supported_parameters(self):
params = ['frequency']
@@ -151,9 +156,14 @@ class CpufreqRuntimeConfig(RuntimeConfig):
self.min_supported_freq = {}
self.max_supported_freq = {}
for cpu in self.target.list_online_cpus():
self.supported_freqs[cpu] = self.target.cpufreq.list_frequencies(cpu) or []
self.supported_govenors[cpu] = self.target.cpufreq.list_governors(cpu) or []
if self.target.has('cpufreq'):
for cpu in self.target.list_online_cpus():
freqs = self.target.cpufreq.list_frequencies(cpu) or []
self.supported_freqs[cpu] = freqs
govs = self.target.cpufreq.list_governors(cpu) or []
self.supported_govenors[cpu] = govs
else:
self.logger.debug('Target does not support cpufreq')
def add(self, name, value):
if not self.target.has('cpufreq'):
@@ -319,6 +329,8 @@ class CpufreqRuntimeConfig(RuntimeConfig):
class CpuidleRuntimeConfig(RuntimeConfig):
name = 'rt-cpuidle'
@property
def supported_parameters(self):
params = ['idle_states']
@@ -330,12 +342,15 @@ class CpuidleRuntimeConfig(RuntimeConfig):
self.aliases = ['ENABLE_ALL', 'DISABLE_ALL']
self.available_states = {}
for cpu in self.target.list_online_cpus():
self.available_states[cpu] = self.target.cpuidle.get_states(cpu) or []
if self.target.has('cpuidle'):
for cpu in self.target.list_online_cpus():
self.available_states[cpu] = self.target.cpuidle.get_states(cpu) or []
else:
self.logger.debug('Target does not support cpuidle.')
def add(self, name, values):
if not self.target.has('cpufreq'):
raise TargetError('Target does not support cpufreq.')
if not self.target.has('cpuidle'):
raise TargetError('Target does not support cpuidle.')
prefix, _ = split_parameter_name(name, self.supported_parameters)
cpus = uniqueDomainCpusFromPrefix(prefix, self.target)