diff --git a/io_scenario/io.py b/io_scenario/io.py
index bd7a325..2ad8f19 100644
--- a/io_scenario/io.py
+++ b/io_scenario/io.py
@@ -215,6 +215,7 @@
 
     # no retest
     cmd.append('-+n')
+
     raw_res = subprocess.check_output(cmd)
 
     try:
@@ -317,6 +318,7 @@
                 "--filename=%s" % tmpname,
                 "--size={0}k".format(benchmark.size),
                 "--numjobs={0}".format(benchmark.concurence),
+                "--runtime=60",
                 "--output-format=json",
                 "--sync=" + ('1' if benchmark.sync else '0')]
 
@@ -346,8 +348,11 @@
     res = {}
 
     # 'bw_dev bw_mean bw_max bw_min'.split()
-    for field in ["bw_mean"]:
+    for field in ["bw_mean", "iops"]:
         res[field] = raw_result[field]
+    res["lat"] = raw_result["lat"]["mean"]
+    res["clat"] = raw_result["clat"]["mean"]
+    res["slat"] = raw_result["slat"]["mean"]
 
     return res, cmd_line
 
@@ -488,9 +493,6 @@
 
     parser.add_argument("--preparation-results", default="{}")
 
-    parser.add_argument("--with-sensors", default="",
-                        dest="with_sensors")
-
     return parser.parse_args(argv)
 
 
@@ -570,7 +572,7 @@
                              " options should be provided, not both")
 
         if argv_obj.test_file is not None:
-            preparation_results['all_files'] = argv_obj.test_file
+            preparation_results['all_files'] = [argv_obj.test_file]
 
         autoremove = False
         if 'all_files' not in preparation_results:
@@ -592,37 +594,19 @@
                 if dt > 0:
                     time.sleep(dt)
 
-            if argv_obj.with_sensors != "":
-                oq = Queue.Queue()
-                iq = Queue.Queue()
-                argv = (argv_obj.with_sensors, oq, iq)
-                th = threading.Thread(None, sensor_thread, None, argv)
-                th.daemon = True
-                th.start()
-
             res, cmd = run_benchmark(argv_obj.type,
                                      benchmark=benchmark,
                                      binary_path=binary_path,
                                      timeout=argv_obj.timeout,
                                      **preparation_results)
-            if argv_obj.with_sensors != "":
-                oq.put(None)
-                th.join()
-                stats = []
-
-                while not iq.empty():
-                    stats.append(iq.get())
-            else:
-                stats = None
 
             res['__meta__'] = benchmark.__dict__.copy()
             res['__meta__']['cmdline'] = cmd
 
-            if stats is not None:
-                res['__meta__']['sensor_data'] = stats
+            import pprint
+            sys.stdout.write(pprint.pformat(res))
 
-            sys.stdout.write(json.dumps(res))
-
+            # sys.stdout.write(json.dumps(res))
             if not argv_obj.prepare_only:
                 sys.stdout.write("\n")
 
