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)
{
    int abt_errno = ABT_SUCCESS;
    ABTI_thread_attr *p_newattr;

    p_newattr = (ABTI_thread_attr *)ABTU_malloc(sizeof(ABTI_thread_attr));

    /* Default values */
    ABTI_thread_attr_init(p_newattr, NULL, ABTI_global_get_thread_stacksize(),
                          ABTI_STACK_TYPE_MEMPOOL, ABT_TRUE);

    /* Return value */
    *newattr = ABTI_thread_attr_get_handle(p_newattr);

    return abt_errno;
}

int ABT_thread_attr_free(ABT_thread_attr *attr)
{
    int abt_errno = ABT_SUCCESS;
    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);

    /* Return value */
    *attr = ABT_THREAD_ATTR_NULL;

fn_exit:
    return abt_errno;

fn_fail:
    HANDLE_ERROR_FUNC_WITH_CODE(abt_errno);
    goto fn_exit;
}

int ABT_thread_attr_set_stack(ABT_thread_attr attr, void *stackaddr,
                              size_t stacksize)
{
    int abt_errno = ABT_SUCCESS;
    ABTI_thread_attr *p_attr = ABTI_thread_attr_get_ptr(attr);
    ABTI_CHECK_NULL_THREAD_ATTR_PTR(p_attr);

    if (stackaddr != NULL) {
        if (((uintptr_t)stackaddr & 0x7) != 0) {
            abt_errno = ABT_ERR_OTHER;
            goto fn_fail;
        }
        p_attr->p_stack = stackaddr;
        p_attr->stacktype = ABTI_STACK_TYPE_USER;
    } else {
        p_attr->stacktype = ABTI_STACK_TYPE_MALLOC;
    }
    p_attr->stacksize = stacksize;

fn_exit:
    return abt_errno;

fn_fail:
    HANDLE_ERROR_FUNC_WITH_CODE(abt_errno);
    goto fn_exit;
}

int ABT_thread_attr_get_stack(ABT_thread_attr attr, void **stackaddr,
                              size_t *stacksize)
{
    int abt_errno = ABT_SUCCESS;
    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;

fn_exit:
    return abt_errno;

fn_fail:
    HANDLE_ERROR_FUNC_WITH_CODE(abt_errno);
    goto fn_exit;
}

int ABT_thread_attr_set_stacksize(ABT_thread_attr attr, size_t stacksize)
{
    int abt_errno = ABT_SUCCESS;
    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;

fn_exit:
    return abt_errno;

fn_fail:
    HANDLE_ERROR_FUNC_WITH_CODE(abt_errno);
    goto fn_exit;
}

int ABT_thread_attr_get_stacksize(ABT_thread_attr attr, size_t *stacksize)
{
    int abt_errno = ABT_SUCCESS;
    ABTI_thread_attr *p_attr = ABTI_thread_attr_get_ptr(attr);
    ABTI_CHECK_NULL_THREAD_ATTR_PTR(p_attr);

    *stacksize = p_attr->stacksize;

fn_exit:
    return abt_errno;

fn_fail:
    HANDLE_ERROR_FUNC_WITH_CODE(abt_errno);
    goto fn_exit;
}

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
    int abt_errno = ABT_SUCCESS;
    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;

fn_exit:
    return abt_errno;

fn_fail:
    HANDLE_ERROR_FUNC_WITH_CODE(abt_errno);
    goto fn_exit;
#else
    return ABT_ERR_FEATURE_NA;
#endif
}

int ABT_thread_attr_set_migratable(ABT_thread_attr attr, ABT_bool flag)
{
#ifndef ABT_CONFIG_DISABLE_MIGRATION
    int abt_errno = ABT_SUCCESS;
    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;

fn_exit:
    return abt_errno;

fn_fail:
    HANDLE_ERROR_FUNC_WITH_CODE(abt_errno);
    goto fn_exit;
#else
    return ABT_ERR_FEATURE_NA;
#endif
}

/*****************************************************************************/
/* Private APIs                                                              */
/*****************************************************************************/

/*
 *
 */

void ABTI_thread_attr_print(ABTI_thread_attr *p_attr, FILE *p_os, int indent)
{
    char *prefix = ABTU_get_indent_str(indent);
    char attr[100];

    ABTI_thread_attr_get_str(p_attr, attr);
    fprintf(p_os, "%sULT attr: %s\n", prefix, attr);
    fflush(p_os);
    ABTU_free(prefix);
}

void ABTI_thread_attr_get_str(ABTI_thread_attr *p_attr, char *p_buf)
{
    if (p_attr == NULL) {
        sprintf(p_buf, "[NULL ATTR]");
        return;
    }

    char *stacktype;
    switch (p_attr->stacktype) {
        case ABTI_STACK_TYPE_MEMPOOL:
            stacktype = "MEMPOOL";
            break;
        case ABTI_STACK_TYPE_MALLOC:
            stacktype = "MALLOC";
            break;
        case ABTI_STACK_TYPE_USER:
            stacktype = "USER";
            break;
        case ABTI_STACK_TYPE_MAIN:
            stacktype = "MAIN";
            break;
        default:
            stacktype = "UNKNOWN";
            break;
    }

#ifndef ABT_CONFIG_DISABLE_MIGRATION
    sprintf(p_buf,
            "["
            "stack:%p "
            "stacksize:%zu "
            "stacktype:%s "
            "migratable:%s "
            "cb_arg:%p"
            "]",
            p_attr->p_stack, p_attr->stacksize, stacktype,
            (p_attr->migratable == ABT_TRUE ? "TRUE" : "FALSE"),
            p_attr->p_cb_arg);
#else
    sprintf(p_buf,
            "["
            "stack:%p "
            "stacksize:%zu "
            "stacktype:%s "
            "]",
            p_attr->p_stack, p_attr->stacksize, stacktype);
#endif
}

ABTI_thread_attr *ABTI_thread_attr_dup(ABTI_thread_attr *p_attr)
{
    ABTI_thread_attr *p_dupattr;

    p_dupattr = (ABTI_thread_attr *)ABTU_malloc(sizeof(ABTI_thread_attr));
    ABTI_thread_attr_copy(p_dupattr, p_attr);

    return p_dupattr;
}