self.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"
 
int ABT_self_get_xstream(ABT_xstream *xstream)
{
    ABTI_xstream *p_local_xstream;
    ABTI_SETUP_LOCAL_XSTREAM(&p_local_xstream);
 
    /* Return value */
    *xstream = ABTI_xstream_get_handle(p_local_xstream);
    return ABT_SUCCESS;
}
 
int ABT_self_get_xstream_rank(int *rank)
{
    ABTI_xstream *p_local_xstream;
    ABTI_SETUP_LOCAL_XSTREAM(&p_local_xstream);
    /* Return value */
    *rank = (int)p_local_xstream->rank;
    return ABT_SUCCESS;
}
 
int ABT_self_get_thread(ABT_thread *thread)
{
    ABTI_xstream *p_local_xstream;
    ABTI_SETUP_LOCAL_XSTREAM(&p_local_xstream);
    *thread = ABTI_thread_get_handle(p_local_xstream->p_thread);
    return ABT_SUCCESS;
}
 
int ABT_self_get_thread_id(ABT_unit_id *id)
{
    ABTI_xstream *p_local_xstream;
    ABTI_SETUP_LOCAL_XSTREAM(&p_local_xstream);
    *id = ABTI_thread_get_id(p_local_xstream->p_thread);
    return ABT_SUCCESS;
}
 
#ifdef ABT_CONFIG_USE_DOXYGEN
 
int ABT_self_get_task(ABT_thread *thread);
#endif
 
#ifdef ABT_CONFIG_USE_DOXYGEN
 
int ABT_self_get_task_id(ABT_unit_id *id);
#endif
 
int ABT_self_set_specific(ABT_key key, void *value)
{
    ABTI_key *p_key = ABTI_key_get_ptr(key);
    ABTI_CHECK_NULL_KEY_PTR(p_key);
 
    ABTI_global *p_global;
    ABTI_SETUP_GLOBAL(&p_global);
 
    ABTI_xstream *p_local_xstream;
    ABTI_SETUP_LOCAL_XSTREAM(&p_local_xstream);
 
    /* Obtain the key-value table pointer. */
    int abt_errno =
        ABTI_ktable_set(p_global, ABTI_xstream_get_local(p_local_xstream),
                        &p_local_xstream->p_thread->p_keytable, p_key, value);
    ABTI_CHECK_ERROR(abt_errno);
    return ABT_SUCCESS;
}
 
int ABT_self_get_specific(ABT_key key, void **value)
{
    ABTI_key *p_key = ABTI_key_get_ptr(key);
    ABTI_CHECK_NULL_KEY_PTR(p_key);
 
    /* We don't allow an external thread to call this routine. */
    ABTI_xstream *p_local_xstream;
    ABTI_SETUP_LOCAL_XSTREAM(&p_local_xstream);
 
    /* Obtain the key-value table pointer */
    *value = ABTI_ktable_get(&p_local_xstream->p_thread->p_keytable, p_key);
    return ABT_SUCCESS;
}
 
int ABT_self_get_type(ABT_unit_type *type)
{
#ifndef ABT_CONFIG_ENABLE_VER_20_API
    /* By default, type is ABT_UNIT_TYPE_EXT in Argobots 1.x */
    *type = ABT_UNIT_TYPE_EXT;
    ABTI_SETUP_GLOBAL(NULL);
    ABTI_xstream *p_local_xstream;
    ABTI_SETUP_LOCAL_XSTREAM(&p_local_xstream);
    *type = ABTI_thread_type_get_type(p_local_xstream->p_thread->type);
#else
    ABTI_xstream *p_local_xstream =
        ABTI_local_get_xstream_or_null(ABTI_local_get_local());
    if (p_local_xstream) {
        *type = ABTI_thread_type_get_type(p_local_xstream->p_thread->type);
    } else {
        *type = ABT_UNIT_TYPE_EXT;
    }
#endif
    return ABT_SUCCESS;
}
 
int ABT_self_is_primary(ABT_bool *is_primary)
{
#ifndef ABT_CONFIG_ENABLE_VER_20_API
    *is_primary = ABT_FALSE;
    ABTI_SETUP_GLOBAL(NULL);
    ABTI_ythread *p_ythread;
    ABTI_SETUP_LOCAL_YTHREAD(NULL, &p_ythread);
    *is_primary = (p_ythread->thread.type & ABTI_THREAD_TYPE_PRIMARY)
                      ? ABT_TRUE
                      : ABT_FALSE;
#else
    ABTI_xstream *p_local_xstream =
        ABTI_local_get_xstream_or_null(ABTI_local_get_local());
    if (p_local_xstream) {
        *is_primary =
            (p_local_xstream->p_thread->type & ABTI_THREAD_TYPE_PRIMARY)
                ? ABT_TRUE
                : ABT_FALSE;
    } else {
        *is_primary = ABT_FALSE;
    }
#endif
    return ABT_SUCCESS;
}
 
int ABT_self_on_primary_xstream(ABT_bool *on_primary)
{
#ifndef ABT_CONFIG_ENABLE_VER_20_API
    *on_primary = ABT_FALSE;
    ABTI_SETUP_GLOBAL(NULL);
    ABTI_xstream *p_local_xstream;
    ABTI_SETUP_LOCAL_XSTREAM(&p_local_xstream);
    *on_primary = (p_local_xstream->type == ABTI_XSTREAM_TYPE_PRIMARY)
                      ? ABT_TRUE
                      : ABT_FALSE;
#else
    ABTI_xstream *p_local_xstream =
        ABTI_local_get_xstream_or_null(ABTI_local_get_local());
    if (p_local_xstream) {
        *on_primary = (p_local_xstream->type == ABTI_XSTREAM_TYPE_PRIMARY)
                          ? ABT_TRUE
                          : ABT_FALSE;
    } else {
        *on_primary = ABT_FALSE;
    }
#endif
    return ABT_SUCCESS;
}
 