diff --git a/io_scenario/io.yaml b/io_scenario/io.yaml
deleted file mode 100644
index deb4b99..0000000
--- a/io_scenario/io.yaml
+++ /dev/null
@@ -1,24 +0,0 @@
-VMTasks.boot_runcommand_delete:
-    -
-        args:
-            flavor:
-                name: "ceph.512"
-            image:
-                name: "ubuntu"
-
-            floating_network: "net04_ext"
-            force_delete: false
-            script: "io.py"
-            interpreter: "/usr/bin/env python2"
-            username: "ubuntu"
-
-        runner:
-            type: "constant"
-            times: 3
-            concurrency: 3
-
-        context:
-            users:
-                tenants: 1
-                users_per_tenant: 1
-            network: {}
\ No newline at end of file
diff --git a/io_scenario/libs/ubuntu_14_04_x64/_psutil_linux.so b/io_scenario/libs/ubuntu_14_04_x64/_psutil_linux.so
deleted file mode 100755
index b5f9713..0000000
--- a/io_scenario/libs/ubuntu_14_04_x64/_psutil_linux.so
+++ /dev/null
Binary files differ
diff --git a/io_scenario/libs/ubuntu_14_04_x64/_psutil_posix.so b/io_scenario/libs/ubuntu_14_04_x64/_psutil_posix.so
deleted file mode 100755
index 520ab67..0000000
--- a/io_scenario/libs/ubuntu_14_04_x64/_psutil_posix.so
+++ /dev/null
Binary files differ
diff --git a/io_scenario/libs/ubuntu_14_04_x64/psutil/__init__.py b/io_scenario/libs/ubuntu_14_04_x64/psutil/__init__.py
deleted file mode 100644
index 322cc21..0000000
--- a/io_scenario/libs/ubuntu_14_04_x64/psutil/__init__.py
+++ /dev/null
@@ -1,2015 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""psutil is a cross-platform library for retrieving information on
-running processes and system utilization (CPU, memory, disks, network)
-in Python.
-"""
-
-from __future__ import division
-
-__author__ = "Giampaolo Rodola'"
-__version__ = "2.2.1"
-version_info = tuple([int(num) for num in __version__.split('.')])
-
-__all__ = [
-    # exceptions
-    "Error", "NoSuchProcess", "AccessDenied", "TimeoutExpired",
-    # constants
-    "version_info", "__version__",
-    "STATUS_RUNNING", "STATUS_IDLE", "STATUS_SLEEPING", "STATUS_DISK_SLEEP",
-    "STATUS_STOPPED", "STATUS_TRACING_STOP", "STATUS_ZOMBIE", "STATUS_DEAD",
-    "STATUS_WAKING", "STATUS_LOCKED", "STATUS_WAITING", "STATUS_LOCKED",
-    "CONN_ESTABLISHED", "CONN_SYN_SENT", "CONN_SYN_RECV", "CONN_FIN_WAIT1",
-    "CONN_FIN_WAIT2", "CONN_TIME_WAIT", "CONN_CLOSE", "CONN_CLOSE_WAIT",
-    "CONN_LAST_ACK", "CONN_LISTEN", "CONN_CLOSING", "CONN_NONE",
-    # classes
-    "Process", "Popen",
-    # functions
-    "pid_exists", "pids", "process_iter", "wait_procs",             # proc
-    "virtual_memory", "swap_memory",                                # memory
-    "cpu_times", "cpu_percent", "cpu_times_percent", "cpu_count",   # cpu
-    "net_io_counters", "net_connections",                           # network
-    "disk_io_counters", "disk_partitions", "disk_usage",            # disk
-    "users", "boot_time",                                           # others
-]
-
-import collections
-import errno
-import functools
-import os
-import signal
-import subprocess
-import sys
-import time
-import warnings
-try:
-    import pwd
-except ImportError:
-    pwd = None
-
-from psutil._common import memoize
-from psutil._compat import callable, long
-from psutil._compat import PY3 as _PY3
-from psutil._common import (deprecated_method as _deprecated_method,
-                            deprecated as _deprecated,
-                            sdiskio as _nt_sys_diskio,
-                            snetio as _nt_sys_netio)
-
-from psutil._common import (STATUS_RUNNING,  # NOQA
-                            STATUS_SLEEPING,
-                            STATUS_DISK_SLEEP,
-                            STATUS_STOPPED,
-                            STATUS_TRACING_STOP,
-                            STATUS_ZOMBIE,
-                            STATUS_DEAD,
-                            STATUS_WAKING,
-                            STATUS_LOCKED,
-                            STATUS_IDLE,  # bsd
-                            STATUS_WAITING,  # bsd
-                            STATUS_LOCKED)  # bsd
-
-from psutil._common import (CONN_ESTABLISHED,
-                            CONN_SYN_SENT,
-                            CONN_SYN_RECV,
-                            CONN_FIN_WAIT1,
-                            CONN_FIN_WAIT2,
-                            CONN_TIME_WAIT,
-                            CONN_CLOSE,
-                            CONN_CLOSE_WAIT,
-                            CONN_LAST_ACK,
-                            CONN_LISTEN,
-                            CONN_CLOSING,
-                            CONN_NONE)
-
-if sys.platform.startswith("linux"):
-    import psutil._pslinux as _psplatform
-    from psutil._pslinux import (phymem_buffers,  # NOQA
-                                 cached_phymem)
-
-    from psutil._pslinux import (IOPRIO_CLASS_NONE,  # NOQA
-                                 IOPRIO_CLASS_RT,
-                                 IOPRIO_CLASS_BE,
-                                 IOPRIO_CLASS_IDLE)
-    # Linux >= 2.6.36
-    if _psplatform.HAS_PRLIMIT:
-        from _psutil_linux import (RLIM_INFINITY,  # NOQA
-                                   RLIMIT_AS,
-                                   RLIMIT_CORE,
-                                   RLIMIT_CPU,
-                                   RLIMIT_DATA,
-                                   RLIMIT_FSIZE,
-                                   RLIMIT_LOCKS,
-                                   RLIMIT_MEMLOCK,
-                                   RLIMIT_NOFILE,
-                                   RLIMIT_NPROC,
-                                   RLIMIT_RSS,
-                                   RLIMIT_STACK)
-        # Kinda ugly but considerably faster than using hasattr() and
-        # setattr() against the module object (we are at import time:
-        # speed matters).
-        import _psutil_linux
-        try:
-            RLIMIT_MSGQUEUE = _psutil_linux.RLIMIT_MSGQUEUE
-        except AttributeError:
-            pass
-        try:
-            RLIMIT_NICE = _psutil_linux.RLIMIT_NICE
-        except AttributeError:
-            pass
-        try:
-            RLIMIT_RTPRIO = _psutil_linux.RLIMIT_RTPRIO
-        except AttributeError:
-            pass
-        try:
-            RLIMIT_RTTIME = _psutil_linux.RLIMIT_RTTIME
-        except AttributeError:
-            pass
-        try:
-            RLIMIT_SIGPENDING = _psutil_linux.RLIMIT_SIGPENDING
-        except AttributeError:
-            pass
-        del _psutil_linux
-
-elif sys.platform.startswith("win32"):
-    import psutil._pswindows as _psplatform
-    from _psutil_windows import (ABOVE_NORMAL_PRIORITY_CLASS,  # NOQA
-                                 BELOW_NORMAL_PRIORITY_CLASS,
-                                 HIGH_PRIORITY_CLASS,
-                                 IDLE_PRIORITY_CLASS,
-                                 NORMAL_PRIORITY_CLASS,
-                                 REALTIME_PRIORITY_CLASS)
-    from psutil._pswindows import CONN_DELETE_TCB  # NOQA
-
-elif sys.platform.startswith("darwin"):
-    import psutil._psosx as _psplatform
-
-elif sys.platform.startswith("freebsd"):
-    import psutil._psbsd as _psplatform
-
-elif sys.platform.startswith("sunos"):
-    import psutil._pssunos as _psplatform
-    from psutil._pssunos import (CONN_IDLE,  # NOQA
-                                 CONN_BOUND)
-
-else:
-    raise NotImplementedError('platform %s is not supported' % sys.platform)
-
-__all__.extend(_psplatform.__extra__all__)
-
-
-_TOTAL_PHYMEM = None
-_POSIX = os.name == 'posix'
-_WINDOWS = os.name == 'nt'
-_timer = getattr(time, 'monotonic', time.time)
-
-
-# Sanity check in case the user messed up with psutil installation
-# or did something weird with sys.path. In this case we might end
-# up importing a python module using a C extension module which
-# was compiled for a different version of psutil.
-# We want to prevent that by failing sooner rather than later.
-# See: https://github.com/giampaolo/psutil/issues/564
-if (int(__version__.replace('.', '')) !=
-        getattr(_psplatform.cext, 'version', None)):
-    msg = "version conflict: %r C extension module was built for another " \
-          "version of psutil (different than %s)" % (_psplatform.cext.__file__,
-                                                     __version__)
-    raise ImportError(msg)
-
-
-# =====================================================================
-# --- exceptions
-# =====================================================================
-
-class Error(Exception):
-    """Base exception class. All other psutil exceptions inherit
-    from this one.
-    """
-
-
-class NoSuchProcess(Error):
-    """Exception raised when a process with a certain PID doesn't
-    or no longer exists (zombie).
-    """
-
-    def __init__(self, pid, name=None, msg=None):
-        Error.__init__(self)
-        self.pid = pid
-        self.name = name
-        self.msg = msg
-        if msg is None:
-            if name:
-                details = "(pid=%s, name=%s)" % (self.pid, repr(self.name))
-            else:
-                details = "(pid=%s)" % self.pid
-            self.msg = "process no longer exists " + details
-
-    def __str__(self):
-        return self.msg
-
-
-class AccessDenied(Error):
-    """Exception raised when permission to perform an action is denied."""
-
-    def __init__(self, pid=None, name=None, msg=None):
-        Error.__init__(self)
-        self.pid = pid
-        self.name = name
-        self.msg = msg
-        if msg is None:
-            if (pid is not None) and (name is not None):
-                self.msg = "(pid=%s, name=%s)" % (pid, repr(name))
-            elif (pid is not None):
-                self.msg = "(pid=%s)" % self.pid
-            else:
-                self.msg = ""
-
-    def __str__(self):
-        return self.msg
-
-
-class TimeoutExpired(Error):
-    """Raised on Process.wait(timeout) if timeout expires and process
-    is still alive.
-    """
-
-    def __init__(self, seconds, pid=None, name=None):
-        Error.__init__(self)
-        self.seconds = seconds
-        self.pid = pid
-        self.name = name
-        self.msg = "timeout after %s seconds" % seconds
-        if (pid is not None) and (name is not None):
-            self.msg += " (pid=%s, name=%s)" % (pid, repr(name))
-        elif (pid is not None):
-            self.msg += " (pid=%s)" % self.pid
-
-    def __str__(self):
-        return self.msg
-
-# push exception classes into platform specific module namespace
-_psplatform.NoSuchProcess = NoSuchProcess
-_psplatform.AccessDenied = AccessDenied
-_psplatform.TimeoutExpired = TimeoutExpired
-
-
-# =====================================================================
-# --- Process class
-# =====================================================================
-
-def _assert_pid_not_reused(fun):
-    """Decorator which raises NoSuchProcess in case a process is no
-    longer running or its PID has been reused.
-    """
-    @functools.wraps(fun)
-    def wrapper(self, *args, **kwargs):
-        if not self.is_running():
-            raise NoSuchProcess(self.pid, self._name)
-        return fun(self, *args, **kwargs)
-    return wrapper
-
-
-class Process(object):
-    """Represents an OS process with the given PID.
-    If PID is omitted current process PID (os.getpid()) is used.
-    Raise NoSuchProcess if PID does not exist.
-
-    Note that most of the methods of this class do not make sure
-    the PID of the process being queried has been reused over time.
-    That means you might end up retrieving an information referring
-    to another process in case the original one this instance
-    refers to is gone in the meantime.
-
-    The only exceptions for which process identity is pre-emptively
-    checked and guaranteed are:
-
-     - parent()
-     - children()
-     - nice() (set)
-     - ionice() (set)
-     - rlimit() (set)
-     - cpu_affinity (set)
-     - suspend()
-     - resume()
-     - send_signal()
-     - terminate()
-     - kill()
-
-    To prevent this problem for all other methods you can:
-      - use is_running() before querying the process
-      - if you're continuously iterating over a set of Process
-        instances use process_iter() which pre-emptively checks
-        process identity for every yielded instance
-    """
-
-    def __init__(self, pid=None):
-        self._init(pid)
-
-    def _init(self, pid, _ignore_nsp=False):
-        if pid is None:
-            pid = os.getpid()
-        else:
-            if not _PY3 and not isinstance(pid, (int, long)):
-                raise TypeError('pid must be an integer (got %r)' % pid)
-            if pid < 0:
-                raise ValueError('pid must be a positive integer (got %s)'
-                                 % pid)
-        self._pid = pid
-        self._name = None
-        self._exe = None
-        self._create_time = None
-        self._gone = False
-        self._hash = None
-        # used for caching on Windows only (on POSIX ppid may change)
-        self._ppid = None
-        # platform-specific modules define an _psplatform.Process
-        # implementation class
-        self._proc = _psplatform.Process(pid)
-        self._last_sys_cpu_times = None
-        self._last_proc_cpu_times = None
-        # cache creation time for later use in is_running() method
-        try:
-            self.create_time()
-        except AccessDenied:
-            # we should never get here as AFAIK we're able to get
-            # process creation time on all platforms even as a
-            # limited user
-            pass
-        except NoSuchProcess:
-            if not _ignore_nsp:
-                msg = 'no process found with pid %s' % pid
-                raise NoSuchProcess(pid, None, msg)
-            else:
-                self._gone = True
-        # This pair is supposed to indentify a Process instance
-        # univocally over time (the PID alone is not enough as
-        # it might refer to a process whose PID has been reused).
-        # This will be used later in __eq__() and is_running().
-        self._ident = (self.pid, self._create_time)
-
-    def __str__(self):
-        try:
-            pid = self.pid
-            name = repr(self.name())
-        except NoSuchProcess:
-            details = "(pid=%s (terminated))" % self.pid
-        except AccessDenied:
-            details = "(pid=%s)" % (self.pid)
-        else:
-            details = "(pid=%s, name=%s)" % (pid, name)
-        return "%s.%s%s" % (self.__class__.__module__,
-                            self.__class__.__name__, details)
-
-    def __repr__(self):
-        return "<%s at %s>" % (self.__str__(), id(self))
-
-    def __eq__(self, other):
-        # Test for equality with another Process object based
-        # on PID and creation time.
-        if not isinstance(other, Process):
-            return NotImplemented
-        return self._ident == other._ident
-
-    def __ne__(self, other):
-        return not self == other
-
-    def __hash__(self):
-        if self._hash is None:
-            self._hash = hash(self._ident)
-        return self._hash
-
-    # --- utility methods
-
-    def as_dict(self, attrs=None, ad_value=None):
-        """Utility method returning process information as a
-        hashable dictionary.
-
-        If 'attrs' is specified it must be a list of strings
-        reflecting available Process class' attribute names
-        (e.g. ['cpu_times', 'name']) else all public (read
-        only) attributes are assumed.
-
-        'ad_value' is the value which gets assigned in case
-        AccessDenied  exception is raised when retrieving that
-        particular process information.
-        """
-        excluded_names = set(
-            ['send_signal', 'suspend', 'resume', 'terminate', 'kill', 'wait',
-             'is_running', 'as_dict', 'parent', 'children', 'rlimit'])
-        retdict = dict()
-        ls = set(attrs or [x for x in dir(self) if not x.startswith('get')])
-        for name in ls:
-            if name.startswith('_'):
-                continue
-            if name.startswith('set_'):
-                continue
-            if name.startswith('get_'):
-                msg = "%s() is deprecated; use %s() instead" % (name, name[4:])
-                warnings.warn(msg, category=DeprecationWarning, stacklevel=2)
-                name = name[4:]
-                if name in ls:
-                    continue
-            if name == 'getcwd':
-                msg = "getcwd() is deprecated; use cwd() instead"
-                warnings.warn(msg, category=DeprecationWarning, stacklevel=2)
-                name = 'cwd'
-                if name in ls:
-                    continue
-
-            if name in excluded_names:
-                continue
-            try:
-                attr = getattr(self, name)
-                if callable(attr):
-                    ret = attr()
-                else:
-                    ret = attr
-            except AccessDenied:
-                ret = ad_value
-            except NotImplementedError:
-                # in case of not implemented functionality (may happen
-                # on old or exotic systems) we want to crash only if
-                # the user explicitly asked for that particular attr
-                if attrs:
-                    raise
-                continue
-            retdict[name] = ret
-        return retdict
-
-    def parent(self):
-        """Return the parent process as a Process object pre-emptively
-        checking whether PID has been reused.
-        If no parent is known return None.
-        """
-        ppid = self.ppid()
-        if ppid is not None:
-            try:
-                parent = Process(ppid)
-                if parent.create_time() <= self.create_time():
-                    return parent
-                # ...else ppid has been reused by another process
-            except NoSuchProcess:
-                pass
-
-    def is_running(self):
-        """Return whether this process is running.
-        It also checks if PID has been reused by another process in
-        which case return False.
-        """
-        if self._gone:
-            return False
-        try:
-            # Checking if PID is alive is not enough as the PID might
-            # have been reused by another process: we also want to
-            # check process identity.
-            # Process identity / uniqueness over time is greanted by
-            # (PID + creation time) and that is verified in __eq__.
-            return self == Process(self.pid)
-        except NoSuchProcess:
-            self._gone = True
-            return False
-
-    # --- actual API
-
-    @property
-    def pid(self):
-        """The process PID."""
-        return self._pid
-
-    def ppid(self):
-        """The process parent PID.
-        On Windows the return value is cached after first call.
-        """
-        # On POSIX we don't want to cache the ppid as it may unexpectedly
-        # change to 1 (init) in case this process turns into a zombie:
-        # https://github.com/giampaolo/psutil/issues/321
-        # http://stackoverflow.com/questions/356722/
-
-        # XXX should we check creation time here rather than in
-        # Process.parent()?
-        if _POSIX:
-            return self._proc.ppid()
-        else:
-            if self._ppid is None:
-                self._ppid = self._proc.ppid()
-            return self._ppid
-
-    def name(self):
-        """The process name. The return value is cached after first call."""
-        if self._name is None:
-            name = self._proc.name()
-            if _POSIX and len(name) >= 15:
-                # On UNIX the name gets truncated to the first 15 characters.
-                # If it matches the first part of the cmdline we return that
-                # one instead because it's usually more explicative.
-                # Examples are "gnome-keyring-d" vs. "gnome-keyring-daemon".
-                try:
-                    cmdline = self.cmdline()
-                except AccessDenied:
-                    pass
-                else:
-                    if cmdline:
-                        extended_name = os.path.basename(cmdline[0])
-                        if extended_name.startswith(name):
-                            name = extended_name
-            self._proc._name = name
-            self._name = name
-        return self._name
-
-    def exe(self):
-        """The process executable as an absolute path.
-        May also be an empty string.
-        The return value is cached after first call.
-        """
-        def guess_it(fallback):
-            # try to guess exe from cmdline[0] in absence of a native
-            # exe representation
-            cmdline = self.cmdline()
-            if cmdline and hasattr(os, 'access') and hasattr(os, 'X_OK'):
-                exe = cmdline[0]  # the possible exe
-                # Attempt to guess only in case of an absolute path.
-                # It is not safe otherwise as the process might have
-                # changed cwd.
-                if (os.path.isabs(exe)
-                        and os.path.isfile(exe)
-                        and os.access(exe, os.X_OK)):
-                    return exe
-            if isinstance(fallback, AccessDenied):
-                raise fallback
-            return fallback
-
-        if self._exe is None:
-            try:
-                exe = self._proc.exe()
-            except AccessDenied as err:
-                return guess_it(fallback=err)
-            else:
-                if not exe:
-                    # underlying implementation can legitimately return an
-                    # empty string; if that's the case we don't want to
-                    # raise AD while guessing from the cmdline
-                    try:
-                        exe = guess_it(fallback=exe)
-                    except AccessDenied:
-                        pass
-                self._exe = exe
-        return self._exe
-
-    def cmdline(self):
-        """The command line this process has been called with."""
-        return self._proc.cmdline()
-
-    def status(self):
-        """The process current status as a STATUS_* constant."""
-        return self._proc.status()
-
-    def username(self):
-        """The name of the user that owns the process.
-        On UNIX this is calculated by using *real* process uid.
-        """
-        if _POSIX:
-            if pwd is None:
-                # might happen if python was installed from sources
-                raise ImportError(
-                    "requires pwd module shipped with standard python")
-            real_uid = self.uids().real
-            try:
-                return pwd.getpwuid(real_uid).pw_name
-            except KeyError:
-                # the uid can't be resolved by the system
-                return str(real_uid)
-        else:
-            return self._proc.username()
-
-    def create_time(self):
-        """The process creation time as a floating point number
-        expressed in seconds since the epoch, in UTC.
-        The return value is cached after first call.
-        """
-        if self._create_time is None:
-            self._create_time = self._proc.create_time()
-        return self._create_time
-
-    def cwd(self):
-        """Process current working directory as an absolute path."""
-        return self._proc.cwd()
-
-    def nice(self, value=None):
-        """Get or set process niceness (priority)."""
-        if value is None:
-            return self._proc.nice_get()
-        else:
-            if not self.is_running():
-                raise NoSuchProcess(self.pid, self._name)
-            self._proc.nice_set(value)
-
-    if _POSIX:
-
-        def uids(self):
-            """Return process UIDs as a (real, effective, saved)
-            namedtuple.
-            """
-            return self._proc.uids()
-
-        def gids(self):
-            """Return process GIDs as a (real, effective, saved)
-            namedtuple.
-            """
-            return self._proc.gids()
-
-        def terminal(self):
-            """The terminal associated with this process, if any,
-            else None.
-            """
-            return self._proc.terminal()
-
-        def num_fds(self):
-            """Return the number of file descriptors opened by this
-            process (POSIX only).
-            """
-            return self._proc.num_fds()
-
-    # Linux, BSD and Windows only
-    if hasattr(_psplatform.Process, "io_counters"):
-
-        def io_counters(self):
-            """Return process I/O statistics as a
-            (read_count, write_count, read_bytes, write_bytes)
-            namedtuple.
-            Those are the number of read/write calls performed and the
-            amount of bytes read and written by the process.
-            """
-            return self._proc.io_counters()
-
-    # Linux and Windows >= Vista only
-    if hasattr(_psplatform.Process, "ionice_get"):
-
-        def ionice(self, ioclass=None, value=None):
-            """Get or set process I/O niceness (priority).
-
-            On Linux 'ioclass' is one of the IOPRIO_CLASS_* constants.
-            'value' is a number which goes from 0 to 7. The higher the
-            value, the lower the I/O priority of the process.
-
-            On Windows only 'ioclass' is used and it can be set to 2
-            (normal), 1 (low) or 0 (very low).
-
-            Available on Linux and Windows > Vista only.
-            """
-            if ioclass is None:
-                if value is not None:
-                    raise ValueError("'ioclass' must be specified")
-                return self._proc.ionice_get()
-            else:
-                return self._proc.ionice_set(ioclass, value)
-
-    # Linux only
-    if hasattr(_psplatform.Process, "rlimit"):
-
-        def rlimit(self, resource, limits=None):
-            """Get or set process resource limits as a (soft, hard)
-            tuple.
-
-            'resource' is one of the RLIMIT_* constants.
-            'limits' is supposed to be a (soft, hard)  tuple.
-
-            See "man prlimit" for further info.
-            Available on Linux only.
-            """
-            if limits is None:
-                return self._proc.rlimit(resource)
-            else:
-                return self._proc.rlimit(resource, limits)
-
-    # Windows, Linux and BSD only
-    if hasattr(_psplatform.Process, "cpu_affinity_get"):
-
-        def cpu_affinity(self, cpus=None):
-            """Get or set process CPU affinity.
-            If specified 'cpus' must be a list of CPUs for which you
-            want to set the affinity (e.g. [0, 1]).
-            (Windows, Linux and BSD only).
-            """
-            if cpus is None:
-                return self._proc.cpu_affinity_get()
-            else:
-                self._proc.cpu_affinity_set(cpus)
-
-    if _WINDOWS:
-
-        def num_handles(self):
-            """Return the number of handles opened by this process
-            (Windows only).
-            """
-            return self._proc.num_handles()
-
-    def num_ctx_switches(self):
-        """Return the number of voluntary and involuntary context
-        switches performed by this process.
-        """
-        return self._proc.num_ctx_switches()
-
-    def num_threads(self):
-        """Return the number of threads used by this process."""
-        return self._proc.num_threads()
-
-    def threads(self):
-        """Return threads opened by process as a list of
-        (id, user_time, system_time) namedtuples representing
-        thread id and thread CPU times (user/system).
-        """
-        return self._proc.threads()
-
-    @_assert_pid_not_reused
-    def children(self, recursive=False):
-        """Return the children of this process as a list of Process
-        instances, pre-emptively checking whether PID has been reused.
-        If recursive is True return all the parent descendants.
-
-        Example (A == this process):
-
-         A ─┐
-            │
-            ├─ B (child) ─┐
-            │             └─ X (grandchild) ─┐
-            │                                └─ Y (great grandchild)
-            ├─ C (child)
-            └─ D (child)
-
-        >>> import psutil
-        >>> p = psutil.Process()
-        >>> p.children()
-        B, C, D
-        >>> p.children(recursive=True)
-        B, X, Y, C, D
-
-        Note that in the example above if process X disappears
-        process Y won't be listed as the reference to process A
-        is lost.
-        """
-        if hasattr(_psplatform, 'ppid_map'):
-            # Windows only: obtain a {pid:ppid, ...} dict for all running
-            # processes in one shot (faster).
-            ppid_map = _psplatform.ppid_map()
-        else:
-            ppid_map = None
-
-        ret = []
-        if not recursive:
-            if ppid_map is None:
-                # 'slow' version, common to all platforms except Windows
-                for p in process_iter():
-                    try:
-                        if p.ppid() == self.pid:
-                            # if child happens to be older than its parent
-                            # (self) it means child's PID has been reused
-                            if self.create_time() <= p.create_time():
-                                ret.append(p)
-                    except NoSuchProcess:
-                        pass
-            else:
-                # Windows only (faster)
-                for pid, ppid in ppid_map.items():
-                    if ppid == self.pid:
-                        try:
-                            child = Process(pid)
-                            # if child happens to be older than its parent
-                            # (self) it means child's PID has been reused
-                            if self.create_time() <= child.create_time():
-                                ret.append(child)
-                        except NoSuchProcess:
-                            pass
-        else:
-            # construct a dict where 'values' are all the processes
-            # having 'key' as their parent
-            table = collections.defaultdict(list)
-            if ppid_map is None:
-                for p in process_iter():
-                    try:
-                        table[p.ppid()].append(p)
-                    except NoSuchProcess:
-                        pass
-            else:
-                for pid, ppid in ppid_map.items():
-                    try:
-                        p = Process(pid)
-                        table[ppid].append(p)
-                    except NoSuchProcess:
-                        pass
-            # At this point we have a mapping table where table[self.pid]
-            # are the current process' children.
-            # Below, we look for all descendants recursively, similarly
-            # to a recursive function call.
-            checkpids = [self.pid]
-            for pid in checkpids:
-                for child in table[pid]:
-                    try:
-                        # if child happens to be older than its parent
-                        # (self) it means child's PID has been reused
-                        intime = self.create_time() <= child.create_time()
-                    except NoSuchProcess:
-                        pass
-                    else:
-                        if intime:
-                            ret.append(child)
-                            if child.pid not in checkpids:
-                                checkpids.append(child.pid)
-        return ret
-
-    def cpu_percent(self, interval=None):
-        """Return a float representing the current process CPU
-        utilization as a percentage.
-
-        When interval is 0.0 or None (default) compares process times
-        to system CPU times elapsed since last call, returning
-        immediately (non-blocking). That means that the first time
-        this is called it will return a meaningful 0.0 value.
-
-        When interval is > 0.0 compares process times to system CPU
-        times elapsed before and after the interval (blocking).
-
-        In this case is recommended for accuracy that this function
-        be called with at least 0.1 seconds between calls.
-
-        Examples:
-
-          >>> import psutil
-          >>> p = psutil.Process(os.getpid())
-          >>> # blocking
-          >>> p.cpu_percent(interval=1)
-          2.0
-          >>> # non-blocking (percentage since last call)
-          >>> p.cpu_percent(interval=None)
-          2.9
-          >>>
-        """
-        blocking = interval is not None and interval > 0.0
-        num_cpus = cpu_count()
-        if _POSIX:
-            timer = lambda: _timer() * num_cpus
-        else:
-            timer = lambda: sum(cpu_times())
-        if blocking:
-            st1 = timer()
-            pt1 = self._proc.cpu_times()
-            time.sleep(interval)
-            st2 = timer()
-            pt2 = self._proc.cpu_times()
-        else:
-            st1 = self._last_sys_cpu_times
-            pt1 = self._last_proc_cpu_times
-            st2 = timer()
-            pt2 = self._proc.cpu_times()
-            if st1 is None or pt1 is None:
-                self._last_sys_cpu_times = st2
-                self._last_proc_cpu_times = pt2
-                return 0.0
-
-        delta_proc = (pt2.user - pt1.user) + (pt2.system - pt1.system)
-        delta_time = st2 - st1
-        # reset values for next call in case of interval == None
-        self._last_sys_cpu_times = st2
-        self._last_proc_cpu_times = pt2
-
-        try:
-            # The utilization split between all CPUs.
-            # Note: a percentage > 100 is legitimate as it can result
-            # from a process with multiple threads running on different
-            # CPU cores, see:
-            # http://stackoverflow.com/questions/1032357
-            # https://github.com/giampaolo/psutil/issues/474
-            overall_percent = ((delta_proc / delta_time) * 100) * num_cpus
-        except ZeroDivisionError:
-            # interval was too low
-            return 0.0
-        else:
-            return round(overall_percent, 1)
-
-    def cpu_times(self):
-        """Return a (user, system) namedtuple representing  the
-        accumulated process time, in seconds.
-        This is the same as os.times() but per-process.
-        """
-        return self._proc.cpu_times()
-
-    def memory_info(self):
-        """Return a tuple representing RSS (Resident Set Size) and VMS
-        (Virtual Memory Size) in bytes.
-
-        On UNIX RSS and VMS are the same values shown by 'ps'.
-
-        On Windows RSS and VMS refer to "Mem Usage" and "VM Size"
-        columns of taskmgr.exe.
-        """
-        return self._proc.memory_info()
-
-    def memory_info_ex(self):
-        """Return a namedtuple with variable fields depending on the
-        platform representing extended memory information about
-        this process. All numbers are expressed in bytes.
-        """
-        return self._proc.memory_info_ex()
-
-    def memory_percent(self):
-        """Compare physical system memory to process resident memory
-        (RSS) and calculate process memory utilization as a percentage.
-        """
-        rss = self._proc.memory_info()[0]
-        # use cached value if available
-        total_phymem = _TOTAL_PHYMEM or virtual_memory().total
-        try:
-            return (rss / float(total_phymem)) * 100
-        except ZeroDivisionError:
-            return 0.0
-
-    def memory_maps(self, grouped=True):
-        """Return process' mapped memory regions as a list of nameduples
-        whose fields are variable depending on the platform.
-
-        If 'grouped' is True the mapped regions with the same 'path'
-        are grouped together and the different memory fields are summed.
-
-        If 'grouped' is False every mapped region is shown as a single
-        entity and the namedtuple will also include the mapped region's
-        address space ('addr') and permission set ('perms').
-        """
-        it = self._proc.memory_maps()
-        if grouped:
-            d = {}
-            for tupl in it:
-                path = tupl[2]
-                nums = tupl[3:]
-                try:
-                    d[path] = map(lambda x, y: x + y, d[path], nums)
-                except KeyError:
-                    d[path] = nums
-            nt = _psplatform.pmmap_grouped
-            return [nt(path, *d[path]) for path in d]  # NOQA
-        else:
-            nt = _psplatform.pmmap_ext
-            return [nt(*x) for x in it]
-
-    def open_files(self):
-        """Return files opened by process as a list of
-        (path, fd) namedtuples including the absolute file name
-        and file descriptor number.
-        """
-        return self._proc.open_files()
-
-    def connections(self, kind='inet'):
-        """Return connections opened by process as a list of
-        (fd, family, type, laddr, raddr, status) namedtuples.
-        The 'kind' parameter filters for connections that match the
-        following criteria:
-
-        Kind Value      Connections using
-        inet            IPv4 and IPv6
-        inet4           IPv4
-        inet6           IPv6
-        tcp             TCP
-        tcp4            TCP over IPv4
-        tcp6            TCP over IPv6
-        udp             UDP
-        udp4            UDP over IPv4
-        udp6            UDP over IPv6
-        unix            UNIX socket (both UDP and TCP protocols)
-        all             the sum of all the possible families and protocols
-        """
-        return self._proc.connections(kind)
-
-    if _POSIX:
-        def _send_signal(self, sig):
-            # XXX: according to "man 2 kill" PID 0 has a special
-            # meaning as it refers to <<every process in the process
-            # group of the calling process>>, so should we prevent
-            # it here?
-            try:
-                os.kill(self.pid, sig)
-            except OSError as err:
-                if err.errno == errno.ESRCH:
-                    self._gone = True
-                    raise NoSuchProcess(self.pid, self._name)
-                if err.errno == errno.EPERM:
-                    raise AccessDenied(self.pid, self._name)
-                raise
-
-    @_assert_pid_not_reused
-    def send_signal(self, sig):
-        """Send a signal to process pre-emptively checking whether
-        PID has been reused (see signal module constants) .
-        On Windows only SIGTERM is valid and is treated as an alias
-        for kill().
-        """
-        if _POSIX:
-            self._send_signal(sig)
-        else:
-            if sig == signal.SIGTERM:
-                self._proc.kill()
-            else:
-                raise ValueError("only SIGTERM is supported on Windows")
-
-    @_assert_pid_not_reused
-    def suspend(self):
-        """Suspend process execution with SIGSTOP pre-emptively checking
-        whether PID has been reused.
-        On Windows this has the effect ot suspending all process threads.
-        """
-        if _POSIX:
-            self._send_signal(signal.SIGSTOP)
-        else:
-            self._proc.suspend()
-
-    @_assert_pid_not_reused
-    def resume(self):
-        """Resume process execution with SIGCONT pre-emptively checking
-        whether PID has been reused.
-        On Windows this has the effect of resuming all process threads.
-        """
-        if _POSIX:
-            self._send_signal(signal.SIGCONT)
-        else:
-            self._proc.resume()
-
-    @_assert_pid_not_reused
-    def terminate(self):
-        """Terminate the process with SIGTERM pre-emptively checking
-        whether PID has been reused.
-        On Windows this is an alias for kill().
-        """
-        if _POSIX:
-            self._send_signal(signal.SIGTERM)
-        else:
-            self._proc.kill()
-
-    @_assert_pid_not_reused
-    def kill(self):
-        """Kill the current process with SIGKILL pre-emptively checking
-        whether PID has been reused.
-        """
-        if _POSIX:
-            self._send_signal(signal.SIGKILL)
-        else:
-            self._proc.kill()
-
-    def wait(self, timeout=None):
-        """Wait for process to terminate and, if process is a children
-        of os.getpid(), also return its exit code, else None.
-
-        If the process is already terminated immediately return None
-        instead of raising NoSuchProcess.
-
-        If timeout (in seconds) is specified and process is still alive
-        raise TimeoutExpired.
-
-        To wait for multiple Process(es) use psutil.wait_procs().
-        """
-        if timeout is not None and not timeout >= 0:
-            raise ValueError("timeout must be a positive integer")
-        return self._proc.wait(timeout)
-
-    # --- deprecated APIs
-
-    _locals = set(locals())
-
-    @_deprecated_method(replacement='children')
-    def get_children(self):
-        pass
-
-    @_deprecated_method(replacement='connections')
-    def get_connections(self):
-        pass
-
-    if "cpu_affinity" in _locals:
-        @_deprecated_method(replacement='cpu_affinity')
-        def get_cpu_affinity(self):
-            pass
-
-        @_deprecated_method(replacement='cpu_affinity')
-        def set_cpu_affinity(self, cpus):
-            pass
-
-    @_deprecated_method(replacement='cpu_percent')
-    def get_cpu_percent(self):
-        pass
-
-    @_deprecated_method(replacement='cpu_times')
-    def get_cpu_times(self):
-        pass
-
-    @_deprecated_method(replacement='cwd')
-    def getcwd(self):
-        pass
-
-    @_deprecated_method(replacement='memory_info_ex')
-    def get_ext_memory_info(self):
-        pass
-
-    if "io_counters" in _locals:
-        @_deprecated_method(replacement='io_counters')
-        def get_io_counters(self):
-            pass
-
-    if "ionice" in _locals:
-        @_deprecated_method(replacement='ionice')
-        def get_ionice(self):
-            pass
-
-        @_deprecated_method(replacement='ionice')
-        def set_ionice(self, ioclass, value=None):
-            pass
-
-    @_deprecated_method(replacement='memory_info')
-    def get_memory_info(self):
-        pass
-
-    @_deprecated_method(replacement='memory_maps')
-    def get_memory_maps(self):
-        pass
-
-    @_deprecated_method(replacement='memory_percent')
-    def get_memory_percent(self):
-        pass
-
-    @_deprecated_method(replacement='nice')
-    def get_nice(self):
-        pass
-
-    @_deprecated_method(replacement='num_ctx_switches')
-    def get_num_ctx_switches(self):
-        pass
-
-    if 'num_fds' in _locals:
-        @_deprecated_method(replacement='num_fds')
-        def get_num_fds(self):
-            pass
-
-    if 'num_handles' in _locals:
-        @_deprecated_method(replacement='num_handles')
-        def get_num_handles(self):
-            pass
-
-    @_deprecated_method(replacement='num_threads')
-    def get_num_threads(self):
-        pass
-
-    @_deprecated_method(replacement='open_files')
-    def get_open_files(self):
-        pass
-
-    if "rlimit" in _locals:
-        @_deprecated_method(replacement='rlimit')
-        def get_rlimit(self):
-            pass
-
-        @_deprecated_method(replacement='rlimit')
-        def set_rlimit(self, resource, limits):
-            pass
-
-    @_deprecated_method(replacement='threads')
-    def get_threads(self):
-        pass
-
-    @_deprecated_method(replacement='nice')
-    def set_nice(self, value):
-        pass
-
-    del _locals
-
-
-# =====================================================================
-# --- Popen class
-# =====================================================================
-
-class Popen(Process):
-    """A more convenient interface to stdlib subprocess module.
-    It starts a sub process and deals with it exactly as when using
-    subprocess.Popen class but in addition also provides all the
-    properties and methods of psutil.Process class as a unified
-    interface:
-
-      >>> import psutil
-      >>> from subprocess import PIPE
-      >>> p = psutil.Popen(["python", "-c", "print 'hi'"], stdout=PIPE)
-      >>> p.name()
-      'python'
-      >>> p.uids()
-      user(real=1000, effective=1000, saved=1000)
-      >>> p.username()
-      'giampaolo'
-      >>> p.communicate()
-      ('hi\n', None)
-      >>> p.terminate()
-      >>> p.wait(timeout=2)
-      0
-      >>>
-
-    For method names common to both classes such as kill(), terminate()
-    and wait(), psutil.Process implementation takes precedence.
-
-    Unlike subprocess.Popen this class pre-emptively checks wheter PID
-    has been reused on send_signal(), terminate() and kill() so that
-    you don't accidentally terminate another process, fixing
-    http://bugs.python.org/issue6973.
-
-    For a complete documentation refer to:
-    http://docs.python.org/library/subprocess.html
-    """
-
-    def __init__(self, *args, **kwargs):
-        # Explicitly avoid to raise NoSuchProcess in case the process
-        # spawned by subprocess.Popen terminates too quickly, see:
-        # https://github.com/giampaolo/psutil/issues/193
-        self.__subproc = subprocess.Popen(*args, **kwargs)
-        self._init(self.__subproc.pid, _ignore_nsp=True)
-
-    def __dir__(self):
-        return sorted(set(dir(Popen) + dir(subprocess.Popen)))
-
-    def __getattribute__(self, name):
-        try:
-            return object.__getattribute__(self, name)
-        except AttributeError:
-            try:
-                return object.__getattribute__(self.__subproc, name)
-            except AttributeError:
-                raise AttributeError("%s instance has no attribute '%s'"
-                                     % (self.__class__.__name__, name))
-
-    def wait(self, timeout=None):
-        if self.__subproc.returncode is not None:
-            return self.__subproc.returncode
-        ret = super(Popen, self).wait(timeout)
-        self.__subproc.returncode = ret
-        return ret
-
-
-# =====================================================================
-# --- system processes related functions
-# =====================================================================
-
-def pids():
-    """Return a list of current running PIDs."""
-    return _psplatform.pids()
-
-
-def pid_exists(pid):
-    """Return True if given PID exists in the current process list.
-    This is faster than doing "pid in psutil.pids()" and
-    should be preferred.
-    """
-    if pid < 0:
-        return False
-    elif pid == 0 and _POSIX:
-        # On POSIX we use os.kill() to determine PID existence.
-        # According to "man 2 kill" PID 0 has a special meaning
-        # though: it refers to <<every process in the process
-        # group of the calling process>> and that is not we want
-        # to do here.
-        return pid in pids()
-    else:
-        return _psplatform.pid_exists(pid)
-
-
-_pmap = {}
-
-
-def process_iter():
-    """Return a generator yielding a Process instance for all
-    running processes.
-
-    Every new Process instance is only created once and then cached
-    into an internal table which is updated every time this is used.
-
-    Cached Process instances are checked for identity so that you're
-    safe in case a PID has been reused by another process, in which
-    case the cached instance is updated.
-
-    The sorting order in which processes are yielded is based on
-    their PIDs.
-    """
-    def add(pid):
-        proc = Process(pid)
-        _pmap[proc.pid] = proc
-        return proc
-
-    def remove(pid):
-        _pmap.pop(pid, None)
-
-    a = set(pids())
-    b = set(_pmap.keys())
-    new_pids = a - b
-    gone_pids = b - a
-
-    for pid in gone_pids:
-        remove(pid)
-    for pid, proc in sorted(list(_pmap.items()) +
-                            list(dict.fromkeys(new_pids).items())):
-        try:
-            if proc is None:  # new process
-                yield add(pid)
-            else:
-                # use is_running() to check whether PID has been reused by
-                # another process in which case yield a new Process instance
-                if proc.is_running():
-                    yield proc
-                else:
-                    yield add(pid)
-        except NoSuchProcess:
-            remove(pid)
-        except AccessDenied:
-            # Process creation time can't be determined hence there's
-            # no way to tell whether the pid of the cached process
-            # has been reused. Just return the cached version.
-            yield proc
-
-
-def wait_procs(procs, timeout=None, callback=None):
-    """Convenience function which waits for a list of processes to
-    terminate.
-
-    Return a (gone, alive) tuple indicating which processes
-    are gone and which ones are still alive.
-
-    The gone ones will have a new 'returncode' attribute indicating
-    process exit status (may be None).
-
-    'callback' is a function which gets called every time a process
-    terminates (a Process instance is passed as callback argument).
-
-    Function will return as soon as all processes terminate or when
-    timeout occurs.
-
-    Typical use case is:
-
-     - send SIGTERM to a list of processes
-     - give them some time to terminate
-     - send SIGKILL to those ones which are still alive
-
-    Example:
-
-    >>> def on_terminate(proc):
-    ...     print("process {} terminated".format(proc))
-    ...
-    >>> for p in procs:
-    ...    p.terminate()
-    ...
-    >>> gone, alive = wait_procs(procs, timeout=3, callback=on_terminate)
-    >>> for p in alive:
-    ...     p.kill()
-    """
-    def check_gone(proc, timeout):
-        try:
-            returncode = proc.wait(timeout=timeout)
-        except TimeoutExpired:
-            pass
-        else:
-            if returncode is not None or not proc.is_running():
-                proc.returncode = returncode
-                gone.add(proc)
-                if callback is not None:
-                    callback(proc)
-
-    if timeout is not None and not timeout >= 0:
-        msg = "timeout must be a positive integer, got %s" % timeout
-        raise ValueError(msg)
-    gone = set()
-    alive = set(procs)
-    if callback is not None and not callable(callback):
-        raise TypeError("callback %r is not a callable" % callable)
-    if timeout is not None:
-        deadline = _timer() + timeout
-
-    while alive:
-        if timeout is not None and timeout <= 0:
-            break
-        for proc in alive:
-            # Make sure that every complete iteration (all processes)
-            # will last max 1 sec.
-            # We do this because we don't want to wait too long on a
-            # single process: in case it terminates too late other
-            # processes may disappear in the meantime and their PID
-            # reused.
-            max_timeout = 1.0 / len(alive)
-            if timeout is not None:
-                timeout = min((deadline - _timer()), max_timeout)
-                if timeout <= 0:
-                    break
-                check_gone(proc, timeout)
-            else:
-                check_gone(proc, max_timeout)
-        alive = alive - gone
-
-    if alive:
-        # Last attempt over processes survived so far.
-        # timeout == 0 won't make this function wait any further.
-        for proc in alive:
-            check_gone(proc, 0)
-        alive = alive - gone
-
-    return (list(gone), list(alive))
-
-
-# =====================================================================
-# --- CPU related functions
-# =====================================================================
-
-@memoize
-def cpu_count(logical=True):
-    """Return the number of logical CPUs in the system (same as
-    os.cpu_count() in Python 3.4).
-
-    If logical is False return the number of physical cores only
-    (hyper thread CPUs are excluded).
-
-    Return None if undetermined.
-
-    The return value is cached after first call.
-    If desired cache can be cleared like this:
-
-    >>> psutil.cpu_count.cache_clear()
-    """
-    if logical:
-        return _psplatform.cpu_count_logical()
-    else:
-        return _psplatform.cpu_count_physical()
-
-
-def cpu_times(percpu=False):
-    """Return system-wide CPU times as a namedtuple.
-    Every CPU time represents the seconds the CPU has spent in the given mode.
-    The namedtuple's fields availability varies depending on the platform:
-     - user
-     - system
-     - idle
-     - nice (UNIX)
-     - iowait (Linux)
-     - irq (Linux, FreeBSD)
-     - softirq (Linux)
-     - steal (Linux >= 2.6.11)
-     - guest (Linux >= 2.6.24)
-     - guest_nice (Linux >= 3.2.0)
-
-    When percpu is True return a list of nameduples for each CPU.
-    First element of the list refers to first CPU, second element
-    to second CPU and so on.
-    The order of the list is consistent across calls.
-    """
-    if not percpu:
-        return _psplatform.cpu_times()
-    else:
-        return _psplatform.per_cpu_times()
-
-
-_last_cpu_times = cpu_times()
-_last_per_cpu_times = cpu_times(percpu=True)
-
-
-def cpu_percent(interval=None, percpu=False):
-    """Return a float representing the current system-wide CPU
-    utilization as a percentage.
-
-    When interval is > 0.0 compares system CPU times elapsed before
-    and after the interval (blocking).
-
-    When interval is 0.0 or None compares system CPU times elapsed
-    since last call or module import, returning immediately (non
-    blocking). That means the first time this is called it will
-    return a meaningless 0.0 value which you should ignore.
-    In this case is recommended for accuracy that this function be
-    called with at least 0.1 seconds between calls.
-
-    When percpu is True returns a list of floats representing the
-    utilization as a percentage for each CPU.
-    First element of the list refers to first CPU, second element
-    to second CPU and so on.
-    The order of the list is consistent across calls.
-
-    Examples:
-
-      >>> # blocking, system-wide
-      >>> psutil.cpu_percent(interval=1)
-      2.0
-      >>>
-      >>> # blocking, per-cpu
-      >>> psutil.cpu_percent(interval=1, percpu=True)
-      [2.0, 1.0]
-      >>>
-      >>> # non-blocking (percentage since last call)
-      >>> psutil.cpu_percent(interval=None)
-      2.9
-      >>>
-    """
-    global _last_cpu_times
-    global _last_per_cpu_times
-    blocking = interval is not None and interval > 0.0
-
-    def calculate(t1, t2):
-        t1_all = sum(t1)
-        t1_busy = t1_all - t1.idle
-
-        t2_all = sum(t2)
-        t2_busy = t2_all - t2.idle
-
-        # this usually indicates a float precision issue
-        if t2_busy <= t1_busy:
-            return 0.0
-
-        busy_delta = t2_busy - t1_busy
-        all_delta = t2_all - t1_all
-        busy_perc = (busy_delta / all_delta) * 100
-        return round(busy_perc, 1)
-
-    # system-wide usage
-    if not percpu:
-        if blocking:
-            t1 = cpu_times()
-            time.sleep(interval)
-        else:
-            t1 = _last_cpu_times
-        _last_cpu_times = cpu_times()
-        return calculate(t1, _last_cpu_times)
-    # per-cpu usage
-    else:
-        ret = []
-        if blocking:
-            tot1 = cpu_times(percpu=True)
-            time.sleep(interval)
-        else:
-            tot1 = _last_per_cpu_times
-        _last_per_cpu_times = cpu_times(percpu=True)
-        for t1, t2 in zip(tot1, _last_per_cpu_times):
-            ret.append(calculate(t1, t2))
-        return ret
-
-
-# Use separate global vars for cpu_times_percent() so that it's
-# independent from cpu_percent() and they can both be used within
-# the same program.
-_last_cpu_times_2 = _last_cpu_times
-_last_per_cpu_times_2 = _last_per_cpu_times
-
-
-def cpu_times_percent(interval=None, percpu=False):
-    """Same as cpu_percent() but provides utilization percentages
-    for each specific CPU time as is returned by cpu_times().
-    For instance, on Linux we'll get:
-
-      >>> cpu_times_percent()
-      cpupercent(user=4.8, nice=0.0, system=4.8, idle=90.5, iowait=0.0,
-                 irq=0.0, softirq=0.0, steal=0.0, guest=0.0, guest_nice=0.0)
-      >>>
-
-    interval and percpu arguments have the same meaning as in
-    cpu_percent().
-    """
-    global _last_cpu_times_2
-    global _last_per_cpu_times_2
-    blocking = interval is not None and interval > 0.0
-
-    def calculate(t1, t2):
-        nums = []
-        all_delta = sum(t2) - sum(t1)
-        for field in t1._fields:
-            field_delta = getattr(t2, field) - getattr(t1, field)
-            try:
-                field_perc = (100 * field_delta) / all_delta
-            except ZeroDivisionError:
-                field_perc = 0.0
-            field_perc = round(field_perc, 1)
-            if _WINDOWS:
-                # XXX
-                # Work around:
-                # https://github.com/giampaolo/psutil/issues/392
-                # CPU times are always supposed to increase over time
-                # or at least remain the same and that's because time
-                # cannot go backwards.
-                # Surprisingly sometimes this might not be the case on
-                # Windows where 'system' CPU time can be smaller
-                # compared to the previous call, resulting in corrupted
-                # percentages (< 0 or > 100).
-                # I really don't know what to do about that except
-                # forcing the value to 0 or 100.
-                if field_perc > 100.0:
-                    field_perc = 100.0
-                elif field_perc < 0.0:
-                    field_perc = 0.0
-            nums.append(field_perc)
-        return _psplatform.scputimes(*nums)
-
-    # system-wide usage
-    if not percpu:
-        if blocking:
-            t1 = cpu_times()
-            time.sleep(interval)
-        else:
-            t1 = _last_cpu_times_2
-        _last_cpu_times_2 = cpu_times()
-        return calculate(t1, _last_cpu_times_2)
-    # per-cpu usage
-    else:
-        ret = []
-        if blocking:
-            tot1 = cpu_times(percpu=True)
-            time.sleep(interval)
-        else:
-            tot1 = _last_per_cpu_times_2
-        _last_per_cpu_times_2 = cpu_times(percpu=True)
-        for t1, t2 in zip(tot1, _last_per_cpu_times_2):
-            ret.append(calculate(t1, t2))
-        return ret
-
-
-# =====================================================================
-# --- system memory related functions
-# =====================================================================
-
-def virtual_memory():
-    """Return statistics about system memory usage as a namedtuple
-    including the following fields, expressed in bytes:
-
-     - total:
-       total physical memory available.
-
-     - available:
-       the actual amount of available memory that can be given
-       instantly to processes that request more memory in bytes; this
-       is calculated by summing different memory values depending on
-       the platform (e.g. free + buffers + cached on Linux) and it is
-       supposed to be used to monitor actual memory usage in a cross
-       platform fashion.
-
-     - percent:
-       the percentage usage calculated as (total - available) / total * 100
-
-     - used:
-       memory used, calculated differently depending on the platform and
-       designed for informational purposes only:
-        OSX: active + inactive + wired
-        BSD: active + wired + cached
-        LINUX: total - free
-
-     - free:
-       memory not being used at all (zeroed) that is readily available;
-       note that this doesn't reflect the actual memory available
-       (use 'available' instead)
-
-    Platform-specific fields:
-
-     - active (UNIX):
-       memory currently in use or very recently used, and so it is in RAM.
-
-     - inactive (UNIX):
-       memory that is marked as not used.
-
-     - buffers (BSD, Linux):
-       cache for things like file system metadata.
-
-     - cached (BSD, OSX):
-       cache for various things.
-
-     - wired (OSX, BSD):
-       memory that is marked to always stay in RAM. It is never moved to disk.
-
-     - shared (BSD):
-       memory that may be simultaneously accessed by multiple processes.
-
-    The sum of 'used' and 'available' does not necessarily equal total.
-    On Windows 'available' and 'free' are the same.
-    """
-    global _TOTAL_PHYMEM
-    ret = _psplatform.virtual_memory()
-    # cached for later use in Process.memory_percent()
-    _TOTAL_PHYMEM = ret.total
-    return ret
-
-
-def swap_memory():
-    """Return system swap memory statistics as a namedtuple including
-    the following fields:
-
-     - total:   total swap memory in bytes
-     - used:    used swap memory in bytes
-     - free:    free swap memory in bytes
-     - percent: the percentage usage
-     - sin:     no. of bytes the system has swapped in from disk (cumulative)
-     - sout:    no. of bytes the system has swapped out from disk (cumulative)
-
-    'sin' and 'sout' on Windows are meaningless and always set to 0.
-    """
-    return _psplatform.swap_memory()
-
-
-# =====================================================================
-# --- disks/paritions related functions
-# =====================================================================
-
-def disk_usage(path):
-    """Return disk usage statistics about the given path as a namedtuple
-    including total, used and free space expressed in bytes plus the
-    percentage usage.
-    """
-    return _psplatform.disk_usage(path)
-
-
-def disk_partitions(all=False):
-    """Return mounted partitions as a list of
-    (device, mountpoint, fstype, opts) namedtuple.
-    'opts' field is a raw string separated by commas indicating mount
-    options which may vary depending on the platform.
-
-    If "all" parameter is False return physical devices only and ignore
-    all others.
-    """
-    return _psplatform.disk_partitions(all)
-
-
-def disk_io_counters(perdisk=False):
-    """Return system disk I/O statistics as a namedtuple including
-    the following fields:
-
-     - read_count:  number of reads
-     - write_count: number of writes
-     - read_bytes:  number of bytes read
-     - write_bytes: number of bytes written
-     - read_time:   time spent reading from disk (in milliseconds)
-     - write_time:  time spent writing to disk (in milliseconds)
-
-    If perdisk is True return the same information for every
-    physical disk installed on the system as a dictionary
-    with partition names as the keys and the namedutuple
-    described above as the values.
-
-    On recent Windows versions 'diskperf -y' command may need to be
-    executed first otherwise this function won't find any disk.
-    """
-    rawdict = _psplatform.disk_io_counters()
-    if not rawdict:
-        raise RuntimeError("couldn't find any physical disk")
-    if perdisk:
-        for disk, fields in rawdict.items():
-            rawdict[disk] = _nt_sys_diskio(*fields)
-        return rawdict
-    else:
-        return _nt_sys_diskio(*[sum(x) for x in zip(*rawdict.values())])
-
-
-# =====================================================================
-# --- network related functions
-# =====================================================================
-
-def net_io_counters(pernic=False):
-    """Return network I/O statistics as a namedtuple including
-    the following fields:
-
-     - bytes_sent:   number of bytes sent
-     - bytes_recv:   number of bytes received
-     - packets_sent: number of packets sent
-     - packets_recv: number of packets received
-     - errin:        total number of errors while receiving
-     - errout:       total number of errors while sending
-     - dropin:       total number of incoming packets which were dropped
-     - dropout:      total number of outgoing packets which were dropped
-                     (always 0 on OSX and BSD)
-
-    If pernic is True return the same information for every
-    network interface installed on the system as a dictionary
-    with network interface names as the keys and the namedtuple
-    described above as the values.
-    """
-    rawdict = _psplatform.net_io_counters()
-    if not rawdict:
-        raise RuntimeError("couldn't find any network interface")
-    if pernic:
-        for nic, fields in rawdict.items():
-            rawdict[nic] = _nt_sys_netio(*fields)
-        return rawdict
-    else:
-        return _nt_sys_netio(*[sum(x) for x in zip(*rawdict.values())])
-
-
-def net_connections(kind='inet'):
-    """Return system-wide connections as a list of
-    (fd, family, type, laddr, raddr, status, pid) namedtuples.
-    In case of limited privileges 'fd' and 'pid' may be set to -1
-    and None respectively.
-    The 'kind' parameter filters for connections that fit the
-    following criteria:
-
-    Kind Value      Connections using
-    inet            IPv4 and IPv6
-    inet4           IPv4
-    inet6           IPv6
-    tcp             TCP
-    tcp4            TCP over IPv4
-    tcp6            TCP over IPv6
-    udp             UDP
-    udp4            UDP over IPv4
-    udp6            UDP over IPv6
-    unix            UNIX socket (both UDP and TCP protocols)
-    all             the sum of all the possible families and protocols
-    """
-    return _psplatform.net_connections(kind)
-
-
-# =====================================================================
-# --- other system related functions
-# =====================================================================
-
-
-def boot_time():
-    """Return the system boot time expressed in seconds since the epoch.
-    This is also available as psutil.BOOT_TIME.
-    """
-    # Note: we are not caching this because it is subject to
-    # system clock updates.
-    return _psplatform.boot_time()
-
-
-def users():
-    """Return users currently connected on the system as a list of
-    namedtuples including the following fields.
-
-     - user: the name of the user
-     - terminal: the tty or pseudo-tty associated with the user, if any.
-     - host: the host name associated with the entry, if any.
-     - started: the creation time as a floating point number expressed in
-       seconds since the epoch.
-    """
-    return _psplatform.users()
-
-
-# =====================================================================
-# --- deprecated functions
-# =====================================================================
-
-@_deprecated(replacement="psutil.pids()")
-def get_pid_list():
-    return pids()
-
-
-@_deprecated(replacement="list(process_iter())")
-def get_process_list():
-    return list(process_iter())
-
-
-@_deprecated(replacement="psutil.users()")
-def get_users():
-    return users()
-
-
-@_deprecated(replacement="psutil.virtual_memory()")
-def phymem_usage():
-    """Return the amount of total, used and free physical memory
-    on the system in bytes plus the percentage usage.
-    Deprecated; use psutil.virtual_memory() instead.
-    """
-    return virtual_memory()
-
-
-@_deprecated(replacement="psutil.swap_memory()")
-def virtmem_usage():
-    return swap_memory()
-
-
-@_deprecated(replacement="psutil.phymem_usage().free")
-def avail_phymem():
-    return phymem_usage().free
-
-
-@_deprecated(replacement="psutil.phymem_usage().used")
-def used_phymem():
-    return phymem_usage().used
-
-
-@_deprecated(replacement="psutil.virtmem_usage().total")
-def total_virtmem():
-    return virtmem_usage().total
-
-
-@_deprecated(replacement="psutil.virtmem_usage().used")
-def used_virtmem():
-    return virtmem_usage().used
-
-
-@_deprecated(replacement="psutil.virtmem_usage().free")
-def avail_virtmem():
-    return virtmem_usage().free
-
-
-@_deprecated(replacement="psutil.net_io_counters()")
-def network_io_counters(pernic=False):
-    return net_io_counters(pernic)
-
-
-def test():
-    """List info of all currently running processes emulating ps aux
-    output.
-    """
-    import datetime
-
-    today_day = datetime.date.today()
-    templ = "%-10s %5s %4s %4s %7s %7s %-13s %5s %7s  %s"
-    attrs = ['pid', 'cpu_percent', 'memory_percent', 'name', 'cpu_times',
-             'create_time', 'memory_info']
-    if _POSIX:
-        attrs.append('uids')
-        attrs.append('terminal')
-    print(templ % ("USER", "PID", "%CPU", "%MEM", "VSZ", "RSS", "TTY",
-                   "START", "TIME", "COMMAND"))
-    for p in process_iter():
-        try:
-            pinfo = p.as_dict(attrs, ad_value='')
-        except NoSuchProcess:
-            pass
-        else:
-            if pinfo['create_time']:
-                ctime = datetime.datetime.fromtimestamp(pinfo['create_time'])
-                if ctime.date() == today_day:
-                    ctime = ctime.strftime("%H:%M")
-                else:
-                    ctime = ctime.strftime("%b%d")
-            else:
-                ctime = ''
-            cputime = time.strftime("%M:%S",
-                                    time.localtime(sum(pinfo['cpu_times'])))
-            try:
-                user = p.username()
-            except KeyError:
-                if _POSIX:
-                    if pinfo['uids']:
-                        user = str(pinfo['uids'].real)
-                    else:
-                        user = ''
-                else:
-                    raise
-            except Error:
-                user = ''
-            if _WINDOWS and '\\' in user:
-                user = user.split('\\')[1]
-            vms = pinfo['memory_info'] and \
-                int(pinfo['memory_info'].vms / 1024) or '?'
-            rss = pinfo['memory_info'] and \
-                int(pinfo['memory_info'].rss / 1024) or '?'
-            memp = pinfo['memory_percent'] and \
-                round(pinfo['memory_percent'], 1) or '?'
-            print(templ % (
-                user[:10],
-                pinfo['pid'],
-                pinfo['cpu_percent'],
-                memp,
-                vms,
-                rss,
-                pinfo.get('terminal', '') or '?',
-                ctime,
-                cputime,
-                pinfo['name'].strip() or '?'))
-
-
-def _replace_module():
-    """Dirty hack to replace the module object in order to access
-    deprecated module constants, see:
-    http://www.dr-josiah.com/2013/12/properties-on-python-modules.html
-    """
-    class ModuleWrapper(object):
-
-        def __repr__(self):
-            return repr(self._module)
-        __str__ = __repr__
-
-        @property
-        def NUM_CPUS(self):
-            msg = "NUM_CPUS constant is deprecated; use cpu_count() instead"
-            warnings.warn(msg, category=DeprecationWarning, stacklevel=2)
-            return cpu_count()
-
-        @property
-        def BOOT_TIME(self):
-            msg = "BOOT_TIME constant is deprecated; use boot_time() instead"
-            warnings.warn(msg, category=DeprecationWarning, stacklevel=2)
-            return boot_time()
-
-        @property
-        def TOTAL_PHYMEM(self):
-            msg = "TOTAL_PHYMEM constant is deprecated; " \
-                  "use virtual_memory().total instead"
-            warnings.warn(msg, category=DeprecationWarning, stacklevel=2)
-            return virtual_memory().total
-
-    mod = ModuleWrapper()
-    mod.__dict__ = globals()
-    mod._module = sys.modules[__name__]
-    sys.modules[__name__] = mod
-
-
-_replace_module()
-del memoize, division, _replace_module
-if sys.version_info < (3, 0):
-    del num
-
-if __name__ == "__main__":
-    test()
diff --git a/io_scenario/libs/ubuntu_14_04_x64/psutil/_common.py b/io_scenario/libs/ubuntu_14_04_x64/psutil/_common.py
deleted file mode 100644
index 92d0fd0..0000000
--- a/io_scenario/libs/ubuntu_14_04_x64/psutil/_common.py
+++ /dev/null
@@ -1,256 +0,0 @@
-# /usr/bin/env python
-
-# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""Common objects shared by all _ps* modules."""
-
-from __future__ import division
-import errno
-import functools
-import os
-import socket
-import stat
-import warnings
-try:
-    import threading
-except ImportError:
-    import dummy_threading as threading
-
-from collections import namedtuple
-from socket import AF_INET, SOCK_STREAM, SOCK_DGRAM
-
-# --- constants
-
-AF_INET6 = getattr(socket, 'AF_INET6', None)
-AF_UNIX = getattr(socket, 'AF_UNIX', None)
-
-STATUS_RUNNING = "running"
-STATUS_SLEEPING = "sleeping"
-STATUS_DISK_SLEEP = "disk-sleep"
-STATUS_STOPPED = "stopped"
-STATUS_TRACING_STOP = "tracing-stop"
-STATUS_ZOMBIE = "zombie"
-STATUS_DEAD = "dead"
-STATUS_WAKE_KILL = "wake-kill"
-STATUS_WAKING = "waking"
-STATUS_IDLE = "idle"  # BSD
-STATUS_LOCKED = "locked"  # BSD
-STATUS_WAITING = "waiting"  # BSD
-
-CONN_ESTABLISHED = "ESTABLISHED"
-CONN_SYN_SENT = "SYN_SENT"
-CONN_SYN_RECV = "SYN_RECV"
-CONN_FIN_WAIT1 = "FIN_WAIT1"
-CONN_FIN_WAIT2 = "FIN_WAIT2"
-CONN_TIME_WAIT = "TIME_WAIT"
-CONN_CLOSE = "CLOSE"
-CONN_CLOSE_WAIT = "CLOSE_WAIT"
-CONN_LAST_ACK = "LAST_ACK"
-CONN_LISTEN = "LISTEN"
-CONN_CLOSING = "CLOSING"
-CONN_NONE = "NONE"
-
-
-# --- functions
-
-def usage_percent(used, total, _round=None):
-    """Calculate percentage usage of 'used' against 'total'."""
-    try:
-        ret = (used / total) * 100
-    except ZeroDivisionError:
-        ret = 0
-    if _round is not None:
-        return round(ret, _round)
-    else:
-        return ret
-
-
-def memoize(fun):
-    """A simple memoize decorator for functions supporting (hashable)
-    positional arguments.
-    It also provides a cache_clear() function for clearing the cache:
-
-    >>> @memoize
-    ... def foo()
-    ...     return 1
-    ...
-    >>> foo()
-    1
-    >>> foo.cache_clear()
-    >>>
-    """
-    @functools.wraps(fun)
-    def wrapper(*args, **kwargs):
-        key = (args, frozenset(sorted(kwargs.items())))
-        lock.acquire()
-        try:
-            try:
-                return cache[key]
-            except KeyError:
-                ret = cache[key] = fun(*args, **kwargs)
-        finally:
-            lock.release()
-        return ret
-
-    def cache_clear():
-        """Clear cache."""
-        lock.acquire()
-        try:
-            cache.clear()
-        finally:
-            lock.release()
-
-    lock = threading.RLock()
-    cache = {}
-    wrapper.cache_clear = cache_clear
-    return wrapper
-
-
-# http://code.activestate.com/recipes/577819-deprecated-decorator/
-def deprecated(replacement=None):
-    """A decorator which can be used to mark functions as deprecated."""
-    def outer(fun):
-        msg = "psutil.%s is deprecated" % fun.__name__
-        if replacement is not None:
-            msg += "; use %s instead" % replacement
-        if fun.__doc__ is None:
-            fun.__doc__ = msg
-
-        @functools.wraps(fun)
-        def inner(*args, **kwargs):
-            warnings.warn(msg, category=DeprecationWarning, stacklevel=2)
-            return fun(*args, **kwargs)
-
-        return inner
-    return outer
-
-
-def deprecated_method(replacement):
-    """A decorator which can be used to mark a method as deprecated
-    'replcement' is the method name which will be called instead.
-    """
-    def outer(fun):
-        msg = "%s() is deprecated; use %s() instead" % (
-            fun.__name__, replacement)
-        if fun.__doc__ is None:
-            fun.__doc__ = msg
-
-        @functools.wraps(fun)
-        def inner(self, *args, **kwargs):
-            warnings.warn(msg, category=DeprecationWarning, stacklevel=2)
-            return getattr(self, replacement)(*args, **kwargs)
-        return inner
-    return outer
-
-
-def isfile_strict(path):
-    """Same as os.path.isfile() but does not swallow EACCES / EPERM
-    exceptions, see:
-    http://mail.python.org/pipermail/python-dev/2012-June/120787.html
-    """
-    try:
-        st = os.stat(path)
-    except OSError as err:
-        if err.errno in (errno.EPERM, errno.EACCES):
-            raise
-        return False
-    else:
-        return stat.S_ISREG(st.st_mode)
-
-
-# --- Process.connections() 'kind' parameter mapping
-
-conn_tmap = {
-    "all": ([AF_INET, AF_INET6, AF_UNIX], [SOCK_STREAM, SOCK_DGRAM]),
-    "tcp": ([AF_INET, AF_INET6], [SOCK_STREAM]),
-    "tcp4": ([AF_INET], [SOCK_STREAM]),
-    "udp": ([AF_INET, AF_INET6], [SOCK_DGRAM]),
-    "udp4": ([AF_INET], [SOCK_DGRAM]),
-    "inet": ([AF_INET, AF_INET6], [SOCK_STREAM, SOCK_DGRAM]),
-    "inet4": ([AF_INET], [SOCK_STREAM, SOCK_DGRAM]),
-    "inet6": ([AF_INET6], [SOCK_STREAM, SOCK_DGRAM]),
-}
-
-if AF_INET6 is not None:
-    conn_tmap.update({
-        "tcp6": ([AF_INET6], [SOCK_STREAM]),
-        "udp6": ([AF_INET6], [SOCK_DGRAM]),
-    })
-
-if AF_UNIX is not None:
-    conn_tmap.update({
-        "unix": ([AF_UNIX], [SOCK_STREAM, SOCK_DGRAM]),
-    })
-
-del AF_INET, AF_INET6, AF_UNIX, SOCK_STREAM, SOCK_DGRAM, socket
-
-
-# --- namedtuples for psutil.* system-related functions
-
-# psutil.swap_memory()
-sswap = namedtuple('sswap', ['total', 'used', 'free', 'percent', 'sin',
-                             'sout'])
-# psutil.disk_usage()
-sdiskusage = namedtuple('sdiskusage', ['total', 'used', 'free', 'percent'])
-# psutil.disk_io_counters()
-sdiskio = namedtuple('sdiskio', ['read_count', 'write_count',
-                                 'read_bytes', 'write_bytes',
-                                 'read_time', 'write_time'])
-# psutil.disk_partitions()
-sdiskpart = namedtuple('sdiskpart', ['device', 'mountpoint', 'fstype', 'opts'])
-# psutil.net_io_counters()
-snetio = namedtuple('snetio', ['bytes_sent', 'bytes_recv',
-                               'packets_sent', 'packets_recv',
-                               'errin', 'errout',
-                               'dropin', 'dropout'])
-# psutil.users()
-suser = namedtuple('suser', ['name', 'terminal', 'host', 'started'])
-# psutil.net_connections()
-sconn = namedtuple('sconn', ['fd', 'family', 'type', 'laddr', 'raddr',
-                             'status', 'pid'])
-
-
-# --- namedtuples for psutil.Process methods
-
-# psutil.Process.memory_info()
-pmem = namedtuple('pmem', ['rss', 'vms'])
-# psutil.Process.cpu_times()
-pcputimes = namedtuple('pcputimes', ['user', 'system'])
-# psutil.Process.open_files()
-popenfile = namedtuple('popenfile', ['path', 'fd'])
-# psutil.Process.threads()
-pthread = namedtuple('pthread', ['id', 'user_time', 'system_time'])
-# psutil.Process.uids()
-puids = namedtuple('puids', ['real', 'effective', 'saved'])
-# psutil.Process.gids()
-pgids = namedtuple('pgids', ['real', 'effective', 'saved'])
-# psutil.Process.io_counters()
-pio = namedtuple('pio', ['read_count', 'write_count',
-                         'read_bytes', 'write_bytes'])
-# psutil.Process.ionice()
-pionice = namedtuple('pionice', ['ioclass', 'value'])
-# psutil.Process.ctx_switches()
-pctxsw = namedtuple('pctxsw', ['voluntary', 'involuntary'])
-
-
-# --- misc
-
-# backward compatibility layer for Process.connections() ntuple
-class pconn(
-    namedtuple('pconn',
-               ['fd', 'family', 'type', 'laddr', 'raddr', 'status'])):
-    __slots__ = ()
-
-    @property
-    def local_address(self):
-        warnings.warn("'local_address' field is deprecated; use 'laddr'"
-                      "instead", category=DeprecationWarning, stacklevel=2)
-        return self.laddr
-
-    @property
-    def remote_address(self):
-        warnings.warn("'remote_address' field is deprecated; use 'raddr'"
-                      "instead", category=DeprecationWarning, stacklevel=2)
-        return self.raddr
diff --git a/io_scenario/libs/ubuntu_14_04_x64/psutil/_compat.py b/io_scenario/libs/ubuntu_14_04_x64/psutil/_compat.py
deleted file mode 100644
index 84fd9ca..0000000
--- a/io_scenario/libs/ubuntu_14_04_x64/psutil/_compat.py
+++ /dev/null
@@ -1,203 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""Module which provides compatibility with older Python versions."""
-
-__all__ = ["PY3", "int", "long", "xrange", "exec_", "callable", "lru_cache"]
-
-import collections
-import functools
-import sys
-try:
-    import __builtin__
-except ImportError:
-    import builtins as __builtin__  # py3
-
-PY3 = sys.version_info[0] == 3
-
-if PY3:
-    int = int
-    long = int
-    xrange = range
-    unicode = str
-    basestring = str
-    exec_ = getattr(__builtin__, "exec")
-else:
-    int = int
-    long = long
-    xrange = xrange
-    unicode = unicode
-    basestring = basestring
-
-    def exec_(code, globs=None, locs=None):
-        if globs is None:
-            frame = sys._getframe(1)
-            globs = frame.f_globals
-            if locs is None:
-                locs = frame.f_locals
-            del frame
-        elif locs is None:
-            locs = globs
-        exec("""exec code in globs, locs""")
-
-
-# removed in 3.0, reintroduced in 3.2
-try:
-    callable = callable
-except NameError:
-    def callable(obj):
-        return any("__call__" in klass.__dict__ for klass in type(obj).__mro__)
-
-
-# --- stdlib additions
-
-
-# py 3.2 functools.lru_cache
-# Taken from: http://code.activestate.com/recipes/578078
-# Credit: Raymond Hettinger
-try:
-    from functools import lru_cache
-except ImportError:
-    try:
-        from threading import RLock
-    except ImportError:
-        from dummy_threading import RLock
-
-    _CacheInfo = collections.namedtuple(
-        "CacheInfo", ["hits", "misses", "maxsize", "currsize"])
-
-    class _HashedSeq(list):
-        __slots__ = 'hashvalue'
-
-        def __init__(self, tup, hash=hash):
-            self[:] = tup
-            self.hashvalue = hash(tup)
-
-        def __hash__(self):
-            return self.hashvalue
-
-    def _make_key(args, kwds, typed,
-                  kwd_mark=(object(), ),
-                  fasttypes=set((int, str, frozenset, type(None))),
-                  sorted=sorted, tuple=tuple, type=type, len=len):
-        key = args
-        if kwds:
-            sorted_items = sorted(kwds.items())
-            key += kwd_mark
-            for item in sorted_items:
-                key += item
-        if typed:
-            key += tuple(type(v) for v in args)
-            if kwds:
-                key += tuple(type(v) for k, v in sorted_items)
-        elif len(key) == 1 and type(key[0]) in fasttypes:
-            return key[0]
-        return _HashedSeq(key)
-
-    def lru_cache(maxsize=100, typed=False):
-        """Least-recently-used cache decorator, see:
-        http://docs.python.org/3/library/functools.html#functools.lru_cache
-        """
-        def decorating_function(user_function):
-            cache = dict()
-            stats = [0, 0]
-            HITS, MISSES = 0, 1
-            make_key = _make_key
-            cache_get = cache.get
-            _len = len
-            lock = RLock()
-            root = []
-            root[:] = [root, root, None, None]
-            nonlocal_root = [root]
-            PREV, NEXT, KEY, RESULT = 0, 1, 2, 3
-            if maxsize == 0:
-                def wrapper(*args, **kwds):
-                    result = user_function(*args, **kwds)
-                    stats[MISSES] += 1
-                    return result
-            elif maxsize is None:
-                def wrapper(*args, **kwds):
-                    key = make_key(args, kwds, typed)
-                    result = cache_get(key, root)
-                    if result is not root:
-                        stats[HITS] += 1
-                        return result
-                    result = user_function(*args, **kwds)
-                    cache[key] = result
-                    stats[MISSES] += 1
-                    return result
-            else:
-                def wrapper(*args, **kwds):
-                    if kwds or typed:
-                        key = make_key(args, kwds, typed)
-                    else:
-                        key = args
-                    lock.acquire()
-                    try:
-                        link = cache_get(key)
-                        if link is not None:
-                            root, = nonlocal_root
-                            link_prev, link_next, key, result = link
-                            link_prev[NEXT] = link_next
-                            link_next[PREV] = link_prev
-                            last = root[PREV]
-                            last[NEXT] = root[PREV] = link
-                            link[PREV] = last
-                            link[NEXT] = root
-                            stats[HITS] += 1
-                            return result
-                    finally:
-                        lock.release()
-                    result = user_function(*args, **kwds)
-                    lock.acquire()
-                    try:
-                        root, = nonlocal_root
-                        if key in cache:
-                            pass
-                        elif _len(cache) >= maxsize:
-                            oldroot = root
-                            oldroot[KEY] = key
-                            oldroot[RESULT] = result
-                            root = nonlocal_root[0] = oldroot[NEXT]
-                            oldkey = root[KEY]
-                            root[KEY] = root[RESULT] = None
-                            del cache[oldkey]
-                            cache[key] = oldroot
-                        else:
-                            last = root[PREV]
-                            link = [last, root, key, result]
-                            last[NEXT] = root[PREV] = cache[key] = link
-                        stats[MISSES] += 1
-                    finally:
-                        lock.release()
-                    return result
-
-            def cache_info():
-                """Report cache statistics"""
-                lock.acquire()
-                try:
-                    return _CacheInfo(stats[HITS], stats[MISSES], maxsize,
-                                      len(cache))
-                finally:
-                    lock.release()
-
-            def cache_clear():
-                """Clear the cache and cache statistics"""
-                lock.acquire()
-                try:
-                    cache.clear()
-                    root = nonlocal_root[0]
-                    root[:] = [root, root, None, None]
-                    stats[:] = [0, 0]
-                finally:
-                    lock.release()
-
-            wrapper.__wrapped__ = user_function
-            wrapper.cache_info = cache_info
-            wrapper.cache_clear = cache_clear
-            return functools.update_wrapper(wrapper, user_function)
-
-        return decorating_function
diff --git a/io_scenario/libs/ubuntu_14_04_x64/psutil/_psbsd.py b/io_scenario/libs/ubuntu_14_04_x64/psutil/_psbsd.py
deleted file mode 100644
index 87ae211..0000000
--- a/io_scenario/libs/ubuntu_14_04_x64/psutil/_psbsd.py
+++ /dev/null
@@ -1,410 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""FreeBSD platform implementation."""
-
-import errno
-import functools
-import os
-import sys
-from collections import namedtuple
-
-from psutil import _common
-from psutil import _psposix
-from psutil._common import conn_tmap, usage_percent
-import _psutil_bsd as cext
-import _psutil_posix
-
-
-__extra__all__ = []
-
-# --- constants
-
-PROC_STATUSES = {
-    cext.SSTOP: _common.STATUS_STOPPED,
-    cext.SSLEEP: _common.STATUS_SLEEPING,
-    cext.SRUN: _common.STATUS_RUNNING,
-    cext.SIDL: _common.STATUS_IDLE,
-    cext.SWAIT: _common.STATUS_WAITING,
-    cext.SLOCK: _common.STATUS_LOCKED,
-    cext.SZOMB: _common.STATUS_ZOMBIE,
-}
-
-TCP_STATUSES = {
-    cext.TCPS_ESTABLISHED: _common.CONN_ESTABLISHED,
-    cext.TCPS_SYN_SENT: _common.CONN_SYN_SENT,
-    cext.TCPS_SYN_RECEIVED: _common.CONN_SYN_RECV,
-    cext.TCPS_FIN_WAIT_1: _common.CONN_FIN_WAIT1,
-    cext.TCPS_FIN_WAIT_2: _common.CONN_FIN_WAIT2,
-    cext.TCPS_TIME_WAIT: _common.CONN_TIME_WAIT,
-    cext.TCPS_CLOSED: _common.CONN_CLOSE,
-    cext.TCPS_CLOSE_WAIT: _common.CONN_CLOSE_WAIT,
-    cext.TCPS_LAST_ACK: _common.CONN_LAST_ACK,
-    cext.TCPS_LISTEN: _common.CONN_LISTEN,
-    cext.TCPS_CLOSING: _common.CONN_CLOSING,
-    cext.PSUTIL_CONN_NONE: _common.CONN_NONE,
-}
-
-PAGESIZE = os.sysconf("SC_PAGE_SIZE")
-
-# extend base mem ntuple with BSD-specific memory metrics
-svmem = namedtuple(
-    'svmem', ['total', 'available', 'percent', 'used', 'free',
-              'active', 'inactive', 'buffers', 'cached', 'shared', 'wired'])
-scputimes = namedtuple(
-    'scputimes', ['user', 'nice', 'system', 'idle', 'irq'])
-pextmem = namedtuple('pextmem', ['rss', 'vms', 'text', 'data', 'stack'])
-pmmap_grouped = namedtuple(
-    'pmmap_grouped', 'path rss, private, ref_count, shadow_count')
-pmmap_ext = namedtuple(
-    'pmmap_ext', 'addr, perms path rss, private, ref_count, shadow_count')
-
-# set later from __init__.py
-NoSuchProcess = None
-AccessDenied = None
-TimeoutExpired = None
-
-
-def virtual_memory():
-    """System virtual memory as a namedtuple."""
-    mem = cext.virtual_mem()
-    total, free, active, inactive, wired, cached, buffers, shared = mem
-    avail = inactive + cached + free
-    used = active + wired + cached
-    percent = usage_percent((total - avail), total, _round=1)
-    return svmem(total, avail, percent, used, free,
-                 active, inactive, buffers, cached, shared, wired)
-
-
-def swap_memory():
-    """System swap memory as (total, used, free, sin, sout) namedtuple."""
-    total, used, free, sin, sout = [x * PAGESIZE for x in cext.swap_mem()]
-    percent = usage_percent(used, total, _round=1)
-    return _common.sswap(total, used, free, percent, sin, sout)
-
-
-def cpu_times():
-    """Return system per-CPU times as a namedtuple"""
-    user, nice, system, idle, irq = cext.cpu_times()
-    return scputimes(user, nice, system, idle, irq)
-
-
-if hasattr(cext, "per_cpu_times"):
-    def per_cpu_times():
-        """Return system CPU times as a namedtuple"""
-        ret = []
-        for cpu_t in cext.per_cpu_times():
-            user, nice, system, idle, irq = cpu_t
-            item = scputimes(user, nice, system, idle, irq)
-            ret.append(item)
-        return ret
-else:
-    # XXX
-    # Ok, this is very dirty.
-    # On FreeBSD < 8 we cannot gather per-cpu information, see:
-    # https://github.com/giampaolo/psutil/issues/226
-    # If num cpus > 1, on first call we return single cpu times to avoid a
-    # crash at psutil import time.
-    # Next calls will fail with NotImplementedError
-    def per_cpu_times():
-        if cpu_count_logical() == 1:
-            return [cpu_times()]
-        if per_cpu_times.__called__:
-            raise NotImplementedError("supported only starting from FreeBSD 8")
-        per_cpu_times.__called__ = True
-        return [cpu_times()]
-
-    per_cpu_times.__called__ = False
-
-
-def cpu_count_logical():
-    """Return the number of logical CPUs in the system."""
-    return cext.cpu_count_logical()
-
-
-def cpu_count_physical():
-    """Return the number of physical CPUs in the system."""
-    # From the C module we'll get an XML string similar to this:
-    # http://manpages.ubuntu.com/manpages/precise/man4/smp.4freebsd.html
-    # We may get None in case "sysctl kern.sched.topology_spec"
-    # is not supported on this BSD version, in which case we'll mimic
-    # os.cpu_count() and return None.
-    s = cext.cpu_count_phys()
-    if s is not None:
-        # get rid of padding chars appended at the end of the string
-        index = s.rfind("</groups>")
-        if index != -1:
-            s = s[:index + 9]
-            if sys.version_info >= (2, 5):
-                import xml.etree.ElementTree as ET
-                root = ET.fromstring(s)
-                return len(root.findall('group/children/group/cpu')) or None
-            else:
-                s = s[s.find('<children>'):]
-                return s.count("<cpu") or None
-
-
-def boot_time():
-    """The system boot time expressed in seconds since the epoch."""
-    return cext.boot_time()
-
-
-def disk_partitions(all=False):
-    retlist = []
-    partitions = cext.disk_partitions()
-    for partition in partitions:
-        device, mountpoint, fstype, opts = partition
-        if device == 'none':
-            device = ''
-        if not all:
-            if not os.path.isabs(device) or not os.path.exists(device):
-                continue
-        ntuple = _common.sdiskpart(device, mountpoint, fstype, opts)
-        retlist.append(ntuple)
-    return retlist
-
-
-def users():
-    retlist = []
-    rawlist = cext.users()
-    for item in rawlist:
-        user, tty, hostname, tstamp = item
-        if tty == '~':
-            continue  # reboot or shutdown
-        nt = _common.suser(user, tty or None, hostname, tstamp)
-        retlist.append(nt)
-    return retlist
-
-
-def net_connections(kind):
-    if kind not in _common.conn_tmap:
-        raise ValueError("invalid %r kind argument; choose between %s"
-                         % (kind, ', '.join([repr(x) for x in conn_tmap])))
-    families, types = conn_tmap[kind]
-    ret = []
-    rawlist = cext.net_connections()
-    for item in rawlist:
-        fd, fam, type, laddr, raddr, status, pid = item
-        # TODO: apply filter at C level
-        if fam in families and type in types:
-            status = TCP_STATUSES[status]
-            nt = _common.sconn(fd, fam, type, laddr, raddr, status, pid)
-            ret.append(nt)
-    return ret
-
-
-pids = cext.pids
-pid_exists = _psposix.pid_exists
-disk_usage = _psposix.disk_usage
-net_io_counters = cext.net_io_counters
-disk_io_counters = cext.disk_io_counters
-
-
-def wrap_exceptions(fun):
-    """Decorator which translates bare OSError exceptions into
-    NoSuchProcess and AccessDenied.
-    """
-    @functools.wraps(fun)
-    def wrapper(self, *args, **kwargs):
-        try:
-            return fun(self, *args, **kwargs)
-        except OSError as err:
-            # support for private module import
-            if NoSuchProcess is None or AccessDenied is None:
-                raise
-            if err.errno == errno.ESRCH:
-                raise NoSuchProcess(self.pid, self._name)
-            if err.errno in (errno.EPERM, errno.EACCES):
-                raise AccessDenied(self.pid, self._name)
-            raise
-    return wrapper
-
-
-class Process(object):
-    """Wrapper class around underlying C implementation."""
-
-    __slots__ = ["pid", "_name"]
-
-    def __init__(self, pid):
-        self.pid = pid
-        self._name = None
-
-    @wrap_exceptions
-    def name(self):
-        return cext.proc_name(self.pid)
-
-    @wrap_exceptions
-    def exe(self):
-        return cext.proc_exe(self.pid)
-
-    @wrap_exceptions
-    def cmdline(self):
-        return cext.proc_cmdline(self.pid)
-
-    @wrap_exceptions
-    def terminal(self):
-        tty_nr = cext.proc_tty_nr(self.pid)
-        tmap = _psposix._get_terminal_map()
-        try:
-            return tmap[tty_nr]
-        except KeyError:
-            return None
-
-    @wrap_exceptions
-    def ppid(self):
-        return cext.proc_ppid(self.pid)
-
-    @wrap_exceptions
-    def uids(self):
-        real, effective, saved = cext.proc_uids(self.pid)
-        return _common.puids(real, effective, saved)
-
-    @wrap_exceptions
-    def gids(self):
-        real, effective, saved = cext.proc_gids(self.pid)
-        return _common.pgids(real, effective, saved)
-
-    @wrap_exceptions
-    def cpu_times(self):
-        user, system = cext.proc_cpu_times(self.pid)
-        return _common.pcputimes(user, system)
-
-    @wrap_exceptions
-    def memory_info(self):
-        rss, vms = cext.proc_memory_info(self.pid)[:2]
-        return _common.pmem(rss, vms)
-
-    @wrap_exceptions
-    def memory_info_ex(self):
-        return pextmem(*cext.proc_memory_info(self.pid))
-
-    @wrap_exceptions
-    def create_time(self):
-        return cext.proc_create_time(self.pid)
-
-    @wrap_exceptions
-    def num_threads(self):
-        return cext.proc_num_threads(self.pid)
-
-    @wrap_exceptions
-    def num_ctx_switches(self):
-        return _common.pctxsw(*cext.proc_num_ctx_switches(self.pid))
-
-    @wrap_exceptions
-    def threads(self):
-        rawlist = cext.proc_threads(self.pid)
-        retlist = []
-        for thread_id, utime, stime in rawlist:
-            ntuple = _common.pthread(thread_id, utime, stime)
-            retlist.append(ntuple)
-        return retlist
-
-    @wrap_exceptions
-    def connections(self, kind='inet'):
-        if kind not in conn_tmap:
-            raise ValueError("invalid %r kind argument; choose between %s"
-                             % (kind, ', '.join([repr(x) for x in conn_tmap])))
-        families, types = conn_tmap[kind]
-        rawlist = cext.proc_connections(self.pid, families, types)
-        ret = []
-        for item in rawlist:
-            fd, fam, type, laddr, raddr, status = item
-            status = TCP_STATUSES[status]
-            nt = _common.pconn(fd, fam, type, laddr, raddr, status)
-            ret.append(nt)
-        return ret
-
-    @wrap_exceptions
-    def wait(self, timeout=None):
-        try:
-            return _psposix.wait_pid(self.pid, timeout)
-        except _psposix.TimeoutExpired:
-            # support for private module import
-            if TimeoutExpired is None:
-                raise
-            raise TimeoutExpired(timeout, self.pid, self._name)
-
-    @wrap_exceptions
-    def nice_get(self):
-        return _psutil_posix.getpriority(self.pid)
-
-    @wrap_exceptions
-    def nice_set(self, value):
-        return _psutil_posix.setpriority(self.pid, value)
-
-    @wrap_exceptions
-    def status(self):
-        code = cext.proc_status(self.pid)
-        if code in PROC_STATUSES:
-            return PROC_STATUSES[code]
-        # XXX is this legit? will we even ever get here?
-        return "?"
-
-    @wrap_exceptions
-    def io_counters(self):
-        rc, wc, rb, wb = cext.proc_io_counters(self.pid)
-        return _common.pio(rc, wc, rb, wb)
-
-    nt_mmap_grouped = namedtuple(
-        'mmap', 'path rss, private, ref_count, shadow_count')
-    nt_mmap_ext = namedtuple(
-        'mmap', 'addr, perms path rss, private, ref_count, shadow_count')
-
-    # FreeBSD < 8 does not support functions based on kinfo_getfile()
-    # and kinfo_getvmmap()
-    if hasattr(cext, 'proc_open_files'):
-
-        @wrap_exceptions
-        def open_files(self):
-            """Return files opened by process as a list of namedtuples."""
-            rawlist = cext.proc_open_files(self.pid)
-            return [_common.popenfile(path, fd) for path, fd in rawlist]
-
-        @wrap_exceptions
-        def cwd(self):
-            """Return process current working directory."""
-            # sometimes we get an empty string, in which case we turn
-            # it into None
-            return cext.proc_cwd(self.pid) or None
-
-        @wrap_exceptions
-        def memory_maps(self):
-            return cext.proc_memory_maps(self.pid)
-
-        @wrap_exceptions
-        def num_fds(self):
-            """Return the number of file descriptors opened by this process."""
-            return cext.proc_num_fds(self.pid)
-
-    else:
-        def _not_implemented(self):
-            raise NotImplementedError("supported only starting from FreeBSD 8")
-
-        open_files = _not_implemented
-        proc_cwd = _not_implemented
-        memory_maps = _not_implemented
-        num_fds = _not_implemented
-
-    @wrap_exceptions
-    def cpu_affinity_get(self):
-        return cext.proc_cpu_affinity_get(self.pid)
-
-    @wrap_exceptions
-    def cpu_affinity_set(self, cpus):
-        try:
-            cext.proc_cpu_affinity_set(self.pid, cpus)
-        except OSError as err:
-            # 'man cpuset_setaffinity' about EDEADLK:
-            # <<the call would leave a thread without a valid CPU to run
-            # on because the set does not overlap with the thread's
-            # anonymous mask>>
-            if err.errno in (errno.EINVAL, errno.EDEADLK):
-                allcpus = tuple(range(len(per_cpu_times())))
-                for cpu in cpus:
-                    if cpu not in allcpus:
-                        raise ValueError("invalid CPU #%i (choose between %s)"
-                                         % (cpu, allcpus))
-            raise
diff --git a/io_scenario/libs/ubuntu_14_04_x64/psutil/_pslinux.py b/io_scenario/libs/ubuntu_14_04_x64/psutil/_pslinux.py
deleted file mode 100644
index 6bde29e..0000000
--- a/io_scenario/libs/ubuntu_14_04_x64/psutil/_pslinux.py
+++ /dev/null
@@ -1,1096 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""Linux platform implementation."""
-
-from __future__ import division
-
-import base64
-import errno
-import functools
-import os
-import re
-import socket
-import struct
-import sys
-import warnings
-from collections import namedtuple, defaultdict
-
-from psutil import _common
-from psutil import _psposix
-from psutil._common import (isfile_strict, usage_percent, deprecated)
-from psutil._compat import PY3
-import _psutil_linux as cext
-import _psutil_posix
-
-
-__extra__all__ = [
-    # io prio constants
-    "IOPRIO_CLASS_NONE", "IOPRIO_CLASS_RT", "IOPRIO_CLASS_BE",
-    "IOPRIO_CLASS_IDLE",
-    # connection status constants
-    "CONN_ESTABLISHED", "CONN_SYN_SENT", "CONN_SYN_RECV", "CONN_FIN_WAIT1",
-    "CONN_FIN_WAIT2", "CONN_TIME_WAIT", "CONN_CLOSE", "CONN_CLOSE_WAIT",
-    "CONN_LAST_ACK", "CONN_LISTEN", "CONN_CLOSING",
-    # other
-    "phymem_buffers", "cached_phymem"]
-
-
-# --- constants
-
-HAS_PRLIMIT = hasattr(cext, "linux_prlimit")
-
-# RLIMIT_* constants, not guaranteed to be present on all kernels
-if HAS_PRLIMIT:
-    for name in dir(cext):
-        if name.startswith('RLIM'):
-            __extra__all__.append(name)
-
-# Number of clock ticks per second
-CLOCK_TICKS = os.sysconf("SC_CLK_TCK")
-PAGESIZE = os.sysconf("SC_PAGE_SIZE")
-BOOT_TIME = None  # set later
-DEFAULT_ENCODING = sys.getdefaultencoding()
-
-# ioprio_* constants http://linux.die.net/man/2/ioprio_get
-IOPRIO_CLASS_NONE = 0
-IOPRIO_CLASS_RT = 1
-IOPRIO_CLASS_BE = 2
-IOPRIO_CLASS_IDLE = 3
-
-# taken from /fs/proc/array.c
-PROC_STATUSES = {
-    "R": _common.STATUS_RUNNING,
-    "S": _common.STATUS_SLEEPING,
-    "D": _common.STATUS_DISK_SLEEP,
-    "T": _common.STATUS_STOPPED,
-    "t": _common.STATUS_TRACING_STOP,
-    "Z": _common.STATUS_ZOMBIE,
-    "X": _common.STATUS_DEAD,
-    "x": _common.STATUS_DEAD,
-    "K": _common.STATUS_WAKE_KILL,
-    "W": _common.STATUS_WAKING
-}
-
-# http://students.mimuw.edu.pl/lxr/source/include/net/tcp_states.h
-TCP_STATUSES = {
-    "01": _common.CONN_ESTABLISHED,
-    "02": _common.CONN_SYN_SENT,
-    "03": _common.CONN_SYN_RECV,
-    "04": _common.CONN_FIN_WAIT1,
-    "05": _common.CONN_FIN_WAIT2,
-    "06": _common.CONN_TIME_WAIT,
-    "07": _common.CONN_CLOSE,
-    "08": _common.CONN_CLOSE_WAIT,
-    "09": _common.CONN_LAST_ACK,
-    "0A": _common.CONN_LISTEN,
-    "0B": _common.CONN_CLOSING
-}
-
-# set later from __init__.py
-NoSuchProcess = None
-AccessDenied = None
-TimeoutExpired = None
-
-
-# --- named tuples
-
-def _get_cputimes_fields():
-    """Return a namedtuple of variable fields depending on the
-    CPU times available on this Linux kernel version which may be:
-    (user, nice, system, idle, iowait, irq, softirq, [steal, [guest,
-     [guest_nice]]])
-    """
-    with open('/proc/stat', 'rb') as f:
-        values = f.readline().split()[1:]
-    fields = ['user', 'nice', 'system', 'idle', 'iowait', 'irq', 'softirq']
-    vlen = len(values)
-    if vlen >= 8:
-        # Linux >= 2.6.11
-        fields.append('steal')
-    if vlen >= 9:
-        # Linux >= 2.6.24
-        fields.append('guest')
-    if vlen >= 10:
-        # Linux >= 3.2.0
-        fields.append('guest_nice')
-    return fields
-
-
-scputimes = namedtuple('scputimes', _get_cputimes_fields())
-
-svmem = namedtuple(
-    'svmem', ['total', 'available', 'percent', 'used', 'free',
-              'active', 'inactive', 'buffers', 'cached'])
-
-pextmem = namedtuple('pextmem', 'rss vms shared text lib data dirty')
-
-pmmap_grouped = namedtuple(
-    'pmmap_grouped', ['path', 'rss', 'size', 'pss', 'shared_clean',
-                      'shared_dirty', 'private_clean', 'private_dirty',
-                      'referenced', 'anonymous', 'swap'])
-
-pmmap_ext = namedtuple(
-    'pmmap_ext', 'addr perms ' + ' '.join(pmmap_grouped._fields))
-
-
-# --- system memory
-
-def virtual_memory():
-    total, free, buffers, shared, _, _ = cext.linux_sysinfo()
-    cached = active = inactive = None
-    with open('/proc/meminfo', 'rb') as f:
-        for line in f:
-            if line.startswith(b"Cached:"):
-                cached = int(line.split()[1]) * 1024
-            elif line.startswith(b"Active:"):
-                active = int(line.split()[1]) * 1024
-            elif line.startswith(b"Inactive:"):
-                inactive = int(line.split()[1]) * 1024
-            if (cached is not None
-                    and active is not None
-                    and inactive is not None):
-                break
-        else:
-            # we might get here when dealing with exotic Linux flavors, see:
-            # https://github.com/giampaolo/psutil/issues/313
-            msg = "'cached', 'active' and 'inactive' memory stats couldn't " \
-                  "be determined and were set to 0"
-            warnings.warn(msg, RuntimeWarning)
-            cached = active = inactive = 0
-    avail = free + buffers + cached
-    used = total - free
-    percent = usage_percent((total - avail), total, _round=1)
-    return svmem(total, avail, percent, used, free,
-                 active, inactive, buffers, cached)
-
-
-def swap_memory():
-    _, _, _, _, total, free = cext.linux_sysinfo()
-    used = total - free
-    percent = usage_percent(used, total, _round=1)
-    # get pgin/pgouts
-    with open("/proc/vmstat", "rb") as f:
-        sin = sout = None
-        for line in f:
-            # values are expressed in 4 kilo bytes, we want bytes instead
-            if line.startswith(b'pswpin'):
-                sin = int(line.split(b' ')[1]) * 4 * 1024
-            elif line.startswith(b'pswpout'):
-                sout = int(line.split(b' ')[1]) * 4 * 1024
-            if sin is not None and sout is not None:
-                break
-        else:
-            # we might get here when dealing with exotic Linux flavors, see:
-            # https://github.com/giampaolo/psutil/issues/313
-            msg = "'sin' and 'sout' swap memory stats couldn't " \
-                  "be determined and were set to 0"
-            warnings.warn(msg, RuntimeWarning)
-            sin = sout = 0
-    return _common.sswap(total, used, free, percent, sin, sout)
-
-
-@deprecated(replacement='psutil.virtual_memory().cached')
-def cached_phymem():
-    return virtual_memory().cached
-
-
-@deprecated(replacement='psutil.virtual_memory().buffers')
-def phymem_buffers():
-    return virtual_memory().buffers
-
-
-# --- CPUs
-
-def cpu_times():
-    """Return a named tuple representing the following system-wide
-    CPU times:
-    (user, nice, system, idle, iowait, irq, softirq [steal, [guest,
-     [guest_nice]]])
-    Last 3 fields may not be available on all Linux kernel versions.
-    """
-    with open('/proc/stat', 'rb') as f:
-        values = f.readline().split()
-    fields = values[1:len(scputimes._fields) + 1]
-    fields = [float(x) / CLOCK_TICKS for x in fields]
-    return scputimes(*fields)
-
-
-def per_cpu_times():
-    """Return a list of namedtuple representing the CPU times
-    for every CPU available on the system.
-    """
-    cpus = []
-    with open('/proc/stat', 'rb') as f:
-        # get rid of the first line which refers to system wide CPU stats
-        f.readline()
-        for line in f:
-            if line.startswith(b'cpu'):
-                values = line.split()
-                fields = values[1:len(scputimes._fields) + 1]
-                fields = [float(x) / CLOCK_TICKS for x in fields]
-                entry = scputimes(*fields)
-                cpus.append(entry)
-        return cpus
-
-
-def cpu_count_logical():
-    """Return the number of logical CPUs in the system."""
-    try:
-        return os.sysconf("SC_NPROCESSORS_ONLN")
-    except ValueError:
-        # as a second fallback we try to parse /proc/cpuinfo
-        num = 0
-        with open('/proc/cpuinfo', 'rb') as f:
-            for line in f:
-                if line.lower().startswith(b'processor'):
-                    num += 1
-
-        # unknown format (e.g. amrel/sparc architectures), see:
-        # https://github.com/giampaolo/psutil/issues/200
-        # try to parse /proc/stat as a last resort
-        if num == 0:
-            search = re.compile('cpu\d')
-            with open('/proc/stat', 'rt') as f:
-                for line in f:
-                    line = line.split(' ')[0]
-                    if search.match(line):
-                        num += 1
-
-        if num == 0:
-            # mimic os.cpu_count()
-            return None
-        return num
-
-
-def cpu_count_physical():
-    """Return the number of physical CPUs in the system."""
-    with open('/proc/cpuinfo', 'rb') as f:
-        found = set()
-        for line in f:
-            if line.lower().startswith(b'physical id'):
-                found.add(line.strip())
-    # mimic os.cpu_count()
-    return len(found) if found else None
-
-
-# --- other system functions
-
-def users():
-    """Return currently connected users as a list of namedtuples."""
-    retlist = []
-    rawlist = cext.users()
-    for item in rawlist:
-        user, tty, hostname, tstamp, user_process = item
-        # note: the underlying C function includes entries about
-        # system boot, run level and others.  We might want
-        # to use them in the future.
-        if not user_process:
-            continue
-        if hostname == ':0.0':
-            hostname = 'localhost'
-        nt = _common.suser(user, tty or None, hostname, tstamp)
-        retlist.append(nt)
-    return retlist
-
-
-def boot_time():
-    """Return the system boot time expressed in seconds since the epoch."""
-    global BOOT_TIME
-    with open('/proc/stat', 'rb') as f:
-        for line in f:
-            if line.startswith(b'btime'):
-                ret = float(line.strip().split()[1])
-                BOOT_TIME = ret
-                return ret
-        raise RuntimeError("line 'btime' not found")
-
-
-# --- processes
-
-def pids():
-    """Returns a list of PIDs currently running on the system."""
-    return [int(x) for x in os.listdir(b'/proc') if x.isdigit()]
-
-
-def pid_exists(pid):
-    """Check For the existence of a unix pid."""
-    return _psposix.pid_exists(pid)
-
-
-# --- network
-
-class Connections:
-    """A wrapper on top of /proc/net/* files, retrieving per-process
-    and system-wide open connections (TCP, UDP, UNIX) similarly to
-    "netstat -an".
-
-    Note: in case of UNIX sockets we're only able to determine the
-    local endpoint/path, not the one it's connected to.
-    According to [1] it would be possible but not easily.
-
-    [1] http://serverfault.com/a/417946
-    """
-
-    def __init__(self):
-        tcp4 = ("tcp", socket.AF_INET, socket.SOCK_STREAM)
-        tcp6 = ("tcp6", socket.AF_INET6, socket.SOCK_STREAM)
-        udp4 = ("udp", socket.AF_INET, socket.SOCK_DGRAM)
-        udp6 = ("udp6", socket.AF_INET6, socket.SOCK_DGRAM)
-        unix = ("unix", socket.AF_UNIX, None)
-        self.tmap = {
-            "all": (tcp4, tcp6, udp4, udp6, unix),
-            "tcp": (tcp4, tcp6),
-            "tcp4": (tcp4,),
-            "tcp6": (tcp6,),
-            "udp": (udp4, udp6),
-            "udp4": (udp4,),
-            "udp6": (udp6,),
-            "unix": (unix,),
-            "inet": (tcp4, tcp6, udp4, udp6),
-            "inet4": (tcp4, udp4),
-            "inet6": (tcp6, udp6),
-        }
-
-    def get_proc_inodes(self, pid):
-        inodes = defaultdict(list)
-        for fd in os.listdir("/proc/%s/fd" % pid):
-            try:
-                inode = os.readlink("/proc/%s/fd/%s" % (pid, fd))
-            except OSError:
-                # TODO: need comment here
-                continue
-            else:
-                if inode.startswith('socket:['):
-                    # the process is using a socket
-                    inode = inode[8:][:-1]
-                    inodes[inode].append((pid, int(fd)))
-        return inodes
-
-    def get_all_inodes(self):
-        inodes = {}
-        for pid in pids():
-            try:
-                inodes.update(self.get_proc_inodes(pid))
-            except OSError as err:
-                # os.listdir() is gonna raise a lot of access denied
-                # exceptions in case of unprivileged user; that's fine
-                # as we'll just end up returning a connection with PID
-                # and fd set to None anyway.
-                # Both netstat -an and lsof does the same so it's
-                # unlikely we can do any better.
-                # ENOENT just means a PID disappeared on us.
-                if err.errno not in (
-                        errno.ENOENT, errno.ESRCH, errno.EPERM, errno.EACCES):
-                    raise
-        return inodes
-
-    def decode_address(self, addr, family):
-        """Accept an "ip:port" address as displayed in /proc/net/*
-        and convert it into a human readable form, like:
-
-        "0500000A:0016" -> ("10.0.0.5", 22)
-        "0000000000000000FFFF00000100007F:9E49" -> ("::ffff:127.0.0.1", 40521)
-
-        The IP address portion is a little or big endian four-byte
-        hexadecimal number; that is, the least significant byte is listed
-        first, so we need to reverse the order of the bytes to convert it
-        to an IP address.
-        The port is represented as a two-byte hexadecimal number.
-
-        Reference:
-        http://linuxdevcenter.com/pub/a/linux/2000/11/16/LinuxAdmin.html
-        """
-        ip, port = addr.split(':')
-        port = int(port, 16)
-        # this usually refers to a local socket in listen mode with
-        # no end-points connected
-        if not port:
-            return ()
-        if PY3:
-            ip = ip.encode('ascii')
-        if family == socket.AF_INET:
-            # see: https://github.com/giampaolo/psutil/issues/201
-            if sys.byteorder == 'little':
-                ip = socket.inet_ntop(family, base64.b16decode(ip)[::-1])
-            else:
-                ip = socket.inet_ntop(family, base64.b16decode(ip))
-        else:  # IPv6
-            # old version - let's keep it, just in case...
-            # ip = ip.decode('hex')
-            # return socket.inet_ntop(socket.AF_INET6,
-            #          ''.join(ip[i:i+4][::-1] for i in xrange(0, 16, 4)))
-            ip = base64.b16decode(ip)
-            # see: https://github.com/giampaolo/psutil/issues/201
-            if sys.byteorder == 'little':
-                ip = socket.inet_ntop(
-                    socket.AF_INET6,
-                    struct.pack('>4I', *struct.unpack('<4I', ip)))
-            else:
-                ip = socket.inet_ntop(
-                    socket.AF_INET6,
-                    struct.pack('<4I', *struct.unpack('<4I', ip)))
-        return (ip, port)
-
-    def process_inet(self, file, family, type_, inodes, filter_pid=None):
-        """Parse /proc/net/tcp* and /proc/net/udp* files."""
-        if file.endswith('6') and not os.path.exists(file):
-            # IPv6 not supported
-            return
-        with open(file, 'rt') as f:
-            f.readline()  # skip the first line
-            for line in f:
-                _, laddr, raddr, status, _, _, _, _, _, inode = \
-                    line.split()[:10]
-                if inode in inodes:
-                    # # We assume inet sockets are unique, so we error
-                    # # out if there are multiple references to the
-                    # # same inode. We won't do this for UNIX sockets.
-                    # if len(inodes[inode]) > 1 and family != socket.AF_UNIX:
-                    #     raise ValueError("ambiguos inode with multiple "
-                    #                      "PIDs references")
-                    pid, fd = inodes[inode][0]
-                else:
-                    pid, fd = None, -1
-                if filter_pid is not None and filter_pid != pid:
-                    continue
-                else:
-                    if type_ == socket.SOCK_STREAM:
-                        status = TCP_STATUSES[status]
-                    else:
-                        status = _common.CONN_NONE
-                    laddr = self.decode_address(laddr, family)
-                    raddr = self.decode_address(raddr, family)
-                    yield (fd, family, type_, laddr, raddr, status, pid)
-
-    def process_unix(self, file, family, inodes, filter_pid=None):
-        """Parse /proc/net/unix files."""
-        with open(file, 'rt') as f:
-            f.readline()  # skip the first line
-            for line in f:
-                tokens = line.split()
-                _, _, _, _, type_, _, inode = tokens[0:7]
-                if inode in inodes:
-                    # With UNIX sockets we can have a single inode
-                    # referencing many file descriptors.
-                    pairs = inodes[inode]
-                else:
-                    pairs = [(None, -1)]
-                for pid, fd in pairs:
-                    if filter_pid is not None and filter_pid != pid:
-                        continue
-                    else:
-                        if len(tokens) == 8:
-                            path = tokens[-1]
-                        else:
-                            path = ""
-                        type_ = int(type_)
-                        raddr = None
-                        status = _common.CONN_NONE
-                        yield (fd, family, type_, path, raddr, status, pid)
-
-    def retrieve(self, kind, pid=None):
-        if kind not in self.tmap:
-            raise ValueError("invalid %r kind argument; choose between %s"
-                             % (kind, ', '.join([repr(x) for x in self.tmap])))
-        if pid is not None:
-            inodes = self.get_proc_inodes(pid)
-            if not inodes:
-                # no connections for this process
-                return []
-        else:
-            inodes = self.get_all_inodes()
-        ret = []
-        for f, family, type_ in self.tmap[kind]:
-            if family in (socket.AF_INET, socket.AF_INET6):
-                ls = self.process_inet(
-                    "/proc/net/%s" % f, family, type_, inodes, filter_pid=pid)
-            else:
-                ls = self.process_unix(
-                    "/proc/net/%s" % f, family, inodes, filter_pid=pid)
-            for fd, family, type_, laddr, raddr, status, bound_pid in ls:
-                if pid:
-                    conn = _common.pconn(fd, family, type_, laddr, raddr,
-                                         status)
-                else:
-                    conn = _common.sconn(fd, family, type_, laddr, raddr,
-                                         status, bound_pid)
-                ret.append(conn)
-        return ret
-
-
-_connections = Connections()
-
-
-def net_connections(kind='inet'):
-    """Return system-wide open connections."""
-    return _connections.retrieve(kind)
-
-
-def net_io_counters():
-    """Return network I/O statistics for every network interface
-    installed on the system as a dict of raw tuples.
-    """
-    with open("/proc/net/dev", "rt") as f:
-        lines = f.readlines()
-    retdict = {}
-    for line in lines[2:]:
-        colon = line.rfind(':')
-        assert colon > 0, repr(line)
-        name = line[:colon].strip()
-        fields = line[colon + 1:].strip().split()
-        bytes_recv = int(fields[0])
-        packets_recv = int(fields[1])
-        errin = int(fields[2])
-        dropin = int(fields[3])
-        bytes_sent = int(fields[8])
-        packets_sent = int(fields[9])
-        errout = int(fields[10])
-        dropout = int(fields[11])
-        retdict[name] = (bytes_sent, bytes_recv, packets_sent, packets_recv,
-                         errin, errout, dropin, dropout)
-    return retdict
-
-
-# --- disks
-
-def disk_io_counters():
-    """Return disk I/O statistics for every disk installed on the
-    system as a dict of raw tuples.
-    """
-    # man iostat states that sectors are equivalent with blocks and
-    # have a size of 512 bytes since 2.4 kernels. This value is
-    # needed to calculate the amount of disk I/O in bytes.
-    SECTOR_SIZE = 512
-
-    # determine partitions we want to look for
-    partitions = []
-    with open("/proc/partitions", "rt") as f:
-        lines = f.readlines()[2:]
-    for line in reversed(lines):
-        _, _, _, name = line.split()
-        if name[-1].isdigit():
-            # we're dealing with a partition (e.g. 'sda1'); 'sda' will
-            # also be around but we want to omit it
-            partitions.append(name)
-        else:
-            if not partitions or not partitions[-1].startswith(name):
-                # we're dealing with a disk entity for which no
-                # partitions have been defined (e.g. 'sda' but
-                # 'sda1' was not around), see:
-                # https://github.com/giampaolo/psutil/issues/338
-                partitions.append(name)
-    #
-    retdict = {}
-    with open("/proc/diskstats", "rt") as f:
-        lines = f.readlines()
-    for line in lines:
-        # http://www.mjmwired.net/kernel/Documentation/iostats.txt
-        fields = line.split()
-        if len(fields) > 7:
-            _, _, name, reads, _, rbytes, rtime, writes, _, wbytes, wtime = \
-                fields[:11]
-        else:
-            # from kernel 2.6.0 to 2.6.25
-            _, _, name, reads, rbytes, writes, wbytes = fields
-            rtime, wtime = 0, 0
-        if name in partitions:
-            rbytes = int(rbytes) * SECTOR_SIZE
-            wbytes = int(wbytes) * SECTOR_SIZE
-            reads = int(reads)
-            writes = int(writes)
-            rtime = int(rtime)
-            wtime = int(wtime)
-            retdict[name] = (reads, writes, rbytes, wbytes, rtime, wtime)
-    return retdict
-
-
-def disk_partitions(all=False):
-    """Return mounted disk partitions as a list of nameduples"""
-    phydevs = []
-    with open("/proc/filesystems", "r") as f:
-        for line in f:
-            if not line.startswith("nodev"):
-                phydevs.append(line.strip())
-
-    retlist = []
-    partitions = cext.disk_partitions()
-    for partition in partitions:
-        device, mountpoint, fstype, opts = partition
-        if device == 'none':
-            device = ''
-        if not all:
-            if device == '' or fstype not in phydevs:
-                continue
-        ntuple = _common.sdiskpart(device, mountpoint, fstype, opts)
-        retlist.append(ntuple)
-    return retlist
-
-
-disk_usage = _psposix.disk_usage
-
-
-# --- decorators
-
-def wrap_exceptions(fun):
-    """Decorator which translates bare OSError and IOError exceptions
-    into NoSuchProcess and AccessDenied.
-    """
-    @functools.wraps(fun)
-    def wrapper(self, *args, **kwargs):
-        try:
-            return fun(self, *args, **kwargs)
-        except EnvironmentError as err:
-            # support for private module import
-            if NoSuchProcess is None or AccessDenied is None:
-                raise
-            # ENOENT (no such file or directory) gets raised on open().
-            # ESRCH (no such process) can get raised on read() if
-            # process is gone in meantime.
-            if err.errno in (errno.ENOENT, errno.ESRCH):
-                raise NoSuchProcess(self.pid, self._name)
-            if err.errno in (errno.EPERM, errno.EACCES):
-                raise AccessDenied(self.pid, self._name)
-            raise
-    return wrapper
-
-
-class Process(object):
-    """Linux process implementation."""
-
-    __slots__ = ["pid", "_name"]
-
-    def __init__(self, pid):
-        self.pid = pid
-        self._name = None
-
-    @wrap_exceptions
-    def name(self):
-        fname = "/proc/%s/stat" % self.pid
-        kw = dict(encoding=DEFAULT_ENCODING) if PY3 else dict()
-        with open(fname, "rt", **kw) as f:
-            # XXX - gets changed later and probably needs refactoring
-            return f.read().split(' ')[1].replace('(', '').replace(')', '')
-
-    def exe(self):
-        try:
-            exe = os.readlink("/proc/%s/exe" % self.pid)
-        except (OSError, IOError) as err:
-            if err.errno in (errno.ENOENT, errno.ESRCH):
-                # no such file error; might be raised also if the
-                # path actually exists for system processes with
-                # low pids (about 0-20)
-                if os.path.lexists("/proc/%s" % self.pid):
-                    return ""
-                else:
-                    # ok, it is a process which has gone away
-                    raise NoSuchProcess(self.pid, self._name)
-            if err.errno in (errno.EPERM, errno.EACCES):
-                raise AccessDenied(self.pid, self._name)
-            raise
-
-        # readlink() might return paths containing null bytes ('\x00').
-        # Certain names have ' (deleted)' appended. Usually this is
-        # bogus as the file actually exists. Either way that's not
-        # important as we don't want to discriminate executables which
-        # have been deleted.
-        exe = exe.split('\x00')[0]
-        if exe.endswith(' (deleted)') and not os.path.exists(exe):
-            exe = exe[:-10]
-        return exe
-
-    @wrap_exceptions
-    def cmdline(self):
-        fname = "/proc/%s/cmdline" % self.pid
-        kw = dict(encoding=DEFAULT_ENCODING) if PY3 else dict()
-        with open(fname, "rt", **kw) as f:
-            return [x for x in f.read().split('\x00') if x]
-
-    @wrap_exceptions
-    def terminal(self):
-        tmap = _psposix._get_terminal_map()
-        with open("/proc/%s/stat" % self.pid, 'rb') as f:
-            tty_nr = int(f.read().split(b' ')[6])
-        try:
-            return tmap[tty_nr]
-        except KeyError:
-            return None
-
-    if os.path.exists('/proc/%s/io' % os.getpid()):
-        @wrap_exceptions
-        def io_counters(self):
-            fname = "/proc/%s/io" % self.pid
-            with open(fname, 'rb') as f:
-                rcount = wcount = rbytes = wbytes = None
-                for line in f:
-                    if rcount is None and line.startswith(b"syscr"):
-                        rcount = int(line.split()[1])
-                    elif wcount is None and line.startswith(b"syscw"):
-                        wcount = int(line.split()[1])
-                    elif rbytes is None and line.startswith(b"read_bytes"):
-                        rbytes = int(line.split()[1])
-                    elif wbytes is None and line.startswith(b"write_bytes"):
-                        wbytes = int(line.split()[1])
-                for x in (rcount, wcount, rbytes, wbytes):
-                    if x is None:
-                        raise NotImplementedError(
-                            "couldn't read all necessary info from %r" % fname)
-                return _common.pio(rcount, wcount, rbytes, wbytes)
-    else:
-        def io_counters(self):
-            raise NotImplementedError("couldn't find /proc/%s/io (kernel "
-                                      "too old?)" % self.pid)
-
-    @wrap_exceptions
-    def cpu_times(self):
-        with open("/proc/%s/stat" % self.pid, 'rb') as f:
-            st = f.read().strip()
-        # ignore the first two values ("pid (exe)")
-        st = st[st.find(b')') + 2:]
-        values = st.split(b' ')
-        utime = float(values[11]) / CLOCK_TICKS
-        stime = float(values[12]) / CLOCK_TICKS
-        return _common.pcputimes(utime, stime)
-
-    @wrap_exceptions
-    def wait(self, timeout=None):
-        try:
-            return _psposix.wait_pid(self.pid, timeout)
-        except _psposix.TimeoutExpired:
-            # support for private module import
-            if TimeoutExpired is None:
-                raise
-            raise TimeoutExpired(timeout, self.pid, self._name)
-
-    @wrap_exceptions
-    def create_time(self):
-        with open("/proc/%s/stat" % self.pid, 'rb') as f:
-            st = f.read().strip()
-        # ignore the first two values ("pid (exe)")
-        st = st[st.rfind(b')') + 2:]
-        values = st.split(b' ')
-        # According to documentation, starttime is in field 21 and the
-        # unit is jiffies (clock ticks).
-        # We first divide it for clock ticks and then add uptime returning
-        # seconds since the epoch, in UTC.
-        # Also use cached value if available.
-        bt = BOOT_TIME or boot_time()
-        return (float(values[19]) / CLOCK_TICKS) + bt
-
-    @wrap_exceptions
-    def memory_info(self):
-        with open("/proc/%s/statm" % self.pid, 'rb') as f:
-            vms, rss = f.readline().split()[:2]
-            return _common.pmem(int(rss) * PAGESIZE,
-                                int(vms) * PAGESIZE)
-
-    @wrap_exceptions
-    def memory_info_ex(self):
-        #  ============================================================
-        # | FIELD  | DESCRIPTION                         | AKA  | TOP  |
-        #  ============================================================
-        # | rss    | resident set size                   |      | RES  |
-        # | vms    | total program size                  | size | VIRT |
-        # | shared | shared pages (from shared mappings) |      | SHR  |
-        # | text   | text ('code')                       | trs  | CODE |
-        # | lib    | library (unused in Linux 2.6)       | lrs  |      |
-        # | data   | data + stack                        | drs  | DATA |
-        # | dirty  | dirty pages (unused in Linux 2.6)   | dt   |      |
-        #  ============================================================
-        with open("/proc/%s/statm" % self.pid, "rb") as f:
-            vms, rss, shared, text, lib, data, dirty = \
-                [int(x) * PAGESIZE for x in f.readline().split()[:7]]
-        return pextmem(rss, vms, shared, text, lib, data, dirty)
-
-    if os.path.exists('/proc/%s/smaps' % os.getpid()):
-
-        @wrap_exceptions
-        def memory_maps(self):
-            """Return process's mapped memory regions as a list of nameduples.
-            Fields are explained in 'man proc'; here is an updated (Apr 2012)
-            version: http://goo.gl/fmebo
-            """
-            with open("/proc/%s/smaps" % self.pid, "rt") as f:
-                first_line = f.readline()
-                current_block = [first_line]
-
-                def get_blocks():
-                    data = {}
-                    for line in f:
-                        fields = line.split(None, 5)
-                        if not fields[0].endswith(':'):
-                            # new block section
-                            yield (current_block.pop(), data)
-                            current_block.append(line)
-                        else:
-                            try:
-                                data[fields[0]] = int(fields[1]) * 1024
-                            except ValueError:
-                                if fields[0].startswith('VmFlags:'):
-                                    # see issue #369
-                                    continue
-                                else:
-                                    raise ValueError("don't know how to inte"
-                                                     "rpret line %r" % line)
-                    yield (current_block.pop(), data)
-
-                ls = []
-                if first_line:  # smaps file can be empty
-                    for header, data in get_blocks():
-                        hfields = header.split(None, 5)
-                        try:
-                            addr, perms, offset, dev, inode, path = hfields
-                        except ValueError:
-                            addr, perms, offset, dev, inode, path = \
-                                hfields + ['']
-                        if not path:
-                            path = '[anon]'
-                        else:
-                            path = path.strip()
-                        ls.append((
-                            addr, perms, path,
-                            data['Rss:'],
-                            data.get('Size:', 0),
-                            data.get('Pss:', 0),
-                            data.get('Shared_Clean:', 0),
-                            data.get('Shared_Dirty:', 0),
-                            data.get('Private_Clean:', 0),
-                            data.get('Private_Dirty:', 0),
-                            data.get('Referenced:', 0),
-                            data.get('Anonymous:', 0),
-                            data.get('Swap:', 0)
-                        ))
-            return ls
-
-    else:
-        def memory_maps(self):
-            msg = "couldn't find /proc/%s/smaps; kernel < 2.6.14 or "  \
-                  "CONFIG_MMU kernel configuration option is not enabled" \
-                  % self.pid
-            raise NotImplementedError(msg)
-
-    @wrap_exceptions
-    def cwd(self):
-        # readlink() might return paths containing null bytes causing
-        # problems when used with other fs-related functions (os.*,
-        # open(), ...)
-        path = os.readlink("/proc/%s/cwd" % self.pid)
-        return path.replace('\x00', '')
-
-    @wrap_exceptions
-    def num_ctx_switches(self):
-        vol = unvol = None
-        with open("/proc/%s/status" % self.pid, "rb") as f:
-            for line in f:
-                if line.startswith(b"voluntary_ctxt_switches"):
-                    vol = int(line.split()[1])
-                elif line.startswith(b"nonvoluntary_ctxt_switches"):
-                    unvol = int(line.split()[1])
-                if vol is not None and unvol is not None:
-                    return _common.pctxsw(vol, unvol)
-            raise NotImplementedError(
-                "'voluntary_ctxt_switches' and 'nonvoluntary_ctxt_switches'"
-                "fields were not found in /proc/%s/status; the kernel is "
-                "probably older than 2.6.23" % self.pid)
-
-    @wrap_exceptions
-    def num_threads(self):
-        with open("/proc/%s/status" % self.pid, "rb") as f:
-            for line in f:
-                if line.startswith(b"Threads:"):
-                    return int(line.split()[1])
-            raise NotImplementedError("line not found")
-
-    @wrap_exceptions
-    def threads(self):
-        thread_ids = os.listdir("/proc/%s/task" % self.pid)
-        thread_ids.sort()
-        retlist = []
-        hit_enoent = False
-        for thread_id in thread_ids:
-            fname = "/proc/%s/task/%s/stat" % (self.pid, thread_id)
-            try:
-                with open(fname, 'rb') as f:
-                    st = f.read().strip()
-            except EnvironmentError as err:
-                if err.errno == errno.ENOENT:
-                    # no such file or directory; it means thread
-                    # disappeared on us
-                    hit_enoent = True
-                    continue
-                raise
-            # ignore the first two values ("pid (exe)")
-            st = st[st.find(b')') + 2:]
-            values = st.split(b' ')
-            utime = float(values[11]) / CLOCK_TICKS
-            stime = float(values[12]) / CLOCK_TICKS
-            ntuple = _common.pthread(int(thread_id), utime, stime)
-            retlist.append(ntuple)
-        if hit_enoent:
-            # raise NSP if the process disappeared on us
-            os.stat('/proc/%s' % self.pid)
-        return retlist
-
-    @wrap_exceptions
-    def nice_get(self):
-        # with open('/proc/%s/stat' % self.pid, 'r') as f:
-        #   data = f.read()
-        #   return int(data.split()[18])
-
-        # Use C implementation
-        return _psutil_posix.getpriority(self.pid)
-
-    @wrap_exceptions
-    def nice_set(self, value):
-        return _psutil_posix.setpriority(self.pid, value)
-
-    @wrap_exceptions
-    def cpu_affinity_get(self):
-        return cext.proc_cpu_affinity_get(self.pid)
-
-    @wrap_exceptions
-    def cpu_affinity_set(self, cpus):
-        try:
-            cext.proc_cpu_affinity_set(self.pid, cpus)
-        except OSError as err:
-            if err.errno == errno.EINVAL:
-                allcpus = tuple(range(len(per_cpu_times())))
-                for cpu in cpus:
-                    if cpu not in allcpus:
-                        raise ValueError("invalid CPU #%i (choose between %s)"
-                                         % (cpu, allcpus))
-            raise
-
-    # only starting from kernel 2.6.13
-    if hasattr(cext, "proc_ioprio_get"):
-
-        @wrap_exceptions
-        def ionice_get(self):
-            ioclass, value = cext.proc_ioprio_get(self.pid)
-            return _common.pionice(ioclass, value)
-
-        @wrap_exceptions
-        def ionice_set(self, ioclass, value):
-            if ioclass in (IOPRIO_CLASS_NONE, None):
-                if value:
-                    msg = "can't specify value with IOPRIO_CLASS_NONE"
-                    raise ValueError(msg)
-                ioclass = IOPRIO_CLASS_NONE
-                value = 0
-            if ioclass in (IOPRIO_CLASS_RT, IOPRIO_CLASS_BE):
-                if value is None:
-                    value = 4
-            elif ioclass == IOPRIO_CLASS_IDLE:
-                if value:
-                    msg = "can't specify value with IOPRIO_CLASS_IDLE"
-                    raise ValueError(msg)
-                value = 0
-            else:
-                value = 0
-            if not 0 <= value <= 8:
-                raise ValueError(
-                    "value argument range expected is between 0 and 8")
-            return cext.proc_ioprio_set(self.pid, ioclass, value)
-
-    if HAS_PRLIMIT:
-        @wrap_exceptions
-        def rlimit(self, resource, limits=None):
-            # if pid is 0 prlimit() applies to the calling process and
-            # we don't want that
-            if self.pid == 0:
-                raise ValueError("can't use prlimit() against PID 0 process")
-            if limits is None:
-                # get
-                return cext.linux_prlimit(self.pid, resource)
-            else:
-                # set
-                if len(limits) != 2:
-                    raise ValueError(
-                        "second argument must be a (soft, hard) tuple")
-                soft, hard = limits
-                cext.linux_prlimit(self.pid, resource, soft, hard)
-
-    @wrap_exceptions
-    def status(self):
-        with open("/proc/%s/status" % self.pid, 'rb') as f:
-            for line in f:
-                if line.startswith(b"State:"):
-                    letter = line.split()[1]
-                    if PY3:
-                        letter = letter.decode()
-                    # XXX is '?' legit? (we're not supposed to return
-                    # it anyway)
-                    return PROC_STATUSES.get(letter, '?')
-
-    @wrap_exceptions
-    def open_files(self):
-        retlist = []
-        files = os.listdir("/proc/%s/fd" % self.pid)
-        hit_enoent = False
-        for fd in files:
-            file = "/proc/%s/fd/%s" % (self.pid, fd)
-            try:
-                file = os.readlink(file)
-            except OSError as err:
-                # ENOENT == file which is gone in the meantime
-                if err.errno in (errno.ENOENT, errno.ESRCH):
-                    hit_enoent = True
-                    continue
-                elif err.errno == errno.EINVAL:
-                    # not a link
-                    continue
-                else:
-                    raise
-            else:
-                # If file is not an absolute path there's no way
-                # to tell whether it's a regular file or not,
-                # so we skip it. A regular file is always supposed
-                # to be absolutized though.
-                if file.startswith('/') and isfile_strict(file):
-                    ntuple = _common.popenfile(file, int(fd))
-                    retlist.append(ntuple)
-        if hit_enoent:
-            # raise NSP if the process disappeared on us
-            os.stat('/proc/%s' % self.pid)
-        return retlist
-
-    @wrap_exceptions
-    def connections(self, kind='inet'):
-        ret = _connections.retrieve(kind, self.pid)
-        # raise NSP if the process disappeared on us
-        os.stat('/proc/%s' % self.pid)
-        return ret
-
-    @wrap_exceptions
-    def num_fds(self):
-        return len(os.listdir("/proc/%s/fd" % self.pid))
-
-    @wrap_exceptions
-    def ppid(self):
-        with open("/proc/%s/status" % self.pid, 'rb') as f:
-            for line in f:
-                if line.startswith(b"PPid:"):
-                    # PPid: nnnn
-                    return int(line.split()[1])
-            raise NotImplementedError("line not found")
-
-    @wrap_exceptions
-    def uids(self):
-        with open("/proc/%s/status" % self.pid, 'rb') as f:
-            for line in f:
-                if line.startswith(b'Uid:'):
-                    _, real, effective, saved, fs = line.split()
-                    return _common.puids(int(real), int(effective), int(saved))
-            raise NotImplementedError("line not found")
-
-    @wrap_exceptions
-    def gids(self):
-        with open("/proc/%s/status" % self.pid, 'rb') as f:
-            for line in f:
-                if line.startswith(b'Gid:'):
-                    _, real, effective, saved, fs = line.split()
-                    return _common.pgids(int(real), int(effective), int(saved))
-            raise NotImplementedError("line not found")
diff --git a/io_scenario/libs/ubuntu_14_04_x64/psutil/_psosx.py b/io_scenario/libs/ubuntu_14_04_x64/psutil/_psosx.py
deleted file mode 100644
index c40ef1d..0000000
--- a/io_scenario/libs/ubuntu_14_04_x64/psutil/_psosx.py
+++ /dev/null
@@ -1,340 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""OSX platform implementation."""
-
-import errno
-import functools
-import os
-from collections import namedtuple
-
-from psutil import _common
-from psutil import _psposix
-from psutil._common import conn_tmap, usage_percent, isfile_strict
-import _psutil_osx as cext
-import _psutil_posix
-
-
-__extra__all__ = []
-
-# --- constants
-
-PAGESIZE = os.sysconf("SC_PAGE_SIZE")
-
-# http://students.mimuw.edu.pl/lxr/source/include/net/tcp_states.h
-TCP_STATUSES = {
-    cext.TCPS_ESTABLISHED: _common.CONN_ESTABLISHED,
-    cext.TCPS_SYN_SENT: _common.CONN_SYN_SENT,
-    cext.TCPS_SYN_RECEIVED: _common.CONN_SYN_RECV,
-    cext.TCPS_FIN_WAIT_1: _common.CONN_FIN_WAIT1,
-    cext.TCPS_FIN_WAIT_2: _common.CONN_FIN_WAIT2,
-    cext.TCPS_TIME_WAIT: _common.CONN_TIME_WAIT,
-    cext.TCPS_CLOSED: _common.CONN_CLOSE,
-    cext.TCPS_CLOSE_WAIT: _common.CONN_CLOSE_WAIT,
-    cext.TCPS_LAST_ACK: _common.CONN_LAST_ACK,
-    cext.TCPS_LISTEN: _common.CONN_LISTEN,
-    cext.TCPS_CLOSING: _common.CONN_CLOSING,
-    cext.PSUTIL_CONN_NONE: _common.CONN_NONE,
-}
-
-PROC_STATUSES = {
-    cext.SIDL: _common.STATUS_IDLE,
-    cext.SRUN: _common.STATUS_RUNNING,
-    cext.SSLEEP: _common.STATUS_SLEEPING,
-    cext.SSTOP: _common.STATUS_STOPPED,
-    cext.SZOMB: _common.STATUS_ZOMBIE,
-}
-
-scputimes = namedtuple('scputimes', ['user', 'nice', 'system', 'idle'])
-
-svmem = namedtuple(
-    'svmem', ['total', 'available', 'percent', 'used', 'free',
-              'active', 'inactive', 'wired'])
-
-pextmem = namedtuple('pextmem', ['rss', 'vms', 'pfaults', 'pageins'])
-
-pmmap_grouped = namedtuple(
-    'pmmap_grouped',
-    'path rss private swapped dirtied ref_count shadow_depth')
-
-pmmap_ext = namedtuple(
-    'pmmap_ext', 'addr perms ' + ' '.join(pmmap_grouped._fields))
-
-# set later from __init__.py
-NoSuchProcess = None
-AccessDenied = None
-TimeoutExpired = None
-
-
-# --- functions
-
-def virtual_memory():
-    """System virtual memory as a namedtuple."""
-    total, active, inactive, wired, free = cext.virtual_mem()
-    avail = inactive + free
-    used = active + inactive + wired
-    percent = usage_percent((total - avail), total, _round=1)
-    return svmem(total, avail, percent, used, free,
-                 active, inactive, wired)
-
-
-def swap_memory():
-    """Swap system memory as a (total, used, free, sin, sout) tuple."""
-    total, used, free, sin, sout = cext.swap_mem()
-    percent = usage_percent(used, total, _round=1)
-    return _common.sswap(total, used, free, percent, sin, sout)
-
-
-def cpu_times():
-    """Return system CPU times as a namedtuple."""
-    user, nice, system, idle = cext.cpu_times()
-    return scputimes(user, nice, system, idle)
-
-
-def per_cpu_times():
-    """Return system CPU times as a named tuple"""
-    ret = []
-    for cpu_t in cext.per_cpu_times():
-        user, nice, system, idle = cpu_t
-        item = scputimes(user, nice, system, idle)
-        ret.append(item)
-    return ret
-
-
-def cpu_count_logical():
-    """Return the number of logical CPUs in the system."""
-    return cext.cpu_count_logical()
-
-
-def cpu_count_physical():
-    """Return the number of physical CPUs in the system."""
-    return cext.cpu_count_phys()
-
-
-def boot_time():
-    """The system boot time expressed in seconds since the epoch."""
-    return cext.boot_time()
-
-
-def disk_partitions(all=False):
-    retlist = []
-    partitions = cext.disk_partitions()
-    for partition in partitions:
-        device, mountpoint, fstype, opts = partition
-        if device == 'none':
-            device = ''
-        if not all:
-            if not os.path.isabs(device) or not os.path.exists(device):
-                continue
-        ntuple = _common.sdiskpart(device, mountpoint, fstype, opts)
-        retlist.append(ntuple)
-    return retlist
-
-
-def users():
-    retlist = []
-    rawlist = cext.users()
-    for item in rawlist:
-        user, tty, hostname, tstamp = item
-        if tty == '~':
-            continue  # reboot or shutdown
-        if not tstamp:
-            continue
-        nt = _common.suser(user, tty or None, hostname or None, tstamp)
-        retlist.append(nt)
-    return retlist
-
-
-def net_connections(kind='inet'):
-    # Note: on OSX this will fail with AccessDenied unless
-    # the process is owned by root.
-    ret = []
-    for pid in pids():
-        try:
-            cons = Process(pid).connections(kind)
-        except NoSuchProcess:
-            continue
-        else:
-            if cons:
-                for c in cons:
-                    c = list(c) + [pid]
-                    ret.append(_common.sconn(*c))
-    return ret
-
-
-pids = cext.pids
-pid_exists = _psposix.pid_exists
-disk_usage = _psposix.disk_usage
-net_io_counters = cext.net_io_counters
-disk_io_counters = cext.disk_io_counters
-
-
-def wrap_exceptions(fun):
-    """Decorator which translates bare OSError exceptions into
-    NoSuchProcess and AccessDenied.
-    """
-    @functools.wraps(fun)
-    def wrapper(self, *args, **kwargs):
-        try:
-            return fun(self, *args, **kwargs)
-        except OSError as err:
-            # support for private module import
-            if NoSuchProcess is None or AccessDenied is None:
-                raise
-            if err.errno == errno.ESRCH:
-                raise NoSuchProcess(self.pid, self._name)
-            if err.errno in (errno.EPERM, errno.EACCES):
-                raise AccessDenied(self.pid, self._name)
-            raise
-    return wrapper
-
-
-class Process(object):
-    """Wrapper class around underlying C implementation."""
-
-    __slots__ = ["pid", "_name"]
-
-    def __init__(self, pid):
-        self.pid = pid
-        self._name = None
-
-    @wrap_exceptions
-    def name(self):
-        return cext.proc_name(self.pid)
-
-    @wrap_exceptions
-    def exe(self):
-        return cext.proc_exe(self.pid)
-
-    @wrap_exceptions
-    def cmdline(self):
-        if not pid_exists(self.pid):
-            raise NoSuchProcess(self.pid, self._name)
-        return cext.proc_cmdline(self.pid)
-
-    @wrap_exceptions
-    def ppid(self):
-        return cext.proc_ppid(self.pid)
-
-    @wrap_exceptions
-    def cwd(self):
-        return cext.proc_cwd(self.pid)
-
-    @wrap_exceptions
-    def uids(self):
-        real, effective, saved = cext.proc_uids(self.pid)
-        return _common.puids(real, effective, saved)
-
-    @wrap_exceptions
-    def gids(self):
-        real, effective, saved = cext.proc_gids(self.pid)
-        return _common.pgids(real, effective, saved)
-
-    @wrap_exceptions
-    def terminal(self):
-        tty_nr = cext.proc_tty_nr(self.pid)
-        tmap = _psposix._get_terminal_map()
-        try:
-            return tmap[tty_nr]
-        except KeyError:
-            return None
-
-    @wrap_exceptions
-    def memory_info(self):
-        rss, vms = cext.proc_memory_info(self.pid)[:2]
-        return _common.pmem(rss, vms)
-
-    @wrap_exceptions
-    def memory_info_ex(self):
-        rss, vms, pfaults, pageins = cext.proc_memory_info(self.pid)
-        return pextmem(rss, vms, pfaults * PAGESIZE, pageins * PAGESIZE)
-
-    @wrap_exceptions
-    def cpu_times(self):
-        user, system = cext.proc_cpu_times(self.pid)
-        return _common.pcputimes(user, system)
-
-    @wrap_exceptions
-    def create_time(self):
-        return cext.proc_create_time(self.pid)
-
-    @wrap_exceptions
-    def num_ctx_switches(self):
-        return _common.pctxsw(*cext.proc_num_ctx_switches(self.pid))
-
-    @wrap_exceptions
-    def num_threads(self):
-        return cext.proc_num_threads(self.pid)
-
-    @wrap_exceptions
-    def open_files(self):
-        if self.pid == 0:
-            return []
-        files = []
-        rawlist = cext.proc_open_files(self.pid)
-        for path, fd in rawlist:
-            if isfile_strict(path):
-                ntuple = _common.popenfile(path, fd)
-                files.append(ntuple)
-        return files
-
-    @wrap_exceptions
-    def connections(self, kind='inet'):
-        if kind not in conn_tmap:
-            raise ValueError("invalid %r kind argument; choose between %s"
-                             % (kind, ', '.join([repr(x) for x in conn_tmap])))
-        families, types = conn_tmap[kind]
-        rawlist = cext.proc_connections(self.pid, families, types)
-        ret = []
-        for item in rawlist:
-            fd, fam, type, laddr, raddr, status = item
-            status = TCP_STATUSES[status]
-            nt = _common.pconn(fd, fam, type, laddr, raddr, status)
-            ret.append(nt)
-        return ret
-
-    @wrap_exceptions
-    def num_fds(self):
-        if self.pid == 0:
-            return 0
-        return cext.proc_num_fds(self.pid)
-
-    @wrap_exceptions
-    def wait(self, timeout=None):
-        try:
-            return _psposix.wait_pid(self.pid, timeout)
-        except _psposix.TimeoutExpired:
-            # support for private module import
-            if TimeoutExpired is None:
-                raise
-            raise TimeoutExpired(timeout, self.pid, self._name)
-
-    @wrap_exceptions
-    def nice_get(self):
-        return _psutil_posix.getpriority(self.pid)
-
-    @wrap_exceptions
-    def nice_set(self, value):
-        return _psutil_posix.setpriority(self.pid, value)
-
-    @wrap_exceptions
-    def status(self):
-        code = cext.proc_status(self.pid)
-        # XXX is '?' legit? (we're not supposed to return it anyway)
-        return PROC_STATUSES.get(code, '?')
-
-    @wrap_exceptions
-    def threads(self):
-        rawlist = cext.proc_threads(self.pid)
-        retlist = []
-        for thread_id, utime, stime in rawlist:
-            ntuple = _common.pthread(thread_id, utime, stime)
-            retlist.append(ntuple)
-        return retlist
-
-    @wrap_exceptions
-    def memory_maps(self):
-        return cext.proc_memory_maps(self.pid)
diff --git a/io_scenario/libs/ubuntu_14_04_x64/psutil/_psposix.py b/io_scenario/libs/ubuntu_14_04_x64/psutil/_psposix.py
deleted file mode 100644
index 94db351..0000000
--- a/io_scenario/libs/ubuntu_14_04_x64/psutil/_psposix.py
+++ /dev/null
@@ -1,154 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""Routines common to all posix systems."""
-
-import errno
-import glob
-import os
-import sys
-import time
-
-from psutil._common import sdiskusage, usage_percent, memoize
-from psutil._compat import PY3, unicode
-
-
-class TimeoutExpired(Exception):
-    pass
-
-
-def pid_exists(pid):
-    """Check whether pid exists in the current process table."""
-    if pid == 0:
-        # According to "man 2 kill" PID 0 has a special meaning:
-        # it refers to <<every process in the process group of the
-        # calling process>> so we don't want to go any further.
-        # If we get here it means this UNIX platform *does* have
-        # a process with id 0.
-        return True
-    try:
-        os.kill(pid, 0)
-    except OSError as err:
-        if err.errno == errno.ESRCH:
-            # ESRCH == No such process
-            return False
-        elif err.errno == errno.EPERM:
-            # EPERM clearly means there's a process to deny access to
-            return True
-        else:
-            # According to "man 2 kill" possible error values are
-            # (EINVAL, EPERM, ESRCH) therefore we should never get
-            # here. If we do let's be explicit in considering this
-            # an error.
-            raise err
-    else:
-        return True
-
-
-def wait_pid(pid, timeout=None):
-    """Wait for process with pid 'pid' to terminate and return its
-    exit status code as an integer.
-
-    If pid is not a children of os.getpid() (current process) just
-    waits until the process disappears and return None.
-
-    If pid does not exist at all return None immediately.
-
-    Raise TimeoutExpired on timeout expired.
-    """
-    def check_timeout(delay):
-        if timeout is not None:
-            if timer() >= stop_at:
-                raise TimeoutExpired()
-        time.sleep(delay)
-        return min(delay * 2, 0.04)
-
-    timer = getattr(time, 'monotonic', time.time)
-    if timeout is not None:
-        waitcall = lambda: os.waitpid(pid, os.WNOHANG)
-        stop_at = timer() + timeout
-    else:
-        waitcall = lambda: os.waitpid(pid, 0)
-
-    delay = 0.0001
-    while True:
-        try:
-            retpid, status = waitcall()
-        except OSError as err:
-            if err.errno == errno.EINTR:
-                delay = check_timeout(delay)
-                continue
-            elif err.errno == errno.ECHILD:
-                # This has two meanings:
-                # - pid is not a child of os.getpid() in which case
-                #   we keep polling until it's gone
-                # - pid never existed in the first place
-                # In both cases we'll eventually return None as we
-                # can't determine its exit status code.
-                while True:
-                    if pid_exists(pid):
-                        delay = check_timeout(delay)
-                    else:
-                        return
-            else:
-                raise
-        else:
-            if retpid == 0:
-                # WNOHANG was used, pid is still running
-                delay = check_timeout(delay)
-                continue
-            # process exited due to a signal; return the integer of
-            # that signal
-            if os.WIFSIGNALED(status):
-                return os.WTERMSIG(status)
-            # process exited using exit(2) system call; return the
-            # integer exit(2) system call has been called with
-            elif os.WIFEXITED(status):
-                return os.WEXITSTATUS(status)
-            else:
-                # should never happen
-                raise RuntimeError("unknown process exit status")
-
-
-def disk_usage(path):
-    """Return disk usage associated with path."""
-    try:
-        st = os.statvfs(path)
-    except UnicodeEncodeError:
-        if not PY3 and isinstance(path, unicode):
-            # this is a bug with os.statvfs() and unicode on
-            # Python 2, see:
-            # - https://github.com/giampaolo/psutil/issues/416
-            # - http://bugs.python.org/issue18695
-            try:
-                path = path.encode(sys.getfilesystemencoding())
-            except UnicodeEncodeError:
-                pass
-            st = os.statvfs(path)
-        else:
-            raise
-    free = (st.f_bavail * st.f_frsize)
-    total = (st.f_blocks * st.f_frsize)
-    used = (st.f_blocks - st.f_bfree) * st.f_frsize
-    percent = usage_percent(used, total, _round=1)
-    # NB: the percentage is -5% than what shown by df due to
-    # reserved blocks that we are currently not considering:
-    # http://goo.gl/sWGbH
-    return sdiskusage(total, used, free, percent)
-
-
-@memoize
-def _get_terminal_map():
-    ret = {}
-    ls = glob.glob('/dev/tty*') + glob.glob('/dev/pts/*')
-    for name in ls:
-        assert name not in ret
-        try:
-            ret[os.stat(name).st_rdev] = name
-        except OSError as err:
-            if err.errno != errno.ENOENT:
-                raise
-    return ret
diff --git a/io_scenario/libs/ubuntu_14_04_x64/psutil/_pssunos.py b/io_scenario/libs/ubuntu_14_04_x64/psutil/_pssunos.py
deleted file mode 100644
index 7b5385e..0000000
--- a/io_scenario/libs/ubuntu_14_04_x64/psutil/_pssunos.py
+++ /dev/null
@@ -1,527 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""Sun OS Solaris platform implementation."""
-
-import errno
-import os
-import socket
-import subprocess
-import sys
-from collections import namedtuple
-
-from psutil import _common
-from psutil import _psposix
-from psutil._common import usage_percent, isfile_strict
-from psutil._compat import PY3
-import _psutil_posix
-import _psutil_sunos as cext
-
-
-__extra__all__ = ["CONN_IDLE", "CONN_BOUND"]
-
-PAGE_SIZE = os.sysconf('SC_PAGE_SIZE')
-
-CONN_IDLE = "IDLE"
-CONN_BOUND = "BOUND"
-
-PROC_STATUSES = {
-    cext.SSLEEP: _common.STATUS_SLEEPING,
-    cext.SRUN: _common.STATUS_RUNNING,
-    cext.SZOMB: _common.STATUS_ZOMBIE,
-    cext.SSTOP: _common.STATUS_STOPPED,
-    cext.SIDL: _common.STATUS_IDLE,
-    cext.SONPROC: _common.STATUS_RUNNING,  # same as run
-    cext.SWAIT: _common.STATUS_WAITING,
-}
-
-TCP_STATUSES = {
-    cext.TCPS_ESTABLISHED: _common.CONN_ESTABLISHED,
-    cext.TCPS_SYN_SENT: _common.CONN_SYN_SENT,
-    cext.TCPS_SYN_RCVD: _common.CONN_SYN_RECV,
-    cext.TCPS_FIN_WAIT_1: _common.CONN_FIN_WAIT1,
-    cext.TCPS_FIN_WAIT_2: _common.CONN_FIN_WAIT2,
-    cext.TCPS_TIME_WAIT: _common.CONN_TIME_WAIT,
-    cext.TCPS_CLOSED: _common.CONN_CLOSE,
-    cext.TCPS_CLOSE_WAIT: _common.CONN_CLOSE_WAIT,
-    cext.TCPS_LAST_ACK: _common.CONN_LAST_ACK,
-    cext.TCPS_LISTEN: _common.CONN_LISTEN,
-    cext.TCPS_CLOSING: _common.CONN_CLOSING,
-    cext.PSUTIL_CONN_NONE: _common.CONN_NONE,
-    cext.TCPS_IDLE: CONN_IDLE,  # sunos specific
-    cext.TCPS_BOUND: CONN_BOUND,  # sunos specific
-}
-
-scputimes = namedtuple('scputimes', ['user', 'system', 'idle', 'iowait'])
-svmem = namedtuple('svmem', ['total', 'available', 'percent', 'used', 'free'])
-pextmem = namedtuple('pextmem', ['rss', 'vms'])
-pmmap_grouped = namedtuple('pmmap_grouped', ['path', 'rss', 'anon', 'locked'])
-pmmap_ext = namedtuple(
-    'pmmap_ext', 'addr perms ' + ' '.join(pmmap_grouped._fields))
-
-# set later from __init__.py
-NoSuchProcess = None
-AccessDenied = None
-TimeoutExpired = None
-
-# --- functions
-
-disk_io_counters = cext.disk_io_counters
-net_io_counters = cext.net_io_counters
-disk_usage = _psposix.disk_usage
-
-
-def virtual_memory():
-    # we could have done this with kstat, but imho this is good enough
-    total = os.sysconf('SC_PHYS_PAGES') * PAGE_SIZE
-    # note: there's no difference on Solaris
-    free = avail = os.sysconf('SC_AVPHYS_PAGES') * PAGE_SIZE
-    used = total - free
-    percent = usage_percent(used, total, _round=1)
-    return svmem(total, avail, percent, used, free)
-
-
-def swap_memory():
-    sin, sout = cext.swap_mem()
-    # XXX
-    # we are supposed to get total/free by doing so:
-    # http://cvs.opensolaris.org/source/xref/onnv/onnv-gate/
-    #     usr/src/cmd/swap/swap.c
-    # ...nevertheless I can't manage to obtain the same numbers as 'swap'
-    # cmdline utility, so let's parse its output (sigh!)
-    p = subprocess.Popen(['swap', '-l', '-k'], stdout=subprocess.PIPE)
-    stdout, stderr = p.communicate()
-    if PY3:
-        stdout = stdout.decode(sys.stdout.encoding)
-    if p.returncode != 0:
-        raise RuntimeError("'swap -l -k' failed (retcode=%s)" % p.returncode)
-
-    lines = stdout.strip().split('\n')[1:]
-    if not lines:
-        raise RuntimeError('no swap device(s) configured')
-    total = free = 0
-    for line in lines:
-        line = line.split()
-        t, f = line[-2:]
-        t = t.replace('K', '')
-        f = f.replace('K', '')
-        total += int(int(t) * 1024)
-        free += int(int(f) * 1024)
-    used = total - free
-    percent = usage_percent(used, total, _round=1)
-    return _common.sswap(total, used, free, percent,
-                         sin * PAGE_SIZE, sout * PAGE_SIZE)
-
-
-def pids():
-    """Returns a list of PIDs currently running on the system."""
-    return [int(x) for x in os.listdir('/proc') if x.isdigit()]
-
-
-def pid_exists(pid):
-    """Check for the existence of a unix pid."""
-    return _psposix.pid_exists(pid)
-
-
-def cpu_times():
-    """Return system-wide CPU times as a named tuple"""
-    ret = cext.per_cpu_times()
-    return scputimes(*[sum(x) for x in zip(*ret)])
-
-
-def per_cpu_times():
-    """Return system per-CPU times as a list of named tuples"""
-    ret = cext.per_cpu_times()
-    return [scputimes(*x) for x in ret]
-
-
-def cpu_count_logical():
-    """Return the number of logical CPUs in the system."""
-    try:
-        return os.sysconf("SC_NPROCESSORS_ONLN")
-    except ValueError:
-        # mimic os.cpu_count() behavior
-        return None
-
-
-def cpu_count_physical():
-    """Return the number of physical CPUs in the system."""
-    return cext.cpu_count_phys()
-
-
-def boot_time():
-    """The system boot time expressed in seconds since the epoch."""
-    return cext.boot_time()
-
-
-def users():
-    """Return currently connected users as a list of namedtuples."""
-    retlist = []
-    rawlist = cext.users()
-    localhost = (':0.0', ':0')
-    for item in rawlist:
-        user, tty, hostname, tstamp, user_process = item
-        # note: the underlying C function includes entries about
-        # system boot, run level and others.  We might want
-        # to use them in the future.
-        if not user_process:
-            continue
-        if hostname in localhost:
-            hostname = 'localhost'
-        nt = _common.suser(user, tty, hostname, tstamp)
-        retlist.append(nt)
-    return retlist
-
-
-def disk_partitions(all=False):
-    """Return system disk partitions."""
-    # TODO - the filtering logic should be better checked so that
-    # it tries to reflect 'df' as much as possible
-    retlist = []
-    partitions = cext.disk_partitions()
-    for partition in partitions:
-        device, mountpoint, fstype, opts = partition
-        if device == 'none':
-            device = ''
-        if not all:
-            # Differently from, say, Linux, we don't have a list of
-            # common fs types so the best we can do, AFAIK, is to
-            # filter by filesystem having a total size > 0.
-            if not disk_usage(mountpoint).total:
-                continue
-        ntuple = _common.sdiskpart(device, mountpoint, fstype, opts)
-        retlist.append(ntuple)
-    return retlist
-
-
-def net_connections(kind, _pid=-1):
-    """Return socket connections.  If pid == -1 return system-wide
-    connections (as opposed to connections opened by one process only).
-    Only INET sockets are returned (UNIX are not).
-    """
-    cmap = _common.conn_tmap.copy()
-    if _pid == -1:
-        cmap.pop('unix', 0)
-    if kind not in cmap:
-        raise ValueError("invalid %r kind argument; choose between %s"
-                         % (kind, ', '.join([repr(x) for x in cmap])))
-    families, types = _common.conn_tmap[kind]
-    rawlist = cext.net_connections(_pid, families, types)
-    ret = []
-    for item in rawlist:
-        fd, fam, type_, laddr, raddr, status, pid = item
-        if fam not in families:
-            continue
-        if type_ not in types:
-            continue
-        status = TCP_STATUSES[status]
-        if _pid == -1:
-            nt = _common.sconn(fd, fam, type_, laddr, raddr, status, pid)
-        else:
-            nt = _common.pconn(fd, fam, type_, laddr, raddr, status)
-        ret.append(nt)
-    return ret
-
-
-def wrap_exceptions(fun):
-    """Call callable into a try/except clause and translate ENOENT,
-    EACCES and EPERM in NoSuchProcess or AccessDenied exceptions.
-    """
-    def wrapper(self, *args, **kwargs):
-        try:
-            return fun(self, *args, **kwargs)
-        except EnvironmentError as err:
-            # support for private module import
-            if NoSuchProcess is None or AccessDenied is None:
-                raise
-            # ENOENT (no such file or directory) gets raised on open().
-            # ESRCH (no such process) can get raised on read() if
-            # process is gone in meantime.
-            if err.errno in (errno.ENOENT, errno.ESRCH):
-                raise NoSuchProcess(self.pid, self._name)
-            if err.errno in (errno.EPERM, errno.EACCES):
-                raise AccessDenied(self.pid, self._name)
-            raise
-    return wrapper
-
-
-class Process(object):
-    """Wrapper class around underlying C implementation."""
-
-    __slots__ = ["pid", "_name"]
-
-    def __init__(self, pid):
-        self.pid = pid
-        self._name = None
-
-    @wrap_exceptions
-    def name(self):
-        # note: max len == 15
-        return cext.proc_name_and_args(self.pid)[0]
-
-    @wrap_exceptions
-    def exe(self):
-        # Will be guess later from cmdline but we want to explicitly
-        # invoke cmdline here in order to get an AccessDenied
-        # exception if the user has not enough privileges.
-        self.cmdline()
-        return ""
-
-    @wrap_exceptions
-    def cmdline(self):
-        return cext.proc_name_and_args(self.pid)[1].split(' ')
-
-    @wrap_exceptions
-    def create_time(self):
-        return cext.proc_basic_info(self.pid)[3]
-
-    @wrap_exceptions
-    def num_threads(self):
-        return cext.proc_basic_info(self.pid)[5]
-
-    @wrap_exceptions
-    def nice_get(self):
-        # For some reason getpriority(3) return ESRCH (no such process)
-        # for certain low-pid processes, no matter what (even as root).
-        # The process actually exists though, as it has a name,
-        # creation time, etc.
-        # The best thing we can do here appears to be raising AD.
-        # Note: tested on Solaris 11; on Open Solaris 5 everything is
-        # fine.
-        try:
-            return _psutil_posix.getpriority(self.pid)
-        except EnvironmentError as err:
-            if err.errno in (errno.ENOENT, errno.ESRCH):
-                if pid_exists(self.pid):
-                    raise AccessDenied(self.pid, self._name)
-            raise
-
-    @wrap_exceptions
-    def nice_set(self, value):
-        if self.pid in (2, 3):
-            # Special case PIDs: internally setpriority(3) return ESRCH
-            # (no such process), no matter what.
-            # The process actually exists though, as it has a name,
-            # creation time, etc.
-            raise AccessDenied(self.pid, self._name)
-        return _psutil_posix.setpriority(self.pid, value)
-
-    @wrap_exceptions
-    def ppid(self):
-        return cext.proc_basic_info(self.pid)[0]
-
-    @wrap_exceptions
-    def uids(self):
-        real, effective, saved, _, _, _ = cext.proc_cred(self.pid)
-        return _common.puids(real, effective, saved)
-
-    @wrap_exceptions
-    def gids(self):
-        _, _, _, real, effective, saved = cext.proc_cred(self.pid)
-        return _common.puids(real, effective, saved)
-
-    @wrap_exceptions
-    def cpu_times(self):
-        user, system = cext.proc_cpu_times(self.pid)
-        return _common.pcputimes(user, system)
-
-    @wrap_exceptions
-    def terminal(self):
-        hit_enoent = False
-        tty = wrap_exceptions(
-            cext.proc_basic_info(self.pid)[0])
-        if tty != cext.PRNODEV:
-            for x in (0, 1, 2, 255):
-                try:
-                    return os.readlink('/proc/%d/path/%d' % (self.pid, x))
-                except OSError as err:
-                    if err.errno == errno.ENOENT:
-                        hit_enoent = True
-                        continue
-                    raise
-        if hit_enoent:
-            # raise NSP if the process disappeared on us
-            os.stat('/proc/%s' % self.pid)
-
-    @wrap_exceptions
-    def cwd(self):
-        # /proc/PID/path/cwd may not be resolved by readlink() even if
-        # it exists (ls shows it). If that's the case and the process
-        # is still alive return None (we can return None also on BSD).
-        # Reference: http://goo.gl/55XgO
-        try:
-            return os.readlink("/proc/%s/path/cwd" % self.pid)
-        except OSError as err:
-            if err.errno == errno.ENOENT:
-                os.stat("/proc/%s" % self.pid)
-                return None
-            raise
-
-    @wrap_exceptions
-    def memory_info(self):
-        ret = cext.proc_basic_info(self.pid)
-        rss, vms = ret[1] * 1024, ret[2] * 1024
-        return _common.pmem(rss, vms)
-
-    # it seems Solaris uses rss and vms only
-    memory_info_ex = memory_info
-
-    @wrap_exceptions
-    def status(self):
-        code = cext.proc_basic_info(self.pid)[6]
-        # XXX is '?' legit? (we're not supposed to return it anyway)
-        return PROC_STATUSES.get(code, '?')
-
-    @wrap_exceptions
-    def threads(self):
-        ret = []
-        tids = os.listdir('/proc/%d/lwp' % self.pid)
-        hit_enoent = False
-        for tid in tids:
-            tid = int(tid)
-            try:
-                utime, stime = cext.query_process_thread(
-                    self.pid, tid)
-            except EnvironmentError as err:
-                # ENOENT == thread gone in meantime
-                if err.errno == errno.ENOENT:
-                    hit_enoent = True
-                    continue
-                raise
-            else:
-                nt = _common.pthread(tid, utime, stime)
-                ret.append(nt)
-        if hit_enoent:
-            # raise NSP if the process disappeared on us
-            os.stat('/proc/%s' % self.pid)
-        return ret
-
-    @wrap_exceptions
-    def open_files(self):
-        retlist = []
-        hit_enoent = False
-        pathdir = '/proc/%d/path' % self.pid
-        for fd in os.listdir('/proc/%d/fd' % self.pid):
-            path = os.path.join(pathdir, fd)
-            if os.path.islink(path):
-                try:
-                    file = os.readlink(path)
-                except OSError as err:
-                    # ENOENT == file which is gone in the meantime
-                    if err.errno == errno.ENOENT:
-                        hit_enoent = True
-                        continue
-                    raise
-                else:
-                    if isfile_strict(file):
-                        retlist.append(_common.popenfile(file, int(fd)))
-        if hit_enoent:
-            # raise NSP if the process disappeared on us
-            os.stat('/proc/%s' % self.pid)
-        return retlist
-
-    def _get_unix_sockets(self, pid):
-        """Get UNIX sockets used by process by parsing 'pfiles' output."""
-        # TODO: rewrite this in C (...but the damn netstat source code
-        # does not include this part! Argh!!)
-        cmd = "pfiles %s" % pid
-        p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE,
-                             stderr=subprocess.PIPE)
-        stdout, stderr = p.communicate()
-        if PY3:
-            stdout, stderr = [x.decode(sys.stdout.encoding)
-                              for x in (stdout, stderr)]
-        if p.returncode != 0:
-            if 'permission denied' in stderr.lower():
-                raise AccessDenied(self.pid, self._name)
-            if 'no such process' in stderr.lower():
-                raise NoSuchProcess(self.pid, self._name)
-            raise RuntimeError("%r command error\n%s" % (cmd, stderr))
-
-        lines = stdout.split('\n')[2:]
-        for i, line in enumerate(lines):
-            line = line.lstrip()
-            if line.startswith('sockname: AF_UNIX'):
-                path = line.split(' ', 2)[2]
-                type = lines[i - 2].strip()
-                if type == 'SOCK_STREAM':
-                    type = socket.SOCK_STREAM
-                elif type == 'SOCK_DGRAM':
-                    type = socket.SOCK_DGRAM
-                else:
-                    type = -1
-                yield (-1, socket.AF_UNIX, type, path, "", _common.CONN_NONE)
-
-    @wrap_exceptions
-    def connections(self, kind='inet'):
-        ret = net_connections(kind, _pid=self.pid)
-        # The underlying C implementation retrieves all OS connections
-        # and filters them by PID.  At this point we can't tell whether
-        # an empty list means there were no connections for process or
-        # process is no longer active so we force NSP in case the PID
-        # is no longer there.
-        if not ret:
-            os.stat('/proc/%s' % self.pid)  # will raise NSP if process is gone
-
-        # UNIX sockets
-        if kind in ('all', 'unix'):
-            ret.extend([_common.pconn(*conn) for conn in
-                        self._get_unix_sockets(self.pid)])
-        return ret
-
-    nt_mmap_grouped = namedtuple('mmap', 'path rss anon locked')
-    nt_mmap_ext = namedtuple('mmap', 'addr perms path rss anon locked')
-
-    @wrap_exceptions
-    def memory_maps(self):
-        def toaddr(start, end):
-            return '%s-%s' % (hex(start)[2:].strip('L'),
-                              hex(end)[2:].strip('L'))
-
-        retlist = []
-        rawlist = cext.proc_memory_maps(self.pid)
-        hit_enoent = False
-        for item in rawlist:
-            addr, addrsize, perm, name, rss, anon, locked = item
-            addr = toaddr(addr, addrsize)
-            if not name.startswith('['):
-                try:
-                    name = os.readlink('/proc/%s/path/%s' % (self.pid, name))
-                except OSError as err:
-                    if err.errno == errno.ENOENT:
-                        # sometimes the link may not be resolved by
-                        # readlink() even if it exists (ls shows it).
-                        # If that's the case we just return the
-                        # unresolved link path.
-                        # This seems an incosistency with /proc similar
-                        # to: http://goo.gl/55XgO
-                        name = '/proc/%s/path/%s' % (self.pid, name)
-                        hit_enoent = True
-                    else:
-                        raise
-            retlist.append((addr, perm, name, rss, anon, locked))
-        if hit_enoent:
-            # raise NSP if the process disappeared on us
-            os.stat('/proc/%s' % self.pid)
-        return retlist
-
-    @wrap_exceptions
-    def num_fds(self):
-        return len(os.listdir("/proc/%s/fd" % self.pid))
-
-    @wrap_exceptions
-    def num_ctx_switches(self):
-        return _common.pctxsw(*cext.proc_num_ctx_switches(self.pid))
-
-    @wrap_exceptions
-    def wait(self, timeout=None):
-        try:
-            return _psposix.wait_pid(self.pid, timeout)
-        except _psposix.TimeoutExpired:
-            # support for private module import
-            if TimeoutExpired is None:
-                raise
-            raise TimeoutExpired(timeout, self.pid, self._name)
diff --git a/io_scenario/libs/ubuntu_14_04_x64/psutil/_pswindows.py b/io_scenario/libs/ubuntu_14_04_x64/psutil/_pswindows.py
deleted file mode 100644
index 6068446..0000000
--- a/io_scenario/libs/ubuntu_14_04_x64/psutil/_pswindows.py
+++ /dev/null
@@ -1,484 +0,0 @@
-#!/usr/bin/env python
-
-# Copyright (c) 2009, Giampaolo Rodola'. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-"""Windows platform implementation."""
-
-import errno
-import functools
-import os
-from collections import namedtuple
-
-from psutil import _common
-from psutil._common import conn_tmap, usage_percent, isfile_strict
-from psutil._compat import PY3, xrange, lru_cache
-import _psutil_windows as cext
-
-# process priority constants, import from __init__.py:
-# http://msdn.microsoft.com/en-us/library/ms686219(v=vs.85).aspx
-__extra__all__ = ["ABOVE_NORMAL_PRIORITY_CLASS", "BELOW_NORMAL_PRIORITY_CLASS",
-                  "HIGH_PRIORITY_CLASS", "IDLE_PRIORITY_CLASS",
-                  "NORMAL_PRIORITY_CLASS", "REALTIME_PRIORITY_CLASS",
-                  #
-                  "CONN_DELETE_TCB",
-                  ]
-
-# --- module level constants (gets pushed up to psutil module)
-
-CONN_DELETE_TCB = "DELETE_TCB"
-WAIT_TIMEOUT = 0x00000102  # 258 in decimal
-ACCESS_DENIED_SET = frozenset([errno.EPERM, errno.EACCES,
-                               cext.ERROR_ACCESS_DENIED])
-
-TCP_STATUSES = {
-    cext.MIB_TCP_STATE_ESTAB: _common.CONN_ESTABLISHED,
-    cext.MIB_TCP_STATE_SYN_SENT: _common.CONN_SYN_SENT,
-    cext.MIB_TCP_STATE_SYN_RCVD: _common.CONN_SYN_RECV,
-    cext.MIB_TCP_STATE_FIN_WAIT1: _common.CONN_FIN_WAIT1,
-    cext.MIB_TCP_STATE_FIN_WAIT2: _common.CONN_FIN_WAIT2,
-    cext.MIB_TCP_STATE_TIME_WAIT: _common.CONN_TIME_WAIT,
-    cext.MIB_TCP_STATE_CLOSED: _common.CONN_CLOSE,
-    cext.MIB_TCP_STATE_CLOSE_WAIT: _common.CONN_CLOSE_WAIT,
-    cext.MIB_TCP_STATE_LAST_ACK: _common.CONN_LAST_ACK,
-    cext.MIB_TCP_STATE_LISTEN: _common.CONN_LISTEN,
-    cext.MIB_TCP_STATE_CLOSING: _common.CONN_CLOSING,
-    cext.MIB_TCP_STATE_DELETE_TCB: CONN_DELETE_TCB,
-    cext.PSUTIL_CONN_NONE: _common.CONN_NONE,
-}
-
-
-scputimes = namedtuple('scputimes', ['user', 'system', 'idle'])
-svmem = namedtuple('svmem', ['total', 'available', 'percent', 'used', 'free'])
-pextmem = namedtuple(
-    'pextmem', ['num_page_faults', 'peak_wset', 'wset', 'peak_paged_pool',
-                'paged_pool', 'peak_nonpaged_pool', 'nonpaged_pool',
-                'pagefile', 'peak_pagefile', 'private'])
-pmmap_grouped = namedtuple('pmmap_grouped', ['path', 'rss'])
-pmmap_ext = namedtuple(
-    'pmmap_ext', 'addr perms ' + ' '.join(pmmap_grouped._fields))
-
-# set later from __init__.py
-NoSuchProcess = None
-AccessDenied = None
-TimeoutExpired = None
-
-
-@lru_cache(maxsize=512)
-def _win32_QueryDosDevice(s):
-    return cext.win32_QueryDosDevice(s)
-
-
-def _convert_raw_path(s):
-    # convert paths using native DOS format like:
-    # "\Device\HarddiskVolume1\Windows\systemew\file.txt"
-    # into: "C:\Windows\systemew\file.txt"
-    if PY3 and not isinstance(s, str):
-        s = s.decode('utf8')
-    rawdrive = '\\'.join(s.split('\\')[:3])
-    driveletter = _win32_QueryDosDevice(rawdrive)
-    return os.path.join(driveletter, s[len(rawdrive):])
-
-
-# --- public functions
-
-
-def virtual_memory():
-    """System virtual memory as a namedtuple."""
-    mem = cext.virtual_mem()
-    totphys, availphys, totpagef, availpagef, totvirt, freevirt = mem
-    #
-    total = totphys
-    avail = availphys
-    free = availphys
-    used = total - avail
-    percent = usage_percent((total - avail), total, _round=1)
-    return svmem(total, avail, percent, used, free)
-
-
-def swap_memory():
-    """Swap system memory as a (total, used, free, sin, sout) tuple."""
-    mem = cext.virtual_mem()
-    total = mem[2]
-    free = mem[3]
-    used = total - free
-    percent = usage_percent(used, total, _round=1)
-    return _common.sswap(total, used, free, percent, 0, 0)
-
-
-def disk_usage(path):
-    """Return disk usage associated with path."""
-    try:
-        total, free = cext.disk_usage(path)
-    except WindowsError:
-        if not os.path.exists(path):
-            msg = "No such file or directory: '%s'" % path
-            raise OSError(errno.ENOENT, msg)
-        raise
-    used = total - free
-    percent = usage_percent(used, total, _round=1)
-    return _common.sdiskusage(total, used, free, percent)
-
-
-def disk_partitions(all):
-    """Return disk partitions."""
-    rawlist = cext.disk_partitions(all)
-    return [_common.sdiskpart(*x) for x in rawlist]
-
-
-def cpu_times():
-    """Return system CPU times as a named tuple."""
-    user, system, idle = cext.cpu_times()
-    return scputimes(user, system, idle)
-
-
-def per_cpu_times():
-    """Return system per-CPU times as a list of named tuples."""
-    ret = []
-    for cpu_t in cext.per_cpu_times():
-        user, system, idle = cpu_t
-        item = scputimes(user, system, idle)
-        ret.append(item)
-    return ret
-
-
-def cpu_count_logical():
-    """Return the number of logical CPUs in the system."""
-    return cext.cpu_count_logical()
-
-
-def cpu_count_physical():
-    """Return the number of physical CPUs in the system."""
-    return cext.cpu_count_phys()
-
-
-def boot_time():
-    """The system boot time expressed in seconds since the epoch."""
-    return cext.boot_time()
-
-
-def net_connections(kind, _pid=-1):
-    """Return socket connections.  If pid == -1 return system-wide
-    connections (as opposed to connections opened by one process only).
-    """
-    if kind not in conn_tmap:
-        raise ValueError("invalid %r kind argument; choose between %s"
-                         % (kind, ', '.join([repr(x) for x in conn_tmap])))
-    families, types = conn_tmap[kind]
-    rawlist = cext.net_connections(_pid, families, types)
-    ret = []
-    for item in rawlist:
-        fd, fam, type, laddr, raddr, status, pid = item
-        status = TCP_STATUSES[status]
-        if _pid == -1:
-            nt = _common.sconn(fd, fam, type, laddr, raddr, status, pid)
-        else:
-            nt = _common.pconn(fd, fam, type, laddr, raddr, status)
-        ret.append(nt)
-    return ret
-
-
-def users():
-    """Return currently connected users as a list of namedtuples."""
-    retlist = []
-    rawlist = cext.users()
-    for item in rawlist:
-        user, hostname, tstamp = item
-        nt = _common.suser(user, None, hostname, tstamp)
-        retlist.append(nt)
-    return retlist
-
-
-pids = cext.pids
-pid_exists = cext.pid_exists
-net_io_counters = cext.net_io_counters
-disk_io_counters = cext.disk_io_counters
-ppid_map = cext.ppid_map  # not meant to be public
-
-
-def wrap_exceptions(fun):
-    """Decorator which translates bare OSError and WindowsError
-    exceptions into NoSuchProcess and AccessDenied.
-    """
-    @functools.wraps(fun)
-    def wrapper(self, *args, **kwargs):
-        try:
-            return fun(self, *args, **kwargs)
-        except OSError as err:
-            # support for private module import
-            if NoSuchProcess is None or AccessDenied is None:
-                raise
-            if err.errno in ACCESS_DENIED_SET:
-                raise AccessDenied(self.pid, self._name)
-            if err.errno == errno.ESRCH:
-                raise NoSuchProcess(self.pid, self._name)
-            raise
-    return wrapper
-
-
-class Process(object):
-    """Wrapper class around underlying C implementation."""
-
-    __slots__ = ["pid", "_name"]
-
-    def __init__(self, pid):
-        self.pid = pid
-        self._name = None
-
-    @wrap_exceptions
-    def name(self):
-        """Return process name, which on Windows is always the final
-        part of the executable.
-        """
-        # This is how PIDs 0 and 4 are always represented in taskmgr
-        # and process-hacker.
-        if self.pid == 0:
-            return "System Idle Process"
-        elif self.pid == 4:
-            return "System"
-        else:
-            return os.path.basename(self.exe())
-
-    @wrap_exceptions
-    def exe(self):
-        # Note: os.path.exists(path) may return False even if the file
-        # is there, see:
-        # http://stackoverflow.com/questions/3112546/os-path-exists-lies
-
-        # see https://github.com/giampaolo/psutil/issues/414
-        # see https://github.com/giampaolo/psutil/issues/528
-        if self.pid in (0, 4):
-            raise AccessDenied(self.pid, self._name)
-        return _convert_raw_path(cext.proc_exe(self.pid))
-
-    @wrap_exceptions
-    def cmdline(self):
-        return cext.proc_cmdline(self.pid)
-
-    def ppid(self):
-        try:
-            return ppid_map()[self.pid]
-        except KeyError:
-            raise NoSuchProcess(self.pid, self._name)
-
-    def _get_raw_meminfo(self):
-        try:
-            return cext.proc_memory_info(self.pid)
-        except OSError as err:
-            if err.errno in ACCESS_DENIED_SET:
-                return cext.proc_memory_info_2(self.pid)
-            raise
-
-    @wrap_exceptions
-    def memory_info(self):
-        # on Windows RSS == WorkingSetSize and VSM == PagefileUsage
-        # fields of PROCESS_MEMORY_COUNTERS struct:
-        # http://msdn.microsoft.com/en-us/library/windows/desktop/
-        #     ms684877(v=vs.85).aspx
-        t = self._get_raw_meminfo()
-        return _common.pmem(t[2], t[7])
-
-    @wrap_exceptions
-    def memory_info_ex(self):
-        return pextmem(*self._get_raw_meminfo())
-
-    def memory_maps(self):
-        try:
-            raw = cext.proc_memory_maps(self.pid)
-        except OSError as err:
-            # XXX - can't use wrap_exceptions decorator as we're
-            # returning a generator; probably needs refactoring.
-            if err.errno in ACCESS_DENIED_SET:
-                raise AccessDenied(self.pid, self._name)
-            if err.errno == errno.ESRCH:
-                raise NoSuchProcess(self.pid, self._name)
-            raise
-        else:
-            for addr, perm, path, rss in raw:
-                path = _convert_raw_path(path)
-                addr = hex(addr)
-                yield (addr, perm, path, rss)
-
-    @wrap_exceptions
-    def kill(self):
-        return cext.proc_kill(self.pid)
-
-    @wrap_exceptions
-    def wait(self, timeout=None):
-        if timeout is None:
-            timeout = cext.INFINITE
-        else:
-            # WaitForSingleObject() expects time in milliseconds
-            timeout = int(timeout * 1000)
-        ret = cext.proc_wait(self.pid, timeout)
-        if ret == WAIT_TIMEOUT:
-            # support for private module import
-            if TimeoutExpired is None:
-                raise RuntimeError("timeout expired")
-            raise TimeoutExpired(timeout, self.pid, self._name)
-        return ret
-
-    @wrap_exceptions
-    def username(self):
-        if self.pid in (0, 4):
-            return 'NT AUTHORITY\\SYSTEM'
-        return cext.proc_username(self.pid)
-
-    @wrap_exceptions
-    def create_time(self):
-        # special case for kernel process PIDs; return system boot time
-        if self.pid in (0, 4):
-            return boot_time()
-        try:
-            return cext.proc_create_time(self.pid)
-        except OSError as err:
-            if err.errno in ACCESS_DENIED_SET:
-                return cext.proc_create_time_2(self.pid)
-            raise
-
-    @wrap_exceptions
-    def num_threads(self):
-        return cext.proc_num_threads(self.pid)
-
-    @wrap_exceptions
-    def threads(self):
-        rawlist = cext.proc_threads(self.pid)
-        retlist = []
-        for thread_id, utime, stime in rawlist:
-            ntuple = _common.pthread(thread_id, utime, stime)
-            retlist.append(ntuple)
-        return retlist
-
-    @wrap_exceptions
-    def cpu_times(self):
-        try:
-            ret = cext.proc_cpu_times(self.pid)
-        except OSError as err:
-            if err.errno in ACCESS_DENIED_SET:
-                ret = cext.proc_cpu_times_2(self.pid)
-            else:
-                raise
-        return _common.pcputimes(*ret)
-
-    @wrap_exceptions
-    def suspend(self):
-        return cext.proc_suspend(self.pid)
-
-    @wrap_exceptions
-    def resume(self):
-        return cext.proc_resume(self.pid)
-
-    @wrap_exceptions
-    def cwd(self):
-        if self.pid in (0, 4):
-            raise AccessDenied(self.pid, self._name)
-        # return a normalized pathname since the native C function appends
-        # "\\" at the and of the path
-        path = cext.proc_cwd(self.pid)
-        return os.path.normpath(path)
-
-    @wrap_exceptions
-    def open_files(self):
-        if self.pid in (0, 4):
-            return []
-        retlist = []
-        # Filenames come in in native format like:
-        # "\Device\HarddiskVolume1\Windows\systemew\file.txt"
-        # Convert the first part in the corresponding drive letter
-        # (e.g. "C:\") by using Windows's QueryDosDevice()
-        raw_file_names = cext.proc_open_files(self.pid)
-        for file in raw_file_names:
-            file = _convert_raw_path(file)
-            if isfile_strict(file) and file not in retlist:
-                ntuple = _common.popenfile(file, -1)
-                retlist.append(ntuple)
-        return retlist
-
-    @wrap_exceptions
-    def connections(self, kind='inet'):
-        return net_connections(kind, _pid=self.pid)
-
-    @wrap_exceptions
-    def nice_get(self):
-        return cext.proc_priority_get(self.pid)
-
-    @wrap_exceptions
-    def nice_set(self, value):
-        return cext.proc_priority_set(self.pid, value)
-
-    # available on Windows >= Vista
-    if hasattr(cext, "proc_io_priority_get"):
-        @wrap_exceptions
-        def ionice_get(self):
-            return cext.proc_io_priority_get(self.pid)
-
-        @wrap_exceptions
-        def ionice_set(self, value, _):
-            if _:
-                raise TypeError("set_proc_ionice() on Windows takes only "
-                                "1 argument (2 given)")
-            if value not in (2, 1, 0):
-                raise ValueError("value must be 2 (normal), 1 (low) or 0 "
-                                 "(very low); got %r" % value)
-            return cext.proc_io_priority_set(self.pid, value)
-
-    @wrap_exceptions
-    def io_counters(self):
-        try:
-            ret = cext.proc_io_counters(self.pid)
-        except OSError as err:
-            if err.errno in ACCESS_DENIED_SET:
-                ret = cext.proc_io_counters_2(self.pid)
-            else:
-                raise
-        return _common.pio(*ret)
-
-    @wrap_exceptions
-    def status(self):
-        suspended = cext.proc_is_suspended(self.pid)
-        if suspended:
-            return _common.STATUS_STOPPED
-        else:
-            return _common.STATUS_RUNNING
-
-    @wrap_exceptions
-    def cpu_affinity_get(self):
-        from_bitmask = lambda x: [i for i in xrange(64) if (1 << i) & x]
-        bitmask = cext.proc_cpu_affinity_get(self.pid)
-        return from_bitmask(bitmask)
-
-    @wrap_exceptions
-    def cpu_affinity_set(self, value):
-        def to_bitmask(l):
-            if not l:
-                raise ValueError("invalid argument %r" % l)
-            out = 0
-            for b in l:
-                out |= 2 ** b
-            return out
-
-        # SetProcessAffinityMask() states that ERROR_INVALID_PARAMETER
-        # is returned for an invalid CPU but this seems not to be true,
-        # therefore we check CPUs validy beforehand.
-        allcpus = list(range(len(per_cpu_times())))
-        for cpu in value:
-            if cpu not in allcpus:
-                raise ValueError("invalid CPU %r" % cpu)
-
-        bitmask = to_bitmask(value)
-        cext.proc_cpu_affinity_set(self.pid, bitmask)
-
-    @wrap_exceptions
-    def num_handles(self):
-        try:
-            return cext.proc_num_handles(self.pid)
-        except OSError as err:
-            if err.errno in ACCESS_DENIED_SET:
-                return cext.proc_num_handles_2(self.pid)
-            raise
-
-    @wrap_exceptions
-    def num_ctx_switches(self):
-        tupl = cext.proc_num_ctx_switches(self.pid)
-        return _common.pctxsw(*tupl)
diff --git a/io_scenario/sensors.py b/io_scenario/sensors.py
deleted file mode 100644
index b7f8cd0..0000000
--- a/io_scenario/sensors.py
+++ /dev/null
@@ -1,56 +0,0 @@
-import os.path
-
-import psutil
-
-
-def get_disk_by_mountpoint(mnt_point):
-    """ Return disk of mountpoint """
-    diskparts = psutil.disk_partitions()
-    for item in diskparts:
-        if item.mountpoint == mnt_point:
-            return os.path.realpath(item.device)
-
-    raise OSError("Can't define disk for {0!r}".format(mnt_point))
-
-
-def find_mount_point(path):
-    """ Find mount point by provided path """
-    path = os.path.abspath(path)
-    while not os.path.ismount(path):
-        path = os.path.dirname(path)
-    return path
-
-
-class DiskInfo(object):
-    def __init__(self, name, rd_cnt=0, wr_cnt=0, rd_bytes=0,
-                 wr_bytes=0, rd_time=0, wr_time=0):
-        self.name = name
-        self.rd_cnt = rd_cnt
-        self.wr_cnt = wr_cnt
-        self.rd_bytes = rd_bytes
-        self.wr_bytes = wr_bytes
-        self.rd_time = rd_time
-        self.wr_time = wr_time
-
-    def __str__(self):
-        message = 'DISK {0.name}: read count {0.rd_cnt}' + \
-                  ', write count {0.wr_cnt}' + \
-                  ', read bytes {0.rd_bytes}' + \
-                  ', write bytes {0.wr_bytes}' + \
-                  ', read time {0.rd_time}' + \
-                  ', write time {0.wr_time}'
-        return message.format(self)
-
-
-def get_io_stats(path):
-    """ Return list of CEPHDiskInfo for all disks that used by CEPH on the
-        local node
-    """
-    stat = psutil.disk_io_counters(perdisk=True)
-    disk = get_disk_by_mountpoint(find_mount_point(path))
-    disk_base = os.path.basename(disk)
-    print disk_base
-    try:
-        return stat[disk_base]
-    except IndexError:
-        raise OSError("Disk {0} not found in stats".format(disk))
diff --git a/report.py b/report.py
index 434c844..4d23b60 100644
--- a/report.py
+++ b/report.py
@@ -1,9 +1,8 @@
 import argparse
 from collections import OrderedDict
-import sys
 
 from chart import charts
-
+from utils import ssize_to_kb
 
 
 OPERATIONS = (('async', ('randwrite asynchronous', 'randread asynchronous',
@@ -15,23 +14,6 @@
                    'a': 'asynchronous'}
 
 
-def ssize_to_kb(ssize):
-    try:
-        smap = dict(k=1, K=1, M=1024, m=1024, G=1024**2, g=1024**2)
-        for ext, coef in smap.items():
-            if ssize.endswith(ext):
-                return int(ssize[:-1]) * coef
-
-        if int(ssize) % 1024 != 0:
-            raise ValueError()
-
-        return int(ssize) / 1024
-
-    except (ValueError, TypeError, AttributeError):
-        tmpl = "Unknow size format {0!r} (or size not multiples 1024)"
-        raise ValueError(tmpl.format(ssize))
-
-
 def parse_args(argv):
     parser = argparse.ArgumentParser()
     parser.add_argument('-s', '--storage', help='storage location', dest="url")
diff --git a/scripts/data2.py b/scripts/data2.py
new file mode 100644
index 0000000..08dbc77
--- /dev/null
+++ b/scripts/data2.py
@@ -0,0 +1,105 @@
+import sys
+import math
+import itertools
+
+
+def key(x):
+    return (x['__meta__']['blocksize'],
+            'd' if x['__meta__']['direct_io'] else 's',
+            x['__meta__']['action'],
+            x['__meta__']['concurence'])
+
+
+def med_dev(vals):
+    med = sum(vals) / len(vals)
+    dev = ((sum(abs(med - i) ** 2 for i in vals) / len(vals)) ** 0.5)
+    return int(med), int(dev)
+
+
+def round_deviation(med_dev):
+    med, dev = med_dev
+
+    if dev < 1E-7:
+        return med_dev
+
+    dev_div = 10.0 ** (math.floor(math.log10(dev)) - 1)
+    dev = int(dev / dev_div) * dev_div
+    med = int(med / dev_div) * dev_div
+    return (type(med_dev[0])(med),
+            type(med_dev[1])(dev))
+
+
+def groupby_globally(data, key_func):
+    grouped = {}
+    grouped_iter = itertools.groupby(data, key_func)
+
+    for (bs, cache_tp, act, conc), curr_data_it in grouped_iter:
+        key = (bs, cache_tp, act, conc)
+        grouped.setdefault(key, []).extend(curr_data_it)
+
+    return grouped
+
+
+template = "{bs:>4}  {action:>12}  {cache_tp:>3}  {conc:>4}"
+template += " | {iops[0]:>6} ~ {iops[1]:>5} | {bw[0]:>7} ~ {bw[1]:>6}"
+template += " | {lat[0]:>6} ~ {lat[1]:>5} |"
+
+headers = dict(bs="BS",
+               action="operation",
+               cache_tp="S/D",
+               conc="CONC",
+               iops=("IOPS", "dev"),
+               bw=("BW kBps", "dev"),
+               lat=("LAT ms", "dev"))
+
+
+def main(argv):
+    data = []
+
+    with open(argv[1]) as fc:
+        block = None
+        for line in fc:
+            if line.startswith("{'__meta__':"):
+                block = line
+            elif block is not None:
+                block += line
+
+            if block is not None:
+                if block.count('}') == block.count('{'):
+                    data.append(eval(block))
+                    block = None
+
+    grouped = groupby_globally(data, key)
+
+    print template.format(**headers)
+
+    for (bs, cache_tp, act, conc), curr_data in sorted(grouped.items()):
+        iops = med_dev([i['iops'] * int(conc) for i in curr_data])
+        bw_mean = med_dev([i['bw_mean'] * int(conc) for i in curr_data])
+        lat = med_dev([i['lat'] / 1000 for i in curr_data])
+
+        iops = round_deviation(iops)
+        bw_mean = round_deviation(bw_mean)
+        lat = round_deviation(lat)
+
+        params = dict(
+            bs=bs,
+            action=act,
+            cache_tp=cache_tp,
+            iops=iops,
+            bw=bw_mean,
+            lat=lat,
+            conc=conc
+        )
+
+        print template.format(**params)
+
+
+if __name__ == "__main__":
+    exit(main(sys.argv))
+
+    # vals = [(123, 23), (125678, 5678), (123.546756, 23.77),
+    #         (123.546756, 102.77), (0.1234, 0.0224),
+    #         (0.001234, 0.000224), (0.001234, 0.0000224)]
+    # for val in :
+    #     print val, "=>", round_deviation(val)
diff --git a/scripts/gen_load.sh b/scripts/gen_load.sh
new file mode 100755
index 0000000..e3af3cd
--- /dev/null
+++ b/scripts/gen_load.sh
@@ -0,0 +1,21 @@
+#!/bin/bash
+
+TESTER="--tester-type fio"
+CACHE="--cache-modes d"
+REPEATS="--repeats 3"
+
+# python generate_load.py $TESTER --size 4k --opers randwrite $CACHE --concurrences 1 --direct-default-size x1000
+# python generate_load.py $TESTER --size 4k --opers randwrite $CACHE --concurrences 1 --direct-default-size x2000
+# python generate_load.py $TESTER --size 4k --opers randwrite $CACHE --concurrences 1 --direct-default-size x4000
+# python generate_load.py $TESTER --size 4k --opers randwrite $CACHE --concurrences 1 --direct-default-size x8000
+# python generate_load.py $TESTER --size 4k --opers randwrite $CACHE --concurrences 1 --direct-default-size x16000
+# python generate_load.py $TESTER --size 4k --opers randwrite $CACHE --concurrences 1 --direct-default-size x32000
+# python generate_load.py $TESTER --size 4k --opers randwrite $CACHE --concurrences 1 --direct-default-size x64000
+# python generate_load.py $TESTER --size 4k --opers randwrite $CACHE --concurrences 1 --direct-default-size x128000
+
+python generate_load.py $TESTER --size 4k --opers randwrite $CACHE --concurrences 1 4 8 $REPEATS --io-size 10G
+python generate_load.py $TESTER --size 4k --opers randread $CACHE --concurrences 1 4 8 $REPEATS --io-size 10G
+
+python generate_load.py $TESTER --size 4k --opers randwrite --cache-modes s --concurrences 1 $REPEATS --io-size 10G
+python generate_load.py $TESTER --size 4k --opers randread randwrite $CACHE --concurrences 1 $REPEATS --io-size 10G
+python generate_load.py $TESTER --size 2m --opers read write $CACHE --concurrences 1 $REPEATS --io-size 10G
diff --git a/scripts/generate_load.py b/scripts/generate_load.py
index f99c816..0d25038 100644
--- a/scripts/generate_load.py
+++ b/scripts/generate_load.py
@@ -1,14 +1,7 @@
-# BLOCK_SIZES = "1k 4k 64k 256k 1m"
-# OPERATIONS="randwrite write randread read"
-# SYNC_TYPES="s a d"
-# REPEAT_COUNT="3"
-# CONCURRENCES="1 8 64"
+import sys
+import argparse
 
-from utils import ssize_to_kb
-
-SYNC_FACTOR = "x500"
-DIRECT_FACTOR = "x10000"
-ASYNC_FACTOR = "r2"
+from disk_perf_test_tool.utils import ssize_to_b
 
 
 def make_list(x):
@@ -16,76 +9,97 @@
         return [x]
     return x
 
-HDD_SIZE_KB = 45 * 1000 * 1000
 
-
-def max_file():
-    pass
-
-
-def make_load(sizes, opers, sync_types, concurrence,
-              tester_type='iozone', repeat_count=3):
+def make_load(settings):
 
     iodepth = 1
-    for conc in make_list(concurrence):
-        for bsize in make_list(sizes):
-            for oper in make_list(opers):
-                for sync_type in make_list(sync_types):
+    for conc in make_list(settings.concurrences):
+        for bsize in make_list(settings.sizes):
+            for oper in make_list(settings.opers):
+                for cache_mode in make_list(settings.cache_modes):
 
                     # filter out too slow options
-                    if bsize in "1k 4k" and sync_type == "a":
+                    if bsize in "1k 4k" and cache_mode == "a":
                         continue
 
                     # filter out sync reads
-                    if oper in "read randread" and sync_type == "s":
+                    if oper in "read randread" and cache_mode == "s":
                         continue
 
-                    if sync_type == "s":
-                        size_sync_opts = "--iosize {0} -s".format(SYNC_FACTOR)
-                    elif sync_type == "d":
-                        if oper == 'randread':
-                            assert SYNC_FACTOR[0] == 'x'
-                            max_f = int(SYNC_FACTOR[1:])
-                        else:
-                            max_f = None
-
-                        mmax_f = HDD_SIZE_KB / (int(conc) * ssize_to_kb(bsize))
-
-                        if max_f is None or mmax_f > max_f:
-                            max_f = mmax_f
-
-                        assert DIRECT_FACTOR[0] == 'x'
-                        if max_f > int(DIRECT_FACTOR[1:]):
-                            max_f = DIRECT_FACTOR
-                        else:
-                            max_f = "x{0}".format(max_f)
-
-                        size_sync_opts = "--iosize {0} -d".format(max_f)
-
+                    if settings.io_size is not None:
+                        size_sync_opts = " --iosize " + str(settings.io_size)
+                        if cache_mode == "s":
+                            size_sync_opts += " -s"
+                        elif cache_mode == "d":
+                            size_sync_opts += " -d"
                     else:
-                        if oper == 'randread' or oper == 'read':
-                            size_sync_opts = "--iosize " + str(SYNC_FACTOR)
+                        if cache_mode == "s":
+                            size_sync_opts = "--iosize {0} -s".format(
+                                settings.sync_default_size)
+                        elif cache_mode == "d":
+                            if oper == 'randread':
+                                assert settings.sync_default_size[0] == 'x'
+                                max_f = int(settings.sync_default_size[1:])
+                            else:
+                                max_f = None
+
+                            mmax_f = ssize_to_b(settings.hdd_size) / \
+                                (int(conc) * ssize_to_b(bsize))
+
+                            if max_f is None or mmax_f > max_f:
+                                max_f = mmax_f
+
+                            assert settings.direct_default_size[0] == 'x'
+                            if max_f > int(settings.direct_default_size[1:]):
+                                max_f = settings.direct_default_size
+                            else:
+                                max_f = "x{0}".format(max_f)
+
+                            size_sync_opts = "--iosize {0} -d".format(max_f)
+
                         else:
-                            size_sync_opts = "--iosize " + str(ASYNC_FACTOR)
+                            if oper == 'randread' or oper == 'read':
+                                size_sync_opts = "--iosize " + \
+                                    str(settings.sync_default_size)
+                            else:
+                                size_sync_opts = "--iosize " + \
+                                    str(settings.sync_default_size)
 
                     # size_sync_opts = get_file_size_opts(sync_type)
 
-                    io_opts = "--type {0} ".format(tester_type)
+                    io_opts = "--type {0} ".format(settings.tester_type)
                     io_opts += "-a {0} ".format(oper)
                     io_opts += "--iodepth {0} ".format(iodepth)
                     io_opts += "--blocksize {0} ".format(bsize)
                     io_opts += size_sync_opts + " "
                     io_opts += "--concurrency {0}".format(conc)
 
-                    for i in range(repeat_count):
+                    for i in range(settings.repeats):
                         yield io_opts
 
 
-sizes = "4k 64k 2m".split()
-opers = "randwrite write randread read".split()
-sync_types = "s a d".split()
-concurrence = "1 8 64".split()
+def parse_opts(args):
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--sizes', nargs="+", required=True)
+    parser.add_argument('--opers', nargs="+", required=True)
+    parser.add_argument('--cache-modes', nargs="+", required=True)
+    parser.add_argument('--concurrences', nargs="+", required=True)
+    parser.add_argument('--repeats', type=int, default=3)
+    parser.add_argument("--hdd-size", default="45G")
+    parser.add_argument("--tester-type", default="iozone")
+    parser.add_argument("--io-size", default=None)
 
-for io_opts in make_load(sizes=sizes, concurrence=concurrence,
-                         sync_types=sync_types, opers=opers):
-    print io_opts
+    parser.add_argument("--direct-default-size", default="x1000")
+    parser.add_argument("--sync-default-size", default="x1000")
+    parser.add_argument("--async-default-size", default="r2")
+
+    return parser.parse_args(args[1:])
+
+
+def main(args):
+    opts = parse_opts(args)
+    for io_opts in make_load(opts):
+        print "python io.py --test-file /opt/xxx.bin " + io_opts
+
+if __name__ == "__main__":
+    exit(main(sys.argv))
diff --git a/scripts/prepare.sh b/scripts/prepare.sh
index 3d85072..7151b2f 100644
--- a/scripts/prepare.sh
+++ b/scripts/prepare.sh
@@ -6,7 +6,7 @@
 
 # settings
 FL_RAM=256
-FL_HDD=50
+FL_HDD=20
 FL_CPU=1
 
 
@@ -100,6 +100,7 @@
     if [ -z "$keypair_id" ] ; then
         echo "Creating server group $SERV_GROUP. Key would be stored into $KEY_FILE_NAME"
         nova keypair-add "$KEYPAIR_NAME" > "$KEY_FILE_NAME"
+        chmod og= "$KEY_FILE_NAME"
     fi
 
     echo "Adding rules for ping and ssh"
diff --git a/scripts/run_vm.sh b/scripts/run_vm.sh
new file mode 100644
index 0000000..ddc5cfc
--- /dev/null
+++ b/scripts/run_vm.sh
@@ -0,0 +1,75 @@
+#!/bin/bash
+MASTER_IP=$1
+FUEL_PASSWD=$2
+
+OS_ORIGIN_IP=192.168.0.2
+OS_EXT_IP=172.16.53.2
+VM_NAME=koder-disk-test
+
+FIXED_NET_NAME="net04"
+FLOATING_NET="net04_ext"
+
+my_dir="$(dirname "$0")"
+source "$my_dir/config.sh"
+SSH_OVER_MASTER="sshpass -p${FUEL_PASSWD} ssh root@${MASTER_IP}"
+VOLUME_NAME="test-volume"
+VOLUME_SIZE=20
+VOLUME_DEVICE="/dev/vdb"
+
+# VM_IP=$(nova floating-ip-create "$FLOATIN_NET" | grep "$FLOATIN_NET" | awk '{print $2}')
+VM_IP=172.16.53.18
+
+function get_openrc() {
+	OPENRC=`tempfile`
+	CONTROLLER_NODE=$($SSH_OVER_MASTER fuel node | grep controller | awk '-F|' '{gsub(" ", "", $5); print $5}')
+	$SSH_OVER_MASTER ssh $CONTROLLER_NODE cat openrc 2>/dev/null | sed "s/$OS_ORIGIN_IP/$OS_EXT_IP/g" > $OPENRC
+	echo $OPENRC
+}
+
+function boot_vm() {
+	FIXED_NET_ID=$(nova net-list | grep "\b${FIXED_NET_NAME}\b" | awk '{print $2}')
+	nova boot --flavor "$FLAVOR_NAME" --image "$IMAGE_NAME" --key-name "$KEYPAIR_NAME" --security-groups default --nic net-id=$FIXED_NET_ID $VM_NAME
+	nova floating-ip-associate $VM_NAME $VM_IP
+	VOL_ID=$(cinder create --display-name $VOLUME_NAME $VOLUME_SIZE | grep '\bid\b' | awk '{print $4}')
+	nova volume-attach $VM_NAME $VOL_ID $VOLUME_DEVICE
+}
+
+function prepare_vm() {
+	scp -i "$KEY_FILE_NAME" -r ../io_scenario ubuntu@${VM_IP}:/tmp
+	scp -i "$KEY_FILE_NAME" $DEBS ubuntu@${VM_IP}:/tmp
+	scp -i "$KEY_FILE_NAME" single_node_test_short.sh ubuntu@${VM_IP}:/tmp
+	ssh -i "$KEY_FILE_NAME" ubuntu@${VM_IP} sudo dpkg -i $DEBS
+}
+
+function prepare_node() {
+	COMPUTE_NODE=$($SSH_OVER_MASTER fuel node | grep compute | awk '-F|' '{gsub(" ", "", $5); print $5}')
+
+	sshpass -p${FUEL_PASSWD} scp -r ../io_scenario root@${MASTER_IP}:/tmp
+	$SSH_OVER_MASTER scp -r /tmp/io_scenario $COMPUTE_NODE:/tmp
+
+	sshpass -p${FUEL_PASSWD} scp $DEBS root@${MASTER_IP}:/tmp
+
+	$SSH_OVER_MASTER scp $DEBS $COMPUTE_NODE:/tmp
+	$SSH_OVER_MASTER ssh $COMPUTE_NODE dpkg -i $DEBS
+
+	sshpass -p${FUEL_PASSWD} scp single_node_test_short.sh root@${MASTER_IP}:/tmp
+	$SSH_OVER_MASTER scp /tmp/single_node_test_short.sh $COMPUTE_NODE:/tmp
+}
+
+function download_debs() {
+	pushd /tmp >/dev/null
+	rm -f *.deb >/dev/null
+	aptitude download libibverbs1 librdmacm1 libaio1 fio >/dev/null
+	popd >/dev/null
+	echo /tmp/*.deb
+}
+
+DEBS=`download_debs`
+OPENRC=`get_openrc`
+source $OPENRC
+rm $OPENRC
+
+boot_vm
+prepare_vm
+
+
diff --git a/scripts/show_disk_delta.py b/scripts/show_disk_delta.py
index 634b201..754e7a8 100644
--- a/scripts/show_disk_delta.py
+++ b/scripts/show_disk_delta.py
@@ -1,7 +1,7 @@
 import os
 import sys
 import time
-# import pprint
+import pprint
 import threading
 
 
@@ -36,8 +36,11 @@
     return {key: (val - obj2[key]) for key, val in obj1.items()}
 
 
-def run_tool(cmd, suppress_console=True):
-    os.system(" ".join(cmd) + " >/dev/null 2>&1 ")
+def run_tool(cmd, suppress_console=False):
+    s_cmd = " ".join(cmd)
+    if suppress_console:
+        s_cmd += " >/dev/null 2>&1 "
+    os.system(s_cmd)
 
 devices = sys.argv[1].split(',')
 cmd = sys.argv[2:]
@@ -47,6 +50,7 @@
 
 rstats = read_dstats()
 prev_stats = {device: rstats[device] for device in devices}
+begin_stats = prev_stats
 
 th.start()
 
@@ -58,15 +62,15 @@
     rstats = read_dstats()
     new_stats = {device: rstats[device] for device in devices}
 
-    print "Delta writes complete =",
+    # print "Delta writes complete =",
     for device in devices:
         delta = new_stats[device][wr_compl] - prev_stats[device][wr_compl]
-        print device, delta,
-    print
+        # print device, delta,
+    # print
 
     prev_stats = new_stats
 
     if not th.is_alive():
         break
 
-# pprint.pprint(diff_stats(stat2, stat1))
+pprint.pprint(diff_stats(new_stats[device], begin_stats[device]))
diff --git a/scripts/single_node_test_short.sh b/scripts/single_node_test_short.sh
new file mode 100644
index 0000000..384e8bd
--- /dev/null
+++ b/scripts/single_node_test_short.sh
@@ -0,0 +1,34 @@
+#!/bin/bash
+set -x
+
+TEST_FILE=$1
+OUT_FILE=$2
+NUM_CYCLES=7
+
+function run_tests(){
+	OPTS="--test-file $TEST_FILE --type fio --iodepth 1 --iosize 10G"
+
+	sync ; echo 3 > /proc/sys/vm/drop_caches ; python io.py $OPTS -a randwrite --blocksize 4k -d --concurrency 1
+
+	sync ; echo 3 > /proc/sys/vm/drop_caches ; dd if=/dev/zero of=$TEST_FILE bs=1048576 count=10240
+	sync ; echo 3 > /proc/sys/vm/drop_caches ; dd if=/dev/zero of=$TEST_FILE bs=1048576 count=10240
+
+	for cycle in $(seq $NUM_CYCLES) ; do
+		for conc in 1 4 8 ; do
+			sync ; echo 3 > /proc/sys/vm/drop_caches ; python io.py $OPTS -a randwrite --blocksize 4k -d --concurrency $conc
+		done
+
+		for conc in 1 4 8 ; do
+			sync ; echo 3 > /proc/sys/vm/drop_caches ; python io.py $OPTS -a randread  --blocksize 4k -d --concurrency $conc
+		done
+
+		sync ; echo 3 > /proc/sys/vm/drop_caches ; python io.py $OPTS -a randwrite --blocksize 4k -s --concurrency 1
+
+		sync ; echo 3 > /proc/sys/vm/drop_caches ; python io.py $OPTS -a read      --blocksize 2m -d --concurrency 1
+		sync ; echo 3 > /proc/sys/vm/drop_caches ; python io.py $OPTS -a write     --blocksize 2m -d --concurrency 1
+	done
+}
+
+run_tests "$FILE_1" 2>&1 | tee "$OUT_FILE"
+
+
diff --git a/sensors/host1_config.json b/sensors/host1_config.json
deleted file mode 100644
index 5f9d2e8..0000000
--- a/sensors/host1_config.json
+++ /dev/null
@@ -1,19 +0,0 @@
-{
-	"block-io": {
-		"allowed_prefixes": ["sdb1"]
-	},
-	"net-io": {
-		"allowed_prefixes": ["eth0"]
-	},
-    "system-cpu": {
-        "allowed_prefixes": ["cpu"]
-    },
-    "system-ram": {
-    },
-    "perprocess-cpu": {
-        "allowed_prefixes": ["ceph"]
-    },
-    "perprocess-ram": {
-        "allowed_prefixes": ["ceph"]
-    }
-}
diff --git a/utils.py b/utils.py
index ca65409..5b9c0a5 100644
--- a/utils.py
+++ b/utils.py
@@ -154,3 +154,16 @@
     except (ValueError, TypeError, AttributeError):
         tmpl = "Unknow size format {0!r} (or size not multiples 1024)"
         raise ValueError(tmpl.format(ssize))
+
+
+def ssize_to_b(ssize):
+    try:
+        smap = dict(k=1, K=1, M=1024, m=1024, G=1024**2, g=1024**2)
+        for ext, coef in smap.items():
+            if ssize.endswith(ext):
+                return int(ssize[:-1]) * coef * 1024
+
+        return int(ssize)
+    except (ValueError, TypeError, AttributeError):
+        tmpl = "Unknow size format {0!r} (or size not multiples 1024)"
+        raise ValueError(tmpl.format(ssize))