├── assets
│   └── mp3-short.json
├── init_env source的环境脚本
├── ipynb  用来分析的ipython脚本
│   ├── chromeos
│   ├── energy
│   ├── examples
│   ├── profiling
│   ├── releases
│   ├── sched_dvfs
│   ├── sched_tune
│   ├── scratchpad
│   ├── thermal
│   └── tutorial
├── libs  各类基础功能和第三方应用
│   ├── bart
│   ├── devlib
│   ├── __init__.py
│   ├── trappy
│   ├── utils
│   └── wlgen
├── LICENSE.txt
├── LisaShell.txt
├── logging.conf
├── README.md
├── results  执行结果
│   └── LisaInANutshell_Backup
├── src  shell配置文件
│   └── shell
├── target.config  待测设备配置文件
├── tests  测试用例编写脚本，host用到的x86和target用到的arm
│   ├── eas
│   ├── sfreq
│   └── stune
├── tools  测试用到的工作
│   ├── arm64
│   ├── armeabi
│   ├── LICENSE.perf
│   ├── LICENSE.rt-app
│   ├── LICENSE.sysbench
│   ├── LICENSE.taskset
│   ├── LICENSE.trace-cmd
│   ├── plots.py
│   ├── report.py
│   ├── scripts
│   └── x86_64
└── Vagrantfile

@classmethod
def _runExperiments(cls):
    """
    Default experiments execution engine
    """

cls.logger.info('Setup tests execution engine...')
    test_env = TestEnv(test_conf=cls._getTestConf())  基于test_conf文件生成TestEnv

experiments_conf = cls._getExperimentsConf(test_env)
    cls.executor = Executor(test_env, experiments_conf)  基于experiments_conf生成Executor

# Alias executor objects to make less verbose tests code
    cls.te = cls.executor.te
    cls.target = cls.executor.target

# Execute pre-experiments code defined by the test
    cls._experimentsInit()  测试前初始化

cls.logger.info('Experiments execution...')
    cls.executor.run()  测试执行实体

# Execute post-experiments code defined by the test
    cls._experimentsFinalize()  测试后收尾工作

def __init__(self, target_conf=None, test_conf=None, wipe=True,
             force_new=False):
…

super(TestEnv, self).__init__()

…

# Keep track of android support
    self.LISA_HOME = os.environ.get('LISA_HOME', '/vagrant')
    self.ANDROID_HOME = os.environ.get('ANDROID_HOME', None)
    self.CATAPULT_HOME = os.environ.get('CATAPULT_HOME',
            os.path.join(self.LISA_HOME, 'tools', 'catapult'))

# Setup logging
    self._log = logging.getLogger('TestEnv')

# Compute base installation path
    self._log.info('Using base path: %s', basepath)

# Setup target configuration
    if isinstance(target_conf, dict):
        self._log.info('Loading custom (inline) target configuration')
        self.conf = target_conf
    elif isinstance(target_conf, str):
        self._log.info('Loading custom (file) target configuration')
        self.conf = self.loadTargetConfig(target_conf)
    elif target_conf is None:
        self._log.info('Loading default (file) target configuration')
        self.conf = self.loadTargetConfig()
    self._log.debug('Target configuration %s', self.conf)

# Setup test configuration
    if test_conf:
        if isinstance(test_conf, dict):
            self._log.info('Loading custom (inline) test configuration')
            self.test_conf = test_conf
        elif isinstance(test_conf, str):
            self._log.info('Loading custom (file) test configuration')
            self.test_conf = self.loadTargetConfig(test_conf)
        else:
            raise ValueError('test_conf must be either a dictionary or a filepath')
        self._log.debug('Test configuration %s', self.conf)

# Setup target working directory
    if 'workdir' in self.conf:
        self.workdir = self.conf['workdir']

# Initialize binary tools to deploy
    if 'tools' in self.conf:
        self.__tools = self.conf['tools']
    # Merge tests specific tools
    if self.test_conf and 'tools' in self.test_conf and \
       self.test_conf['tools']:
        if 'tools' not in self.conf:
            self.conf['tools'] = []
        self.__tools = list(set(
            self.conf['tools'] + self.test_conf['tools']
        ))

# Initialize ftrace events
    # test configuration override target one
    if self.test_conf and 'ftrace' in self.test_conf:
        self.conf['ftrace'] = self.test_conf['ftrace']
    if 'ftrace' in self.conf and self.conf['ftrace']:
        self.__tools.append('trace-cmd')

# Initialize features
    if '__features__' not in self.conf:
        self.conf['__features__'] = []

self._init()

# Initialize FTrace events collection
    self._init_ftrace(True)

# Initialize RT-App calibration values
    self.calibration()

# Initialize local results folder
    # test configuration override target one
…

res_lnk = os.path.join(basepath, LATEST_LINK)
    if os.path.islink(res_lnk):
        os.remove(res_lnk)
    os.symlink(self.res_dir, res_lnk)

