TM: Update and Refactor

TM has been updated and restructured to be clearer, including splitting off
assistant and creating a runtime parameter manager into their own files.

wa/framework/target/manager.py

@@ -1,39 +1,19 @@
 import logging
-import tempfile
-import threading
-import os
-import time
-import shutil
-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,
                                             instantiate_assistant)
 from wa.framework.target.info import TargetInfo
-from wa.framework.target.runtime_config import (SysfileValuesRuntimeConfig,
-                                                HotplugRuntimeConfig,
-                                                CpufreqRuntimeConfig,
-                                                CpuidleRuntimeConfig)
-from wa.utils.misc import isiterable
-from wa.utils.serializer import json
+from wa.framework.target.runtime_parameter_manager import RuntimeParameterManager
 
-
-from devlib import LocalLinuxTarget, LinuxTarget, AndroidTarget
-from devlib.utils.types import identifier
 from devlib.utils.misc import memoized
 
 
 class TargetManager(object):
-
-    name = 'target-manager'
-
-    description = """
-    Instanciated the required target and performs configuration and validation
-    of the device.
-
+    """
+    Instantiate the required target and perform configuration and validation of the device.
     """
 
     parameters = [
@@ -44,14 +24,6 @@ class TargetManager(object):
                   """),
     ]
 
-    runtime_config_cls = [
-        # order matters
-        SysfileValuesRuntimeConfig,
-        HotplugRuntimeConfig,
-        CpufreqRuntimeConfig,
-        CpuidleRuntimeConfig,
-    ]
-
     def __init__(self, name, parameters):
         self.logger = logging.getLogger('tm')
         self.target_name = name
@@ -60,29 +32,26 @@ class TargetManager(object):
         self.platform_name = None
         self.parameters = parameters
         self.disconnect = parameters.get('disconnect')
-        self.info = TargetInfo()
 
         self._init_target()
-        self.runtime_configs = [cls(self.target) for cls in self.runtime_config_cls]
+
+        # If target supports hotplugging, online all cpus before perform discovery
+        # and restore orignal configuration after completed.
+        if self.target.has('hotplug'):
+            online_cpus = self.target.list_online_cpus()
+            self.target.hotplug.online_all()
+            self.rpm = RuntimeParameterManager(self.target)
+            all_cpus = set(range(self.target.number_of_cpus))
+            self.target.hotplug.offline(*all_cpus.difference(online_cpus))
+        else:
+            self.rpm = RuntimeParameterManager(self.target)
 
     def finalize(self):
-        # self.logger.info('Disconnecting from the device')
+        self.logger.info('Disconnecting from the device')
         if self.disconnect:
             with signal.wrap('TARGET_DISCONNECT'):
                 self.target.disconnect()
 
-    def add_parameters(self, parameters=None):
-        if parameters:
-            self.parameters = parameters
-        if not self.parameters:
-            raise ConfigError('No Configuration Provided')
-
-        for name in self.parameters.keys():
-            for cfg in self.runtime_configs:
-                # if name in cfg.supported_parameters:
-                if any(parameter in name for parameter in cfg.supported_parameters):
-                    cfg.add(name, self.parameters.pop(name))
-
     def start(self):
         self.assistant.start()
 
@@ -96,27 +65,21 @@ class TargetManager(object):
     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, parameters):
+        return self.rpm.merge_runtime_parameters(parameters)
 
-    def merge_runtime_parameters(self, params):
-        pass
+    def validate_runtime_parameters(self, parameters):
+        self.rpm.validate_runtime_parameters(parameters)
 
-    def set_parameters(self):
-        for cfg in self.runtime_configs:
-            cfg.set()
-
-    def clear_parameters(self):
-        for cfg in self.runtime_configs:
-            cfg.clear()
+    def commit_runtime_parameters(self, parameters):
+        self.rpm.commit_runtime_parameters(parameters)
 
     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.logger.debug('Creating {} target'.format(self.target_name))
         self.target = instantiate_target(tdesc, self.parameters, connect=False)
 
         with signal.wrap('TARGET_CONNECT'):