workload-automation/wlauto/instrumentation/pmu_logger/__init__.py

#    Copyright 2013-2015 ARM Limited
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#


# pylint: disable=W0613,E1101,W0201
import os
import re
import csv

from wlauto import Instrument, settings, Parameter
from wlauto.instrumentation import instrument_is_installed
from wlauto.exceptions import ConfigError
from wlauto.utils.types import boolean


NUMBER_OF_CCI_PMU_COUNTERS = 4
DEFAULT_EVENTS = ['0x63', '0x6A', '0x83', '0x8A']
DEFAULT_PERIOD = 10  # in jiffies

CPL_BASE = '/sys/kernel/debug/cci_pmu_logger/'
CPL_CONTROL_FILE = CPL_BASE + 'control'
CPL_PERIOD_FILE = CPL_BASE + 'period_jiffies'

DRIVER = 'pmu_logger.ko'

REGEX = re.compile(r'(\d+(?:\.\d+)?):\s+bprint:.*Cycles:\s*(\S+)\s*Counter_0:\s*(\S+)\s*Counter_1:\s*(\S+)\s*Counter_2:\s*(\S+)\s*Counter_3:\s*(\S+)')


class CciPmuLogger(Instrument):

    name = "cci_pmu_logger"
    description = """
    This instrument allows collecting CCI counter data.

    It relies on the pmu_logger.ko kernel driver, the source for which is
    included with Workload Automation (see inside ``wlauto/external`` directory).
    You will need to build this against your specific kernel. Once compiled, it needs
    to be placed in the dependencies directory (usually ``~/.workload_uatomation/dependencies``).

    .. note:: When compling pmu_logger.ko for a new hardware platform, you may need to
              modify CCI_BASE inside pmu_logger.c to contain the base address of where
              CCI is mapped in memory on your device.

    This instrument relies on ``trace-cmd`` instrument to also be enabled. You should enable
    at least ``'bprint'`` trace event.

    """

    parameters = [
        Parameter('events', kind=list, default=DEFAULT_EVENTS,
                  global_alias='cci_pmu_events',
                  description="""
                  A list of strings, each representing an event to be counted. The length
                  of the list cannot exceed the number of PMU counters available (4 in CCI-400).
                  If this is not specified, shareable read transactions and snoop hits on both
                  clusters will be counted by default.  E.g. ``['0x63', '0x83']``.
                  """),
        Parameter('event_labels', kind=list, default=[],
                  global_alias='cci_pmu_event_labels',
                  description="""
                  A list of labels to be used when reporting PMU counts. If specified,
                  this must be of the same length as ``cci_pmu_events``. If not specified,
                  events will be labeled "event_<event_number>".
                  """),
        Parameter('period', kind=int, default=10,
                  global_alias='cci_pmu_period',
                  description='The period (in jiffies) between counter reads.'),
        Parameter('install_module', kind=boolean, default=True,
                  global_alias='cci_pmu_install_module',
                  description="""
                  Specifies whether pmu_logger has been compiled as a .ko module that needs
                  to be installed by the instrument. (.ko binary must be in {}). If this is set
                  to ``False``, it will be assumed that pmu_logger has been compiled into the kernel,
                  or that it has been installed prior to the invocation of WA.
                  """.format(settings.dependencies_directory)),
    ]

    def on_run_init(self, context):
        if self.install_module:
            self.device_driver_file = self.device.path.join(self.device.working_directory, DRIVER)
            host_driver_file = os.path.join(settings.dependencies_directory, DRIVER)
            self.device.push_file(host_driver_file, self.device_driver_file)

    def setup(self, context):
        if self.install_module:
            self.device.execute('insmod {}'.format(self.device_driver_file), check_exit_code=False)
        self.device.set_sysfile_value(CPL_PERIOD_FILE, self.period)
        for i, event in enumerate(self.events):
            counter = CPL_BASE + 'counter{}'.format(i)
            self.device.set_sysfile_value(counter, event, verify=False)

    def start(self, context):
        self.device.set_sysfile_value(CPL_CONTROL_FILE, 1, verify=False)

    def stop(self, context):
        self.device.set_sysfile_value(CPL_CONTROL_FILE, 1, verify=False)

    # Doing result processing inside teardown because need to make sure that
    # trace-cmd has processed its results and generated the trace.txt
    def teardown(self, context):
        trace_file = os.path.join(context.output_directory, 'trace.txt')
        rows = [['timestamp', 'cycles'] + self.event_labels]
        with open(trace_file) as fh:
            for line in fh:
                match = REGEX.search(line)
                if match:
                    rows.append([
                        float(match.group(1)),
                        int(match.group(2), 16),
                        int(match.group(3), 16),
                        int(match.group(4), 16),
                        int(match.group(5), 16),
                        int(match.group(6), 16),
                    ])
        output_file = os.path.join(context.output_directory, 'cci_counters.txt')
        with open(output_file, 'wb') as wfh:
            writer = csv.writer(wfh)
            writer.writerows(rows)
        context.add_iteration_artifact('cci_counters', path='cci_counters.txt', kind='data',
                                       description='CCI PMU counter data.')

        # summary metrics
        sums = map(sum, zip(*(r[1:] for r in rows[1:])))
        labels = ['cycles'] + self.event_labels
        for label, value in zip(labels, sums):
            context.result.add_metric('cci ' + label, value, lower_is_better=True)

        # actual teardown
        if self.install_module:
            self.device.execute('rmmod pmu_logger', check_exit_code=False)

    def validate(self):
        if not instrument_is_installed('trace-cmd'):
            raise ConfigError('To use cci_pmu_logger, trace-cmd instrument must also be enabled.')
        if not self.event_labels:  # pylint: disable=E0203
            self.event_labels = ['event_{}'.format(e) for e in self.events]
        elif len(self.events) != len(self.event_labels):
            raise ConfigError('cci_pmu_events and cci_pmu_event_labels must be of the same length.')
        if len(self.events) > NUMBER_OF_CCI_PMU_COUNTERS:
            raise ConfigError('The number cci_pmu_counters must be at most {}'.format(NUMBER_OF_CCI_PMU_COUNTERS))