thread_attr.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"
 
static void thread_attr_set_stack(ABTI_global *p_global,
                                  ABTI_thread_attr *p_attr, void *stackaddr,
                                  size_t stacksize);
 
int ABT_thread_attr_create(ABT_thread_attr *newattr)
{
#ifndef ABT_CONFIG_ENABLE_VER_20_API
    /* Argobots 1.x sets newattr to NULL on error. */
    *newattr = ABT_THREAD_ATTR_NULL;
#endif
    ABTI_global *p_global;
    ABTI_SETUP_GLOBAL(&p_global);
 
    ABTI_thread_attr *p_newattr;
    int abt_errno = ABTU_malloc(sizeof(ABTI_thread_attr), (void **)&p_newattr);
    ABTI_CHECK_ERROR(abt_errno);
 
    /* Default values */
    ABTI_thread_attr_init(p_newattr, NULL, p_global->thread_stacksize,
                          ABTI_THREAD_TYPE_MEM_MEMPOOL_DESC_STACK, ABT_TRUE);
    *newattr = ABTI_thread_attr_get_handle(p_newattr);
    return ABT_SUCCESS;
}
 
int ABT_thread_attr_free(ABT_thread_attr *attr)
{
    ABT_thread_attr h_attr = *attr;
    ABTI_thread_attr *p_attr = ABTI_thread_attr_get_ptr(h_attr);
    ABTI_CHECK_NULL_THREAD_ATTR_PTR(p_attr);
 
    /* Free the memory */
    ABTU_free(p_attr);
    *attr = ABT_THREAD_ATTR_NULL;
    return ABT_SUCCESS;
}
 
int ABT_thread_attr_set_stack(ABT_thread_attr attr, void *stackaddr,
                              size_t stacksize)
{
    ABTI_global *p_global;
    ABTI_SETUP_GLOBAL(&p_global);
 
    ABTI_thread_attr *p_attr = ABTI_thread_attr_get_ptr(attr);
    ABTI_CHECK_NULL_THREAD_ATTR_PTR(p_attr);
    /* If stackaddr is not NULL, it must be aligned by 8 bytes. */
    ABTI_CHECK_TRUE(stackaddr == NULL || ((uintptr_t)stackaddr & 0x7) == 0,
                    ABT_ERR_INV_ARG);
    thread_attr_set_stack(p_global, p_attr, stackaddr, stacksize);
    return ABT_SUCCESS;
}
 
int ABT_thread_attr_get_stack(ABT_thread_attr attr, void **stackaddr,
                              size_t *stacksize)
{
    ABTI_thread_attr *p_attr = ABTI_thread_attr_get_ptr(attr);
    ABTI_CHECK_NULL_THREAD_ATTR_PTR(p_attr);
 
    *stackaddr = p_attr->p_stack;
    *stacksize = p_attr->stacksize;
    return ABT_SUCCESS;
}
 
int ABT_thread_attr_set_stacksize(ABT_thread_attr attr, size_t stacksize)
{
    ABTI_global *p_global;
    ABTI_SETUP_GLOBAL(&p_global);
 
    ABTI_thread_attr *p_attr = ABTI_thread_attr_get_ptr(attr);
    ABTI_CHECK_NULL_THREAD_ATTR_PTR(p_attr);
 
    thread_attr_set_stack(p_global, p_attr, p_attr->p_stack, stacksize);
    return ABT_SUCCESS;
}
 
int ABT_thread_attr_get_stacksize(ABT_thread_attr attr, size_t *stacksize)
{
    ABTI_thread_attr *p_attr = ABTI_thread_attr_get_ptr(attr);
    ABTI_CHECK_NULL_THREAD_ATTR_PTR(p_attr);
 
    *stacksize = p_attr->stacksize;
    return ABT_SUCCESS;
}
 
int ABT_thread_attr_set_callback(ABT_thread_attr attr,
                                 void (*cb_func)(ABT_thread thread,
                                                 void *cb_arg),
                                 void *cb_arg)
{
#ifndef ABT_CONFIG_DISABLE_MIGRATION
    ABTI_thread_attr *p_attr = ABTI_thread_attr_get_ptr(attr);
    ABTI_CHECK_NULL_THREAD_ATTR_PTR(p_attr);
 
    /* Set the value */
    p_attr->f_cb = cb_func;
    p_attr->p_cb_arg = cb_arg;
    return ABT_SUCCESS;
#else
    ABTI_HANDLE_ERROR(ABT_ERR_FEATURE_NA);
#endif
}
 
