class ProfilingPanel(Panel):
"""
Panel that displays profiling information.
"""
title = _('Profiling')
template = 'debug_toolbar_line_profiler/panels/profiling.html'
def _unwrap_closure_and_profile(self, func):
if not hasattr(func, '__code__'):
return
self.line_profiler.add_function(func)
for subfunc in getattr(func, 'profile_additional', []):
self._unwrap_closure_and_profile(subfunc)
if func.__closure__:
for cell in func.__closure__:
target = cell.cell_contents
if inspect.isclass(target) and View in inspect.getmro(target):
for name, value in inspect.getmembers(target):
if name[0] != '_' and inspect.ismethod(value):
self._unwrap_closure_and_profile(value)
else:
self._unwrap_closure_and_profile(target)
def process_view(self, request, view_func, view_args, view_kwargs):
self.profiler = cProfile.Profile()
args = (request,) + view_args
self.line_profiler = LineProfiler()
self._unwrap_closure_and_profile(view_func)
self.line_profiler.enable_by_count()
out = self.profiler.runcall(view_func, *args, **view_kwargs)
self.line_profiler.disable_by_count()
return out
def add_node(self, func_list, func, max_depth, cum_time=0.1):
func_list.append(func)
func.has_subfuncs = False
if func.depth < max_depth:
for subfunc in func.subfuncs():
if (subfunc.stats[3] >= cum_time or
(hasattr(self.stats, 'line_stats') and
(subfunc.func in self.stats.line_stats.timings))):
func.has_subfuncs = True
self.add_node(func_list, subfunc, max_depth, cum_time=cum_time)
def process_response(self, request, response):
if not hasattr(self, 'profiler'):
return None
# Could be delayed until the panel content is requested (perf. optim.)
self.profiler.create_stats()
self.stats = DjangoDebugToolbarStats(self.profiler)
self.stats.line_stats = self.line_profiler.get_stats()
self.stats.calc_callees()
root = FunctionCall(self.stats, self.stats.get_root_func(), depth=0)
func_list = []
self.add_node(func_list, root, 10, root.stats[3] / 8)
self.record_stats({'func_list': func_list})
df["oversample"] = params.simulator.oversample
if params.opt_det is not None:
df["opt_det"] = params.opt_det
df["stage1_refls"] = stg1_refls
df["stage1_output_img"] = stg1_img_path
df.to_pickle(pandas_path)
return df
if __name__ == '__main__':
from dials.util import show_mail_on_error
with show_mail_on_error():
script = Script()
RUN = script.run
lp = None
if LineProfiler is not None and script.params.profile:
lp = LineProfiler()
lp.add_function(hopper_utils.model)
lp.add_function(hopper_utils.target_func)
RUN = lp(script.run)
elif script.params.profile:
print("Install line_profiler in order to use logging: libtbx.python -m pip install line_profiler")
RUN()
if lp is not None:
stats = lp.get_stats()
hopper_utils.print_profile(stats, ["model", "target_func"])
class ProfilingDebugPanel(DebugPanel):
"""
Panel that displays the Django version.
"""
name = 'Profiling'
template = 'debug_toolbar/panels/profiling.html'
has_content = True
def nav_title(self):
return _('Profiling')
def url(self):
return ''
def title(self):
return _('Profiling')
def _unwrap_closure_and_profile(self, func):
if not hasattr(func, 'func_code'):
return
self.line_profiler.add_function(func)
if func.func_closure:
for cell in func.func_closure:
if hasattr(cell.cell_contents, 'func_code'):
self._unwrap_closure_and_profile(cell.cell_contents)
def process_view(self, request, view_func, view_args, view_kwargs):
__traceback_hide__ = True
self.profiler = cProfile.Profile()
args = (request,) + view_args
if DJ_PROFILE_USE_LINE_PROFILER:
self.line_profiler = LineProfiler()
self._unwrap_closure_and_profile(view_func)
self.line_profiler.enable_by_count()
out = self.profiler.runcall(view_func, *args, **view_kwargs)
self.line_profiler.disable_by_count()
else:
self.line_profiler = None
out = self.profiler.runcall(view_func, *args, **view_kwargs)
return out
def add_node(self, func_list, func, max_depth, cum_time=0.1):
func_list.append(func)
func.has_subfuncs = False
if func.depth < max_depth:
for subfunc in func.subfuncs():
if (subfunc.stats[3] >= cum_time or
(hasattr(self.stats, 'line_stats') and
(subfunc.func in self.stats.line_stats.timings))):
func.has_subfuncs = True
self.add_node(func_list, subfunc, max_depth, cum_time=cum_time)
def process_response(self, request, response):
self.profiler.create_stats()
self.stats = DjangoDebugToolbarStats(self.profiler)
if DJ_PROFILE_USE_LINE_PROFILER:
self.stats.line_stats = self.line_profiler.get_stats()
self.stats.calc_callees()
root = FunctionCall(self.stats, self.stats.get_root_func(), depth=0)
func_list = []
self.add_node(func_list, root, 10, root.stats[3]/8)
self.stats_record({'func_list': func_list})
def main(program_dir, scale_factor, wta_k, score_type):
# num_features_list stores the number of features detected in each frame.
# time stores the time taken in miliseconds to get features in each frame, by the function getKeyPoints
# num_frames stores the number of frames
num_features_list = []
time = []
num_frames = 0
# Created the ORB feature matcher object, with the requisite arguments (some default some taken from command line)
orb = cv2.ORB_create(nfeatures=10000,
edgeThreshold=50,
patchSize=50,
fastThreshold=20,
scaleFactor=scale_factor,
WTA_K=wta_k,
scoreType=score_type)
# Place your data set in the BENCHMARKS/ORB_feature_detector_algorithm/datasets directory. Make sure it is encoded in FFMPEG
# format for OpenCV to use it.
cap = cv2.VideoCapture(program_dir + '/datasets/Raw.mp4')
if cap.isOpened() == False:
print("Error opening video file.")
return
while cap.isOpened():
ret, frame = cap.read()
if np.shape(frame) == ():
break
num_frames = num_frames + 1
# This section computes the time taken in each function call of getKeyPoints. Instead of calling getKeyPoints directly,
# you call the function through a wrapper which measures the time taken for it's execution.
profile = LineProfiler()
profile_wrapper = profile(getKeyPoints)
kp = profile_wrapper(orb, frame)
# This part is a bit tricky to understand. Basically, the data variable here is a dictionary. Here is an example of
# this data variable {('ORB_feature.py', 6, 'getKeyPoints'): [(7, 1, 90299), (8, 1, 27768), (9, 1, 2)]}
# I also don't know why it is this complicated :((
# The keys consist of tuples of the type ('path/to/python/program', line_number_of_function_definition, 'function_name').
# The items consist of a list of tuples, each tuple corresponding to each line in the function definition
# The tuple is of the type (line_number, number_of_times_the_line_ran, time_taken_in_microseconds)
# Since I am benchmarking only one function, I used the first and only key in list of keys (data.keys()) as my key,
# and added the time taken at each line using the last index of tuples corresponding to each line to get the total
# time of execution of the function. I then stored it in the time list, in ms.
data = profile.get_stats().timings
time_taken = data[list(data.keys())[0]][0][2] + data[list(
data.keys())[0]][1][2] + data[list(data.keys())[0]][2][2]
time.append(time_taken / 1000.0)
num_features_list.append(len(kp))
frame = cv2.drawKeypoints(frame, kp, None, color=(0, 255, 0), flags=0)
cap.release()
frame_list = range(1, num_frames + 1)
# This part prepares plots of the requisite data, and saves it in an SVG file, which is unique to the parameters passed.
plt.figure(figsize=(25, 10))
plt.plot(frame_list, num_features_list)
plt.xlabel('Frame Number')
plt.ylabel('Detected Features')
plt.title('Plot of Detected Features in Each Frame')
plt.tight_layout()
plt.savefig(program_dir + '/plots/features_number_plot_' +
str(scale_factor) + '_' + str(wta_k) + '_' +
('HARRIS' if score_type == cv2.ORB_HARRIS_SCORE else 'FAST') +
'.svg')
plt.clf()
plt.figure(figsize=(25, 10))
plt.plot(frame_list, time)
plt.xlabel('Frame Number')
plt.ylabel('Time Taken for Identifying Features(ms)')
plt.title('Plot of Time Taken for Identifying Features in Each Frame')
plt.tight_layout()
plt.savefig(program_dir + '/plots/time_plot_' + str(scale_factor) + '_' +
str(wta_k) + '_' +
('HARRIS' if score_type == cv2.ORB_HARRIS_SCORE else 'FAST') +
'.svg')
plt.close('all')
# Returns the average time taken/frame and the average number of features detected/frame
return sum(time) / len(time), sum(num_features_list) / len(
num_features_list)
class ProfilingPanel(Panel):
"""
Panel that displays profiling information.
"""
title = _('Profiling')
template = 'debug_toolbar_line_profiler/panels/profiling.html'
def _unwrap_closure_and_profile(self, func):
if not hasattr(func, '__code__'):
return
self.line_profiler.add_function(func)
for subfunc in getattr(func, 'profile_additional', []):
self._unwrap_closure_and_profile(subfunc)
if PY2:
func_closure = func.func_closure
else:
func_closure = func.__closure__
if func_closure:
for cell in func_closure:
target = cell.cell_contents
if hasattr(target, '__code__'):
self._unwrap_closure_and_profile(cell.cell_contents)
if inspect.isclass(target) and View in inspect.getmro(target):
for name, value in inspect.getmembers(target):
if name[0] != '_' and inspect.ismethod(value):
self._unwrap_closure_and_profile(value)
def process_view(self, request, view_func, view_args, view_kwargs):
self.view_func = view_func
self.profiler = cProfile.Profile()
args = (request,) + view_args
self.line_profiler = LineProfiler()
self._unwrap_closure_and_profile(view_func)
signals.profiler_setup.send(sender=self,
profiler=self.line_profiler,
view_func=view_func,
view_args=view_args,
view_kwargs=view_kwargs)
self.line_profiler.enable_by_count()
out = self.profiler.runcall(view_func, *args, **view_kwargs)
self.line_profiler.disable_by_count()
return out
def add_node(self, func_list, func, max_depth, cum_time=0.1):
"""
add_node does a depth first traversal of the call graph, appending a
FunctionCall object to func_list, so that the Django template only
has to do a single for loop over func_list that can render a tree
structure
Parameters:
func_list is an array that will have a FunctionCall for each call
added to it
func is a FunctionCall object that will have all its callees added
max_depth is the maximum depth we should recurse
cum_time is the minimum cum_time a function should have to be
included in the output
"""
func_list.append(func)
func.has_subfuncs = False
# this function somewhat dangerously relies on FunctionCall to set its
# subfuncs' depth argument correctly
if func.depth >= max_depth:
return
# func.subfuncs returns FunctionCall objects
subs = sorted(func.subfuncs(), key=FunctionCall.cumtime, reverse=True)
for subfunc in subs:
# a sub function is important if it takes a long time or it has
# line_stats
if (subfunc.cumtime() >= cum_time or
(hasattr(self.stats, 'line_stats') and
subfunc.func in self.stats.line_stats.timings)):
func.has_subfuncs = True
self.add_node(
func_list=func_list,
func=subfunc,
max_depth=max_depth,
cum_time=subfunc.cumtime()/16)
def process_response(self, request, response):
if not hasattr(self, 'profiler'):
return None
# Could be delayed until the panel content is requested (perf. optim.)
self.profiler.create_stats()
self.stats = DjangoDebugToolbarStats(self.profiler)
self.stats.line_stats = self.line_profiler.get_stats()
self.stats.calc_callees()
func_list = []
root_func = self.stats.get_root_func(self.view_func)
if root_func is not None:
root_node = FunctionCall(statobj=self.stats,
func=root_func,
depth=0)
self.add_node(
func_list=func_list,
func=root_node,
max_depth=10,
cum_time=root_node.cumtime() / 8
)
# else:
# what should we do if we didn't detect a root function? It's not
# clear what causes this, but there are real world examples of it (see
# https://github.com/dmclain/django-debug-toolbar-line-profiler/issues/11)
self.record_stats({'func_list': func_list})
class ProfilingPanel(Panel):
"""
Panel that displays profiling information.
"""
title = _('Profiling')
template = 'debug_toolbar_line_profiler/panels/profiling.html'
def _unwrap_closure_and_profile(self, func):
if not hasattr(func, '__code__'):
return
self.line_profiler.add_function(func)
for subfunc in getattr(func, 'profile_additional', []):
self._unwrap_closure_and_profile(subfunc)
if PY2:
func_closure = func.func_closure
else:
func_closure = func.__closure__
if func_closure:
for cell in func_closure:
target = cell.cell_contents
if hasattr(target, '__code__'):
self._unwrap_closure_and_profile(cell.cell_contents)
if inspect.isclass(target) and View in inspect.getmro(target):
for name, value in inspect.getmembers(target):
if name[0] != '_' and inspect.ismethod(value):
self._unwrap_closure_and_profile(value)
def process_view(self, request, view_func, view_args, view_kwargs):
self.view_func = view_func
self.profiler = cProfile.Profile()
args = (request,) + view_args
self.line_profiler = LineProfiler()
self._unwrap_closure_and_profile(view_func)
signals.profiler_setup.send(sender=self,
profiler=self.line_profiler,
view_func=view_func,
view_args=view_args,
view_kwargs=view_kwargs)
self.line_profiler.enable_by_count()
out = self.profiler.runcall(view_func, *args, **view_kwargs)
self.line_profiler.disable_by_count()
return out
def add_node(self, func_list, func, max_depth, cum_time=0.1):
"""
add_node does a depth first traversal of the call graph, appending a
FunctionCall object to func_list, so that the Django template only
has to do a single for loop over func_list that can render a tree
structure
Parameters:
func_list is an array that will have a FunctionCall for each call
added to it
func is a FunctionCall object that will have all its callees added
max_depth is the maximum depth we should recurse
cum_time is the minimum cum_time a function should have to be
included in the output
"""
func_list.append(func)
func.has_subfuncs = False
# this function somewhat dangerously relies on FunctionCall to set its
# subfuncs' depth argument correctly
if func.depth >= max_depth:
return
# func.subfuncs returns FunctionCall objects
subs = sorted(func.subfuncs(), key=FunctionCall.cumtime, reverse=True)
for subfunc in subs:
# a sub function is important if it takes a long time or it has
# line_stats
if (subfunc.cumtime() >= cum_time or
(hasattr(self.stats, 'line_stats') and
subfunc.func in self.stats.line_stats.timings)):
func.has_subfuncs = True
self.add_node(
func_list=func_list,
func=subfunc,
max_depth=max_depth,
cum_time=subfunc.cumtime()/16)
def process_response(self, request, response):
if not hasattr(self, 'profiler'):
return None
# Could be delayed until the panel content is requested (perf. optim.)
self.profiler.create_stats()
self.stats = DjangoDebugToolbarStats(self.profiler)
self.stats.line_stats = self.line_profiler.get_stats()
self.stats.calc_callees()
func_list = []
root_func = self.stats.get_root_func(self.view_func)
if root_func is not None:
root_node = FunctionCall(statobj=self.stats,
func=root_func,
depth=0)
self.add_node(
func_list=func_list,
func=root_node,
max_depth=10,
cum_time=root_node.cumtime() / 8
)
# else:
# what should we do if we didn't detect a root function? It's not
# clear what causes this, but there are real world examples of it (see
# https://github.com/dmclain/django-debug-toolbar-line-profiler/issues/11)
self.record_stats({'func_list': func_list})
class ProfilingDebugPanel(DebugPanel):
"""
Panel that displays the Django version.
"""
name = 'Profiling'
template = 'debug_toolbar/panels/profiling.html'
has_content = True
def nav_title(self):
return _('Profiling')
def url(self):
return ''
def title(self):
return _('Profiling')
def _unwrap_closure_and_profile(self, func):
if not hasattr(func, 'func_code'):
return
self.line_profiler.add_function(func)
if func.func_closure:
for cell in func.func_closure:
if hasattr(cell.cell_contents, 'func_code'):
self._unwrap_closure_and_profile(cell.cell_contents)
def process_view(self, request, view_func, view_args, view_kwargs):
__traceback_hide__ = True
self.profiler = cProfile.Profile()
args = (request, ) + view_args
if DJ_PROFILE_USE_LINE_PROFILER:
self.line_profiler = LineProfiler()
self._unwrap_closure_and_profile(view_func)
self.line_profiler.enable_by_count()
out = self.profiler.runcall(view_func, *args, **view_kwargs)
self.line_profiler.disable_by_count()
else:
self.line_profiler = None
out = self.profiler.runcall(view_func, *args, **view_kwargs)
return out
def add_node(self, func_list, func, max_depth, cum_time=0.1):
func_list.append(func)
func.has_subfuncs = False
if func.depth < max_depth:
for subfunc in func.subfuncs():
if (subfunc.stats[3] >= cum_time
or (hasattr(self.stats, 'line_stats') and
(subfunc.func in self.stats.line_stats.timings))):
func.has_subfuncs = True
self.add_node(func_list,
subfunc,
max_depth,
cum_time=cum_time)
def process_response(self, request, response):
__traceback_hide__ = True
if not hasattr(self, 'profiler'):
return None
self.profiler.create_stats()
self.stats = DjangoDebugToolbarStats(self.profiler)
if DJ_PROFILE_USE_LINE_PROFILER:
self.stats.line_stats = self.line_profiler.get_stats()
self.stats.calc_callees()
root = FunctionCall(self.stats, self.stats.get_root_func(), depth=0)
func_list = []
self.add_node(func_list, root, 10, root.stats[3] / 8)
self.record_stats({'func_list': func_list})
"C",
"B",
],
"B": ["K"],
"C": ["F", "D"],
"D": ["G", "H", "E"],
"E": [],
"F": ["J", "G"],
"G": [],
"H": [],
"J": ["H"],
"K": []
}
# profile the depth_traversal
lp_wrapper = lp(depth_traversal)
lp_wrapper(graph_1, "A")
stats1 = lp.get_stats()
# profile the breadth_traversal
lp_wrapper = lp(breadth_traversal)
lp_wrapper(graph_1, "A")
stats2 = lp.get_stats()
create_chart(stats1, 1)
create_chart(stats2, 2)
plt.show()