| 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 |