# Initialize energy probe instrument
    self._init_energy(True)

def __init__(self, test_env, experiments_conf):
    """
    Tests Executor

A tests executor is a module which support the execution of a
    configured set of experiments. Each experiment is composed by:
    - a target configuration
    - a worload to execute

The executor module can be configured to run a set of workloads (wloads)
    in each different target configuration of a specified set (confs). These
    wloads and confs can be specified by the "experiments_conf" input
    dictionary. Each (workload, conf, iteration) tuple is called an
    "experiment".

All the results generated by each experiment will be collected a result
    folder which is named according to this template:
        results/<test_id>/<wltype>:<conf>:<wload>/<run_id>
    where:
    - <test_id> : the "tid" defined by the experiments_conf, or a timestamp
                  based folder in case "tid" is not specified
    - <wltype>  : the class of workload executed, e.g. rtapp or sched_perf
    - <conf>    : the identifier of one of the specified configurations
    - <wload>   : the identified of one of the specified workload
    - <run_id>  : the progressive execution number from 1 up to the
                  specified iterations

After the workloads have been run, the Executor object's `experiments`
    attribute is a list of Experiment objects. The `out_dir` attribute of
    these objects can be used to find the results of the experiment.
    """

# Initialize globals
    self._default_cgroup = None
    self._cgroup = None

# Setup logging
    self._log = logging.getLogger('Executor')

# Setup test configuration  解析experiments_conf，这些参数都会传递给wlgen执行。
…

self._print_section('Experiments configuration')  打印此实验配置

…

def run(self):
    self._print_section('Experiments execution')

self.experiments = []

# Run all the configured experiments
    exp_idx = 0
    for tc in self._experiments_conf['confs']:
        # TARGET: configuration
        if not self._target_configure(tc): 配置待测设备
            continue
        for wl_idx in self._experiments_conf['wloads']:
            # TEST: configuration
            wload, test_dir = self._wload_init(tc, wl_idx)  workload初始化
            for itr_idx in range(1, self._iterations + 1):
                exp = Experiment(
                    wload_name=wl_idx,
                    wload=wload,
                    conf=tc,
                    iteration=itr_idx,
                    out_dir=os.path.join(test_dir, str(itr_idx)))
                self.experiments.append(exp)

# WORKLOAD: execution
                self._wload_run(exp_idx, exp)  worload执行
                exp_idx += 1
        self._target_cleanup(tc)

self._print_section('Experiments execution completed')
    self._log.info('Results available in:')
    self._log.info('      %s', self.te.res_dir)

def _wload_run(self, exp_idx, experiment):
    tc = experiment.conf
    wload = experiment.wload
    tc_idx = tc['tag']

self._print_title('Experiment {}/{}, [{}:{}] {}/{}'\
            .format(exp_idx, self._exp_count,
                    tc_idx, experiment.wload_name,
                    experiment.iteration, self._iterations))

# Setup local results folder
    self._log.debug('out_dir set to [%s]', experiment.out_dir)
    os.system('mkdir -p ' + experiment.out_dir)

# Freeze all userspace tasks that we don't need for running tests
    need_thaw = False
    if self._target_conf_flag(tc, 'freeze_userspace'):
        need_thaw = self._freeze_userspace()

# FTRACE: start (if a configuration has been provided)
    if self.te.ftrace and self._target_conf_flag(tc, 'ftrace'):
        self._log.warning('FTrace events collection enabled')  准备抓取ftrace
        self.te.ftrace.start()

# ENERGY: start sampling  抓取Power Meter数据
    if self.te.emeter:
        self.te.emeter.reset()

# WORKLOAD: Run the configured workload
    wload.run(out_dir=experiment.out_dir, cgroup=self._cgroup)  执行workload

下面是收集Power Meter和ftrace数据。

# ENERGY: collect measurements
    if self.te.emeter:
        self.te.emeter.report(experiment.out_dir)

# FTRACE: stop and collect measurements
    if self.te.ftrace and self._target_conf_flag(tc, 'ftrace'):
        self.te.ftrace.stop()

trace_file = experiment.out_dir + '/trace.dat'
        self.te.ftrace.get_trace(trace_file)
        self._log.info('Collected FTrace binary trace:')
        self._log.info('   %s',
                       trace_file.replace(self.te.res_dir, '<res_dir>'))

stats_file = experiment.out_dir + '/trace_stat.json'
        self.te.ftrace.get_stats(stats_file)
        self._log.info('Collected FTrace function profiling:')
        self._log.info('   %s',
                       stats_file.replace(self.te.res_dir, '<res_dir>'))

# Unfreeze the tasks we froze
    if need_thaw:
        self._thaw_userspace()

self._print_footer()

critical_tasks = {
    'linux': ['init', 'systemd', 'sh', 'ssh'],
    'android': [
        'sh', 'adbd', 'init',
        'usb', 'transport',
        # We don't actually need this task but on Google Pixel it apparently
        # cannot be frozen, so the cgroup state gets stuck in FREEZING if we
        # try to freeze it.
        'thermal-engine'
    ]
}

