path: root/openmp/libompd/gdb-plugin/ompd/ompd.py

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 not gdb.parse_and_eval("(char**)ompd_dll_locations"):
                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 <api name>"
        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