def starfish(): parser = build_parser() args, argv = parser.parse_known_args() art = """ _ __ _ _ | | / _(_) | | ___| |_ __ _ _ __| |_ _ ___| |__ / __| __/ _` | '__| _| / __| '_ ` \__ \ || (_| | | | | | \__ \ | | | |___/\__\__,_|_| |_| |_|___/_| |_| """ print(art) if args.profile: profiler = cProfile.Profile() profiler.enable() if args.starfish_command is None: parser.print_help() parser.exit(status=2) args.starfish_command(args, len(argv) != 0) if args.profile: stats = Stats(profiler) stats.sort_stats('tottime').print_stats(PROFILER_LINES)
def example_one(): """ 20003 function calls in 0.778 seconds Ordered by: cumulative time ncalls tottime percall cumtime percall filename:lineno(function) 1 0.000 0.000 0.778 0.778 item_58_profile.py:38(<lambda>) 1 0.001 0.001 0.778 0.778 item_58_profile.py:19(insertion_sort) 10000 0.764 0.000 0.777 0.000 item_58_profile.py:26(insert_value) 9989 0.013 0.000 0.013 0.000 {method 'insert' of 'list' objects} 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} 11 0.000 0.000 0.000 0.000 {method 'append' of 'list' objects} - notes for Nick: - we can see that the biggest use of CPU in our test is the cumulative time spent in the 'insert_value' function. """ max_size = 10**4 data = [randint(0, max_size) for _ in range(max_size)] test = lambda: insertion_sort(data) profiler = Profile() profiler.runcall(test) # to extract statistics about the 'test' function's performance, we use pstats stats = Stats(profiler) stats.strip_dirs() stats.sort_stats('cumulative') stats.print_stats()
def expose(self, widget, event): context = widget.window.cairo_create() #r = (event.area.x, event.area.y, event.area.width, event.area.height) #context.rectangle(r[0]-.5, r[1]-.5, r[2]+1, r[3]+1) #context.clip() if False: import profile profile.runctx("self.draw(context, event.area)", locals(), globals(), "/tmp/pychessprofile") from pstats import Stats s = Stats("/tmp/pychessprofile") s.sort_stats('cumulative') s.print_stats() else: self.drawcount += 1 start = time() self.animationLock.acquire() self.draw(context, event.area) self.animationLock.release() self.drawtime += time() - start #if self.drawcount % 100 == 0: # print "Average FPS: %0.3f - %d / %d" % \ # (self.drawcount/self.drawtime, self.drawcount, self.drawtime) return False
def example_two(): """ 30003 function calls in 0.018 seconds Ordered by: cumulative time ncalls tottime percall cumtime percall filename:lineno(function) 1 0.000 0.000 0.018 0.018 item_58_profile.py:98(<lambda>) 1 0.001 0.001 0.018 0.018 item_58_profile.py:38(insertion_sort) 10000 0.002 0.000 0.017 0.000 item_58_profile.py:88(insert_value_better) 10000 0.012 0.000 0.012 0.000 {method 'insert' of 'list' objects} 10000 0.003 0.000 0.003 0.000 {built-in method _bisect.bisect_left} 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} """ max_size = 10**4 data = [randint(0, max_size) for _ in range(max_size)] test = lambda: insertion_sort(data) profiler = Profile() profiler.runcall(test) # to extract statistics about the 'test' function's performance, we use pstats stats = Stats(profiler) stats.strip_dirs() stats.sort_stats('cumulative') stats.print_stats()
def tearDown(self): """ """ p = Stats(self.prof) p.sort_stats("cumtime") if self.verbose: p.dump_stats("profiles/test_graph.py.prof") p.strip_dirs()
def profile(): prof = Profile() prof.runcall(f1) stat = Stats(prof) stat.strip_dirs() stat.sort_stats('cumulative') stat.print_stats()
def __call__(self, environ, start_response): response_body = [] def catching_start_response(status, headers, exc_info=None): start_response(status, headers, exc_info) return response_body.append def runapp(): appiter = self._app(environ, catching_start_response) response_body.extend(appiter) if hasattr(appiter, 'close'): appiter.close() p = Profile() p.runcall(runapp) body = ''.join(response_body) stats = Stats(p) stats.sort_stats(*self._sort_by) self._stream.write('-' * 80) self._stream.write('\nPATH: %r\n' % environ.get('PATH_INFO')) stats.print_stats(*self._restrictions) self._stream.write('-' * 80 + '\n\n') return [body]
def __init__(self): settings_manager = SettingsManager() # Set up the settings_manager max_workers = settings_manager.getint('application', 'max-workers') # Get the max workers from settings manager profiler_on = settings_manager.getint('debugging', 'profiler-on') # Get whether there is a profiler absolute = settings_manager.getint('save', 'absolute') # Get whether it's an absolute path save_path = settings_manager.get('save', 'path') # Get whether it's an absolute path if not absolute: save_path = PROJECT_PATH + os.path.sep + save_path executor = ThreadPoolExecutor(max_workers=max_workers, profiler_on=profiler_on) # Set up the thread executor dis = Disassembler(settings_manager) # Build the disassembler server = PyDAServer('0.0.0.0',9000) # Set up the PyDA server save_manager = SaveManager(save_path) if profiler_on: profile = Profile() profile.enable() app.build_and_run(settings_manager, dis, executor, server, save_manager) # Run the interface if profiler_on: profile.disable() stats = executor.getProfileStats() if stats == None: stats = Stats(profile) else: stats.add(profile) with open('profile.stats', 'wb') as statsfile: stats.stream = statsfile stats.sort_stats('cumulative').print_stats()
def __analyze2 (): import profile profile.runctx("self.__analyze2()", locals(), globals(), "/tmp/pychessprofile") from pstats import Stats s = Stats("/tmp/pychessprofile") s.sort_stats('cumulative') s.print_stats()
def tearDown(self): """Report profiling results""" p = Stats(self.pr) p.strip_dirs() p.sort_stats('cumtime') p.print_stats() print "\n--->>>"
def tearDown(self): if self.should_profile: results = Stats(self.profile) results.strip_dirs() results.sort_stats('cumulative') results.print_stats(50) super().tearDown()
def _execute(self, func, phase_name, n, *args): if not self.profile_dir: return func(*args) basename = '%s-%s-%d-%02d-%d' % ( self.contender_name, phase_name, self.objects_per_txn, n, self.rep) txt_fn = os.path.join(self.profile_dir, basename + ".txt") prof_fn = os.path.join(self.profile_dir, basename + ".prof") profiler = cProfile.Profile() profiler.enable() try: res = func(*args) finally: profiler.disable() profiler.dump_stats(prof_fn) with open(txt_fn, 'w') as f: st = Stats(profiler, stream=f) st.strip_dirs() st.sort_stats('cumulative') st.print_stats() return res
def stopTest(self, test): super(BenchTestResult, self).stopTest(test) if self._benchmark: self._profiler.disable() stats = Stats(self._profiler) stats.sort_stats(self._sort) stats.print_stats(self._limit)
def prof_wrapper(*args, **kwargs): with cProfile.Profile() as pr: value = profunc(*args, **kwargs) p = Stats(pr) p.sort_stats(SortKey.TIME).dump_stats( f"profiles/{profunc.__name__}_{args[0]}.prof") return value
def __call__(self, environ, start_response): response_body = [] def catching_start_response(status, headers, exc_info=None): start_response(status, headers, exc_info) return response_body.append def runapp(): appiter = self._app(environ, catching_start_response) response_body.extend(appiter) if hasattr(appiter, 'close'): appiter.close() p = Profile() p.runcall(runapp) body = ''.join(response_body) stats = Stats(p, stream=self._stream) stats.sort_stats(*self._sort_by) self._stream.write('-' * 80) self._stream.write('\nPATH: %r\n' % environ.get('PATH_INFO')) stats.print_stats(*self._restrictions) self._stream.write('-' * 80 + '\n\n') return [body]
def main(): """Main sequence""" analyser = Analyser(config=ProfilingConfig) data = import_all(config=ProfilingConfig) analyser.run(data) del analyser del data profiler = Profile() tracemalloc.start(10) time1 = tracemalloc.take_snapshot() profiler.runcall(test) time2 = tracemalloc.take_snapshot() time_stats = Stats(profiler) time_stats.strip_dirs() time_stats.sort_stats('cumulative') print("\n===Time Profiler Stats===\n") time_stats.print_stats(TOP_STATS) print("\n===Time Profiler Callers===\n") time_stats.print_callers(TOP_STATS) memory_stats = time2.compare_to(time1, 'lineno') print("\n===Memory Profiler Callers===\n") for stat in memory_stats[:3]: print(stat) print("\n===Top Memory Consumer===\n") top = memory_stats[0] print('\n'.join(top.traceback.format()))
def profile(to=None, sort_by='cumtime'): '''Profiles a chunk of code, use with the ``with`` statement:: from halonctl.debug import profile with profile('~/Desktop/stats'): pass # Do something performance-critical here... Results for individual runs are collected into ``to``. The specifics of how reports are done varies depending on what type ``to`` is. * **File-like objects**: Stats are dumped, according to ``sort_by``, into the stream, separated by newlines - watch out, the file/buffer may grow very big when used in loops. * **List-like objects**: A number of pstats.Stats objects are appended. * **str and unicode**: Treated as a path and opened for appending. Tildes (~) will be expanded, and intermediary directories created if possible. * **None or omitted**: Results are printed to sys.stderr. ''' if isinstance(to, six.string_types): to = open_fuzzy(to, 'a') to_is_stream = hasattr(to, 'write') to_is_list = hasattr(to, 'append') p = Profile() p.enable() yield p.disable() ps = Stats(p, stream=to if to_is_stream else sys.stderr) ps.sort_stats('cumtime') if to_is_stream or to is None: ps.print_stats() elif to_is_list: to.append(ps)
def tearDown(self): if PROFILE: p = Stats(self.pr) p.strip_dirs() p.sort_stats('cumtime') p.print_stats() if DEBUG: print('\n{}>>>'.format('-' * 77))
def wrap(*args, **kwargs): prof = Profile() res = prof.runcall(func, *args, **kwargs) stats = Stats(prof) stats.strip_dirs() stats.sort_stats('tottime') stats.print_stats(20) return res
def tearDown(self): """finish any test""" if hasattr(self, "prof"): p = Stats(self.prof) p.strip_dirs() p.sort_stats('cumtime') p.print_stats() print("\n--->>>")
def tearDown(self): """Disconnect from statseg""" self.stat.disconnect() profile = Stats(self.profile) profile.strip_dirs() profile.sort_stats("cumtime") profile.print_stats() print("\n--->>>")
def print_stats(statsfile, statstext): with open(statstext, 'w') as f: mystats = Stats(statsfile, stream=f) mystats.strip_dirs() mystats.sort_stats('cumtime') # mystats.print_callers('_strptime') mystats.print_stats() startfile(statstext)
def tearDownClass(cls): if cls.is_running: return urlopen('http://localhost:8000/quit') cls.cli.close() p = Stats(cls.profiler) p.strip_dirs() p.sort_stats('cumtime')
def tearDown(self): '''Disconnect from statseg''' self.stat.disconnect() profile = Stats(self.profile) profile.strip_dirs() profile.sort_stats('cumtime') profile.print_stats() print("\n--->>>")
def tearDown(self): return """finish any test""" p = Stats(self.pr) p.strip_dirs() p.sort_stats('cumtime') p.print_stats() print("\n--->>>")
def search_method(): """Match for applicable methods and their arguments. Input: * username: username. * theory_name: name of the theory. * thm_name: name of the theorem. Returns: * search_res: list of search results. * ctxt: current proof context. """ data = json.loads(request.get_data().decode("utf-8")) if data['profile']: pr = cProfile.Profile() pr.enable() if not proof_cache.check_cache(data): start_time = time.perf_counter() proof_cache.create_cache(data) print("Load: %f" % (time.perf_counter() - start_time)) if data['thm_name'] != '': limit = ('thm', data['thm_name']) else: limit = None basic.load_theory(data['theory_name'], limit=limit, username=data['username']) start_time = time.perf_counter() state = proof_cache.states[data['index']] fact_ids = data['step']['fact_ids'] goal_id = data['step']['goal_id'] search_res = state.search_method(goal_id, fact_ids) with settings.global_setting(unicode=True): for res in search_res: if '_goal' in res: res['_goal'] = [printer.print_term(t) for t in res['_goal']] if '_fact' in res: res['_fact'] = [printer.print_term(t) for t in res['_fact']] vars = state.get_vars(goal_id) with settings.global_setting(unicode=True, highlight=True): print_vars = dict((k, printer.print_type(v)) for k, v in vars.items()) print("Response:", time.perf_counter() - start_time) if data['profile']: p = Stats(pr) p.strip_dirs() p.sort_stats('cumtime') p.print_stats() return jsonify({'search_res': search_res, 'ctxt': print_vars})
def print_profile_data(): """ Print the collected profile data. """ stream = StringIO() statistics = Stats(profiler, stream=stream) statistics.sort_stats('cumulative') statistics.print_stats() print(stream.getvalue())
def home_p(request): """Profiled version of home""" prof = Profile() prof = prof.runctx("home(request)", globals(), locals()) stream = StringIO() stats = Stats(prof, stream=stream) stats.sort_stats("time").print_stats(80) log.info("Profile data:\n%s", stream.getvalue()) return HttpResponse(u"OK")
def inner(*args, **kwargs): pro = Profile() pro.runcall(func, *args, **kwargs) stats = Stats(pro) stats.strip_dirs() stats.sort_stats(field) print("Profile for {}()".format(func.__name__)) stats.print_stats() stats.print_callers()
def run(): if sys.version_info < (3, 0, 0): sys.stderr.write("You need python 3.0 or later to run this script\n") sys.exit(1) arg_parser = get_arg_parser() args = arg_parser.parse_args() if not args.p1_path and (not args.p1_draft or not args.p1_battle): arg_parser.error("You should use either p1-path or both " "p1-draft and p1-battle.\n") elif not args.p2_path and (not args.p2_draft or not args.p2_battle): arg_parser.error("You should use either p2-path or both " "p2-draft and p2-battle.\n") if args.p1_path is not None: player_1 = agents.NativeAgent(args.p1_path) player_1 = (player_1, player_1) else: player_1 = parse_draft_agent(args.p1_draft)(), \ parse_battle_agent(args.p1_battle)() if args.p2_path is not None: player_2 = agents.NativeAgent(args.p2_path) player_2 = (player_2, player_2) else: player_2 = parse_draft_agent(args.p2_draft)(), \ parse_battle_agent(args.p2_battle)() if args.profile: profiler = cProfile.Profile() result = io.StringIO() profiler.enable() for i in range(args.games): evaluate((i, player_1, player_2, args.seed)) profiler.disable() profiler_stats = Stats(profiler, stream=result) profiler_stats.sort_stats('cumulative') profiler_stats.print_stats() print(result.getvalue()) else: params = ((j, player_1, player_2, args.seed, args.silent) for j in range(args.games)) with Pool(args.processes) as pool: pool.map(evaluate, params) wins, games = wins_by_p0 ratio = 100 * wins / games print(f"{'%.2f' % ratio}% {'%.2f' % (100 - ratio)}%")
def build_document(self, file_name): """This is the entry point for the NetcfBuilders from the ingestManager. These documents are id'd by fcstValidEpoch. The data section is an array each element of which contains variable data and a station name. To process this file we need to itterate the document by recNum and process the station name along with all the other variables in the variableList. Args: file_name (str): the name of the file being processed Returns: [dict]: document """ # noinspection PyBroadException try: # stash the file_name so that it can be used later self.file_name = os.path.basename(file_name) # pylint: disable=no-member self.ncdf_data_set = nc.Dataset(file_name) if len(self.station_names) == 0: result = self.cluster.query("""SELECT raw name FROM mdata WHERE type = 'MD' AND docType = 'station' AND subset = 'METAR' AND version = 'V01'; """) self.station_names = list(result) self.initialize_document_map() logging.info("%s building documents for file %s", self.__class__.__name__, file_name) if self.do_profiling: with cProfile.Profile() as _pr: self.handle_document() with open("profiling_stats.txt", "w") as stream: stats = Stats(_pr, stream=stream) stats.strip_dirs() stats.sort_stats("time") stats.dump_stats("profiling_stats.prof") stats.print_stats() else: self.handle_document() # pylint: disable=assignment-from-no-return document_map = self.get_document_map() data_file_id = self.create_data_file_id(file_name=file_name) data_file_doc = self.build_datafile_doc( file_name=file_name, data_file_id=data_file_id, ) document_map[data_file_doc["id"]] = data_file_doc return document_map except Exception as _e: # pylint:disable=broad-except logging.error( "%s: Exception with builder build_document: error: %s", self.__class__.__name__, str(_e), ) return {}
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 tearDown(self): if not DEBUG_MODE: self.test_elasticity.collection.drop() self.test_tasks.collection.drop() if PROFILE_MODE: p = Stats(self.pr) p.strip_dirs() p.sort_stats('cumtime') p.print_stats() print("\n--->>>")
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 tearDown(self): for worker in self.driver._workers: worker.stop() worker.wait() self.cvx.endpoint_data.clear() super(MechTestBase, self).tearDown() if ENABLE_PROFILER: p = Stats(self.pr) p.strip_dirs() p.sort_stats('cumtime') p.print_stats()
def wrapper(*args, **kwg): f = func res = None try: cProfile.runctx("res = f(*args, **kwg)", globals(), locals(), filename) return res finally: if filename: pstats = Stats(filename) pstats.sort_stats(*sort_fields) pstats.print_stats(*p_amount)
def show_time_profiler_results(pr, top_records): """ Show results of timed profiling. :param pr: profiler instance :param top_records: how many top function calls to show. """ if pr: st = Stats(pr) st.strip_dirs() st.sort_stats('cumulative') st.print_stats(top_records)
def example_three(): """ 20242 function calls in 0.063 seconds Ordered by: cumulative time ncalls tottime percall cumtime percall filename:lineno(function) 1 0.000 0.000 0.063 0.063 item_58_profile.py:140(my_program) 20 0.002 0.000 0.063 0.003 item_58_profile.py:130(first_func) 20200 0.061 0.000 0.061 0.000 item_58_profile.py:124(my_utility) 20 0.000 0.000 0.001 0.000 item_58_profile.py:135(second_func) 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} -notes for Nick - you may profile your program only to find that a common utility function is responsible for majority of the execution time. - default output from the profiler doesn't show how the utility function is called by many different parts of your program. - 'my_utility' function is evidently the source of most execution time, but it is not immediately obvious why that function is called so many times. ---- Callers ----- Ordered by: cumulative time Function was called by... ncalls tottime cumtime item_58_profile.py:140(my_program) <- item_58_profile.py:130(first_func) <- 20 0.002 0.062 item_58_profile.py:140(my_program) item_58_profile.py:124(my_utility) <- 20000 0.061 0.061 item_58_profile.py:130(first_func) 200 0.001 0.001 item_58_profile.py:135(second_func) item_58_profile.py:135(second_func) <- 20 0.000 0.001 item_58_profile.py:140(my_program) {method 'disable' of '_lsprof.Profiler' objects} <- """ profiler = Profile() profiler.runcall(my_program) # to extract statistics about the 'test' function's performance, we use pstats stats = Stats(profiler) stats.strip_dirs() stats.sort_stats('cumulative') stats.print_stats() print('\n---- Callers -----\n') # to see how many times a function is called stats.print_callers()
def print_stats(profiler, printCallers=False): from pstats import Stats stats = Stats(profiler) stats.strip_dirs() stats.sort_stats('cumulative') if printCallers is True: stats.print_callers() else: stats.print_stats()
def profile(func, args=None, kwargs=None, sort="time"): prof = profile_.Profile() if args is None: args = () if kwargs is None: kwargs = {} ret = prof.runcall(func, *args, **kwargs) stats = Stats(prof) stats.sort_stats(sort) stats.print_stats() return ret
def save_data(self): try: import gprof2dot import pyprof2calltree except ImportError: msg = ('Unable to start profiling.\n Please either ' 'disable performance profiling in settings.yaml or ' 'install all modules listed in test-requirements.txt.') raise error.ProfilingError(msg) self.profiler.disable() elapsed = time.time() - self.start pref_filename = os.path.join( self.paths['last_performance_test'], '{method:s}.{handler_name:s}.{elapsed_time:.0f}ms.{t_time}.'. format( method=self.method, handler_name=self.handler_name or 'root', elapsed_time=elapsed * 1000.0, t_time=time.time())) tree_file = pref_filename + 'prof' stats_file = pref_filename + 'txt' callgraph_file = pref_filename + 'dot' # write pstats with file(stats_file, 'w') as file_o: stats = Stats(self.profiler, stream=file_o) stats.sort_stats('time', 'cumulative').print_stats() # write callgraph in dot format parser = gprof2dot.PstatsParser(self.profiler) def get_function_name(args): filename, line, name = args module = os.path.splitext(filename)[0] module_pieces = module.split(os.path.sep) return "{module:s}:{line:d}:{name:s}".format( module="/".join(module_pieces[-4:]), line=line, name=name) parser.get_function_name = get_function_name gprof = parser.parse() with open(callgraph_file, 'w') as file_o: dot = gprof2dot.DotWriter(file_o) theme = gprof2dot.TEMPERATURE_COLORMAP dot.graph(gprof, theme) # write calltree call_tree = pyprof2calltree.CalltreeConverter(stats) with file(tree_file, 'wb') as file_o: call_tree.output(file_o)
def tearDown(self): if ENABLE_PROFILE: if DUMP_PROFILE: self.pr.dump_stats('profile.out') p = Stats(self.pr) p.strip_dirs() p.sort_stats('time') p.print_stats(40) p.print_callees('types.py:846\(validate_value', 20) p.print_callees('types.py:828\(_validate_primitive_value', 20) p.print_callees('uploadsession.py:185\(write', 20) TestBase.teardown(self)
def profiler(enable, outfile): try: if enable: profiler = Profile() profiler.enable() yield finally: if enable: profiler.disable() stats = Stats(profiler) stats.sort_stats('tottime') stats.dump_stats(outfile)
def tearDownClass(cls): # stop swarm print("TEST: stopping swarm") for node in cls.swarm: node.stop() shutil.rmtree(STORAGE_DIR) # get profiler stats stats = Stats(cls.profile) stats.strip_dirs() stats.sort_stats('cumtime') stats.print_stats()
def _call(self, *args, **kw): profile = RawProfile() def _run(): with DisableGc(): for _ in range(self._iterations): _run.result = super(Profile, self)._call(*args, **kw) profile.runctx('_run()', {}, {'_run': _run}) profile.create_stats() stats = Stats(profile) stats.sort_stats('cumulative') stats.fcn_list = stats.fcn_list[:self._max_lines] self._reporter(stats) return _run.result
def get_profile_report(profiler): from pstats import Stats from cStringIO import StringIO io = StringIO() stats = Stats(profiler, stream = io) io.write('\nby cumulative time:\n\n') stats.sort_stats('cumulative').print_stats(25) io.write('\nby number of calls:\n\n') stats.sort_stats('time').print_stats(25) return io.getvalue()
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 run(self): """method calling cProfile and printing the output""" tests=self.tests() for test in tests: tmpBuffer=StringIO.StringIO() profile=cProfile.Profile() profile.runctx('self.'+str(test[0])+"()",globals(),locals()) stats=Stats(profile,stream=tmpBuffer) stats.sort_stats('time','calls') stats.print_stats(1) match=re.findall(r'\bin\b(.*?)\bCPU\b',tmpBuffer.getvalue()) print str(test[1].__doc__ )+":"+str(match[0])+" CPU Time"
def process_response(self, request, response): if self.is_on(request): self.prof.create_stats() out = StringIO.StringIO() stats = Stats(self.prof, stream=out) stats.sort_stats(*sort_tuple) stats.print_stats() stats_str = out.getvalue() if response and response.content and stats_str: response.content = "<pre>" + stats_str + "</pre>" return response
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 profiling(): from cProfile import Profile from pstats import Stats ir_params = { 'ev_params' : {'space':'e3', 'F': [0.1,0.1,0.1], 'j_max':30}, 'duration' : 1, 'nu' : 1.7e-5, 'sampling_rate' : 8000, } p = Profile() p.runcall(lambda : get_ir(ir_params)) stats = Stats(p, stream=sys.stdout) stats.sort_stats('time') stats.print_stats(10)
def __profile_code(): """ @return: None @rtype: None Edit this function to do all profiling. """ import cProfile from pstats import Stats profile_file = "C:\\Users\\PBS Biotech\\Documents\\Personal\\PBS_Office\\MSOffice\\officelib\\pbslib\\test\\profile.txt" cProfile.run('full_scan(manyfile3, manyrecipesteps)', filename=profile_file) with open("C:\\Users\\Public\\Documents\\PBSSS\\Functional Testing\\tpid.txt", 'w') as f: stats = Stats(profile_file, stream=f) # stats.strip_dirs() stats.sort_stats('time') stats.print_stats('MSOffice')