def _wload_conf(self, wl_idx, wlspec):

# CPUS: setup execution on CPUs if required by configuration
    cpus = self._wload_cpus(wl_idx, wlspec)

# CGroup: setup CGroups if requried by configuration
    self._cgroup = self._default_cgroup
    if 'cgroup' in wlspec:
        if 'cgroups' not in self.target.modules:
            raise RuntimeError('Target not supporting CGroups or CGroups '
                               'not configured for the current test configuration')
        self._cgroup = wlspec['cgroup']

if wlspec['type'] == 'rt-app':
        return self._wload_rtapp(wl_idx, wlspec, cpus)  rtapp类型的workload
    if wlspec['type'] == 'perf_bench':
        return self._wload_perf_bench(wl_idx, wlspec, cpus)  perf_bench类型的workload

raise ValueError('unsupported "type" value for [{}] '
                     'workload specification'
                     .format(wl_idx))

{
    /* Platform */
    /* - linux   : accessed via SSH connection                    */
    /* - android : accessed via ADB connection                    */
    /* - host    : run on the local host                          */
    "platform" : "android", 不同类型的Target，对应不同类型的Connection

/* Board */
    /* Currently supported boards are:                            */
    /*  juno  : target is a JUNO board                            */
    /*  tc2   : target is a TC2 board                             */
    /* Leave commented if your board is not listed above          */
    "board" : "hikey",  主板类型对应libs/utils/platforms/hikey.json文件。

/* Target Android device ID */
    "device" : "0123456789abcdef",  adb设备的ID

/* Login username (has to be sudo enabled) */
    "username" : "root",

…

/* Devlib modules to enable/disbale for all the experiments */
    "modules"         : [],
    "exclude_modules" : [],

…

/* List of test environment features to enable */
    /*  no-kernel : do not deploy kernel/dtb images               */
    /*  no-reboot : do not force reboot the target at each        */
    /*              configuration change                          */
    /*  debug     : enable debugging messages                     */
    "__features__" : "no-kernel no-reboot"
}

def run(self,
        ftrace=None,
        cgroup=None,
        cpus=None,
        background=False,
        out_dir='./',
        as_root=False,
        start_pause_s=None,
        end_pause_s=None):

self.cgroup = cgroup

# Compose the actual execution command starting from the base command
    # defined by the base class
    _command = self.command

if not _command:
        self._log.error('Error: empty executor command')

# Prepend eventually required taskset command
    if cpus or self.cpus:  如果需要设置CPU亲和性，使用taskset进行设置。
        cpus_mask = self.getCpusMask(cpus if cpus else self.cpus)
        self.taskset_cmd = '{}/taskset 0x{:X}'\
                .format(self.target.executables_directory,
                        cpus_mask)
        _command = '{} {}'\
                .format(self.taskset_cmd, _command)

if self.cgroup and hasattr(self.target, 'cgroups'):
        # Get a reference to the CGroup to use
        _command = self.target.cgroups.run_into_cmd(self.cgroup, _command)

# Start FTrace (if required)
    if ftrace:  设置ftrace相关sysfs节点，启动ftrace抓取
        ftrace.start()

# Wait `start_pause` seconds before running the workload
    if start_pause_s:
        self._log.info('Waiting %f seconds before starting workload execution',
                       start_pause_s)
        sleep(start_pause_s)

# Start task in background if required
    if background:  是否作为背景进程运行
        self._log.debug('WlGen [background]: %s', _command)
        self.target.background(_command, as_root=as_root)
        self.output['executor'] = ''

# Start task in foreground
    else:
        self._log.info('Workload execution START:')
        self._log.info('   %s', _command)
        # Run command and wait for it to complete
        results = self.target.execute(_command, as_root=as_root)  在class TestEnv的_init_target创建了class Target的子类class AndroidTarget。此处execute都是通过adb shell执行。
        self.output['executor'] = results

# Wait `end_pause` seconds before stopping ftrace
    if end_pause_s:
        self._log.info('Waiting %f seconds before stopping trace collection',
                       end_pause_s)
        sleep(end_pause_s)

# Stop FTrace (if required)
    ftrace_dat = None
    if ftrace:  停止ftrace抓取，并导出ftrace内容。
        ftrace.stop()
        ftrace_dat = out_dir + '/' + self.test_label + '.dat'
        dirname = os.path.dirname(ftrace_dat)
        if not os.path.exists(dirname):
            self._log.debug('Create ftrace results folder [%s]',
                            dirname)
            os.makedirs(dirname)
        self._log.info('Pulling trace file into [%s]...', ftrace_dat)
        ftrace.get_trace(ftrace_dat)

if not background:
        self.__callback('postrun', destdir=out_dir)
        self._log.debug('Workload execution COMPLETED')

return ftrace_dat