| import ompdModule |
| import imp |
| |
| |
| class ompd_parallel(object): |
| def __init__(self, parallel_handle): |
| """Initializes an ompd_parallel object with the pointer |
| to a handle of a parallel region.""" |
| self.parallel_handle = parallel_handle |
| self.threads = {} |
| self.itasks = {} |
| self.enclosing_parallel_handle = None |
| self.enclosing_parallel = False |
| self.task_handle = None |
| |
| def get_thread_in_parallel(self, thread_num): |
| """Obtains thread handles for the threads associated with the |
| parallel region specified by parallel_handle.""" |
| if not thread_num in self.threads: |
| thread_handle = ompdModule.call_ompd_get_thread_in_parallel( |
| self.parallel_handle, thread_num |
| ) |
| self.threads[thread_num] = ompd_thread(thread_handle) |
| return self.threads[thread_num] |
| |
| def get_enclosing_parallel_handle(self): |
| """Obtains a parallel handle for the parallel region enclosing |
| the parallel region specified by parallel_handle.""" |
| if not self.enclosing_parallel_handle: |
| self.enclosing_parallel_handle = ( |
| ompdModule.call_ompd_get_enclosing_parallel_handle(self.parallel_handle) |
| ) |
| return self.enclosing_parallel_handle |
| |
| def get_enclosing_parallel(self): |
| if not self.enclosing_parallel: |
| self.enclosing_parallel = ompd_parallel( |
| self.get_enclosing_parallel_handle() |
| ) |
| return self.enclosing_parallel |
| |
| def get_task_in_parallel(self, thread_num): |
| """Obtains handles for the implicit tasks associated with the |
| parallel region specified by parallel_handle.""" |
| if not thread_num in self.itasks: |
| task_handle = ompdModule.call_ompd_get_task_in_parallel( |
| self.parallel_handle, thread_num |
| ) |
| self.itasks[thread_num] = ompd_task(task_handle) |
| return self.itasks[thread_num] |
| |
| def __del__(self): |
| """Releases the parallel handle.""" |
| pass # let capsule destructors do the job |
| |
| |
| class ompd_task(object): |
| def __init__(self, task_handle): |
| """Initializes a new ompd_task_handle object and sets the attribute |
| to the task handle specified.""" |
| self.task_handle = task_handle |
| self.task_parallel_handle = False |
| self.generating_task_handle = False |
| self.scheduling_task_handle = False |
| self.task_parallel = False |
| self.generating_task = False |
| self.scheduling_task = False |
| self.task_frames = None |
| self.task_frame_flags = None |
| |
| def get_task_parallel_handle(self): |
| """Obtains a task parallel handle for the parallel region enclosing |
| the task region specified.""" |
| if not self.task_parallel_handle: |
| self.task_parallel_handle = ompdModule.call_ompd_get_task_parallel_handle( |
| self.task_handle |
| ) |
| return self.task_parallel_handle |
| |
| def get_task_parallel(self): |
| if not self.task_parallel: |
| self.task_parallel = ompd_parallel(self.get_task_parallel_handle()) |
| return self.task_parallel |
| |
| def get_generating_task_handle(self): |
| """Obtains the task handle for the task that created the task specified |
| by the task handle.""" |
| if not self.generating_task_handle: |
| self.generating_task_handle = ( |
| ompdModule.call_ompd_get_generating_task_handle(self.task_handle) |
| ) |
| return self.generating_task_handle |
| |
| def get_generating_task(self): |
| if not self.generating_task: |
| self.generating_task = ompd_task( |
| ompdModule.call_ompd_get_generating_task_handle(self.task_handle) |
| ) |
| return self.generating_task |
| |
| def get_scheduling_task_handle(self): |
| """Obtains the task handle for the task that scheduled the task specified.""" |
| if not self.scheduling_task_handle: |
| self.scheduling_task_handle = ( |
| ompdModule.call_ompd_get_scheduling_task_handle(self.task_handle) |
| ) |
| return self.scheduling_task_handle |
| |
| def get_scheduling_task(self): |
| """Returns ompd_task object for the task that scheduled the current task.""" |
| if not self.scheduling_task: |
| self.scheduling_task = ompd_task(self.get_scheduling_task_handle()) |
| return self.scheduling_task |
| |
| def get_task_function(self): |
| """Returns long with address of function entry point.""" |
| return ompdModule.call_ompd_get_task_function(self.task_handle) |
| |
| def get_task_frame_with_flags(self): |
| """Returns enter frame address and flag, exit frame address and flag for current task handle.""" |
| if self.task_frames is None or self.task_frame_flags is None: |
| ret_value = ompdModule.call_ompd_get_task_frame(self.task_handle) |
| if isinstance(ret_value, tuple): |
| self.task_frames = (ret_value[0], ret_value[2]) |
| self.task_frame_flags = (ret_value[1], ret_value[3]) |
| else: |
| return ret_value |
| return ( |
| self.task_frames[0], |
| self.task_frame_flags[0], |
| self.task_frames[1], |
| self.task_frame_flags[1], |
| ) |
| |
| def get_task_frame(self): |
| """Returns enter and exit frame address for current task handle.""" |
| if self.task_frames is None: |
| ret_value = ompdModule.call_ompd_get_task_frame(self.task_handle) |
| if isinstance(ret_value, tuple): |
| self.task_frames = (ret_value[0], ret_value[2]) |
| else: |
| return ret_value |
| return self.task_frames |
| |
| def __del__(self): |
| """Releases the task handle.""" |
| pass # let capsule destructors do the job |
| |
| |
| class ompd_thread(object): |
| def __init__(self, thread_handle): |
| """Initializes an ompd_thread with the data received from |
| GDB.""" |
| self.thread_handle = thread_handle |
| self.parallel_handle = None |
| self.task_handle = None |
| self.current_task = False |
| self.current_parallel = False |
| self.thread_id = False |
| |
| def get_current_parallel_handle(self): |
| """Obtains the parallel handle for the parallel region associated with |
| the given thread handle.""" |
| # TODO: invalidate thread objects based on `gdb.event.cont`. This should invalidate all internal state. |
| self.parallel_handle = ompdModule.call_ompd_get_curr_parallel_handle( |
| self.thread_handle |
| ) |
| return self.parallel_handle |
| |
| def get_current_parallel(self): |
| """Returns parallel object for parallel handle of the parallel region |
| associated with the current thread handle.""" |
| if not self.current_parallel: |
| self.current_parallel = ompd_parallel(self.get_current_parallel_handle()) |
| return self.current_parallel |
| |
| def get_current_task_handle(self): |
| """Obtains the task handle for the current task region of the |
| given thread.""" |
| return ompdModule.call_ompd_get_curr_task_handle(self.thread_handle) |
| |
| def get_thread_id(self): |
| """Obtains the ID for the given thread.""" |
| if not self.thread_id: |
| self.thread_id = ompdModule.call_ompd_get_thread_id(self.thread_handle) |
| return self.thread_id |
| |
| def get_current_task(self): |
| """Returns task object for task handle of the current task region.""" |
| return ompd_task(self.get_current_task_handle()) |
| |
| def get_state(self): |
| """Returns tuple with OMPD state (long) and wait_id, in case the thread is in a |
| waiting state. Helper function for 'ompd threads' command.""" |
| (state, wait_id) = ompdModule.call_ompd_get_state(self.thread_handle) |
| return (state, wait_id) |
| |
| def __del__(self): |
| """Releases the given thread handle.""" |
| pass # let capsule destructors do the job |
