diff options
Diffstat (limited to 'scripts/training/cmert-0.5/python/psyco')
| -rw-r--r-- | scripts/training/cmert-0.5/python/psyco/__init__.py | 57 | ||||
| -rwxr-xr-x | scripts/training/cmert-0.5/python/psyco/_psyco.so | bin | 839774 -> 0 bytes | |||
| -rw-r--r-- | scripts/training/cmert-0.5/python/psyco/classes.py | 53 | ||||
| -rw-r--r-- | scripts/training/cmert-0.5/python/psyco/core.py | 232 | ||||
| -rw-r--r-- | scripts/training/cmert-0.5/python/psyco/kdictproxy.py | 133 | ||||
| -rw-r--r-- | scripts/training/cmert-0.5/python/psyco/logger.py | 90 | ||||
| -rw-r--r-- | scripts/training/cmert-0.5/python/psyco/profiler.py | 388 | ||||
| -rw-r--r-- | scripts/training/cmert-0.5/python/psyco/support.py | 196 |
8 files changed, 0 insertions, 1149 deletions
diff --git a/scripts/training/cmert-0.5/python/psyco/__init__.py b/scripts/training/cmert-0.5/python/psyco/__init__.py deleted file mode 100644 index 23a12495a..000000000 --- a/scripts/training/cmert-0.5/python/psyco/__init__.py +++ /dev/null @@ -1,57 +0,0 @@ -########################################################################### -# -# Psyco top-level file of the Psyco package. -# Copyright (C) 2001-2002 Armin Rigo et.al. - -"""Psyco -- the Python Specializing Compiler. - -Typical usage: add the following lines to your application's main module: - -try: - import psyco - psyco.profile() -except: - print 'Psyco not found, ignoring it' -""" -########################################################################### - - -# -# This module is present to make 'psyco' a package and to -# publish the main functions and variables. -# -# More documentation can be found in core.py. -# - - -# Try to import the dynamic-loading _psyco and report errors -try: - import _psyco -except ImportError, e: - extramsg = '' - import sys, imp - try: - file, filename, (suffix, mode, type) = imp.find_module('_psyco', __path__) - except ImportError: - ext = [suffix for suffix, mode, type in imp.get_suffixes() - if type == imp.C_EXTENSION] - if ext: - extramsg = (" (cannot locate the compiled extension '_psyco%s' " - "in the package path '%s')" % (ext[0], '; '.join(__path__))) - else: - extramsg = (" (check that the compiled extension '%s' is for " - "the correct Python version; this is Python %s)" % - (filename, sys.version.split()[0])) - raise ImportError, str(e) + extramsg - -# Publish important data by importing them in the package -from support import __version__, error, warning, _getrealframe, _getemulframe -from support import version_info, __version__ as hexversion -from core import full, profile, background, runonly, stop, cannotcompile -from core import log, bind, unbind, proxy, unproxy, dumpcodebuf -from _psyco import setfilter - -try: - from _psyco import compact, compacttype # Python 2.2 and above only -except ImportError: - pass diff --git a/scripts/training/cmert-0.5/python/psyco/_psyco.so b/scripts/training/cmert-0.5/python/psyco/_psyco.so Binary files differdeleted file mode 100755 index f7c8fc883..000000000 --- a/scripts/training/cmert-0.5/python/psyco/_psyco.so +++ /dev/null diff --git a/scripts/training/cmert-0.5/python/psyco/classes.py b/scripts/training/cmert-0.5/python/psyco/classes.py deleted file mode 100644 index 11c2d169b..000000000 --- a/scripts/training/cmert-0.5/python/psyco/classes.py +++ /dev/null @@ -1,53 +0,0 @@ -########################################################################### -# -# Psyco class support module. -# Copyright (C) 2001-2002 Armin Rigo et.al. - -"""Psyco class support module. - -'psyco.classes.psyobj' is an alternate Psyco-optimized root for classes. -Any class inheriting from it or using the metaclass '__metaclass__' might -get optimized specifically for Psyco. It is equivalent to call -psyco.bind() on the class object after its creation. - -Note that this module has no effect with Python version 2.1 or earlier. - -Importing everything from psyco.classes in a module will import the -'__metaclass__' name, so all classes defined after a - - from psyco.classes import * - -will automatically use the Psyco-optimized metaclass. -""" -########################################################################### - -__all__ = ['psyobj', 'psymetaclass', '__metaclass__'] - - -# Python version check -try: - from _psyco import compacttype -except ImportError: - class psyobj: # compatilibity - pass - psymetaclass = None -else: - # version >= 2.2 only - - import core - from types import FunctionType - - class psymetaclass(compacttype): - "Psyco-optimized meta-class. Turns all methods into Psyco proxies." - - def __new__(cls, name, bases, dict): - bindlist = dict.get('__psyco__bind__') - if bindlist is None: - bindlist = [key for key, value in dict.items() - if isinstance(value, FunctionType)] - for attr in bindlist: - dict[attr] = core.proxy(dict[attr]) - return super(psymetaclass, cls).__new__(cls, name, bases, dict) - - psyobj = psymetaclass("psyobj", (), {}) -__metaclass__ = psymetaclass diff --git a/scripts/training/cmert-0.5/python/psyco/core.py b/scripts/training/cmert-0.5/python/psyco/core.py deleted file mode 100644 index 42a6c2fb3..000000000 --- a/scripts/training/cmert-0.5/python/psyco/core.py +++ /dev/null @@ -1,232 +0,0 @@ -########################################################################### -# -# Psyco main functions. -# Copyright (C) 2001-2002 Armin Rigo et.al. - -"""Psyco main functions. - -Here are the routines that you can use from your applications. -These are mostly interfaces to the C core, but they depend on -the Python version. - -You can use these functions from the 'psyco' module instead of -'psyco.core', e.g. - - import psyco - psyco.log('/tmp/psyco.log') - psyco.profile() -""" -########################################################################### - -import _psyco -import types, new -from support import * - - -# Default charge profiler values -default_watermark = 0.09 # between 0.0 (0%) and 1.0 (100%) -default_halflife = 0.5 # seconds -default_pollfreq_profile = 20 # Hz -default_pollfreq_background = 100 # Hz -- a maximum for sleep's resolution -default_parentframe = 0.25 # should not be more than 0.5 (50%) - - -def full(memory=None, time=None, memorymax=None, timemax=None): - """Compile as much as possible. - -Typical use is for small scripts performing intensive computations -or string handling.""" - import profiler - if PYTHON_SUPPORT: - p = profiler.FullCompiler() - else: - p = profiler.ActiveProfiler(0.0, 0.5) - p.run(memory, time, memorymax, timemax) - - -def profile(watermark = default_watermark, - halflife = default_halflife, - pollfreq = default_pollfreq_profile, - parentframe = default_parentframe, - memory=None, time=None, memorymax=None, timemax=None): - """Turn on profiling. - -The 'watermark' parameter controls how easily running functions will -be compiled. The smaller the value, the more functions are compiled.""" - import profiler - p = profiler.ActivePassiveProfiler(watermark, halflife, - pollfreq, parentframe) - p.run(memory, time, memorymax, timemax) - - -def background(watermark = default_watermark, - halflife = default_halflife, - pollfreq = default_pollfreq_background, - parentframe = default_parentframe, - memory=None, time=None, memorymax=None, timemax=None): - """Turn on passive profiling. - -This is a very lightweight mode in which only intensively computing -functions can be detected. The smaller the 'watermark', the more functions -are compiled.""" - import profiler - p = profiler.PassiveProfiler(watermark, halflife, pollfreq, parentframe) - p.run(memory, time, memorymax, timemax) - - -def runonly(memory=None, time=None, memorymax=None, timemax=None): - """Nonprofiler. - -XXX check if this is useful and document.""" - if PYTHON_SUPPORT: - import profiler - p = profiler.RunOnly() - p.run(memory, time, memorymax, timemax) - - -def stop(): - """Turn off all automatic compilation. bind() calls remain in effect.""" - import profiler - profiler.go([]) - - -def log(logfile='', mode='w', top=10): - """Enable logging to the given file. - -If the file name is unspecified, a default name is built by appending -a 'log-psyco' extension to the main script name. - -Mode is 'a' to append to a possibly existing file or 'w' to overwrite -an existing file. Note that the log file may grow quickly in 'a' mode.""" - import profiler, logger - if not logfile: - import os - logfile, dummy = os.path.splitext(sys.argv[0]) - if os.path.basename(logfile): - logfile += '.' - logfile += 'log-psyco' - if hasattr(_psyco, 'VERBOSE_LEVEL'): - print >> sys.stderr, 'psyco: logging to', logfile - # logger.current should be a real file object; subtle problems - # will show up if its write() and flush() methods are written - # in Python, as Psyco will invoke them while compiling. - logger.current = open(logfile, mode) - logger.print_charges = top - profiler.logger = logger - logger.writedate('Logging started') - cannotcompile(logger.psycowrite) - _psyco.statwrite(logger=logger.psycowrite) - - -def bind(x, rec=None): - """Enable compilation of the given function, method, or class object. - -If C is a class (or anything with a '__dict__' attribute), bind(C) will -rebind all functions and methods found in C.__dict__ (which means, for -classes, all methods defined in the class but not in its parents). - -The optional second argument specifies the number of recursive -compilation levels: all functions called by func are compiled -up to the given depth of indirection.""" - if isinstance(x, types.MethodType): - x = x.im_func - if isinstance(x, types.FunctionType): - if rec is None: - x.func_code = _psyco.proxycode(x) - else: - x.func_code = _psyco.proxycode(x, rec) - return - if hasattr(x, '__dict__'): - funcs = [o for o in x.__dict__.values() - if isinstance(o, types.MethodType) - or isinstance(o, types.FunctionType)] - if not funcs: - raise error, ("nothing bindable found in %s object" % - type(x).__name__) - for o in funcs: - bind(o, rec) - return - raise TypeError, "cannot bind %s objects" % type(x).__name__ - - -def unbind(x): - """Reverse of bind().""" - if isinstance(x, types.MethodType): - x = x.im_func - if isinstance(x, types.FunctionType): - try: - f = _psyco.unproxycode(x.func_code) - except error: - pass - else: - x.func_code = f.func_code - return - if hasattr(x, '__dict__'): - for o in x.__dict__.values(): - if (isinstance(o, types.MethodType) - or isinstance(o, types.FunctionType)): - unbind(o) - return - raise TypeError, "cannot unbind %s objects" % type(x).__name__ - - -def proxy(x, rec=None): - """Return a Psyco-enabled copy of the function. - -The original function is still available for non-compiled calls. -The optional second argument specifies the number of recursive -compilation levels: all functions called by func are compiled -up to the given depth of indirection.""" - if isinstance(x, types.FunctionType): - if rec is None: - code = _psyco.proxycode(x) - else: - code = _psyco.proxycode(x, rec) - return new.function(code, x.func_globals, x.func_name) - if isinstance(x, types.MethodType): - p = proxy(x.im_func, rec) - return new.instancemethod(p, x.im_self, x.im_class) - raise TypeError, "cannot proxy %s objects" % type(x).__name__ - - -def unproxy(proxy): - """Return a new copy of the original function of method behind a proxy. -The result behaves like the original function in that calling it -does not trigger compilation nor execution of any compiled code.""" - if isinstance(proxy, types.FunctionType): - return _psyco.unproxycode(proxy.func_code) - if isinstance(proxy, types.MethodType): - f = unproxy(proxy.im_func) - return new.instancemethod(f, proxy.im_self, proxy.im_class) - raise TypeError, "%s objects cannot be proxies" % type(proxy).__name__ - - -def cannotcompile(x): - """Instruct Psyco never to compile the given function, method -or code object.""" - if isinstance(x, types.MethodType): - x = x.im_func - if isinstance(x, types.FunctionType): - x = x.func_code - if isinstance(x, types.CodeType): - _psyco.cannotcompile(x) - else: - raise TypeError, "unexpected %s object" % type(x).__name__ - - -def dumpcodebuf(): - """Write in file psyco.dump a copy of the emitted machine code, -provided Psyco was compiled with a non-zero CODE_DUMP. -See py-utils/httpxam.py to examine psyco.dump.""" - if hasattr(_psyco, 'dumpcodebuf'): - _psyco.dumpcodebuf() - - -########################################################################### -# Psyco variables -# error * the error raised by Psyco -# warning * the warning raised by Psyco -# __in_psyco__ * a new built-in variable which is always zero, but which -# Psyco special-cases by returning 1 instead. So -# __in_psyco__ can be used in a function to know if -# that function is being executed by Psyco or not. diff --git a/scripts/training/cmert-0.5/python/psyco/kdictproxy.py b/scripts/training/cmert-0.5/python/psyco/kdictproxy.py deleted file mode 100644 index 710677b00..000000000 --- a/scripts/training/cmert-0.5/python/psyco/kdictproxy.py +++ /dev/null @@ -1,133 +0,0 @@ -########################################################################### -# -# Support code for the 'psyco.compact' type. - -from __future__ import generators - -try: - from UserDict import DictMixin -except ImportError: - - # backported from Python 2.3 to Python 2.2 - class DictMixin: - # Mixin defining all dictionary methods for classes that already have - # a minimum dictionary interface including getitem, setitem, delitem, - # and keys. Without knowledge of the subclass constructor, the mixin - # does not define __init__() or copy(). In addition to the four base - # methods, progressively more efficiency comes with defining - # __contains__(), __iter__(), and iteritems(). - - # second level definitions support higher levels - def __iter__(self): - for k in self.keys(): - yield k - def has_key(self, key): - try: - value = self[key] - except KeyError: - return False - return True - def __contains__(self, key): - return self.has_key(key) - - # third level takes advantage of second level definitions - def iteritems(self): - for k in self: - yield (k, self[k]) - def iterkeys(self): - return self.__iter__() - - # fourth level uses definitions from lower levels - def itervalues(self): - for _, v in self.iteritems(): - yield v - def values(self): - return [v for _, v in self.iteritems()] - def items(self): - return list(self.iteritems()) - def clear(self): - for key in self.keys(): - del self[key] - def setdefault(self, key, default): - try: - return self[key] - except KeyError: - self[key] = default - return default - def pop(self, key, *args): - if len(args) > 1: - raise TypeError, "pop expected at most 2 arguments, got "\ - + repr(1 + len(args)) - try: - value = self[key] - except KeyError: - if args: - return args[0] - raise - del self[key] - return value - def popitem(self): - try: - k, v = self.iteritems().next() - except StopIteration: - raise KeyError, 'container is empty' - del self[k] - return (k, v) - def update(self, other): - # Make progressively weaker assumptions about "other" - if hasattr(other, 'iteritems'): # iteritems saves memory and lookups - for k, v in other.iteritems(): - self[k] = v - elif hasattr(other, '__iter__'): # iter saves memory - for k in other: - self[k] = other[k] - else: - for k in other.keys(): - self[k] = other[k] - def get(self, key, default=None): - try: - return self[key] - except KeyError: - return default - def __repr__(self): - return repr(dict(self.iteritems())) - def __cmp__(self, other): - if other is None: - return 1 - if isinstance(other, DictMixin): - other = dict(other.iteritems()) - return cmp(dict(self.iteritems()), other) - def __len__(self): - return len(self.keys()) - -########################################################################### - -from _psyco import compact # Python 2.2 and above only - - -class compactdictproxy(DictMixin): - - def __init__(self, ko): - self._ko = ko # compact object of which 'self' is the dict - - def __getitem__(self, key): - return compact.__getslot__(self._ko, key) - - def __setitem__(self, key, value): - compact.__setslot__(self._ko, key, value) - - def __delitem__(self, key): - compact.__delslot__(self._ko, key) - - def keys(self): - return compact.__members__.__get__(self._ko) - - def clear(self): - keys = self.keys() - keys.reverse() - for key in keys: - del self[key] - - def __repr__(self): - keys = ', '.join(self.keys()) - return '<compactdictproxy object {%s}>' % (keys,) diff --git a/scripts/training/cmert-0.5/python/psyco/logger.py b/scripts/training/cmert-0.5/python/psyco/logger.py deleted file mode 100644 index 33cb90a4e..000000000 --- a/scripts/training/cmert-0.5/python/psyco/logger.py +++ /dev/null @@ -1,90 +0,0 @@ -########################################################################### -# -# Psyco logger. -# Copyright (C) 2001-2002 Armin Rigo et.al. - -"""Psyco logger. - -See log() in core.py. -""" -########################################################################### - - -import _psyco -from time import time, localtime, strftime - - -current = None -print_charges = 10 -dump_delay = 0.2 -dump_last = 0.0 - -def write(s, level): - t = time() - f = t-int(t) - current.write("%s.%02d %-*s%s\n" % ( - strftime("%X", localtime(int(t))), - int(f*100.0), 63-level, s, - "%"*level)) - current.flush() - -def psycowrite(s): - t = time() - f = t-int(t) - current.write("%s.%02d %-*s%s\n" % ( - strftime("%X", localtime(int(t))), - int(f*100.0), 60, s.strip(), - "% %")) - current.flush() - -##def writelines(lines, level=0): -## if lines: -## t = time() -## f = t-int(t) -## timedesc = strftime("%x %X", localtime(int(t))) -## print >> current, "%s.%03d %-*s %s" % ( -## timedesc, int(f*1000), -## 50-level, lines[0], -## "+"*level) -## timedesc = " " * (len(timedesc)+5) -## for line in lines[1:]: -## print >> current, timedesc, line - -def writememory(): - write("memory usage: %d+ kb" % _psyco.memory(), 1) - -def dumpcharges(): - global dump_last - if print_charges: - t = time() - if not (dump_last <= t < dump_last+dump_delay): - if t <= dump_last+1.5*dump_delay: - dump_last += dump_delay - else: - dump_last = t - #write("%s: charges:" % who, 0) - lst = _psyco.stattop(print_charges) - if lst: - f = t-int(t) - lines = ["%s.%02d ______\n" % ( - strftime("%X", localtime(int(t))), - int(f*100.0))] - i = 1 - for co, charge in lst: - detail = co.co_filename - if len(detail) > 19: - detail = '...' + detail[-17:] - lines.append(" #%-3d |%4.1f %%| %-26s%20s:%d\n" % - (i, charge*100.0, co.co_name, detail, - co.co_firstlineno)) - i += 1 - current.writelines(lines) - current.flush() - -def writefinalstats(): - dumpcharges() - writememory() - writedate("program exit") - -def writedate(msg): - write('%s, %s' % (msg, strftime("%x")), 20) diff --git a/scripts/training/cmert-0.5/python/psyco/profiler.py b/scripts/training/cmert-0.5/python/psyco/profiler.py deleted file mode 100644 index ef7bf8e59..000000000 --- a/scripts/training/cmert-0.5/python/psyco/profiler.py +++ /dev/null @@ -1,388 +0,0 @@ -########################################################################### -# -# Psyco profiler (Python part). -# Copyright (C) 2001-2002 Armin Rigo et.al. - -"""Psyco profiler (Python part). - -The implementation of the non-time-critical parts of the profiler. -See profile() and full() in core.py for the easy interface. -""" -########################################################################### - -import _psyco -from support import * -import math, time, types, atexit -now = time.time -try: - import thread -except ImportError: - import dummy_thread as thread - - -# current profiler instance -current = None - -# enabled profilers, in order of priority -profilers = [] - -# logger module (when enabled by core.log()) -logger = None - -# a lock for a thread-safe go() -go_lock = thread.allocate_lock() - -def go(stop=0): - # run the highest-priority profiler in 'profilers' - global current - go_lock.acquire() - try: - prev = current - if stop: - del profilers[:] - if prev: - if profilers and profilers[0] is prev: - return # best profiler already running - prev.stop() - current = None - for p in profilers[:]: - if p.start(): - current = p - if logger: # and p is not prev: - logger.write("%s: starting" % p.__class__.__name__, 5) - return - finally: - go_lock.release() - # no profiler is running now - if stop: - if logger: - logger.writefinalstats() - else: - tag2bind() - -atexit.register(go, 1) - - -def buildfncache(globals, cache): - if hasattr(types.IntType, '__dict__'): - clstypes = (types.ClassType, types.TypeType) - else: - clstypes = types.ClassType - for x in globals.values(): - if isinstance(x, types.MethodType): - x = x.im_func - if isinstance(x, types.FunctionType): - cache[x.func_code] = x, '' - elif isinstance(x, clstypes): - for y in x.__dict__.values(): - if isinstance(y, types.MethodType): - y = y.im_func - if isinstance(y, types.FunctionType): - cache[y.func_code] = y, x.__name__ - -# code-to-function mapping (cache) -function_cache = {} - -def trytobind(co, globals, log=1): - try: - f, clsname = function_cache[co] - except KeyError: - buildfncache(globals, function_cache) - try: - f, clsname = function_cache[co] - except KeyError: - if logger: - logger.write('warning: cannot find function %s in %s' % - (co.co_name, globals.get('__name__', '?')), 3) - return # give up - if logger and log: - modulename = globals.get('__name__', '?') - if clsname: - modulename += '.' + clsname - logger.write('bind function: %s.%s' % (modulename, co.co_name), 1) - f.func_code = _psyco.proxycode(f) - - -if PYTHON_SUPPORT: - # the list of code objects that have been tagged - tagged_codes = [] - - def tag(co, globals): - if logger: - try: - f, clsname = function_cache[co] - except KeyError: - buildfncache(globals, function_cache) - try: - f, clsname = function_cache[co] - except KeyError: - clsname = '' # give up - modulename = globals.get('__name__', '?') - if clsname: - modulename += '.' + clsname - logger.write('tag function: %s.%s' % (modulename, co.co_name), 1) - tagged_codes.append((co, globals)) - _psyco.turbo_frame(co) - _psyco.turbo_code(co) - - def tag2bind(): - if tagged_codes: - if logger: - logger.write('profiling stopped, binding %d functions' % - len(tagged_codes), 2) - for co, globals in tagged_codes: - trytobind(co, globals, 0) - function_cache.clear() - del tagged_codes[:] - -else: - # tagging is impossible, always bind - tag = trytobind - def tag2bind(): - pass - - - -class Profiler: - MemoryTimerResolution = 0.103 - - def run(self, memory, time, memorymax, timemax): - self.memory = memory - self.memorymax = memorymax - self.time = time - if timemax is None: - self.endtime = None - else: - self.endtime = now() + timemax - self.alarms = [] - profilers.append(self) - go() - - def start(self): - curmem = _psyco.memory() - memlimits = [] - if self.memorymax is not None: - if curmem >= self.memorymax: - if logger: - logger.writememory() - return self.limitreached('memorymax') - memlimits.append(self.memorymax) - if self.memory is not None: - if self.memory <= 0: - if logger: - logger.writememory() - return self.limitreached('memory') - memlimits.append(curmem + self.memory) - self.memory_at_start = curmem - - curtime = now() - timelimits = [] - if self.endtime is not None: - if curtime >= self.endtime: - return self.limitreached('timemax') - timelimits.append(self.endtime - curtime) - if self.time is not None: - if self.time <= 0.0: - return self.limitreached('time') - timelimits.append(self.time) - self.time_at_start = curtime - - try: - self.do_start() - except error, e: - if logger: - logger.write('%s: disabled by psyco.error:' % ( - self.__class__.__name__), 4) - logger.write(' %s' % str(e), 3) - return 0 - - if memlimits: - self.memlimits_args = (time.sleep, (self.MemoryTimerResolution,), - self.check_memory, (min(memlimits),)) - self.alarms.append(_psyco.alarm(*self.memlimits_args)) - if timelimits: - self.alarms.append(_psyco.alarm(time.sleep, (min(timelimits),), - self.time_out)) - return 1 - - def stop(self): - for alarm in self.alarms: - alarm.stop(0) - for alarm in self.alarms: - alarm.stop(1) # wait for parallel threads to stop - del self.alarms[:] - if self.time is not None: - self.time -= now() - self.time_at_start - if self.memory is not None: - self.memory -= _psyco.memory() - self.memory_at_start - - try: - self.do_stop() - except error: - return 0 - return 1 - - def check_memory(self, limit): - if _psyco.memory() < limit: - return self.memlimits_args - go() - - def time_out(self): - self.time = 0.0 - go() - - def limitreached(self, limitname): - try: - profilers.remove(self) - except ValueError: - pass - if logger: - logger.write('%s: disabled (%s limit reached)' % ( - self.__class__.__name__, limitname), 4) - return 0 - - -class FullCompiler(Profiler): - - def do_start(self): - _psyco.profiling('f') - - def do_stop(self): - _psyco.profiling('.') - - -class RunOnly(Profiler): - - def do_start(self): - _psyco.profiling('n') - - def do_stop(self): - _psyco.profiling('.') - - -class ChargeProfiler(Profiler): - - def __init__(self, watermark, parentframe): - self.watermark = watermark - self.parent2 = parentframe * 2.0 - self.lock = thread.allocate_lock() - - def init_charges(self): - _psyco.statwrite(watermark = self.watermark, - parent2 = self.parent2) - - def do_stop(self): - _psyco.profiling('.') - _psyco.statwrite(callback = None) - - -class ActiveProfiler(ChargeProfiler): - - def active_start(self): - _psyco.profiling('p') - - def do_start(self): - self.init_charges() - self.active_start() - _psyco.statwrite(callback = self.charge_callback) - - def charge_callback(self, frame, charge): - tag(frame.f_code, frame.f_globals) - - -class PassiveProfiler(ChargeProfiler): - - initial_charge_unit = _psyco.statread('unit') - reset_stats_after = 120 # half-lives (maximum 200!) - reset_limit = initial_charge_unit * (2.0 ** reset_stats_after) - - def __init__(self, watermark, halflife, pollfreq, parentframe): - ChargeProfiler.__init__(self, watermark, parentframe) - self.pollfreq = pollfreq - # self.progress is slightly more than 1.0, and computed so that - # do_profile() will double the change_unit every 'halflife' seconds. - self.progress = 2.0 ** (1.0 / (halflife * pollfreq)) - - def reset(self): - _psyco.statwrite(unit = self.initial_charge_unit, callback = None) - _psyco.statreset() - if logger: - logger.write("%s: resetting stats" % self.__class__.__name__, 1) - - def passive_start(self): - self.passivealarm_args = (time.sleep, (1.0 / self.pollfreq,), - self.do_profile) - self.alarms.append(_psyco.alarm(*self.passivealarm_args)) - - def do_start(self): - tag2bind() - self.init_charges() - self.passive_start() - - def do_profile(self): - _psyco.statcollect() - if logger: - logger.dumpcharges() - nunit = _psyco.statread('unit') * self.progress - if nunit > self.reset_limit: - self.reset() - else: - _psyco.statwrite(unit = nunit, callback = self.charge_callback) - return self.passivealarm_args - - def charge_callback(self, frame, charge): - trytobind(frame.f_code, frame.f_globals) - - -class ActivePassiveProfiler(PassiveProfiler, ActiveProfiler): - - def do_start(self): - self.init_charges() - self.active_start() - self.passive_start() - - def charge_callback(self, frame, charge): - tag(frame.f_code, frame.f_globals) - - - -# -# we register our own version of sys.settrace(), sys.setprofile() -# and thread.start_new_thread(). -# - -def psyco_settrace(*args, **kw): - "This is the Psyco-aware version of sys.settrace()." - result = original_settrace(*args, **kw) - go() - return result - -def psyco_setprofile(*args, **kw): - "This is the Psyco-aware version of sys.setprofile()." - result = original_setprofile(*args, **kw) - go() - return result - -def psyco_thread_stub(callable, args, kw): - _psyco.statcollect() - if kw is None: - return callable(*args) - else: - return callable(*args, **kw) - -def psyco_start_new_thread(callable, args, kw=None): - "This is the Psyco-aware version of thread.start_new_thread()." - return original_start_new_thread(psyco_thread_stub, (callable, args, kw)) - -original_settrace = sys.settrace -original_setprofile = sys.setprofile -original_start_new_thread = thread.start_new_thread -sys.settrace = psyco_settrace -sys.setprofile = psyco_setprofile -if PYTHON_SUPPORT: - thread.start_new_thread = psyco_start_new_thread - # hack to patch threading._start_new_thread if the module is - # already loaded - if (sys.modules.has_key('threading') and - hasattr(sys.modules['threading'], '_start_new_thread')): - sys.modules['threading']._start_new_thread = psyco_start_new_thread diff --git a/scripts/training/cmert-0.5/python/psyco/support.py b/scripts/training/cmert-0.5/python/psyco/support.py deleted file mode 100644 index 596ca7f59..000000000 --- a/scripts/training/cmert-0.5/python/psyco/support.py +++ /dev/null @@ -1,196 +0,0 @@ -########################################################################### -# -# Psyco general support module. -# Copyright (C) 2001-2002 Armin Rigo et.al. - -"""Psyco general support module. - -For internal use. -""" -########################################################################### - -import sys, _psyco, __builtin__ - -error = _psyco.error -class warning(Warning): - pass - -_psyco.NoLocalsWarning = warning - -def warn(msg): - from warnings import warn - warn(msg, warning, stacklevel=2) - -# -# Version checks -# -__version__ = 0x010500f0 -if _psyco.PSYVER != __version__: - raise error, "version mismatch between Psyco parts, reinstall it" - -version_info = (__version__ >> 24, - (__version__ >> 16) & 0xff, - (__version__ >> 8) & 0xff, - {0xa0: 'alpha', - 0xb0: 'beta', - 0xc0: 'candidate', - 0xf0: 'final'}[__version__ & 0xf0], - __version__ & 0xf) - - -VERSION_LIMITS = [0x02010000, # 2.1 - 0x02020000, # 2.2 - 0x02020200, # 2.2.2 - 0x02030000, # 2.3 - 0x02040000] # 2.4 - -if ([v for v in VERSION_LIMITS if v <= sys.hexversion] != - [v for v in VERSION_LIMITS if v <= _psyco.PYVER ]): - if sys.hexversion < VERSION_LIMITS[0]: - warn("Psyco requires Python version 2.1 or later") - else: - warn("Psyco version does not match Python version. " - "Psyco must be updated or recompiled") - -PYTHON_SUPPORT = hasattr(_psyco, 'turbo_code') - - -if hasattr(_psyco, 'ALL_CHECKS') and hasattr(_psyco, 'VERBOSE_LEVEL'): - print >> sys.stderr, ('psyco: running in debugging mode on %s' % - _psyco.PROCESSOR) - - -########################################################################### -# sys._getframe() gives strange results on a mixed Psyco- and Python-style -# stack frame. Psyco provides a replacement that partially emulates Python -# frames from Psyco frames. The new sys._getframe() may return objects of -# a custom "Psyco frame" type, which with Python >=2.2 is a subtype of the -# normal frame type. -# -# The same problems require some other built-in functions to be replaced -# as well. Note that the local variables are not available in any -# dictionary with Psyco. - - -class Frame: - pass - - -class PythonFrame(Frame): - - def __init__(self, frame): - self.__dict__.update({ - '_frame': frame, - }) - - def __getattr__(self, attr): - if attr == 'f_back': - try: - result = embedframe(_psyco.getframe(self._frame)) - except ValueError: - result = None - except error: - warn("f_back is skipping dead Psyco frames") - result = self._frame.f_back - self.__dict__['f_back'] = result - return result - else: - return getattr(self._frame, attr) - - def __setattr__(self, attr, value): - setattr(self._frame, attr, value) - - def __delattr__(self, attr): - delattr(self._frame, attr) - - -class PsycoFrame(Frame): - - def __init__(self, tag): - self.__dict__.update({ - '_tag' : tag, - 'f_code' : tag[0], - 'f_globals': tag[1], - }) - - def __getattr__(self, attr): - if attr == 'f_back': - try: - result = embedframe(_psyco.getframe(self._tag)) - except ValueError: - result = None - elif attr == 'f_lineno': - result = self.f_code.co_firstlineno # better than nothing - elif attr == 'f_builtins': - result = self.f_globals['__builtins__'] - elif attr == 'f_restricted': - result = self.f_builtins is not __builtins__ - elif attr == 'f_locals': - raise AttributeError, ("local variables of functions run by Psyco " - "cannot be accessed in any way, sorry") - else: - raise AttributeError, ("emulated Psyco frames have " - "no '%s' attribute" % attr) - self.__dict__[attr] = result - return result - - def __setattr__(self, attr, value): - raise AttributeError, "Psyco frame objects are read-only" - - def __delattr__(self, attr): - if attr == 'f_trace': - # for bdb which relies on CPython frames exhibiting a slightly - # buggy behavior: you can 'del f.f_trace' as often as you like - # even without having set it previously. - return - raise AttributeError, "Psyco frame objects are read-only" - - -def embedframe(result): - if type(result) is type(()): - return PsycoFrame(result) - else: - return PythonFrame(result) - -def _getframe(depth=0): - """Return a frame object from the call stack. This is a replacement for -sys._getframe() which is aware of Psyco frames. - -The returned objects are instances of either PythonFrame or PsycoFrame -instead of being real Python-level frame object, so that they can emulate -the common attributes of frame objects. - -The original sys._getframe() ignoring Psyco frames altogether is stored in -psyco._getrealframe(). See also psyco._getemulframe().""" - # 'depth+1' to account for this _getframe() Python function - return embedframe(_psyco.getframe(depth+1)) - -def _getemulframe(depth=0): - """As _getframe(), but the returned objects are real Python frame objects -emulating Psyco frames. Some of their attributes can be wrong or missing, -however.""" - # 'depth+1' to account for this _getemulframe() Python function - return _psyco.getframe(depth+1, 1) - -def patch(name, module=__builtin__): - f = getattr(_psyco, name) - org = getattr(module, name) - if org is not f: - setattr(module, name, f) - setattr(_psyco, 'original_' + name, org) - -_getrealframe = sys._getframe -sys._getframe = _getframe -patch('globals') -patch('eval') -patch('execfile') -patch('locals') -patch('vars') -patch('dir') -patch('input') -_psyco.original_raw_input = raw_input -__builtin__.__in_psyco__ = 0==1 # False - -if hasattr(_psyco, 'compact'): - import kdictproxy - _psyco.compactdictproxy = kdictproxy.compactdictproxy |