def inner(*args, **kwargs):
bm_data = dict()
bm_data.update(self._bm_static)
bm_data['_func'] = func
bm_data['_args'] = args
bm_data['_kwargs'] = kwargs
if isinstance(self, MBLineProfiler):
if not line_profiler:
raise ImportError('This functionality requires the '
'"line_profiler" package')
self._line_profiler = line_profiler.LineProfiler(func)
self.pre_run_triggers(bm_data)
if isinstance(self, MBLineProfiler):
res = self._line_profiler.runcall(func, *args, **kwargs)
else:
res = func(*args, **kwargs)
self.post_run_triggers(bm_data)
if isinstance(self, MBReturnValue):
bm_data['return_value'] = res
# Delete any underscore-prefixed keys
bm_data = {
k: v
for k, v in bm_data.items() if not k.startswith('_')
}
self.output_result(bm_data)
return res
def run_command(self):
settings = get_settings(self.arguments.configuration)
app = self.make_app(settings)
if self.arguments.line_profiler:
if not HAS_LINE_PROFILER:
sys.stderr.write(
'You must first install line_profiler for the --line-profiler option to work.\n'
'Use `pip install line_profiler` to install line_profiler.\n'
)
return 1
self.line_profiler = line_profiler.LineProfiler()
for func in profile.get_profilable_functions():
if fnmatch(get_dotted_name(func),
self.arguments.line_profiler_matcher or '*'):
self.line_profiler.add_function(func)
self.line_profiler.enable_by_count()
run_func = self.__run
if self.arguments.monitor:
if not HAS_AIOMONITOR:
sys.stderr.write(
'You must install aiomonitor for the '
'--monitor option to work.\n'
'Use `pip install aiomonitor` to install aiomonitor.\n')
return 1
run_func = self.__run_with_monitor
if self.arguments.profile:
self.profiler = cProfile.Profile()
self.profiler.runcall(run_func, app, settings)
else:
run_func(app, settings)
def _run(self, cmd):
"""Run the given command under the currently configured profiler."""
if self.jobinfo.profile_mode == 'mem':
profiler = _MemoryProfile()
self._run_profiler(cmd, profiler, 'profile_mem_txt')
elif self.jobinfo.profile_mode == 'line':
profiler = None
try:
profiler = line_profiler.LineProfiler()
except NameError:
martian.throw(
'Line-level profiling was requested, but line_profiler was not found.')
for func in self.funcs:
profiler.add_function(func)
self._run_profiler(cmd, profiler, 'profile_line_bin')
iostr = StringIO.StringIO()
profiler.print_stats(stream=iostr)
self.metadata.write_raw('profile_line_txt', iostr.getvalue())
elif self.jobinfo.profile_mode == 'cpu':
profiler = cProfile.Profile()
self._run_profiler(cmd, profiler, 'profile_cpu_bin')
iostr = StringIO.StringIO()
stats = pstats.Stats(
profiler, stream=iostr).sort_stats('cumulative')
stats.print_stats()
self.metadata.write_raw('profile_cpu_txt', iostr.getvalue())
else:
if self.jobinfo.profile_mode and self.jobinfo.profile_mode != 'disable':
# Give the profiler a little bit of time to attach.
time.sleep(0.5)
cmd()
def wrapped(*args, **kwargs):
pr = line_profiler.LineProfiler(func)
pr.enable()
result = func(*args, **kwargs)
pr.disable()
pr.print_stats()
return result
def main_prof():
import line_profiler
prof = line_profiler.LineProfiler(main, Dem3D.create,
Dem3D.make_terrain_grid, Dem3D.fill_base,
Dem3D.to_stl, Dem3D.simplify)
prof.runcall(main)
prof.print_stats()
def dynamic_profile(func):
import line_profiler
profile = line_profiler.LineProfiler()
new_func = profile(func)
new_func.profile_info = KernprofParser(profile)
new_func.print_report = new_func.profile_info.print_report
return new_func
def process_request(self):
self.profiler = line_profiler.LineProfiler()
for f in functions_to_profile:
self.profiler.add_function(f)
self.stats = None
def _test_line_profiler(self):
import line_profiler
profiler = line_profiler.LineProfiler()
import pyexpect
profiler.add_module(pyexpect)
profiler.run("from pyexpect import expect; expect('foo') == 'foo'")
profiler.print_stats(stripzeros=True)
self.fail()
def handler(*args, **kwargs):
import line_profiler
profiler = line_profiler.LineProfiler()
profiler.enable_by_count()
profiler.add_function(func)
result = func(*args, **kwargs)
profiler.print_stats()
return result
def profiled_func(*args, **kwargs):
profiler = line_profiler.LineProfiler()
try:
profiler.add_function(func_or_list)
profiler.enable_by_count()
return func_or_list(*args, **kwargs)
finally:
profiler.print_stats()
def __init__(self, original_path, renditions_paths, metrics_list, duration,
do_profiling):
# ************************************************************************
# Initialize global variables
# ************************************************************************
self.original_path = original_path # Stores system path to original asset
self.original = cv2.VideoCapture(
self.original_path
) # Initializes original asset to OpenCV VideoCapture class
self.fps = int(self.original.get(
cv2.CAP_PROP_FPS)) # Frames Per Second of the original asset
self.asset_length = int(self.original.get(
cv2.CAP_PROP_FRAME_COUNT)) # Counts number of frames of the asset
self.duration = duration # Establishes how many seconds of the original asset are used
self.skip_frames = 1 # Defines whether to use all frames or leap frog skip_frames frames
self.hash_size = 16 # Size of the hash for frame hash analysis in video_metrics
self.renditions = {
} # Dictionary containing dict of renditions ('frame_list',
# 'dimensions',
# 'ID')
self.metrics = {} # Dictionary containing dict of metrics
self.metrics_list = metrics_list # List of metrics to be extracted from the asset and its renditions
self.renditions_paths = renditions_paths # List of paths to renditions
# Retrieve original rendition dimensions
self.height = self.original.get(
cv2.CAP_PROP_FRAME_HEIGHT
) # Obtains vertical dimension of the frames of the original
self.width = self.original.get(
cv2.CAP_PROP_FRAME_WIDTH
) # Obtains horizontal dimension of the frames of the original
self.dimensions = '{}:{}'.format(int(self.width), int(
self.height)) # Collects both dimensional values in a string
if do_profiling:
import line_profiler
self.cpu_profiler = line_profiler.LineProfiler()
else:
self.cpu_profiler = None
self.do_profiling = do_profiling
self.video_metrics = video_metrics(
self.metrics_list, self.skip_frames, self.hash_size,
int(self.dimensions[self.dimensions.find(':') + 1:]),
self.cpu_profiler,
self.do_profiling) # Instance of the video_metrics class
# Convert OpenCV video captures of original to list
# of numpy arrays for better performance of numerical computations
self.original = self.capture_to_array(self.original)
# Compute its features
self.metrics[self.original_path] = self.compute(
self.original, self.original_path, self.dimensions)
# Store the value in the renditions dictionary
self.renditions['original'] = {
'frame_list': self.original,
'dimensions': self.dimensions,
'ID': self.original_path.split('/')[-2]
}
def profile(loops):
profile = line_profiler.LineProfiler(nilakantha_infinite_series)
profile.runcall(nilakantha_infinite_series, loops)
now = datetime.now()
file = open(
"./profile/pi_python_profile_" + now.strftime("%Y-%m-%d_%H-%M-%S") +
".txt", 'w+')
profile.print_stats(file)
file.close()
def wrapped(*args, **kwargs):
prof = line_profiler.LineProfiler()
prof.add_function(view)
if extra_view:
[prof.add_function(v) for v in extra_view]
with prof:
resp = view(*args, **kwargs)
prof.print_stats()
return resp
def line_profiling(*functions):
import line_profiler
profiler = line_profiler.LineProfiler(*functions)
try:
with profiler:
yield
finally:
profiler.print_stats()
def start_line_profiler():
"""Start the line profiler"""
global _active_line_profiler
_active_line_profiler = line_profiler.LineProfiler()
xlcAlert(
"Line Profiler Active\n"
"Run the function you are interested in and then stop the profiler.\n"
"Ensure you have decoratored the function with @enable_line_profiler.")
def lets_profile():
import random
import make_set_cython
import line_profiler
A = bytes([random.randrange(256) for i in range(3 * 10000)])
B = bytes([random.randrange(256) for i in range(3 * 10000)])
profile = line_profiler.LineProfiler(
make_set_cython.detect_users_densehash)
profile.runcall(make_set_cython.detect_users_densehash, A, B)
profile.print_stats()
def __init__(self):
self.num_functions_marked = len(_functions_to_profile)
if line_profiler is None:
self.line_prof = None
else:
self.line_prof = line_profiler.LineProfiler()
for f in _functions_to_profile:
self.line_prof.add_function(f)
def line_profile():
sampledata = flattened.data[:, :, 0, 0]
import line_profiler
profile = line_profiler.LineProfiler(nangeomedian_axis_one)
# profile.add_function(nangeomedian_axis_one)
# profile.runcall(nangeomedian_axis_one, sampledata)
profile.run('simple_reduce()')
profile.print_stats()
def wrapper(*args, **kwargs):
profiler = line_profiler.LineProfiler()
profiler.add_function(func)
profiler.enable()
result = func(*args, **kwargs)
profiler.print_stats()
return result
def _enable_profiler(line_by_line=False): # pragma: no cover
if 'profile' in builtins.__dict__:
return builtins.__dict__['profile']
if line_by_line:
import line_profiler
prof = line_profiler.LineProfiler()
else:
prof = ContextualProfile()
builtins.__dict__['profile'] = prof
return prof
def handle(self):
if conf.MEASUREMENT_MODE_PROCESSOR:
utilities.clean_folder(conf.PROF_FOLDER)
if conf.PROFILER == 'cProfiler':
import cProfile
import pstats
pr = cProfile.Profile()
pr.enable()
self.handle_clean()
pr.disable()
#pr.dump_stats(conf.PROF_FILE_PROCESSOR + "pickle") #pickled
#readable
sortby = 'cumulative'
ps = pstats.Stats(pr,
stream=open(
conf.PROF_FILE_PROCESSOR + "prof",
'w')).sort_stats(sortby)
ps.print_stats()
elif conf.PROFILER == 'LineProfiler':
import line_profiler
import pstats
import io
pr = line_profiler.LineProfiler(
self.handle_clean, get_sketches_from_relays_non_blocking,
Classes.CountSketchCt.aggregate, op.median_operation,
op.mean_operation, op.variance_operation)
pr.enable()
self.handle_clean()
pr.disable()
pr.print_stats(open(conf.PROF_FILE_PROCESSOR + "prof",
'w')) #readable
#pr.dump_stats(conf.PROF_FILE_PROCESSOR + "pickle") #pickled
elif conf.PROFILER == "viz":
from pycallgraph import PyCallGraph
from pycallgraph.output import GraphvizOutput
from pycallgraph import Config
config = Config(max_depth=conf.DEPTH)
graphviz = GraphvizOutput()
graphviz.output_file = conf.PROF_FILE_PROCESSOR + 'png'
with PyCallGraph(output=graphviz, config=config):
self.handle_clean()
else:
self.handle_clean()
else:
self.handle_clean()
def __init__(self, sketch):
self._sketch = sketch
self._functions = dict()
self._function_param_counts = dict()
self._pre_hooks = defaultdict(dict)
self._post_hooks = defaultdict(dict)
self._profiler = line_profiler.LineProfiler()
self._is_terminated = False
from .java_conversion import convert_to_python_types
self._convert_to_python_types = convert_to_python_types
def run_command(self, settings=None, loop=None):
if loop is not None:
self.loop = loop
if settings is None:
settings = get_settings(self.arguments.configuration,
self.arguments.override)
if settings.get("loop_policy"):
loop_policy = resolve_dotted_name(settings["loop_policy"])
asyncio.set_event_loop_policy(loop_policy())
app = self.make_app(settings)
if self.arguments.line_profiler:
if not HAS_LINE_PROFILER:
sys.stderr.write(
"You must first install line_profiler for the --line-profiler option to work.\n"
"Use `pip install line_profiler` to install line_profiler.\n"
)
return 1
self.line_profiler = line_profiler.LineProfiler()
for func in profile.get_profilable_functions():
if fnmatch(get_dotted_name(func),
self.arguments.line_profiler_matcher or "*"):
self.line_profiler.add_function(func)
self.line_profiler.enable_by_count()
run_func = self.__run
if self.arguments.monitor:
if not HAS_AIOMONITOR:
sys.stderr.write(
"You must install aiomonitor for the "
"--monitor option to work.\n"
"Use `pip install aiomonitor` to install aiomonitor.\n")
return 1
run_func = self.__run_with_monitor
if self.arguments.profile:
self.profiler = cProfile.Profile()
self.profiler.runcall(run_func, app, settings)
if self.arguments.profile_output:
self.profiler.dump_stats(self.arguments.profile_output)
else:
# dump to screen
self.profiler.print_stats(-1)
else:
run_func(app, settings)
if self.line_profiler is not None:
self.line_profiler.disable_by_count()
if self.arguments.line_profiler_output:
self.line_profiler.dump_stats(
self.arguments.line_profiler_output)
else:
self.line_profiler.print_stats()
def decorated_func(*args, **kwargs):
import line_profiler
profile = line_profiler.LineProfiler()
f = profile(func)
return_value = f(*args, **kwargs)
profile.print_stats()
return return_value
def profile_analyse_image():
"""
Profile the analysis function
"""
path = "../data/Real_Application/"
model = load_model(path="./state_dicts/custom_cnn_e4_0.pt", tracing=True)
lp = line_profiler.LineProfiler()
lp_wrapper = lp(analyse_image)
lp_wrapper(path, model)
lp.print_stats()
def profile_function_np(number_of_points):
points = np.zeros((number_of_points, 2), dtype=np.float64)
for i in range(number_of_points):
points[i] = np.random.uniform(-10, 10), np.random.uniform(-10, 10)
profile = line_profiler.LineProfiler(convex_hull_np_array)
profile.runcall(convex_hull_np_array, points)
now = datetime.now()
file = open(
"../cython_profiler_np_" + now.strftime("%Y-%m-%d_%H-%M-%S") + ".txt",
'w+')
profile.print_stats(file)
file.close()
def run_worker(infile, master, work_id=None):
worker = Worker(infile,
master,
work_id=work_id,
process_line=proc_dur_count)
prof = line_profiler.LineProfiler(
worker.run, worker.upload_data, worker.find_skyline_diff,
worker.get_master_updates, worker.expire_points, worker.update_skyline,
worker.sky.update_sky_for_point, worker.sky.check_dominated)
prof.enable()
worker.run()
prof.disable()
prof.dump_stats("worker.prof")
def line_profile_func(func, args):
'''
Print time to run each line.
*** There are issues after reloading code.
Import function (with preceding module name, without trailing parentheses),
its arguments (all within ()).
'''
import line_profiler
reload(line_profiler)
ppp = line_profiler.LineProfiler(func)
ppp.runcall(func, *args)
ppp.print_stats()
def process_view(self, request, view_func, view_args, view_kwargs):
if getattr(settings, 'PAUSE_PROFILING', False):
return None
codes = inspect.getmodule(view_func).__dict__.values()
request.profiler = line_profiler.LineProfiler()
for code in codes:
try:
request.profiler.add_module(inspect.getmodule(code))
request.mem_profiler.add_function(code)
except AttributeError:
continue
request.profiler.enable_by_count()
def profile_onthefly(func):
import line_profiler
profile = line_profiler.LineProfiler()
new_func = profile(func)
new_func.profile_info = KernprofParser(profile)
new_func.print_report = new_func.profile_info.print_report
def wraper(*args, **kwargs):
retval = new_func(*args, **kwargs)
new_func.print_report()
return retval
return wraper
