import gdb
import ompdModule
import itertools
from gdb.FrameDecorator import FrameDecorator
import ompd
from ompd_handles import ompd_task, ompd_parallel, ompd_thread
import traceback
from tempfile import NamedTemporaryFile
class OmpdFrameDecorator(FrameDecorator):
def __init__(self, fobj, curr_task_handle):
"""Initializes a FrameDecorator with the given GDB Frame object. The global OMPD address space defined in
ompd.py is set as well.
"""
super(OmpdFrameDecorator, self).__init__(fobj)
self.addr_space = ompd.addr_space
self.fobj = None
if isinstance(fobj, gdb.Frame):
self.fobj = fobj
elif isinstance(fobj, FrameDecorator):
self.fobj = fobj.inferior_frame()
self.curr_task_handle = curr_task_handle
def function(self):
"""This appends the name of a frame that is printed with the information whether the task started in the frame
is implicit or explicit. The ICVs are evaluated to determine that.
"""
name = str(self.fobj.name())
if self.curr_task_handle is None:
return name
icv_value = ompdModule.call_ompd_get_icv_from_scope(
self.curr_task_handle,
ompd.icv_map["implicit-task-var"][1],
ompd.icv_map["implicit-task-var"][0],
)
if icv_value == 0:
name = '@thread %i: %s "#pragma omp task"' % (
gdb.selected_thread().num,
name,
)
elif icv_value == 1:
name = '@thread %i: %s "#pragma omp parallel"' % (
gdb.selected_thread().num,
name,
)
else:
name = "@thread %i: %s" % (gdb.selected_thread().num, name)
return name
class OmpdFrameDecoratorThread(FrameDecorator):
def __init__(self, fobj):
"""Initializes a FrameDecorator with the given GDB Frame object."""
super(OmpdFrameDecoratorThread, self).__init__(fobj)
if isinstance(fobj, gdb.Frame):
self.fobj = fobj
elif isinstance(fobj, FrameDecorator):
self.fobj = fobj.inferior_frame()
def function(self):
name = str(self.fobj.name())
return "@thread %i: %s" % (gdb.selected_thread().num, name)
class FrameFilter:
def __init__(self, addr_space):
"""Initializes the FrameFilter, registers is in the GDB runtime and saves the given OMPD address space capsule."""
self.addr_space = addr_space
self.name = "Filter"
self.priority = 100
self.enabled = True
gdb.frame_filters[self.name] = self
self.switched_on = False
self.continue_to_master = False
def set_switch(self, on_off):
"""Prints output when executing 'ompd bt on' or 'ompd bt off'."""
self.switched_on = on_off
if self.switched_on:
print('Enabled filter for "bt" output successfully.')
else:
print('Disabled filter for "bt" output successfully.')
def set_switch_continue(self, on_off):
"""Prints output when executing 'ompd bt on continued'." """
self.continue_to_master = on_off
if self.continue_to_master:
print(
'Enabled "bt" mode that continues backtrace on to master thread for worker threads.'
)
else:
print('Disabled "bt" mode that continues onto master thread.')
def get_master_frames_for_worker(self, past_thread_num, latest_sp):
"""Prints master frames for worker thread with id past_thread_num."""
gdb.execute("t 1")
gdb.execute("ompd bt on")
gdb.execute("bt")
frame = gdb.newest_frame()
while frame.older() is not None:
print("master frame sp:", str(frame.read_register("sp")))
yield OmpdFrameDecorator(frame)
frame = frame.older()
print("latest sp:", str(latest_sp))
gdb.execute("ompd bt on continued")
gdb.execute("t %d" % int(past_thread_num))
def filter_frames(self, frame_iter):
"""Iterates through frames and only returns those that are relevant to the application
being debugged. The OmpdFrameDecorator is applied automatically.
"""
curr_thread_num = gdb.selected_thread().num
is_no_omp_thread = False
if curr_thread_num in self.addr_space.threads:
curr_thread_obj = self.addr_space.threads[curr_thread_num]
self.curr_task = curr_thread_obj.get_current_task()
self.frames = self.curr_task.get_task_frame()
else:
is_no_omp_thread = True
print(
"Thread %d is no OpenMP thread, printing all frames:" % curr_thread_num
)
stop_iter = False
for x in frame_iter:
if is_no_omp_thread:
yield OmpdFrameDecoratorThread(x)
continue
if x.inferior_frame().older() is None:
continue
if self.curr_task.task_handle is None:
continue
gdb_sp = int(str(x.inferior_frame().read_register("sp")), 16)
gdb_sp_next_new = int(
str(x.inferior_frame()).split(",")[0].split("=")[1], 16
)
if x.inferior_frame().older():
gdb_sp_next = int(
str(x.inferior_frame().older().read_register("sp")), 16
)
else:
gdb_sp_next = int(str(x.inferior_frame().read_register("sp")), 16)
while 1:
(ompd_enter_frame, ompd_exit_frame) = self.frames
if ompd_enter_frame != 0 and gdb_sp_next_new < ompd_enter_frame:
break
if ompd_exit_frame != 0 and gdb_sp_next_new < ompd_exit_frame:
if (
x.inferior_frame().older().older()
and int(
str(x.inferior_frame().older().older().read_register("sp")),
16,
)
< ompd_exit_frame
):
if self.continue_to_master:
yield OmpdFrameDecoratorThread(x)
else:
yield OmpdFrameDecorator(x, self.curr_task.task_handle)
else:
yield OmpdFrameDecorator(x, self.curr_task.task_handle)
break
sched_task_handle = self.curr_task.get_scheduling_task_handle()
if sched_task_handle is None:
stop_iter = True
break
self.curr_task = self.curr_task.get_scheduling_task()
self.frames = self.curr_task.get_task_frame()
if stop_iter:
break
# implementation of "ompd bt continued"
if self.continue_to_master:
orig_thread = gdb.selected_thread().num
gdb_threads = dict([(t.num, t) for t in gdb.selected_inferior().threads()])
# iterate through generating tasks until outermost task is reached
while 1:
# get OMPD thread id for master thread (systag in GDB output)
try:
master_num = (
self.curr_task.get_task_parallel()
.get_thread_in_parallel(0)
.get_thread_id()
)
except:
break
# search for thread id without the "l" for long via "thread find" and get GDB thread num from output
hex_str = str(hex(master_num))
thread_output = gdb.execute(
"thread find %s" % hex_str[0 : len(hex_str) - 1], to_string=True
).split(" ")
if thread_output[0] == "No":
raise ValueError("Master thread num could not be found!")
gdb_master_num = int(thread_output[1])
# get task that generated last task of worker thread
try:
self.curr_task = (
self.curr_task.get_task_parallel()
.get_task_in_parallel(0)
.get_generating_task()
)
except:
break
self.frames = self.curr_task.get_task_frame()
(enter_frame, exit_frame) = self.frames
if exit_frame == 0:
print("outermost generating task was reached")
break
# save GDB num for worker thread to change back to it later
worker_thread = gdb.selected_thread().num
# use InferiorThread.switch()
gdb_threads = dict(
[(t.num, t) for t in gdb.selected_inferior().threads()]
)
gdb_threads[gdb_master_num].switch()
print("#### switching to thread %i ####" % gdb_master_num)
frame = gdb.newest_frame()
stop_iter = False
while not stop_iter:
if self.curr_task.task_handle is None:
break
self.frames = self.curr_task.get_task_frame()
while frame:
if self.curr_task.task_handle is None:
break
gdb_sp_next_new = int(
str(frame).split(",")[0].split("=")[1], 16
)
if frame.older():
gdb_sp_next = int(
str(frame.older().read_register("sp")), 16
)
else:
gdb_sp_next = int(str(frame.read_register("sp")), 16)
while 1:
(ompd_enter_frame, ompd_exit_frame) = self.frames
if (
ompd_enter_frame != 0
and gdb_sp_next_new < ompd_enter_frame
):
break
if (
ompd_exit_frame == 0
or gdb_sp_next_new < ompd_exit_frame
):
if (
ompd_exit_frame == 0
or frame.older()
and frame.older().older()
and int(
str(frame.older().older().read_register("sp")),
16,
)
< ompd_exit_frame
):
yield OmpdFrameDecoratorThread(frame)
else:
yield OmpdFrameDecorator(
frame, self.curr_task.task_handle
)
break
sched_task_handle = (
ompdModule.call_ompd_get_scheduling_task_handle(
self.curr_task.task_handle
)
)
if sched_task_handle is None:
stop_iter = True
break
self.curr_task = self.curr_task.get_generating_task()
self.frames = self.curr_task.get_task_frame()
frame = frame.older()
break
gdb_threads[worker_thread].switch()
gdb_threads[orig_thread].switch()
def filter(self, frame_iter):
"""Function is called automatically with every 'bt' executed. If switched on, this will only let revelant frames be printed
or all frames otherwise. If switched on, a FrameDecorator will be applied to state whether '.ompd_task_entry.' refers to an
explicit or implicit task.
"""
if self.switched_on:
return self.filter_frames(frame_iter)
else:
return frame_iter
Codebase Browser
llvm