# Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.


import logging
import os
from autotest_lib.client.bin import test, utils
from autotest_lib.client.common_lib import error


class kernel_Lmbench(test.test):
    """Run some benchmarks from the lmbench3 suite.

    lmbench is a series of micro benchmarks intended to measure basic operating
    system and hardware system metrics.

    For further details about lmbench refer to:
    http://lmbench.sourceforge.net/man/lmbench.8.html

    This test is copied from from client/tests to avoid depending on make and
    perl. Here we can also tune the individual benchmarks to be more
    deterministic using taskset, nice, etc.

    Example benchmark runs and outputs on a Lumpy device:
    ./lat_pagefault -N 100 -W 10000 /usr/local/zeros 2>&1
    Pagefaults on /usr/local/zeros: 1.5215 microseconds

    ./lat_syscall -N 100 -W 10000 null 2>&1
    Simple syscall: 0.1052 microseconds

    ./lat_syscall -N 100 -W 10000 read /usr/local/zeros 2>&1
    Simple read: 0.2422 microseconds

    ./lat_syscall -N 100 -W 10000 write /usr/local/zeros 2>&1
    Simple write: 0.2036 microseconds

    ./lat_proc -N 100 -W 10000 fork 2>&1
    Process fork+exit: 250.9048 microseconds

    ./lat_proc -N 100 -W 10000 exec 2>&1
    Process fork+execve: 270.8000 microseconds

    ./lat_mmap -N 100 -W 10000 128M /usr/local/zeros 2>&1
    134.217728 1644

    ./lat_mmap -P 2 -W 10000 128M /usr/local/zeros 2>&1
    134.217728 2932

    ./lat_pipe -N 100 -W 10000 2>&1
    Pipe latency: 14.3242 microseconds

    taskset 0x1 nice -20 ./lat_ctx -s 0 -W 10000  8 2>&1
    "size=0k ovr=1.09
    8 1.80
    """

    version = 1


    def setup(self, tarball='lmbench3.tar.bz2'):
        """
        Build lmbench. This only happens when building the test.

        Uncompresses the original lmbench tarball, applies patches to fix
        some build issues, configures lmbench and then modifies the config
        files to use appropriate directory and file locations.

        @param tarball: Lmbench tarball.
        @see: http://www.bitmover.com/lm/lmbench/lmbench3.tar.gz
                (original tarball, shipped as is in autotest).
        """
        tarball = utils.unmap_url(self.bindir, tarball, self.tmpdir)
        utils.extract_tarball_to_dir(tarball, self.srcdir)
        pwd = os.getcwd()
        os.chdir(self.srcdir)
        patches = ['0001-Fix-build-issues-with-lmbench.patch',
                   '0002-Changing-shebangs-on-lmbench-scripts.patch',
                   '0003-makefile.patch',
                   '0004-clang-syntax.patch']
        for patch in patches:
            utils.system('patch -p1 < ../%s' % patch)
        # Set OS='' to avoid create a host-specific bin directory
        utils.make('OS=')
        os.chdir(pwd)


    def _run_benchmarks(self):
        """Run the benchmarks.

        For details and output format refer to individual benchmark man pages:
        http://lmbench.sourceforge.net/man/

        To improve determinism, we sometimes use taskset to pin to a CPU and
        nice.
        """

        benchmarks = [
            ('lat_pagefault',
             '%(lmpath)s/lat_pagefault -N %(N)d -W %(W)d %(fname)s 2>&1'),
            ('lat_syscall_null',
             '%(lmpath)s/lat_syscall -N %(N)d -W %(W)d null 2>&1'),
            ('lat_syscall_read',
             '%(lmpath)s/lat_syscall -N %(N)d -W %(W)d read %(fname)s 2>&1'),
            ('lat_syscall_write',
             '%(lmpath)s/lat_syscall -N %(N)d -W %(W)d write %(fname)s 2>&1'),
            ('lat_proc_fork',
             '%(lmpath)s/lat_proc -N %(N)d -W %(W)d fork 2>&1'),
            ('lat_proc_exec',
             '%(lmpath)s/lat_proc -N %(N)d -W %(W)d exec 2>&1'),
            ('lat_mmap',
             ('%(lmpath)s/lat_mmap -N %(N)d -W %(W)d '
              '%(fsize)dM %(fname)s 2>&1')),
            ('lat_mmap_P2',
             '%(lmpath)s/lat_mmap -P 2 -W %(W)d %(fsize)dM %(fname)s 2>&1'),
            ('lat_pipe',
             '%(lmpath)s/lat_pipe -N %(N)d -W %(W)d 2>&1'),
            ('lat_ctx_s0',
             ('taskset 0x1 nice -20 %(lmpath)s/'
              'lat_ctx -s 0 -W %(W)d  %(procs)d 2>&1'))
        ]

        keyvals = {}

        # Create a file with <fsize> MB of zeros in /usr/local
        cmd = 'dd if=/dev/zero of=%(fname)s bs=1M count=%(fsize)d'
        cmd = cmd % self.lmparams
        utils.system(cmd)

        for (bm, cmd) in benchmarks:
            cmd = cmd % self.lmparams
            logging.info('Running: %s, cmd: %s', bm, cmd)
            out = utils.system_output(cmd)
            logging.info('Output: %s', out)

            # See class doc string for output examples
            lst = out.split()
            idx = -2
            if '_mmap' in bm or '_ctx' in bm:
                idx = -1
            useconds = float(lst[idx])
            keyvals['us_' + bm] = useconds

        self.lmkeyvals.update(keyvals)


    def initialize(self):
        self.job.require_gcc()
        self.lmkeyvals = {}

        # Where the lmbench binaries are
        self.lmpath = os.path.join(self.srcdir, 'bin')

        # Common parameters for the benchmarks. More details here:
        # http://lmbench.sourceforge.net/man/lmbench.8.html
        # N - number of repetitions
        # P - parallelism
        # W - warmup time in microseconds
        # fname - file to operate on
        # fsize - size of the above file in MB
        # procs - number of processes for context switch benchmark - lat_ctx
        self.lmparams = {
            'N':100,
            'P':2,
            'fname':'/usr/local/zeros',
            'fsize':128,
            'W':10000,
            'procs':8,
            'lmpath': self.lmpath}

        # Write out the params as kevals now to keep them even if test fails
        param_kvals = [('param_%s' % p,v) for (p,v) in self.lmparams.items()]
        self.write_perf_keyval(dict(param_kvals))

    def run_once(self):
        self._run_benchmarks()
        self.write_perf_keyval(self.lmkeyvals)