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"

int ABT_thread_attr_create(ABT_thread_attr *newattr)
{
    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, gp_ABTI_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_thread_attr *p_attr = ABTI_thread_attr_get_ptr(attr);
    ABTI_CHECK_NULL_THREAD_ATTR_PTR(p_attr);

    ABTI_thread_type new_thread_type;
    if (stackaddr != NULL) {
        if (((uintptr_t)stackaddr & 0x7) != 0) {
            ABTI_HANDLE_ERROR(ABT_ERR_OTHER);
        }
        new_thread_type = ABTI_THREAD_TYPE_MEM_MEMPOOL_DESC;
    } else {
        if (stacksize == gp_ABTI_global->thread_stacksize) {
            new_thread_type = ABTI_THREAD_TYPE_MEM_MEMPOOL_DESC_STACK;
        } else {
            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;
    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_thread_attr *p_attr = ABTI_thread_attr_get_ptr(attr);
    ABTI_CHECK_NULL_THREAD_ATTR_PTR(p_attr);

    /* Set the value */
    p_attr->stacksize = stacksize;
    ABTI_thread_type new_thread_type;
    if (stacksize == gp_ABTI_global->thread_stacksize) {
        new_thread_type = ABTI_THREAD_TYPE_MEM_MEMPOOL_DESC_STACK;
    } else {
        new_thread_type = ABTI_THREAD_TYPE_MEM_MEMPOOL_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;
    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 flag)
{
#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 = flag;
    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;
}