1 files changed, 211 insertions, 0 deletions
diff --git a/Tools/pybench/pybench-2.0/systimes.py b/Tools/pybench/pybench-2.0/systimes.py
new file mode 100644
index 0000000..bf07e36
--- /dev/null
+++ b/Tools/pybench/pybench-2.0/systimes.py
@@ -0,0 +1,211 @@
+#!/usr/bin/env python
+
+""" systimes() user and system timer implementations for use by
+    pybench.
+
+    This module implements various different strategies for measuring
+    performance timings. It tries to choose the best available method
+    based on the platforma and available tools.
+
+    On Windows, it is recommended to have the Mark Hammond win32
+    package installed. Alternatively, the Thomas Heller ctypes
+    packages can also be used.
+
+    On Unix systems, the standard resource module provides the highest
+    resolution timings. Unfortunately, it is not available on all Unix
+    platforms.
+
+    If no supported timing methods based on process time can be found,
+    the module reverts to the highest resolution wall-clock timer
+    instead. The system time part will then always be 0.0.
+
+    The module exports one public API:
+
+    def systimes():
+
+        Return the current timer values for measuring user and system
+        time as tuple of seconds (user_time, system_time).
+
+    Copyright (c) 2006, Marc-Andre Lemburg (mal@egenix.com). See the
+    documentation for further information on copyrights, or contact
+    the author. All Rights Reserved.
+
+"""
+import time, sys, struct
+
+#
+# Note: Please keep this module compatible to Python 1.5.2.
+#
+# TODOs:
+#
+# * Add ctypes wrapper for new clock_gettime() real-time POSIX APIs;
+#   these will then provide nano-second resolution where available.
+#
+# * Add a function that returns the resolution of systimes()
+#   values, ie. systimesres().
+#
+
+### Choose an implementation
+
+SYSTIMES_IMPLEMENTATION = None
+USE_CTYPES_GETPROCESSTIMES = 'cytpes GetProcessTimes() wrapper'
+USE_WIN32PROCESS_GETPROCESSTIMES = 'win32process.GetProcessTimes()'
+USE_RESOURCE_GETRUSAGE = 'resource.getrusage()'
+USE_PROCESS_TIME_CLOCK = 'time.clock() (process time)'
+USE_WALL_TIME_CLOCK = 'time.clock() (wall-clock)'
+USE_WALL_TIME_TIME = 'time.time() (wall-clock)'
+
+if sys.platform[:3] == 'win':
+    # Windows platform
+    try:
+        import win32process
+    except ImportError:
+        try:
+            import ctypes
+        except ImportError:
+            # Use the wall-clock implementation time.clock(), since this
+            # is the highest resolution clock available on Windows
+            SYSTIMES_IMPLEMENTATION = USE_WALL_TIME_CLOCK
+        else:
+            SYSTIMES_IMPLEMENTATION = USE_CTYPES_GETPROCESSTIMES
+    else:
+        SYSTIMES_IMPLEMENTATION = USE_WIN32PROCESS_GETPROCESSTIMES
+else:
+    # All other platforms
+    try:
+        import resource
+    except ImportError:
+        pass
+    else:
+        SYSTIMES_IMPLEMENTATION = USE_RESOURCE_GETRUSAGE
+
+# Fall-back solution
+if SYSTIMES_IMPLEMENTATION is None:
+    # Check whether we can use time.clock() as approximation
+    # for systimes()
+    start = time.clock()
+    time.sleep(0.1)
+    stop = time.clock()
+    if stop - start < 0.001:
+        # Looks like time.clock() is usable (and measures process
+        # time)
+        SYSTIMES_IMPLEMENTATION = USE_PROCESS_TIME_CLOCK
+    else:
+        # Use wall-clock implementation time.time() since this provides
+        # the highest resolution clock on most systems
+        SYSTIMES_IMPLEMENTATION = USE_WALL_TIME_TIME
+
+### Implementations
+
+def getrusage_systimes():
+    return resource.getrusage(resource.RUSAGE_SELF)[:2]
+
+def process_time_clock_systimes():
+    return (time.clock(), 0.0)
+
+def wall_clock_clock_systimes():
+    return (time.clock(), 0.0)
+
+def wall_clock_time_systimes():
+    return (time.time(), 0.0)
+
+# Number of clock ticks per second for the values returned
+# by GetProcessTimes() on Windows.
+#
+# Note: Ticks returned by GetProcessTimes() are 100ns intervals on
+# Windows XP. However, the process times are only updated with every
+# clock tick and the frequency of these is somewhat lower: depending
+# on the OS version between 10ms and 15ms. Even worse, the process
+# time seems to be allocated to process currently running when the
+# clock interrupt arrives, ie. it is possible that the current time
+# slice gets accounted to a different process.
+
+WIN32_PROCESS_TIMES_TICKS_PER_SECOND = 1e7
+
+def win32process_getprocesstimes_systimes():
+    d = win32process.GetProcessTimes(win32process.GetCurrentProcess())
+    return (d['UserTime'] / WIN32_PROCESS_TIMES_TICKS_PER_SECOND,
+            d['KernelTime'] / WIN32_PROCESS_TIMES_TICKS_PER_SECOND)
+
+def ctypes_getprocesstimes_systimes():
+    creationtime = ctypes.c_ulonglong()
+    exittime = ctypes.c_ulonglong()
+    kerneltime = ctypes.c_ulonglong()
+    usertime = ctypes.c_ulonglong()
+    rc = ctypes.windll.kernel32.GetProcessTimes(
+        ctypes.windll.kernel32.GetCurrentProcess(),
+        ctypes.byref(creationtime),
+        ctypes.byref(exittime),
+        ctypes.byref(kerneltime),
+        ctypes.byref(usertime))
+    if not rc:
+        raise TypeError('GetProcessTimes() returned an error')
+    return (usertime.value / WIN32_PROCESS_TIMES_TICKS_PER_SECOND,
+            kerneltime.value / WIN32_PROCESS_TIMES_TICKS_PER_SECOND)
+
+# Select the default for the systimes() function
+
+if SYSTIMES_IMPLEMENTATION is USE_RESOURCE_GETRUSAGE:
+    systimes = getrusage_systimes
+
+elif SYSTIMES_IMPLEMENTATION is USE_PROCESS_TIME_CLOCK:
+    systimes = process_time_clock_systimes
+
+elif SYSTIMES_IMPLEMENTATION is USE_WALL_TIME_CLOCK:
+    systimes = wall_clock_clock_systimes
+
+elif SYSTIMES_IMPLEMENTATION is USE_WALL_TIME_TIME:
+    systimes = wall_clock_time_systimes
+
+elif SYSTIMES_IMPLEMENTATION is USE_WIN32PROCESS_GETPROCESSTIMES:
+    systimes = win32process_getprocesstimes_systimes
+
+elif SYSTIMES_IMPLEMENTATION is USE_CTYPES_GETPROCESSTIMES:
+    systimes = ctypes_getprocesstimes_systimes
+
+else:
+    raise TypeError('no suitable systimes() implementation found')
+
+def processtime():
+
+    """ Return the total time spent on the process.
+
+        This is the sum of user and system time as returned by
+        systimes().
+
+    """
+    user, system = systimes()
+    return user + system
+
+### Testing
+
+def some_workload():
+    x = 0L
+    for i in xrange(10000000L):
+        x = x + 1L
+
+def test_workload():
+    print 'Testing systimes() under load conditions'
+    t0 = systimes()
+    some_workload()
+    t1 = systimes()
+    print 'before:', t0
+    print 'after:', t1
+    print 'differences:', (t1[0] - t0[0], t1[1] - t0[1])
+    print
+
+def test_idle():
+    print 'Testing systimes() under idle conditions'
+    t0 = systimes()
+    time.sleep(1)
+    t1 = systimes()
+    print 'before:', t0
+    print 'after:', t1
+    print 'differences:', (t1[0] - t0[0], t1[1] - t0[1])
+    print
+
+if __name__ == '__main__':
+    print 'Using %s as timer' % SYSTIMES_IMPLEMENTATION
+    print
+    test_workload()
+    test_idle()