import ompdModule import gdb import re import traceback from ompd_address_space import ompd_address_space from ompd_handles import ompd_thread, ompd_task, ompd_parallel from frame_filter import FrameFilter from enum import Enum addr_space = None ff = None icv_map = None ompd_scope_map = {1:'global', 2:'address_space', 3:'thread', 4:'parallel', 5:'implicit_task', 6:'task'} in_task_function = False class ompd(gdb.Command): def __init__(self): super(ompd, self).__init__('ompd', gdb.COMMAND_STATUS, gdb.COMPLETE_NONE, True) class ompd_init(gdb.Command): """Find and initialize ompd library""" # first parameter is command-line input, second parameter is gdb-specific data def __init__(self): self.__doc__ = 'Find and initialize OMPD library\n usage: ompd init' super(ompd_init, self).__init__('ompd init', gdb.COMMAND_DATA) def invoke(self, arg, from_tty): global addr_space global ff try: try: print(gdb.newest_frame()) except: gdb.execute("start") try: lib_list = gdb.parse_and_eval("(char**)ompd_dll_locations") except gdb.error: raise ValueError("No ompd_dll_locations symbol in execution, make sure to have an OMPD enabled OpenMP runtime"); while(gdb.parse_and_eval("(char**)ompd_dll_locations") == False): gdb.execute("tbreak ompd_dll_locations_valid") gdb.execute("continue") lib_list = gdb.parse_and_eval("(char**)ompd_dll_locations") i = 0 while(lib_list[i]): ret = ompdModule.ompd_open(lib_list[i].string()) if ret == -1: raise ValueError("Handle of OMPD library is not a valid string!") if ret == -2: print("ret == -2") pass # It's ok to fail on dlopen if ret == -3: print("ret == -3") pass # It's ok to fail on dlsym if ret < -10: raise ValueError("OMPD error code %i!" % (-10 - ret)) if ret > 0: print("Loaded OMPD lib successfully!") try: addr_space = ompd_address_space() ff = FrameFilter(addr_space) except: traceback.print_exc() return i = i+1 raise ValueError("OMPD library could not be loaded!") except: traceback.print_exc() class ompd_threads(gdb.Command): """Register thread ids of current context""" def __init__(self): self.__doc__ = 'Provide information on threads of current context.\n usage: ompd threads' super(ompd_threads, self).__init__('ompd threads', gdb.COMMAND_STATUS) def invoke(self, arg, from_tty): global addr_space if init_error(): return addr_space.list_threads(True) def print_parallel_region(curr_parallel, team_size): """Helper function for ompd_parallel_region. To print out the details of the parallel region.""" for omp_thr in range(team_size): thread = curr_parallel.get_thread_in_parallel(omp_thr) ompd_state = str(addr_space.states[thread.get_state()[0]]) ompd_wait_id = thread.get_state()[1] task = curr_parallel.get_task_in_parallel(omp_thr) task_func_addr = task.get_task_function() # Get the function this addr belongs to sal = gdb.find_pc_line(task_func_addr) block = gdb.block_for_pc(task_func_addr) while block and not block.function: block = block.superblock if omp_thr == 0: print('%6d (master) %-37s %ld 0x%lx %-25s %-17s:%d' % \ (omp_thr, ompd_state, ompd_wait_id, task_func_addr, \ block.function.print_name, sal.symtab.filename, sal.line)) else: print('%6d %-37s %ld 0x%lx %-25s %-17s:%d' % \ (omp_thr, ompd_state, ompd_wait_id, task_func_addr, \ block.function.print_name, sal.symtab.filename, sal.line)) class ompd_parallel_region(gdb.Command): """Parallel Region Details""" def __init__(self): self.__doc__ = 'Display the details of the current and enclosing parallel regions.\n usage: ompd parallel' super(ompd_parallel_region, self).__init__('ompd parallel', gdb.COMMAND_STATUS) def invoke(self, arg, from_tty): global addr_space if init_error(): return if addr_space.icv_map is None: addr_space.get_icv_map() if addr_space.states is None: addr_space.enumerate_states() curr_thread_handle = addr_space.get_curr_thread() curr_parallel_handle = curr_thread_handle.get_current_parallel_handle() curr_parallel = ompd_parallel(curr_parallel_handle) while curr_parallel_handle is not None and curr_parallel is not None: nest_level = ompdModule.call_ompd_get_icv_from_scope(curr_parallel_handle,\ addr_space.icv_map['levels-var'][1], addr_space.icv_map['levels-var'][0]) if nest_level == 0: break team_size = ompdModule.call_ompd_get_icv_from_scope(curr_parallel_handle, \ addr_space.icv_map['team-size-var'][1], \ addr_space.icv_map['team-size-var'][0]) print ("") print ("Parallel Region: Nesting Level %d: Team Size: %d" % (nest_level, team_size)) print ("================================================") print ("") print ("OMP Thread Nbr Thread State Wait Id EntryAddr FuncName File:Line"); print ("======================================================================================================"); print_parallel_region(curr_parallel, team_size) enclosing_parallel = curr_parallel.get_enclosing_parallel() enclosing_parallel_handle = curr_parallel.get_enclosing_parallel_handle() curr_parallel = enclosing_parallel curr_parallel_handle = enclosing_parallel_handle class ompd_icvs(gdb.Command): """ICVs""" def __init__(self): self.__doc__ = 'Display the values of the Internal Control Variables.\n usage: ompd icvs' super(ompd_icvs, self).__init__('ompd icvs', gdb.COMMAND_STATUS) def invoke(self, arg, from_tty): global addr_space global ompd_scope_map if init_error(): return curr_thread_handle = addr_space.get_curr_thread() if addr_space.icv_map is None: addr_space.get_icv_map() print("ICV Name Scope Value") print("===============================================================") try: for icv_name in addr_space.icv_map: scope = addr_space.icv_map[icv_name][1] #{1:'global', 2:'address_space', 3:'thread', 4:'parallel', 5:'implicit_task', 6:'task'} if scope == 2: handle = addr_space.addr_space elif scope == 3: handle = curr_thread_handle.thread_handle elif scope == 4: handle = curr_thread_handle.get_current_parallel_handle() elif scope == 6: handle = curr_thread_handle.get_current_task_handle() else: raise ValueError("Invalid scope") if (icv_name == "nthreads-var" or icv_name == "bind-var"): icv_value = ompdModule.call_ompd_get_icv_from_scope( handle, scope, addr_space.icv_map[icv_name][0]) if icv_value is None: icv_string = ompdModule.call_ompd_get_icv_string_from_scope( \ handle, scope, addr_space.icv_map[icv_name][0]) print('%-31s %-26s %s' % (icv_name, ompd_scope_map[scope], icv_string)) else: print('%-31s %-26s %d' % (icv_name, ompd_scope_map[scope], icv_value)) elif (icv_name == "affinity-format-var" or icv_name == "run-sched-var" or \ icv_name == "tool-libraries-var" or icv_name == "tool-verbose-init-var"): icv_string = ompdModule.call_ompd_get_icv_string_from_scope( \ handle, scope, addr_space.icv_map[icv_name][0]) print('%-31s %-26s %s' % (icv_name, ompd_scope_map[scope], icv_string)) else: icv_value = ompdModule.call_ompd_get_icv_from_scope(handle, \ scope, addr_space.icv_map[icv_name][0]) print('%-31s %-26s %d' % (icv_name, ompd_scope_map[scope], icv_value)) except: traceback.print_exc() def curr_thread(): """Helper function for ompd_step. Returns the thread object for the current thread number.""" global addr_space if addr_space is not None: return addr_space.threads[int(gdb.selected_thread().num)] return None class ompd_test(gdb.Command): """Test area""" def __init__(self): self.__doc__ = 'Test functionalities for correctness\n usage: ompd test' super(ompd_test, self).__init__('ompd test', gdb.COMMAND_OBSCURE) def invoke(self, arg, from_tty): global addr_space if init_error(): return # get task function for current task of current thread try: current_thread = int(gdb.selected_thread().num) current_thread_obj = addr_space.threads[current_thread] task_function = current_thread_obj.get_current_task().get_task_function() print("bt value:", int("0x0000000000400b6c",0)) print("get_task_function value:", task_function) # get task function of implicit task in current parallel region for current thread current_parallel_obj = current_thread_obj.get_current_parallel() task_in_parallel = current_parallel_obj.get_task_in_parallel(current_thread) task_function_in_parallel = task_in_parallel.get_task_function() print("task_function_in_parallel:", task_function_in_parallel) except: print('Task function value not found for this thread') class ompdtestapi (gdb.Command): """ To test API's return code """ def __init__(self): self.__doc__ = 'Test OMPD tool Interface APIs.\nUsage: ompdtestapi ' super (ompdtestapi, self).__init__('ompdtestapi', gdb.COMMAND_OBSCURE) def invoke (self, arg, from_tty): global addr_space if init_error(): print ("Error in Initialization."); return if not arg: print ("No API provided to test, eg: ompdtestapi ompd_initialize") if arg == "ompd_get_thread_handle": addr_handle = addr_space.addr_space threadId = gdb.selected_thread().ptid[1] ompdModule.test_ompd_get_thread_handle(addr_handle, threadId) elif arg == "ompd_get_curr_parallel_handle": addr_handle = addr_space.addr_space threadId = gdb.selected_thread().ptid[1] thread_handle = ompdModule.get_thread_handle(threadId, addr_handle) ompdModule.test_ompd_get_curr_parallel_handle(thread_handle) elif arg == "ompd_get_thread_in_parallel": addr_handle = addr_space.addr_space threadId = gdb.selected_thread().ptid[1] thread_handle = ompdModule.get_thread_handle(threadId, addr_handle) parallel_handle = ompdModule.call_ompd_get_curr_parallel_handle(thread_handle) ompdModule.test_ompd_get_thread_in_parallel(parallel_handle) elif arg == "ompd_thread_handle_compare": addr_handle = addr_space.addr_space threadId = gdb.selected_thread().ptid[1] thread_handle = ompdModule.get_thread_handle(threadId, addr_handle) parallel_handle = ompdModule.call_ompd_get_curr_parallel_handle(thread_handle) thread_handle1 = ompdModule.call_ompd_get_thread_in_parallel(parallel_handle, 1); thread_handle2 = ompdModule.call_ompd_get_thread_in_parallel(parallel_handle, 2); ompdModule.test_ompd_thread_handle_compare(thread_handle1, thread_handle1) ompdModule.test_ompd_thread_handle_compare(thread_handle1, thread_handle2) elif arg == "ompd_get_thread_id": addr_handle = addr_space.addr_space threadId = gdb.selected_thread().ptid[1] thread_handle = ompdModule.get_thread_handle(threadId, addr_handle) ompdModule.test_ompd_get_thread_id(thread_handle) elif arg == "ompd_rel_thread_handle": addr_handle = addr_space.addr_space threadId = gdb.selected_thread().ptid[1] thread_handle = ompdModule.get_thread_handle(threadId, addr_handle) ompdModule.test_ompd_rel_thread_handle(thread_handle) elif arg == "ompd_get_enclosing_parallel_handle": addr_handle = addr_space.addr_space threadId = gdb.selected_thread().ptid[1] thread_handle = ompdModule.get_thread_handle(threadId, addr_handle) parallel_handle = ompdModule.call_ompd_get_curr_parallel_handle(thread_handle) ompdModule.test_ompd_get_enclosing_parallel_handle(parallel_handle) elif arg == "ompd_parallel_handle_compare": addr_handle = addr_space.addr_space threadId = gdb.selected_thread().ptid[1] thread_handle = ompdModule.get_thread_handle(threadId, addr_handle) parallel_handle1 = ompdModule.call_ompd_get_curr_parallel_handle(thread_handle) parallel_handle2 = ompdModule.call_ompd_get_enclosing_parallel_handle(parallel_handle1) ompdModule.test_ompd_parallel_handle_compare(parallel_handle1, parallel_handle1) ompdModule.test_ompd_parallel_handle_compare(parallel_handle1, parallel_handle2) elif arg == "ompd_rel_parallel_handle": addr_handle = addr_space.addr_space threadId = gdb.selected_thread().ptid[1] thread_handle = ompdModule.get_thread_handle(threadId, addr_handle) parallel_handle = ompdModule.call_ompd_get_curr_parallel_handle(thread_handle) ompdModule.test_ompd_rel_parallel_handle(parallel_handle) elif arg == "ompd_initialize": ompdModule.test_ompd_initialize() elif arg == "ompd_get_api_version": ompdModule.test_ompd_get_api_version() elif arg == "ompd_get_version_string": ompdModule.test_ompd_get_version_string() elif arg == "ompd_finalize": ompdModule.test_ompd_finalize() elif arg == "ompd_process_initialize": ompdModule.call_ompd_initialize() ompdModule.test_ompd_process_initialize() elif arg == "ompd_device_initialize": ompdModule.test_ompd_device_initialize() elif arg == "ompd_rel_address_space_handle": ompdModule.test_ompd_rel_address_space_handle() elif arg == "ompd_get_omp_version": addr_handle = addr_space.addr_space ompdModule.test_ompd_get_omp_version(addr_handle) elif arg == "ompd_get_omp_version_string": addr_handle = addr_space.addr_space ompdModule.test_ompd_get_omp_version_string(addr_handle) elif arg == "ompd_get_curr_task_handle": addr_handle = addr_space.addr_space threadId = gdb.selected_thread().ptid[1] thread_handle = ompdModule.get_thread_handle(threadId, addr_handle) ompdModule.test_ompd_get_curr_task_handle(thread_handle) elif arg == "ompd_get_task_parallel_handle": addr_handle = addr_space.addr_space threadId = gdb.selected_thread().ptid[1] thread_handle = ompdModule.get_thread_handle(threadId, addr_handle) task_handle = ompdModule.call_ompd_get_curr_task_handle(thread_handle) ompdModule.test_ompd_get_task_parallel_handle(task_handle) elif arg == "ompd_get_generating_task_handle": addr_handle = addr_space.addr_space threadId = gdb.selected_thread().ptid[1] thread_handle = ompdModule.get_thread_handle(threadId, addr_handle) task_handle = ompdModule.call_ompd_get_curr_task_handle(thread_handle) ompdModule.test_ompd_get_generating_task_handle(task_handle) elif arg == "ompd_get_scheduling_task_handle": addr_handle = addr_space.addr_space threadId = gdb.selected_thread().ptid[1] thread_handle = ompdModule.get_thread_handle(threadId, addr_handle) task_handle = ompdModule.call_ompd_get_curr_task_handle(thread_handle) ompdModule.test_ompd_get_scheduling_task_handle(task_handle) elif arg == "ompd_get_task_in_parallel": addr_handle = addr_space.addr_space threadId = gdb.selected_thread().ptid[1] thread_handle = ompdModule.get_thread_handle(threadId, addr_handle) parallel_handle = ompdModule.call_ompd_get_curr_parallel_handle(thread_handle) ompdModule.test_ompd_get_task_in_parallel(parallel_handle) elif arg == "ompd_rel_task_handle": addr_handle = addr_space.addr_space threadId = gdb.selected_thread().ptid[1] thread_handle = ompdModule.get_thread_handle(threadId, addr_handle) task_handle = ompdModule.call_ompd_get_curr_task_handle(thread_handle) ompdModule.test_ompd_rel_task_handle(task_handle) elif arg == "ompd_task_handle_compare": addr_handle = addr_space.addr_space threadId = gdb.selected_thread().ptid[1] thread_handle = ompdModule.get_thread_handle(threadId, addr_handle) task_handle1 = ompdModule.call_ompd_get_curr_task_handle(thread_handle) task_handle2 = ompdModule.call_ompd_get_generating_task_handle(task_handle1) ompdModule.test_ompd_task_handle_compare(task_handle1, task_handle2) ompdModule.test_ompd_task_handle_compare(task_handle2, task_handle1) elif arg == "ompd_get_task_function": addr_handle = addr_space.addr_space threadId = gdb.selected_thread().ptid[1] thread_handle = ompdModule.get_thread_handle(threadId, addr_handle) task_handle = ompdModule.call_ompd_get_curr_task_handle(thread_handle) ompdModule.test_ompd_get_task_function(task_handle) elif arg == "ompd_get_task_frame": addr_handle = addr_space.addr_space threadId = gdb.selected_thread().ptid[1] thread_handle = ompdModule.get_thread_handle(threadId, addr_handle) task_handle = ompdModule.call_ompd_get_curr_task_handle(thread_handle) ompdModule.test_ompd_get_task_frame(task_handle) elif arg == "ompd_get_state": addr_handle = addr_space.addr_space threadId = gdb.selected_thread().ptid[1] thread_handle = ompdModule.get_thread_handle(threadId, addr_handle) ompdModule.test_ompd_get_state(thread_handle) elif arg == "ompd_get_display_control_vars": addr_handle = addr_space.addr_space ompdModule.test_ompd_get_display_control_vars(addr_handle) elif arg == "ompd_rel_display_control_vars": ompdModule.test_ompd_rel_display_control_vars() elif arg == "ompd_enumerate_icvs": addr_handle = addr_space.addr_space ompdModule.test_ompd_enumerate_icvs(addr_handle) elif arg== "ompd_get_icv_from_scope": addr_handle = addr_space.addr_space threadId = gdb.selected_thread().ptid[1] thread_handle = ompdModule.get_thread_handle(threadId, addr_handle) parallel_handle = ompdModule.call_ompd_get_curr_parallel_handle(thread_handle) task_handle = ompdModule.call_ompd_get_curr_task_handle(thread_handle) ompdModule.test_ompd_get_icv_from_scope_with_addr_handle(addr_handle) ompdModule.test_ompd_get_icv_from_scope_with_thread_handle(thread_handle) ompdModule.test_ompd_get_icv_from_scope_with_parallel_handle(parallel_handle) ompdModule.test_ompd_get_icv_from_scope_with_task_handle(task_handle) elif arg == "ompd_get_icv_string_from_scope": addr_handle = addr_space.addr_space ompdModule.test_ompd_get_icv_string_from_scope(addr_handle) elif arg == "ompd_get_tool_data": ompdModule.test_ompd_get_tool_data() elif arg == "ompd_enumerate_states": ompdModule.test_ompd_enumerate_states() else: print ("Invalid API.") class ompd_bt(gdb.Command): """Turn filter for 'bt' on/off for output to only contain frames relevant to the application or all frames.""" def __init__(self): self.__doc__ = 'Turn filter for "bt" output on or off. Specify "on continued" option to trace worker threads back to master threads.\n usage: ompd bt on|on continued|off' super(ompd_bt, self).__init__('ompd bt', gdb.COMMAND_STACK) def invoke(self, arg, from_tty): global ff global addr_space global icv_map global ompd_scope_map if init_error(): return if icv_map is None: icv_map = {} current = 0 more = 1 while more > 0: tup = ompdModule.call_ompd_enumerate_icvs(addr_space.addr_space, current) (current, next_icv, next_scope, more) = tup icv_map[next_icv] = (current, next_scope, ompd_scope_map[next_scope]) print('Initialized ICV map successfully for filtering "bt".') arg_list = gdb.string_to_argv(arg) if len(arg_list) == 0: print('When calling "ompd bt", you must either specify "on", "on continued" or "off". Check "help ompd".') elif len(arg_list) == 1 and arg_list[0] == 'on': addr_space.list_threads(False) ff.set_switch(True) ff.set_switch_continue(False) elif arg_list[0] == 'on' and arg_list[1] == 'continued': ff.set_switch(True) ff.set_switch_continue(True) elif len(arg_list) == 1 and arg_list[0] == 'off': ff.set_switch(False) ff.set_switch_continue(False) else: print('When calling "ompd bt", you must either specify "on", "on continued" or "off". Check "help ompd".') # TODO: remove class ompd_taskframes(gdb.Command): """Prints task handles for relevant task frames. Meant for debugging.""" def __init__(self): self.__doc__ = 'Prints list of tasks.\nUsage: ompd taskframes' super(ompd_taskframes, self).__init__('ompd taskframes', gdb.COMMAND_STACK) def invoke(self, arg, from_tty): global addr_space if init_error(): return frame = gdb.newest_frame() while(frame): print (frame.read_register('sp')) frame = frame.older() curr_task_handle = None if(addr_space.threads and addr_space.threads.get(gdb.selected_thread().num)): curr_thread_handle = curr_thread().thread_handle curr_task_handle = ompdModule.call_ompd_get_curr_task_handle(curr_thread_handle) if(not curr_task_handle): return None prev_frames = None try: while(1): frames_with_flags = ompdModule.call_ompd_get_task_frame(curr_task_handle) frames = (frames_with_flags[0], frames_with_flags[3]) if(prev_frames == frames): break if(not isinstance(frames,tuple)): break (ompd_enter_frame, ompd_exit_frame) = frames print(hex(ompd_enter_frame), hex(ompd_exit_frame)) curr_task_handle = ompdModule.call_ompd_get_scheduling_task_handle(curr_task_handle) prev_frames = frames if(not curr_task_handle): break except: traceback.print_exc() def print_and_exec(string): """Helper function for ompd_step. Executes the given command in GDB and prints it.""" print(string) gdb.execute(string) class TempFrameFunctionBp(gdb.Breakpoint): """Helper class for ompd_step. Defines stop function for breakpoint on frame function.""" def stop(self): global in_task_function in_task_function = True self.enabled = False class ompd_step(gdb.Command): """Executes 'step' and skips frames irrelevant to the application / the ones without debug information.""" def __init__(self): self.__doc__ = 'Executes "step" and skips runtime frames as much as possible.' super(ompd_step, self).__init__('ompd step', gdb.COMMAND_STACK) class TaskBeginBp(gdb.Breakpoint): """Helper class. Defines stop function for breakpoint ompd_bp_task_begin.""" def stop(self): try: code_line = curr_thread().get_current_task().get_task_function() frame_fct_bp = TempFrameFunctionBp(('*%i' % code_line), temporary=True, internal=True) frame_fct_bp.thread = self.thread return False except: return False def invoke(self, arg, from_tty): global in_task_function if init_error(): return tbp = self.TaskBeginBp('ompd_bp_task_begin', temporary=True, internal=True) tbp.thread = int(gdb.selected_thread().num) print_and_exec('step') while gdb.selected_frame().find_sal().symtab is None: if not in_task_function: print_and_exec('finish') else: print_and_exec('si') def init_error(): global addr_space if (gdb.selected_thread() is None) or (addr_space is None) or (not addr_space): print("Run 'ompd init' before running any of the ompd commands") return True return False def main(): ompd() ompd_init() ompd_threads() ompd_icvs() ompd_parallel_region() ompd_test() ompdtestapi() ompd_taskframes() ompd_bt() ompd_step() if __name__ == "__main__": try: main() except: traceback.print_exc() # NOTE: test code using: # OMP_NUM_THREADS=... gdb a.out -x ../../projects/gdb_plugin/gdb-ompd/__init__.py # ompd init # ompd threads