tool.c

Go to the documentation of this file.

/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil ; -*- */
/*
 * See COPYRIGHT in top-level directory.
 */
 
#include "abti.h"
 
#ifndef ABT_CONFIG_DISABLE_TOOL_INTERFACE
ABTU_ret_err static inline int tool_query(ABTI_tool_context *p_tctx,
                                          ABT_tool_query_kind query_kind,
                                          void *val);
#endif
 
int ABT_tool_register_thread_callback(ABT_tool_thread_callback_fn cb_func,
                                      uint64_t event_mask, void *user_arg)
{
#ifdef ABT_CONFIG_DISABLE_TOOL_INTERFACE
    ABTI_HANDLE_ERROR(ABT_ERR_FEATURE_NA);
#else
    ABTI_global *p_global;
    ABTI_SETUP_GLOBAL(&p_global);
 
    if (cb_func == NULL)
        event_mask = ABT_TOOL_EVENT_THREAD_NONE;
    ABTI_tool_event_thread_update_callback(p_global, cb_func,
                                           event_mask &
                                               ABT_TOOL_EVENT_THREAD_ALL,
                                           user_arg);
    return ABT_SUCCESS;
#endif
}
 
int ABT_tool_query_thread(ABT_tool_context context, uint64_t event,
                          ABT_tool_query_kind query_kind, void *val)
{
#ifdef ABT_CONFIG_DISABLE_TOOL_INTERFACE
    ABTI_HANDLE_ERROR(ABT_ERR_FEATURE_NA);
#else
    ABTI_tool_context *p_tctx = ABTI_tool_context_get_ptr(context);
    ABTI_CHECK_NULL_TOOL_CONTEXT_PTR(p_tctx);
 
    int abt_errno = tool_query(p_tctx, query_kind, val);
    ABTI_CHECK_ERROR(abt_errno);
    return ABT_SUCCESS;
#endif
}
 
/*****************************************************************************/
/* Internal static functions                                                 */
/*****************************************************************************/
 
#ifndef ABT_CONFIG_DISABLE_TOOL_INTERFACE
ABTU_ret_err static inline int
tool_query(ABTI_tool_context *p_tctx, ABT_tool_query_kind query_kind, void *val)
{
    switch (query_kind) {
        case ABT_TOOL_QUERY_KIND_POOL:
            *(ABT_pool *)val = ABTI_pool_get_handle(p_tctx->p_pool);
            break;
        case ABT_TOOL_QUERY_KIND_STACK_DEPTH:
            if (!p_tctx->p_parent) {
                *(int *)val = 0;
            } else {
                int depth = 0;
                ABTI_thread *p_cur = p_tctx->p_parent;
                while (p_cur) {
                    depth++;
                    p_cur = p_cur->p_parent;
                }
                /* We do not count the root thread, so -1. */
                *(int *)val = depth - 1;
            }
            break;
        case ABT_TOOL_QUERY_KIND_CALLER_TYPE:
            if (!p_tctx->p_caller) {
                *(ABT_exec_entity_type *)val = ABT_EXEC_ENTITY_TYPE_EXT;
            } else {
                *(ABT_exec_entity_type *)val = ABT_EXEC_ENTITY_TYPE_THREAD;
            }
            break;
        case ABT_TOOL_QUERY_KIND_CALLER_HANDLE:
            if (!p_tctx->p_caller) {
                *(void **)val = NULL;
            } else {
                *(ABT_thread *)val = ABTI_thread_get_handle(p_tctx->p_caller);
            }
            break;
        case ABT_TOOL_QUERY_KIND_SYNC_OBJECT_TYPE:
            *(ABT_sync_event_type *)val = p_tctx->sync_event_type;
            break;
        case ABT_TOOL_QUERY_KIND_SYNC_OBJECT_HANDLE:
            switch (p_tctx->sync_event_type) {
                case ABT_SYNC_EVENT_TYPE_XSTREAM_JOIN:
                    *(ABT_xstream *)val = ABTI_xstream_get_handle(
                        (ABTI_xstream *)p_tctx->p_sync_object);
                    break;
                case ABT_SYNC_EVENT_TYPE_THREAD_JOIN:
                    *(ABT_thread *)val = ABTI_thread_get_handle(
                        (ABTI_thread *)p_tctx->p_sync_object);
                    break;
                case ABT_SYNC_EVENT_TYPE_MUTEX:
                    *(ABT_mutex *)val = ABTI_mutex_get_handle(
                        (ABTI_mutex *)p_tctx->p_sync_object);
                    break;
                case ABT_SYNC_EVENT_TYPE_COND:
                    *(ABT_cond *)val = ABTI_cond_get_handle(
                        (ABTI_cond *)p_tctx->p_sync_object);
                    break;
                case ABT_SYNC_EVENT_TYPE_RWLOCK:
                    *(ABT_rwlock *)val = ABTI_rwlock_get_handle(
                        (ABTI_rwlock *)p_tctx->p_sync_object);
                    break;
                case ABT_SYNC_EVENT_TYPE_EVENTUAL:
                    *(ABT_eventual *)val = ABTI_eventual_get_handle(
                        (ABTI_eventual *)p_tctx->p_sync_object);
                    break;
                case ABT_SYNC_EVENT_TYPE_FUTURE:
                    *(ABT_future *)val = ABTI_future_get_handle(
                        (ABTI_future *)p_tctx->p_sync_object);
                    break;
                case ABT_SYNC_EVENT_TYPE_BARRIER:
                    *(ABT_barrier *)val = ABTI_barrier_get_handle(
                        (ABTI_barrier *)p_tctx->p_sync_object);
                    break;
                default:
                    *(void **)val = NULL;
            }
            break;
        default:
            ABTI_HANDLE_ERROR(ABT_ERR_OTHER);
    }
    return ABT_SUCCESS;
}
#endif