diff options
Diffstat (limited to 'Calibre_Plugins/eReaderPDB2PML_plugin/osx/psyco/.svn/text-base/profiler.py.svn-base')
-rw-r--r-- | Calibre_Plugins/eReaderPDB2PML_plugin/osx/psyco/.svn/text-base/profiler.py.svn-base | 379 |
1 files changed, 0 insertions, 379 deletions
diff --git a/Calibre_Plugins/eReaderPDB2PML_plugin/osx/psyco/.svn/text-base/profiler.py.svn-base b/Calibre_Plugins/eReaderPDB2PML_plugin/osx/psyco/.svn/text-base/profiler.py.svn-base deleted file mode 100644 index f1d06f1..0000000 --- a/Calibre_Plugins/eReaderPDB2PML_plugin/osx/psyco/.svn/text-base/profiler.py.svn-base +++ /dev/null @@ -1,379 +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) - - -# 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[:] - - -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 -thread.start_new_thread = psyco_start_new_thread -# hack to patch threading._start_new_thread if the module is -# already loaded -if ('threading' in sys.modules and - hasattr(sys.modules['threading'], '_start_new_thread')): - sys.modules['threading']._start_new_thread = psyco_start_new_thread |