def decorator(*args, **kwargs):
if should_profile and not should_profile():
return func(*args, **kwargs)
result = None
if cumulative:
global profiler
else:
profiler = Profile()
try:
result = profiler.runcall(func, *args, **kwargs)
finally:
if lock.acquire(False):
if dump_stats:
profiler.dump_stats(profile_filename)
if callgrind_filename:
stats = pstats.Stats(profiler)
conv = pyprof2calltree.CalltreeConverter(stats)
with open(callgrind_filename, 'w') as fd:
conv.output(fd)
if print_stats:
stats.strip_dirs().sort_stats(
sort_stats).print_stats(print_stats)
lock.release()
return result
return result
class Monitor:
def __init__(self, monitoring_dir: str,
with_runtime: bool = False,
with_profiler: bool = False):
self._monitoring_dir = monitoring_dir
self._duration_sampler = _new_duration_sampler(monitoring_dir)
self._runtime_bucket = None
self._profiler = None
self._lock = Lock()
if with_runtime:
self._runtime_bucket = _start_runtime_sampler(monitoring_dir)
if with_profiler:
self._profiler = Profile()
self._profiler.enable()
def start_duration_sample(self) -> str:
return self._duration_sampler.sample()
def stop_duration_sample(self, label: str, sample_id: str):
self._duration_sampler.collect(label, sample_id)
def stop(self):
if self._profiler:
with self._lock:
self._profiler.disable()
outfile = _profiler_file_pathname(self._monitoring_dir)
self._profiler.dump_stats(outfile)
self._duration_sampler.bucket().empty()
if self._runtime_bucket:
self._runtime_bucket.empty()
def make_melody():
valence = request.args.get("valence", default=1, type=float)
arousal = request.args.get("arousal", default=1, type=float)
if environ.get("PROFILE", False):
print("~~ profiling ~~")
pr = Profile()
pr.enable()
mg = MelodyGenerator(valence, arousal)
m = mg.gen_melody()
if environ.get("PROFILE", False):
pr.disable()
print("~~ end profile ~~")
pr.dump_stats("profile.perf")
# TODO: move this where appropriate maybe
meta = m21.metadata.Metadata()
meta.title = "Mood of the day" # TODO: maybe we can generate random titles
meta.composer = "Meldy"
meta.date = date.today().strftime("%Y/%m/%d")
m.metadata = meta
with NamedTemporaryFile() as t:
m.write("musicxml", fp=t.name)
t.seek(0)
return Response(t.read(),
mimetype="application/vnd.recordare.musicxml")
def _exec_main(parser, values):
sconsflags = os.environ.get('SCONSFLAGS', '')
all_args = string.split(sconsflags) + sys.argv[1:]
options, args = parser.parse_args(all_args, values)
if type(options.debug) == type([]) and "pdb" in options.debug:
import pdb
pdb.Pdb().runcall(_main, parser)
elif options.profile_file:
try:
from cProfile import Profile
except ImportError, e:
from profile import Profile
# Some versions of Python 2.4 shipped a profiler that had the
# wrong 'c_exception' entry in its dispatch table. Make sure
# we have the right one. (This may put an unnecessary entry
# in the table in earlier versions of Python, but its presence
# shouldn't hurt anything).
try:
dispatch = Profile.dispatch
except AttributeError:
pass
else:
dispatch['c_exception'] = Profile.trace_dispatch_return
prof = Profile()
try:
prof.runcall(_main, parser)
except SConsPrintHelpException, e:
prof.dump_stats(options.profile_file)
raise e
def profile(filename, log=None):
"""!Context manager for profiling with cProfile
@param filename filename to which to write profile (profiling disabled if None or empty)
@param log log object for logging the profile operations
If profiling is enabled, the context manager returns the cProfile.Profile object (otherwise
it returns None), which allows additional control over profiling. You can obtain this using
the "as" clause, e.g.:
with profile(filename) as prof:
runYourCodeHere()
The output cumulative profile can be printed with a command-line like:
python -c 'import pstats; pstats.Stats("<filename>").sort_stats("cumtime").print_stats(30)'
"""
if not filename:
# Nothing to do
yield
return
from cProfile import Profile
prof = Profile()
if log is not None:
log.info("Enabling cProfile profiling")
prof.enable()
yield prof
prof.disable()
prof.dump_stats(filename)
if log is not None:
log.info("cProfile stats written to %s" % filename)
def _run_unit(self, unit, set_title=False):
try:
if set_title:
setproctitle('coordinate worker {0!r} {1!r}'
.format(unit.work_spec_name, unit.key))
profiler = None
if ((self.profile_destination and
unit.work_spec_name in self.profile_work_specs)):
now = datetime.now()
unit_info = {
'work_spec_name': unit.work_spec_name,
'work_unit_key': unit.key,
'ymd': now.strftime('%Y%m%d'),
'hms': now.strftime('%H%M%S'),
}
destination = self.profile_destination % unit_info
profiler = Profile()
profiler.enable()
unit.run()
if profiler:
profiler.disable()
profiler.dump_stats(destination)
unit.finish()
except LostLease:
# We don't own the unit any more so don't try to report on it
logger.warn('Lost Lease on %r %r', unit.work_spec_name, unit.key)
except Exception, exc: # pylint: disable=broad-except
unit.fail(exc)
def profiled_fn(*args, **kwargs):
filename = fn.__name__ + '.profile'
prof = Profiler()
ret = prof.runcall(fn, *args, **kwargs)
prof.dump_stats(filename)
return ret
def profile_function(self, func, args, kwargs, profile_name):
"""
Profile a Proteus function using the call: func(*args, **kwargs)
Returns the output of the function call.
"""
comm = self.comm
if type(comm) is None:
raise ValueError(
"The Dispatcher does not have a valid Comm object")
prof = Profile()
func_return = prof.runcall(func, *args, **kwargs)
profile_rank_name = profile_name + str(comm.rank())
stripped_profile_name = profile_name + '_c' + str(comm.rank())
prof.dump_stats(profile_rank_name)
comm.barrier() #ensure files are ready for master
if comm.isMaster():
import copy
import StringIO
profilingLog = StringIO.StringIO()
stats = pstats.Stats(profile_rank_name, stream=profilingLog)
stats.__dict__['files'] = [
'Maximum times across MPI tasks for',
stats.__dict__['files'][0]
]
statsm = stats.stats
for i in range(1, comm.size()):
pstatsi = pstats.Stats(profile_name + str(i))
statsi = pstatsi.stats
stats.__dict__['files'].append(pstatsi.__dict__['files'][0])
for f, c in statsi.iteritems():
if f in statsm:
if c[2] > statsm[f][2]:
statsm[f] = c
else:
statsm[f] = c
stats.sort_stats('cumulative')
stats.print_stats(30)
stats.sort_stats('time')
stats.print_stats(30)
logEvent(profilingLog.getvalue())
msg = r"""
Wall clock percentage of top 20 calls
-------------------------------------
"""
total = 0.0
for f in stats.__dict__['fcn_list'][0:20]:
if f[0] == '~':
fname = f[-1].strip("<").strip(">")
else:
fname = "function '{2:s}' at {0:s}:{1:d}".format(*f)
msg += ("{0:11.1%} {1:s}\n".format(
statsm[f][2] / stats.__dict__['total_tt'], str(fname)))
total += statsm[f][2] / stats.__dict__['total_tt']
logEvent(msg)
logEvent("Representing " + ` total * 100. ` + "%")
return func_return
def handle(self, *args, **options):
"""
Main function, called by django.
"""
if options['upis']:
options['upis'] = options['upis'].split(',')
elif options['upi_file']:
with open(options['upi_file'], 'rb') as raw:
options['upis'] = [line.strip() for line in raw]
else:
if not options['min'] and options['min'] != 0:
raise CommandError('Please specify --min')
if not options['max']:
raise CommandError('Please specify --max')
options['min'] = int(options['min'])
options['max'] = int(options['max'])
if not options['date']:
options['date'] = date.today()
else:
options['date'] = dt.strptime(options['date'], '%Y-%m-%d')
if options['profile']:
profiler = Profile()
profiler.runcall(self.run, options)
profiler.print_stats()
profiler.dump_stats('profile.txt')
else:
self.run(options)
def profile_function(self, func, args, kwargs, profile_name):
"""
Profile a Proteus function using the call: func(*args, **kwargs)
Returns the output of the function call.
"""
comm = self.comm
if type(comm) is None:
raise ValueError("The Dispatcher does not have a valid Comm object")
prof = Profile()
func_return = prof.runcall(func, *args, **kwargs)
profile_rank_name = profile_name + str(comm.rank())
stripped_profile_name = profile_name + '_c' + str(comm.rank())
prof.dump_stats(profile_rank_name)
comm.beginSequential()
stats = pstats.Stats(profile_rank_name)
stats.strip_dirs()
stats.dump_stats(stripped_profile_name)
stats.sort_stats('cumulative')
if verbose and comm.isMaster():
stats.print_stats(30)
stats.sort_stats('time')
if verbose and comm.isMaster():
stats.print_stats(30)
comm.endSequential()
return func_return
def handle(self, **options):
"""Django entry point."""
def validate_options():
"""Validate command line options."""
if not options['destination']:
raise CommandError('Please specify the --destination option')
if not options['format']:
raise CommandError('Please specify the --format option')
if options['format'] in ['bed', 'all'] and not options['bedToBigBed']:
raise CommandError('Please specify the --bedToBigBed option')
if options['format'] not in self.formats:
raise CommandError('Please choose a valid output format (%s)' % '|'.join(self.formats))
validate_options()
if options['profile']:
profiler = Profile()
profiler.runcall(self.export, **options)
profiler.print_stats()
profiler.dump_stats('profile.txt')
elif options['format'] == 'all':
self.export_all(**options)
else:
self.export(**options)
def _exec_main(parser, values):
sconsflags = os.environ.get('SCONSFLAGS', '')
all_args = string.split(sconsflags) + sys.argv[1:]
options, args = parser.parse_args(all_args, values)
if type(options.debug) == type([]) and "pdb" in options.debug:
import pdb
pdb.Pdb().runcall(_main, parser)
elif options.profile_file:
try:
from cProfile import Profile
except ImportError, e:
from profile import Profile
# Some versions of Python 2.4 shipped a profiler that had the
# wrong 'c_exception' entry in its dispatch table. Make sure
# we have the right one. (This may put an unnecessary entry
# in the table in earlier versions of Python, but its presence
# shouldn't hurt anything).
try:
dispatch = Profile.dispatch
except AttributeError:
pass
else:
dispatch['c_exception'] = Profile.trace_dispatch_return
prof = Profile()
try:
prof.runcall(_main, parser)
except SConsPrintHelpException, e:
prof.dump_stats(options.profile_file)
raise e
def handle(self, *args, **options):
if options['profile']:
profiler = Profile()
profiler.runcall(self._handle, *args, **options)
profiler.dump_stats('parse_gtfs.prof')
else:
self._handle(*args, **options)
def main(args):
SEED = 12345
torch.manual_seed(SEED)
torch.cuda.manual_seed(SEED)
np.random.seed(SEED)
model = models.vgg16(pretrained=True)
model.classifier[0] = nn.Linear(8*8*512, 4096)
model.classifier[6] = nn.Linear(4096, 27)
model.load_state_dict(torch.load("model.pth"))
print("total params:{}".format(count_params(model)))
dataset_test = MyDataset(args.pickle_path, args.test_list_path, args.test_dir)
test_loader = DataLoader(dataset_test, batch_size=args.batch_size, shuffle=False)
device = torch.device("cpu" if args.no_cuda else "cuda:0")
model = model.to(device)
model.eval()
if not args.no_prof:
pr = Profile()
pr.runcall(bench, model, test_loader, device)
pr.dump_stats("profile.txt")
ps = pstats.Stats("profile.txt")
ps.sort_stats('time').print_stats(15)
def stats_for_fib(type_, fib):
p = Profile()
p.runcall(fib, 30)
p.dump_stats(type_.lower().replace(' ', '_') + '.stats')
s = Stats(p)
s.strip_dirs().sort_stats('time', 'cumulative')
print_stats(type_, s)
def handle(self, *args, **options):
if options["profile"]:
profiler = Profile()
profiler.runcall(self._handle, *args, **options)
profiler.dump_stats("import_games.profile")
else:
self._handle(*args, **options)
def profile_function(self, func, args, kwargs, profile_name):
"""
Profile a Proteus function using the call: func(*args, **kwargs)
Returns the output of the function call.
"""
comm = self.comm
if type(comm) is None:
raise ValueError(
"The Dispatcher does not have a valid Comm object")
prof = Profile()
func_return = prof.runcall(func, *args, **kwargs)
profile_rank_name = profile_name + str(comm.rank())
stripped_profile_name = profile_name + '_c' + str(comm.rank())
prof.dump_stats(profile_rank_name)
comm.beginSequential()
stats = pstats.Stats(profile_rank_name)
stats.strip_dirs()
stats.dump_stats(stripped_profile_name)
stats.sort_stats('cumulative')
if verbose and comm.isMaster():
stats.print_stats(30)
stats.sort_stats('time')
if verbose and comm.isMaster():
stats.print_stats(30)
comm.endSequential()
return func_return
def profile(filename, log=None):
"""!Context manager for profiling with cProfile
@param filename filename to which to write profile (profiling disabled if None or empty)
@param log log object for logging the profile operations
If profiling is enabled, the context manager returns the cProfile.Profile object (otherwise
it returns None), which allows additional control over profiling. You can obtain this using
the "as" clause, e.g.:
with profile(filename) as prof:
runYourCodeHere()
The output cumulative profile can be printed with a command-line like:
python -c 'import pstats; pstats.Stats("<filename>").sort_stats("cumtime").print_stats(30)'
"""
if not filename:
# Nothing to do
yield
return
from cProfile import Profile
profile = Profile()
if log is not None:
log.info("Enabling cProfile profiling")
profile.enable()
yield profile
profile.disable()
profile.dump_stats(filename)
if log is not None:
log.info("cProfile stats written to %s" % filename)
def intprofiled(*n, **kw):
prof = Profile(timer=timer)
a = prof.runcall(eff, *n, **kw)
TRACE('Dumping profile stats to: %r' % (outputfile,))
prof.dump_stats(outputfile)
TRACE('Profile run: %d' % timer())
return a
def handle(self, **options):
"""
Django entry point.
"""
def validate_options():
"""
Validate command line options.
"""
if not options['destination']:
raise CommandError('Please specify the --destination option')
if not options['format']:
raise CommandError('Please specify the --format option')
if options['format'] in ['bed', 'all'] and not options['bedToBigBed']:
raise CommandError('Please specify the --bedToBigBed option')
if options['format'] not in self.formats:
raise CommandError('Please choose a valid output format (%s)' % '|'.join(self.formats))
validate_options()
if options['profile']:
profiler = Profile()
profiler.runcall(self.export, **options)
profiler.print_stats()
profiler.dump_stats('profile.txt')
elif options['format'] == 'all':
self.export_all(**options)
else:
self.export(**options)
def profiled(*args, **kargs):
profile = Profile()
profile.enable()
func(*args, **kargs)
profile.disable()
ident = current_thread().ident
profile.dump_stats("/tmp/%s.%s.%i.pstat" %
(hs.hostname, func.__name__, ident))
def intprofiled(*n, **kw):
import arch
prof = Profile(timer=arch.startup.get_rss)
a = prof.runcall(eff, *n, **kw)
TRACE('Dumping stats to: %r' % (outputfile,))
prof.dump_stats(outputfile)
TRACE('Final RSS = %d' % arch.startup.get_rss())
return a
def thenewfunc(*n, **kw):
if not hasattr(sys, 'getmallocbytecount'):
raise RuntimeError('Not a memory debug version of Python!')
prof = Profile(timer=sys.getmallocbytecount)
a = prof.runcall(eff, *n, **kw)
prof.dump_stats(outputfile)
TRACE('Allocated %d bytes' % sys.getmallocbytecount())
return a
def handle(self, *args, **options):
if options['profile_file']:
profiler = Profile()
profiler.runcall(self._handle, *args, **options)
profiler.dump_stats(options['profile_file'])
else:
self._handle(*args, **options)
def handle(self, *args, **options):
if options['profile_file']:
profiler = Profile()
profiler.runcall(self._handle, *args, **options)
profiler.dump_stats(options['profile_file'])
else:
self._handle(*args, **options)
def profile(func, stats_path):
profiler = Profile()
try:
profiler.runcall(func)
except KeyboardInterrupt:
profiler.dump_stats(stats_path)
s = pstats.Stats(stats_path)
s.strip_dirs().sort_stats("time").print_stats(30)
raise
def intprofiled(*n, **kw):
import arch
timer = arch.util.get_cpu_timer()
prof = Profile(timer=timer)
a = prof.runcall(eff, *n, **kw)
TRACE('Dumping stats to: %r' % (outputfile,))
prof.dump_stats(outputfile)
TRACE('Total CPU time (maybe in jiffies) %.4f' % timer(close=True))
return a
def stats_for_main():
p = Profile()
p.runcall(main)
p.dump_stats('main.stats')
s = Stats(p)
s.strip_dirs().sort_stats('time', 'cumulative')
print_stats('MAIN - ALL STATS', s)
print_stats('MAIN - CALLERS', s, 'sleep')
print_stats('MAIN - CALLEES', s, 'heavy')
def profile(func, stats_path):
profiler = Profile()
try:
profiler.runcall(func)
except KeyboardInterrupt:
profiler.dump_stats(stats_path)
s = pstats.Stats(stats_path)
s.strip_dirs().sort_stats("time").print_stats(30)
raise
def test_xid_perfs(self):
for i in range(10000):
self.make(i)
self.model.invalidate_cache()
records = self.model.search([])
p = Profile()
p.runcall(records._export_rows, [['id'], ['value']])
p.dump_stats('xid_perfs.pstats')
def test_xid_perfs(self):
for i in range(10000):
self.make(i)
self.model.invalidate_cache()
records = self.model.search([])
p = Profile()
p.runcall(records._export_rows, [['id'], ['value']])
p.dump_stats('xid_perfs.pstats')
def profiled(*args, **kargs):
profile = Profile()
profile.enable()
func(*args, **kargs)
profile.disable()
ident = current_thread().ident
profile.dump_stats("/tmp/%s.%s.%i.pstat" % (
hs.hostname, func.__name__, ident
))
def profile_function(self, func, args, kwargs, profile_name):
"""
Profile a Proteus function using the call: func(*args, **kwargs)
Returns the output of the function call.
"""
comm = self.comm
if type(comm) is None:
raise ValueError("The Dispatcher does not have a valid Comm object")
prof = Profile()
func_return = prof.runcall(func, *args, **kwargs)
profile_rank_name = profile_name + str(comm.rank())
stripped_profile_name = profile_name + '_c' + str(comm.rank())
prof.dump_stats(profile_rank_name)
comm.barrier()#ensure files are ready for master
if comm.isMaster():
import copy
import StringIO
profilingLog = StringIO.StringIO()
stats = pstats.Stats(profile_rank_name, stream=profilingLog)
stats.__dict__['files']=['Maximum times across MPI tasks for',
stats.__dict__['files'][0]]
statsm = stats.stats
for i in range(1,comm.size()):
pstatsi = pstats.Stats(profile_name+str(i))
statsi = pstatsi.stats
stats.__dict__['files'].append(pstatsi.__dict__['files'][0])
for f,c in statsi.iteritems():
if f in statsm:
if c[2] > statsm[f][2]:
statsm[f] = c
else:
statsm[f] = c
stats.sort_stats('cumulative')
stats.print_stats(30)
stats.sort_stats('time')
stats.print_stats(30)
logEvent(profilingLog.getvalue())
msg = r"""
Wall clock percentage of top 20 calls
-------------------------------------
"""
total=0.0
for f in stats.__dict__['fcn_list'][0:20]:
if f[0] == '~':
fname=f[-1].strip("<").strip(">")
else:
fname="function '{2:s}' at {0:s}:{1:d}".format(*f)
msg+=("{0:11.1%} {1:s}\n".format(statsm[f][2]/stats.__dict__['total_tt'],str(fname)))
total += statsm[f][2]/stats.__dict__['total_tt']
logEvent(msg)
logEvent("Representing "+`total*100.`+"%")
return func_return
def profile(self, func, suffix=''):
from cProfile import Profile
prof_file = '%s%s' % (func.__name__, suffix)
try:
os.unlink(prof_file)
except OSError:
pass
prof = Profile()
prof.runcall(func)
prof.dump_stats(prof_file)
def run_with_profile():
profile = Profile()
profile.enable()
yield profile
profile.disable()
with NamedTemporaryFile() as statsfile:
profile.dump_stats(statsfile.name)
statsfile.flush()
statsfile.seek(0)
profile.stats = base64.b64encode(statsfile.read()).decode()
def profile_call(_func, *args, **kwargs):
p = Profile()
rv = []
p.runcall(lambda: rv.append(_func(*args, **kwargs)))
p.dump_stats(f"/tmp/sentry-{time.time()}-{_func.__name__}.prof")
stats = Stats(p, stream=sys.stderr)
stats.sort_stats("time", "calls")
stats.print_stats()
return rv[0]
def profile_call(_func, *args, **kwargs):
p = Profile()
rv = []
p.runcall(lambda: rv.append(_func(*args, **kwargs)))
p.dump_stats('/tmp/sentry-%s-%s.prof' % (time.time(), _func.__name__))
stats = Stats(p, stream=sys.stderr)
stats.sort_stats('time', 'calls')
stats.print_stats()
return rv[0]
def profile(self, func, suffix=''):
from cProfile import Profile
prof_file = '%s%s' % (func.__name__, suffix)
try:
os.unlink(prof_file)
except OSError:
pass
prof = Profile()
prof.runcall(func)
prof.dump_stats(prof_file)
def wrapper(*args, **kwargs):
profiler = Profile()
result = profiler.runcall(func, *args, **kwargs)
if print_data:
profiler.print_stats()
filename = func.__name__
profiler.dump_stats(filename)
if visualized:
visualize(filename, host, port)
return result
def wrapped(*args, **kwargs):
if param:
pr = Profile()
pr.enable()
result = func(*args, **kwargs)
pr.disable()
pr.dump_stats(func.__name__ + ".cprofile")
else:
result = func(*args, **kwargs)
return result
def profiled_execution(*args, **kwargs):
logging.info('profiling method %s' % func.__name__)
profiler = Profile()
ret = profiler.runcall(func, *args, **kwargs)
prof_file = NamedTemporaryFile(mode='w',
prefix=func.__name__,
delete=False)
profiler.dump_stats(prof_file.name)
logging.info('profiled method %s and dumped results to %s' % (
func.__name__, prof_file.name))
return ret
def main():
from ..logging.base import setup_context as setup_logging_context
from ..logging.base import teardown as teardown_logging
opts = None
pr = None
debug = False
profile = False
try:
setup_logging_context()
from ..utils.pickle import patch_nipype_unpickler
patch_nipype_unpickler()
from .parser import parse_args
opts, should_run = parse_args()
debug = opts.debug
profile = opts.profile
if profile is True:
from cProfile import Profile
pr = Profile()
pr.enable()
run(opts, should_run)
except Exception as e:
logger.exception("Exception: %s", e, exc_info=True)
if debug:
import pdb
pdb.post_mortem()
finally:
if profile and pr is not None:
pr.disable()
if opts is not None:
pr.dump_stats(
Path(opts.workdir) /
f"profile.{format_current_time():s}.prof")
teardown_logging()
# clean up orphan processes
from ..utils.multiprocessing import terminate
terminate()
def wrapper(*args, **kwargs):
profile = Profile()
profile.enable()
try:
func(*args, **kwargs)
finally:
profile.disable()
try:
thread = current_thread()
profile.dump_stats('profile_%s.%s.%s.log' % (getpid(), thread.name, thread.ident))
except:
logger.exception('Failed to dump stats')
def prof_to_stats(profile: cProfile.Profile) -> None:
"""."""
import pstats
import datetime
now = datetime.datetime.now()
stats = pstats.Stats(profile)
stats.strip_dirs()
stats.sort_stats('cumulative')
stats.print_stats(15)
filename = f'./logs/profile_{now.day}-{now.month}-{now.year}.prof'
profile.dump_stats(filename)
def _save_profile(self, profile: cProfile.Profile, sync: str) -> None:
"""
Dump the profiler data to file in the current working directory.
"""
if profile:
profile_name = "{}/cProfile-{}-{}-{}.pstats".format(
os.getcwd(), self.__class__.__name__, self._parallel_index,
sync)
print("Dumping profile data to {}".format(profile_name))
profile.dump_stats(profile_name)
else:
print("No profile generated.")
def wrapper(*args, **kwargs):
profile = Profile()
profile.enable()
try:
func(*args, **kwargs)
finally:
profile.disable()
try:
thread = current_thread()
profile.dump_stats('profile_%s.%s.%s.log' %
(getpid(), thread.name, thread.ident))
except:
logger.exception('Failed to dump stats')
def helper(*args, **kargs):
filename = "profile-%s-%d.out" % (current_thread().name, get_ident())
if filename in profiled_threads:
raise RuntimeError("Can not attach profiler on the same thread twice")
dprint("running with profiler [", filename, "]")
profiled_threads.add(filename)
profiler = Profile()
try:
return profiler.runcall(func, *args, **kargs)
finally:
dprint("profiler results [", filename, "]")
profiler.dump_stats(filename)
def runAndTimeSRM(srm, srm_type, make_plot=False):
print("Testing {} SRM model!".format(srm_type))
prof = Profile()
prof.enable()
P, T, A, x = burnSRM(srm, srm_type, make_plot)
prof.disable()
t = delta_t * np.arange(P.size)
prof.dump_stats('{}_srm.stats'.format(srm_type))
return P, T, A, x, t
def profile_func(func):
from cProfile import Profile
from pstats import Stats
p = Profile()
rv = []
p.runcall(lambda: rv.append(func()))
p.dump_stats('/tmp/lektor-%s.prof' % func.__name__)
stats = Stats(p, stream=sys.stderr)
stats.sort_stats('time', 'calls')
stats.print_stats()
return rv[0]
def profile_func(func):
from cProfile import Profile
from pstats import Stats
p = Profile()
rv = []
p.runcall(lambda: rv.append(func()))
p.dump_stats('/tmp/lektor-%s.prof' % func.__name__)
stats = Stats(p, stream=sys.stderr)
stats.sort_stats('time', 'calls')
stats.print_stats()
return rv[0]
def profile_call(func, *args, **kw):
from cProfile import Profile
p = Profile() #clock)
print "Profiling to", profile_filename
p.runcall(func, *args, **kw)
from pytools import lsprofcalltree
k = lsprofcalltree.KCacheGrind(p)
pdump_filename = profile_filename+'.pstats'
p.dump_stats(pdump_filename)
print "Profile dumped to", pdump_filename
kcache_grind_filename = profile_filename+'.kcachegrind'
with open(kcache_grind_filename, 'w+b') as f:
k.output(f)
print "Profile results written to", kcache_grind_filename
def pytest_runtest_call(item):
if SHOULD_PROFILE:
p = Profile()
p.enable()
yield
p.disable()
stats = Stats(p)
if SHOULD_PRINT:
stats.sort_stats('cumulative').print_stats(50)
if SHOULD_STORE:
if not os.path.exists(BASEDIR):
os.mkdir(BASEDIR)
p.dump_stats(os.path.join(BASEDIR, '%s.pkl' % item.name))
else:
yield
def helper(*args, **kargs):
filename = "profile-%s-%d.out" % (current_thread().name, get_ident())
if filename in profiled_threads:
raise RuntimeError(
"Can not attach profiler on the same thread twice")
dprint("running with profiler [", filename, "]")
profiled_threads.add(filename)
profiler = Profile()
try:
return profiler.runcall(func, *args, **kargs)
finally:
dprint("profiler results [", filename, "]")
profiler.dump_stats(filename)
def output_timings(self, profile: Profile) -> None:
"""
Output the timings measured by the profiler.
:param profile: The profile.
"""
directory = self.experiment_results_directory()
stats_file_path = path.join(directory, 'timings.pstats')
# Write raw stats
profile.dump_stats(stats_file_path)
# Process raw stats
step_timings = pstats_to_step_timings(stats_file_path)
self.output_case_results('timings', step_timings)
def __call__(self, environ: "WSGIEnvironment",
start_response: "StartResponse") -> t.Iterable[bytes]:
response_body: t.List[bytes] = []
def catching_start_response(status,
headers,
exc_info=None): # type: ignore
start_response(status, headers, exc_info)
return response_body.append
def runapp() -> None:
app_iter = self._app(
environ, t.cast("StartResponse", catching_start_response))
response_body.extend(app_iter)
if hasattr(app_iter, "close"):
app_iter.close() # type: ignore
profile = Profile()
start = time.time()
profile.runcall(runapp)
body = b"".join(response_body)
elapsed = time.time() - start
if self._profile_dir is not None:
if callable(self._filename_format):
filename = self._filename_format(environ)
else:
filename = self._filename_format.format(
method=environ["REQUEST_METHOD"],
path=environ["PATH_INFO"].strip("/").replace("/", ".")
or "root",
elapsed=elapsed * 1000.0,
time=time.time(),
)
filename = os.path.join(self._profile_dir, filename)
profile.dump_stats(filename)
if self._stream is not None:
stats = Stats(profile, stream=self._stream)
stats.sort_stats(*self._sort_by)
print("-" * 80, file=self._stream)
path_info = environ.get("PATH_INFO", "")
print(f"PATH: {path_info!r}", file=self._stream)
stats.print_stats(*self._restrictions)
print(f"{'-' * 80}\n", file=self._stream)
return [body]
def profile_func(func):
# pylint: disable=import-outside-toplevel
from cProfile import Profile
from pstats import Stats
p = Profile()
rv = []
p.runcall(lambda: rv.append(func()))
p.dump_stats("/tmp/lektor-%s.prof" % func.__name__)
stats = Stats(p, stream=sys.stderr)
stats.sort_stats("time", "calls")
stats.print_stats()
return rv[0]
def main(self):
if len(sys.argv) > 1 and sys.argv[1].lower().startswith('prof'):
self._shouldProfile = True
if self._shouldRunTestSuite:
from TestCSVParser import main
main()
start = time.time()
if self._shouldProfile:
prof = Profile()
prof.runcall(self._main)
filename = '%s.pstats' % self.__class__.__name__
prof.dump_stats(filename)
print 'Wrote', filename
else:
self._main()
duration = time.time() - start
print '%.1f secs' % duration
class ProfileHelper(ProfilingHelper):
def run(self):
def run_callable():
"A local function we can refer to in a string with profile.run"
self.result = self.callable(*self.args, **self.kwargs)
try:
from cProfile import Profile
except ImportError:
from profile import Profile
self.p = Profile().runctx("run_callable()", globals(), locals())
self.p.dump_stats(self.filename)
def stats(self):
import pstats
return pstats.Stats(self.p)
class BenchmarkThread(Thread):
def __init__(self, thread_num, session, query, values, num_queries, profile):
Thread.__init__(self)
self.thread_num = thread_num
self.session = session
self.query = query
self.values = values
self.num_queries = num_queries
self.profiler = Profile() if profile else None
def start_profile(self):
if self.profiler:
self.profiler.enable()
def finish_profile(self):
if self.profiler:
self.profiler.disable()
self.profiler.dump_stats("profile-%d" % self.thread_num)