int ABT_thread_attr_set_migratable(ABT_thread_attr attr, ABT_bool is_migratable)
{
#ifndef ABT_CONFIG_DISABLE_MIGRATION
    ABTI_thread_attr *p_attr = ABTI_thread_attr_get_ptr(attr);
    ABTI_CHECK_NULL_THREAD_ATTR_PTR(p_attr);
 
    /* Set the value */
    p_attr->migratable = is_migratable;
    return ABT_SUCCESS;
#else
    ABTI_HANDLE_ERROR(ABT_ERR_FEATURE_NA);
#endif
}
 
/*****************************************************************************/
/* Private APIs                                                              */
/*****************************************************************************/
 
void ABTI_thread_attr_print(ABTI_thread_attr *p_attr, FILE *p_os, int indent)
{
    if (p_attr == NULL) {
        fprintf(p_os, "%*sULT attr: [NULL ATTR]\n", indent, "");
    } else {
        const char *stacktype;
        if (p_attr->thread_type & ABTI_THREAD_TYPE_MEM_MEMPOOL_DESC) {
            stacktype = "MEMPOOL_DESC";
        } else if (p_attr->thread_type & ABTI_THREAD_TYPE_MEM_MALLOC_DESC) {
            stacktype = "MALLOC_DESC";
        } else if (p_attr->thread_type &
                   ABTI_THREAD_TYPE_MEM_MEMPOOL_DESC_STACK) {
            stacktype = "MEMPOOL_DESC_STACK";
        } else if (p_attr->thread_type &
                   ABTI_THREAD_TYPE_MEM_MALLOC_DESC_STACK) {
            stacktype = "MALLOC_DESC_STACK";
        } else {
            stacktype = "UNKNOWN";
        }
#ifndef ABT_CONFIG_DISABLE_MIGRATION
        fprintf(p_os,
                "%*sULT attr: ["
                "stack:%p "
                "stacksize:%zu "
                "stacktype:%s "
                "migratable:%s "
                "cb_arg:%p"
                "]\n",
                indent, "", p_attr->p_stack, p_attr->stacksize, stacktype,
                (p_attr->migratable == ABT_TRUE ? "TRUE" : "FALSE"),
                p_attr->p_cb_arg);
#else
        fprintf(p_os,
                "%*sULT attr: ["
                "stack:%p "
                "stacksize:%zu "
                "stacktype:%s "
                "]\n",
                indent, "", p_attr->p_stack, p_attr->stacksize, stacktype);
#endif
    }
    fflush(p_os);
}
 
ABTU_ret_err int ABTI_thread_attr_dup(const ABTI_thread_attr *p_attr,
                                      ABTI_thread_attr **pp_dup_attr)
{
    ABTI_thread_attr *p_dup_attr;
    int abt_errno = ABTU_malloc(sizeof(ABTI_thread_attr), (void **)&p_dup_attr);
    ABTI_CHECK_ERROR(abt_errno);
 
    memcpy(p_dup_attr, p_attr, sizeof(ABTI_thread_attr));
    *pp_dup_attr = p_dup_attr;
    return ABT_SUCCESS;
}
 
/*****************************************************************************/
/* Internal static functions                                                 */
/*****************************************************************************/
 
static void thread_attr_set_stack(ABTI_global *p_global,
                                  ABTI_thread_attr *p_attr, void *stackaddr,
                                  size_t stacksize)
{
    /* Get the best thread type. */
    ABTI_thread_type new_thread_type;
    if (stackaddr != NULL) {
        /* This check must be done by the caller. */
        ABTI_ASSERT(((uintptr_t)stackaddr & 0x7) == 0);
        /* Only a descriptor will be allocated from a memory pool.  A stack
         * is given by the user. */
        new_thread_type = ABTI_THREAD_TYPE_MEM_MEMPOOL_DESC;
    } else {
        if (stacksize == p_global->thread_stacksize) {
            /* Both a stack and a descriptor will be allocated from a memory
             * pool. */
            new_thread_type = ABTI_THREAD_TYPE_MEM_MEMPOOL_DESC_STACK;
        } else {
            /* The stack must be allocated by malloc().  Let's allocate both
             * a stack and a descriptor together by a single malloc(). */
            new_thread_type = ABTI_THREAD_TYPE_MEM_MALLOC_DESC_STACK;
        }
    }
 
    /* Unset the stack type and set new_thread_type. */
    p_attr->thread_type &= ~ABTI_THREAD_TYPES_MEM;
    p_attr->thread_type |= new_thread_type;
 
    p_attr->p_stack = stackaddr;
    p_attr->stacksize = stacksize;
}