int ABT_self_get_last_pool(ABT_pool *pool)
{
    ABTI_xstream *p_local_xstream;
    ABTI_SETUP_LOCAL_XSTREAM(&p_local_xstream);
    ABTI_thread *p_self = p_local_xstream->p_thread;
    ABTI_ASSERT(p_self->p_pool);
    *pool = ABTI_pool_get_handle(p_self->p_pool);
    return ABT_SUCCESS;
}
 
int ABT_self_get_last_pool_id(int *pool_id)
{
    ABTI_xstream *p_local_xstream;
#ifndef ABT_CONFIG_ENABLE_VER_20_API
    *pool_id = -1;
    ABTI_SETUP_GLOBAL(NULL);
    ABTI_SETUP_LOCAL_XSTREAM(&p_local_xstream);
    ABTI_thread *p_self = p_local_xstream->p_thread;
    ABTI_ASSERT(p_self->p_pool);
    *pool_id = p_self->p_pool->id;
#else
    ABTI_SETUP_LOCAL_XSTREAM(&p_local_xstream);
    ABTI_thread *p_self = p_local_xstream->p_thread;
    ABTI_ASSERT(p_self->p_pool);
    *pool_id = p_self->p_pool->id;
#endif
    return ABT_SUCCESS;
}
 
int ABT_self_set_associated_pool(ABT_pool pool)
{
    ABTI_global *p_global = ABTI_global_get_global();
    ABTI_xstream *p_local_xstream;
    ABTI_SETUP_LOCAL_XSTREAM(&p_local_xstream);
    ABTI_pool *p_pool = ABTI_pool_get_ptr(pool);
    ABTI_CHECK_NULL_POOL_PTR(p_pool);
    ABTI_thread *p_self = p_local_xstream->p_thread;
 
    int abt_errno = ABTI_thread_set_associated_pool(p_global, p_self, p_pool);
    ABTI_CHECK_ERROR(abt_errno);
    return ABT_SUCCESS;
}
 
int ABT_self_get_unit(ABT_unit *unit)
{
    /* We don't allow an external thread to call this routine. */
    ABTI_xstream *p_local_xstream;
    ABTI_SETUP_LOCAL_XSTREAM(&p_local_xstream);
    *unit = p_local_xstream->p_thread->unit;
    return ABT_SUCCESS;
}
 
int ABT_self_yield(void)
{
    ABTI_xstream *p_local_xstream;
    ABTI_ythread *p_ythread;
    ABTI_SETUP_LOCAL_YTHREAD(&p_local_xstream, &p_ythread);
 
    ABTI_ythread_yield(&p_local_xstream, p_ythread, ABT_SYNC_EVENT_TYPE_USER,
                       NULL);
    return ABT_SUCCESS;
}
 
int ABT_self_suspend(void)
{
    ABTI_xstream *p_local_xstream;
    ABTI_ythread *p_self;
    ABTI_SETUP_LOCAL_YTHREAD(&p_local_xstream, &p_self);
 
    ABTI_ythread_set_blocked(p_self);
    ABTI_ythread_suspend(&p_local_xstream, p_self, ABT_SYNC_EVENT_TYPE_USER,
                         NULL);
    return ABT_SUCCESS;
}
 
int ABT_self_exit(void)
{
    ABTI_xstream *p_local_xstream;
    ABTI_ythread *p_ythread;
    ABTI_SETUP_LOCAL_YTHREAD(&p_local_xstream, &p_ythread);
    ABTI_CHECK_TRUE(!(p_ythread->thread.type & ABTI_THREAD_TYPE_PRIMARY),
                    ABT_ERR_INV_THREAD);
 
    ABTI_ythread_exit(p_local_xstream, p_ythread);
    return ABT_SUCCESS;
}
 
int ABT_self_set_arg(void *arg)
{
    ABTI_xstream *p_local_xstream;
#ifndef ABT_CONFIG_ENABLE_VER_20_API
    ABTI_SETUP_GLOBAL(NULL);
#endif
    ABTI_SETUP_LOCAL_XSTREAM(&p_local_xstream);
 
    p_local_xstream->p_thread->p_arg = arg;
    return ABT_SUCCESS;
}
 
int ABT_self_get_arg(void **arg)
{
    ABTI_xstream *p_local_xstream;
#ifndef ABT_CONFIG_ENABLE_VER_20_API
    *arg = NULL;
    ABTI_SETUP_GLOBAL(NULL);
#endif
    ABTI_SETUP_LOCAL_XSTREAM(&p_local_xstream);
 
    *arg = p_local_xstream->p_thread->p_arg;
    return ABT_SUCCESS;
}
 
int ABT_self_get_thread_func(void (**thread_func)(void *))
{
    ABTI_xstream *p_local_xstream;
    ABTI_SETUP_LOCAL_XSTREAM(&p_local_xstream);
 
    *thread_func = p_local_xstream->p_thread->f_thread;
    return ABT_SUCCESS;
}
 
int ABT_self_is_unnamed(ABT_bool *is_unnamed)
{
    ABTI_xstream *p_local_xstream;
    ABTI_SETUP_LOCAL_XSTREAM(&p_local_xstream);
 
    *is_unnamed = (p_local_xstream->p_thread->type & ABTI_THREAD_TYPE_NAMED)
                      ? ABT_FALSE
                      : ABT_TRUE;
    return ABT_SUCCESS;
}