#!/usr/bin/python
#
# Copyright (c) 2011 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 optparse
import os, re
from autotest_lib.client.bin import utils, test
from autotest_lib.client.common_lib import error

re_float = r"[+-]? *(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?"

class kernel_fs_Punybench(test.test):
    """Run a selected subset of the puny benchmarks
    """
    version = 1
    Bin = '/usr/local/opt/punybench/bin/'


    def initialize(self):
        self.results = []
        self.job.drop_caches_between_iterations = True


    def _run(self, cmd, args):
        """Run a puny benchmark

        Prepends the path to the puny benchmark bin.

        @param cmd: command to be run
        @param args: arguments for the command
        """
        result = utils.system_output(
            os.path.join(self.Bin, cmd) + ' ' + args)
        logging.debug(result)
        return result


    @staticmethod
    def _ecrypt_mount(dir, mnt):
        """Mount the eCrypt File System

        @param dir: directory where encrypted file system is stored
        @param mnt: mount point for encrypted file system
        """
        options = ('-o'
                   ' key=passphrase:passphrase_passwd=secret'
                   ',ecryptfs_cipher=aes'
                   ',ecryptfs_key_bytes=32'
                   ',no_sig_cache'
                   ',ecryptfs_passthrough=no'
                   ',ecryptfs_enable_filename_crypto=no')
        utils.system_output('mkdir -p %s %s' % (dir, mnt))
        utils.system_output('mount -t ecryptfs %s %s %s' %
                           (options, dir, mnt))


    @staticmethod
    def _ecrypt_unmount(dir, mnt):
        """Unmount the eCrypt File System and remove it and its mount point

        @param dir: directory where encrypted file system was stored
        @param mnt: mount point for encrypted file system
        """
        utils.system_output('umount ' + dir)
        utils.system_output('rm -R ' + dir)
        utils.system_output('rm -R ' + mnt)


    @staticmethod
    def _find_max(tag, text):
        """Find the max in a memcpy result.

        @param tag: name of sub-test to select from text.
        @param text: output from memcpy test.
        @return Best result from that sub-test.

        Example input text:
          memcpy (Meg = 2**20)
          0. 4746.96 MiB/sec
          1. 4748.99 MiB/sec
          2. 4748.14 MiB/sec
          3. 4748.59 MiB/sec
          simple (Meg = 2**20)
          0. 727.996 MiB/sec
          1. 728.031 MiB/sec
          2. 728.22 MiB/sec
          3. 728.049 MiB/sec
          32bit (Meg = 2**20)
          0. 2713.16 MiB/sec
          1. 2719.93 MiB/sec
          2. 2724.33 MiB/sec
          3. 2711.5 MiB/sec
        """
        r1 = re.search(tag + ".*\n(\d.*sec\n)+", text)
        r2 = re.findall(r"\d+\. (" + re_float + r") M.*\n", r1.group(0))
        return max(float(result) for result in r2)


    def _memcpy(self):
        """Measure memory to memory copy.

        The size has to be large enough that it doesn't fit
        in the cache. We then take the best of serveral runs
        so we have a guarenteed not to exceed number.

        Several different ways are used to move memory.
        """
        size = 64 * 1024 * 1024
        loops = 4
        iterations = 10
        args  = '-z %d -i %d -l %d' % (size, iterations, loops)
        result = self._run('memcpy', args)

        for tag in ['memcpy', '32bit', '64bit']:
            value = self._find_max(tag, result)
            self.write_perf_keyval({tag + '_MiB_s': value})


    @staticmethod
    def _get_mib_s(tag, text):
        """Extract the MiB/s for tag from text

        @param tag: name of sub-test to select from text
        @param text: extact MiB/s from this text

        Example input text:
          SDRAM:
          memcpy_trivial:  (2097152 bytes copy) =  727.6 MiB/s /  729.9 MiB/s
          memcpy        :  (2097152 bytes copy) = 4514.2 MiB/s / 4746.9 MiB/s
          memcpy_trivial:  (3145728 bytes copy) =  727.7 MiB/s /  729.5 MiB/s
          memcpy        :  (3145728 bytes copy) = 4489.5 MiB/s / 4701.5 MiB/s
        """
        r1 = re.search(tag + ".*\n.*\n.*", text)
        r2 = re.search(r"[^\s]+ MiB/s$", r1.group(0))
        r3 = re.search(re_float, r2.group(0))
        return r3.group(0)


    def _memcpy_test(self):
        """Test the various caches and alignments

        WARNING: test will have to be changed if cache sizes change.
        """
        result = self._run('memcpy_test', "")
        self.write_perf_keyval({'L1cache_MiB_s':
                               self._get_mib_s('L1 cache', result)})
        self.write_perf_keyval({'L2cache_MiB_s':
                               self._get_mib_s('L2 cache', result)})
        self.write_perf_keyval({'SDRAM_MiB_s':
                               self._get_mib_s('SDRAM', result)})


    def _threadtree(self, prefix, dir):
        """Create and manipulate directory trees.

        Threadtree creates a directory tree with files for each task.
        It then copies that tree then deletes it.

        @param prefix: prefix to use on name/value pair for identifying results
        @param dir: directory path to use for test

        Example results:
          opens   =       3641
          created =       2914
          dirs    =       1456
          files   =       1458
          deleted =       4372
          read    = 1046306816
          written = 2095407104
           51.7   2. timer avg= 57.9 stdv= 8.76
        """
        iterations = 4
        tasks = 2
        width = 3
        depth = 5
        args = ('-d %s -i %d -t %d -w %d -k %d' %
               (dir, iterations, tasks, width, depth))
        result = self._run('threadtree', args)
        r1 = re.search(r"timer avg= *([^\s]*).*$", result)
        timer_avg = float(r1.group(1))
        p = tasks * pow(width, depth + 1) / timer_avg
        self.write_perf_keyval({prefix + 'threadtree_ops': p})


    def _uread_args(self):
        """Set custom args for _uread tests
        """
        size = 8 * 1024 * 1024 * 1024
        loops = 4
        iterations = 1
        return ('-f %s -z %d -i %d -l %d -b12' %
               (file, size, iterations, loops))


    def _uread(self, prefix, file):
        """Read a large file.

        @param prefix: prefix to use on name/value pair for identifying results
        @param file: file path to use for test

        The size should be picked so the file will
        not fit in memory.

        Example results:
          size=8589934592 n=1 55.5 3. timer avg= 55.5 stdv=0.0693 147.6 MiB/s
          size=8589934592 n=1 55.6 4. timer avg= 55.5 stdv=0.0817 147.5 MiB/s
        """
        args = '-f %s' % file
        result = self._run('uread', args)
        r1 = re.search(r"[^\s]+ MiB/s.*$", result)
        r2 = re.search(re_float, r1.group(0))
        mib_s = r2.group(0)
        self.write_perf_keyval({prefix + 'uread_MiB_s': mib_s})


    def _ureadrand_args(self):
        """Set custom args for _ureadrand
        """
        size = 8 * 1024 * 1024 * 1024
        loops = 4
        iterations = 100000
        return ('-f %s -z %d -i %d -l %d -b12' %
               (file, size, iterations, loops))


    def _ureadrand(self, prefix, file):
        """Read randomly a large file

        @param prefix: prefix to use on name/value pair for identifying results
        @param file: file path to use for test

        Example results (modified to fit in 80 columes):
size=8589934592 n=10000 4.7 3. timer avg= 4 stdv= 4.6 9.1 MiB/s 2326 IOPs/sec
size=8589934592 n=10000 4.9 4. timer avg= 4.2 stdv= 4.5 8.8 MiB/s 2262 IOPs/sec
        """
        args = '-f %s' % file
        result = self._run('ureadrand', args)
        r1 = re.search(r"([^\s]+ IOPs/sec).*$", result)
        r2 = re.search(re_float, r1.group(0))
        iops = r2.group(0)
        self.write_perf_keyval({prefix + 'ureadrand_iops': iops})


    def _uwrite_args(self):
        """Custom args for _uwrite
        """
        size = 8 * 1024 * 1024 * 1024
        loops = 4
        iterations = 1
        return ('-f %s -z %d -i %d -l %d -b12' %
               (file, size, iterations, loops))


    def _uwrite(self, prefix, file):
        """Write a large file.

        @param prefix: prefix to use on name/value pair for identifying results
        @param file: file path to use for test

        The size should be picked so the file will not fit in memory.

        Example results:
          size=8589934592 n=1 55.5 3. timer avg= 55.5 stdv=0.0693 147.6 MiB/s
          size=8589934592 n=1 55.6 4. timer avg= 55.5 stdv=0.0817 147.5 MiB/s
        """
        args = '-f %s' % file
        result = self._run('uwrite', args)
        r1 = re.search(r"[^\s]+ MiB/s.*$", result)
        r2 = re.search(re_float, r1.group(0))
        mib_s = r2.group(0)
        self.write_perf_keyval({prefix + 'uwrite_MiB_s': mib_s})


    def _uwriterand(self, prefix, file, size):
        """Write randomly a file

        @param prefix: prefix to use on name/value pair for identifying results
        @param file: file path to use for test
        @param size: size of file - large files are much slower than small files

        Example results (modified to fit in 80 columes):
size=16777216 n=1000 13.4 1. timer avg= 13.4 stdv= 0 0.29 MiB/s 74.8 IOPs/sec
size=16777216 n=1000 13.3 2. timer avg= 13.3 stdv=0.032 0.3 MiB/s 75.0 IOPs/sec

        """
        loops = 4
        iterations = 1000
        args = ('-f %s -z %d -i %d -l %d -b12' %
                (file, size, iterations, loops))
        result = self._run('uwriterand', args)
        r1 = re.search(r"([^\s]+ IOPs/sec).*$", result)
        r2 = re.search(re_float, r1.group(0))
        iops = r2.group(0)
        self.write_perf_keyval({prefix + 'uwriterand_iops': iops})


    def _uwritesync(self, prefix, file):
        """Synchronously writes a file

        @param prefix: prefix to use on name/value pair for identifying results
        @param file: file path to use for test

        Example results (modified to fit in 80 columes):
size=409600 n=100 4.58 3. timer avg= 4.41 stdv=0.195 0.0887 MiB/s 22.7 IOPs/sec
size=409600 n=100 4.84 4. timer avg= 4.52 stdv= 0.27 0.0885 MiB/s 22.15 IOPs/sec
        """
        loops = 4  # minimum loops to average or see trends
        num_blocks_to_write = 100  # Because sync writes are slow,
                                   # don't do too many
        args = ('-f %s -i %d -l %d -b12' %
                (file, num_blocks_to_write, loops))
        result = self._run('uwritesync', args)
        r1 = re.search(r"([^\s]+ IOPs/sec).*$", result)
        r2 = re.search(re_float, r1.group(0))
        iops = r2.group(0)
        self.write_perf_keyval({prefix + 'uwritesync_iops': iops})


    def _disk_tests(self, prefix,  dir, file):
        """Run this collection of disk tests

        @param prefix: prefix to use on name/value pair for identifying results
        @param dir: directory path to use for tests
        @param file: file path to use for tests
        """
        self._uread(prefix, file)
        self._ureadrand(prefix, file)
        self._uwrite(prefix, file)
        self._uwriterand(prefix + '_large_', file, 8 * 1024 * 1024 * 1024)
        # This tests sometimes gives invalid results
        # self._uwriterand(prefix + '_small_', file, 8 * 1024)
        self._uwritesync(prefix, file)
        self._threadtree(prefix, dir)


    def _ecryptfs(self):
        """Setup up to run disk tests on encrypted volume
        """
        dir = '/usr/local/ecrypt_tst'
        mnt = '/usr/local/ecrypt_mnt'
        self._ecrypt_mount(dir, mnt)
        self._disk_tests('ecryptfs_', mnt + '/_Dir', mnt + '/xyzzy')
        self._ecrypt_unmount(dir, mnt)


    def _parse_args(self, args):
        """Parse input arguments to this autotest.

        Args:
        @param args: List of arguments to parse.
        @return
          opts: Options, as per optparse.
          args: Non-option arguments, as per optparse.
        """
        parser = optparse.OptionParser()
        parser.add_option('--disk', dest='want_disk_tests',
                          action='store_true', default=False,
                          help='Run disk tests.')
        parser.add_option('--ecryptfs', dest='want_ecryptfs_tests',
                          action='store_true', default=False,
                          help='Run ecryptfs tests.')
        parser.add_option('--mem', dest='want_mem_tests',
                          action='store_true', default=False,
                          help='Run memory tests.')
        parser.add_option('--nop', dest='want_nop_tests',
                          action='store_true', default=False,
                          help='Do nothing.')
        # Preprocess the args to remove quotes before/after each one if they
        # exist.  This is necessary because arguments passed via
        # run_remote_tests.sh may be individually quoted, and those quotes must
        # be stripped before they are parsed.
        return parser.parse_args(map(lambda arg: arg.strip('\'\"'), args))


    def run_once(self, args=[]):
        """Run the PyAuto performance tests.

        @param args: Either space-separated arguments or a list of string
              arguments.  If this is a space separated string, we'll just
              call split() on it to get a list.  The list will be sent to
              optparse for parsing.
        """
        if isinstance(args, str):
            args = args.split()
        options, test_args = self._parse_args(args)

        if test_args:
            raise error.TestFail("Unknown args: %s" % repr(test_args))

        if not os.path.exists(self.Bin):
            raise error.TestFail("%s does not exist" % self.Bin)

        try:
            restart_swap = True
            utils.system_output('swapoff /dev/zram0')
        except:
            restart_swap = False
        utils.system_output('stop ui')
        if options.want_nop_tests:
            pass
        if options.want_mem_tests:
            self._memcpy_test()
            self._memcpy()
        if options.want_disk_tests:
            self._disk_tests('ext4_', '/usr/local/_Dir', '/usr/local/xyzzy')
        if options.want_ecryptfs_tests:
            self._ecryptfs()

        if restart_swap:
            utils.system_output('swapon /dev/zram0')
        utils.system_output('start ui')