In [1]:

    

from test import LisaTest

print LisaTest.__doc__


    

    




    A base class for LISA tests

    This class is intended to be subclassed in order to create automated tests
    for LISA. It sets up the TestEnv and Executor and provides convenience
    methods for making assertions on results.

    Subclasses should provide a test_conf to configure the TestEnv and an
    experiments_conf to configure the executor.

    Tests whose behaviour is dependent on target parameters, for example
    presence of cpufreq governors or number of CPUs, can override
    _getExperimentsConf to generate target-dependent experiments.

    Example users of this class can be found under LISA's tests/ directory.

    :ivar experiments: List of :class:`Experiment` s executed for the test. Only
                       available after :meth:`init` has been called.
    

In [2]:

    

from energy_model import EnergyModel
print EnergyModel.__doc__


    

    




Represents hierarchical CPU topology with power and capacity data

    An energy model consists of

    - A CPU topology, representing the physical (cache/interconnect) topology of
      the CPUs.  Each node stores the energy usage of that node's hardware when
      it is in each active or idle state. They also store a compute capacity at
      each frequency, but this is only meaningful for leaf nodes (CPUs) and may
      be None at higher levels. These capacity values are relative; the maximum
      capacity would usually be 1024, the value of SCHED_CAPACITY_SCALE in the
      Linux kernel scheduler.  Use EnergyModelNodes to describe this.

    - A power domain topology, representing the hierarchy of areas that can be
      powered down (idled).
      The power domains are a single tree. Leaf nodes must contain exactly one
      CPU and the root node must indirectly contain every CPU. Each power domain
      has a list (maybe empty) of names of idle states that that domain can
      enter.
      Use PowerDomains to describe this.

    - A set of frequency domains, representing groups of CPUs whose clock
      frequencies must be equal (probably because they share a clock). The
      frequency domains must be a partition of the CPUs.

    :ivar cpu_nodes: List of leaf (CPU) :class:`EnergyModelNode`
    :ivar cpus: List of logical CPU numbers in the system

    :param root_node: Root of :class:`EnergyModelNode` tree
    :param root_power_domain: Root of :class:`PowerDomain` tree
    :param freq_domains: Collection of collections of logical CPU numbers
                         representing frequency (clock) domains.

    .. note::
      The most signficant shortcomings of the model are:

        1. Voltage domains are assumed to be congruent to frequency domains

        2. Idle state power is assumed to be independent of voltage

        3. Temperature is ignored entirely

    .. _cpu-utils:

    .. admonition:: ``cpu_utils``: CPU util distributions

        Used throughout this module: A ``cpu_utils`` is a list ``u`` where
        ``u[N]`` is the sum of the frequency-invariant, capacity-invariant
        utilization of tasks placed on CPU N. That is, the quantity represented
        by a CPU runqueue's util_avg in the Linux kernel scheduler's
        load-tracking system with EAS features enabled.

        The range of utilization values is 0 -
        :attr:`EnergyModel.capacity_scale`.

        This represents a static utilization, assuming that tasks don't change
        in size (for example representing a set of fixed periodic RT-App
        workloads). For workloads that change over time, a series of
        ``cpu_utils`` items would be needed to describe the utilization, with a
        distinct estimation for each item in the series.
    

In [28]:

    

# juno_energy provides an instance of EnergyModel for ARM Juno platforms
from platforms.juno_energy import juno_energy
import pandas as pd
import matplotlib.pyplot as plt
%matplotlib inline

possible_placements = juno_energy.get_optimal_placements({'task1': 10, 'task2': 15})
fig, axs = plt.subplots(1, 4, sharey=True)
# fig.set_ylabel('Utilization')
for ax, placement in zip(axs, possible_placements):
    ax.set_ylabel('Utilization')
    ax.set_xlabel('CPU')

    pd.DataFrame(list(placement)).plot(kind='bar', figsize=(16, 2), ax=ax, legend=False)


    

In [4]:

    

from android import Workload

print Workload.__doc__


    

    




    Base class for Android related workloads
    

In [5]:

    

{ k:v for k,v in vars(Workload).items() if not k.startswith('_') }


    

    
Out[5]:





{'getInstance': <classmethod at 0x7f9b5e1c5398>,
 'run': <function android.workload.run>,
 'tracingStart': <function android.workload.tracingStart>,
 'tracingStop': <function android.workload.tracingStop>}

In [6]:

    

!tree $LISA_HOME/libs/utils/android/workloads


    

    




/home/brendan/sources/lisa/libs/utils/android/workloads
├── geekbench.py
├── geekbench.pyc
├── gmaps.py
├── gmaps.pyc
├── jankbench.py
├── jankbench.pyc
├── uibench.py
├── uibench.pyc
├── vellamo.py
├── vellamo.pyc
├── youtube.py
└── youtube.pyc

0 directories, 12 files

In [7]:

    

from android import LisaBenchmark

print LisaBenchmark.__doc__


    

    




    A base class for LISA custom benchmarks execution

    This class is intended to be subclassed in order to create a custom
    benckmark execution for LISA.
    It sets up the TestEnv and and provides convenience methods for
    test environment setup, execution and post-processing.

    Subclasses should provide a bm_conf to setup the TestEnv and
    a set of optional callback methods to configuere a test environment
    and process collected data.

    Example users of this class can be found under LISA's tests/benchmarks
    directory.
    

In [8]:

    

{ k:v for k,v in vars(LisaBenchmark).items() if not k.startswith('_') }


    

    
Out[8]:





{'benchmarkFinalize': <function android.benchmark.benchmarkFinalize>,
 'benchmarkInit': <function android.benchmark.benchmarkInit>,
 'bm_collect': None,
 'bm_conf': None,
 'bm_name': None,
 'bm_params': None,
 'reboot_target': <function android.benchmark.reboot_target>}