--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/symbian-qemu-0.9.1-12/python-2.6.1/Tools/pybench/systimes.py Fri Jul 31 15:01:17 2009 +0100
@@ -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
+
+#
+# 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 = 'ctypes 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()