config.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"
 
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
 
static inline size_t sched_config_type_size(ABT_sched_config_type type);
ABTU_ret_err static int sched_config_get(const ABTI_sched_config *p_config,
                                         int idx, ABT_sched_config_type *p_type,
                                         void *p_val);
ABTU_ret_err static int sched_config_set(ABTI_sched_config *p_config, int idx,
                                         ABT_sched_config_type type,
                                         const void *p_val);
static void sched_config_free(ABTI_sched_config *p_config);
 
/* Global configurable parameters */
ABT_sched_config_var ABT_sched_config_var_end = { .idx = -1,
                                                  .type =
                                                      ABT_SCHED_CONFIG_INT };
 
ABT_sched_config_var ABT_sched_config_access = { .idx = -2,
                                                 .type = ABT_SCHED_CONFIG_INT };
 
ABT_sched_config_var ABT_sched_config_automatic = { .idx = -3,
                                                    .type =
                                                        ABT_SCHED_CONFIG_INT };
 
ABT_sched_config_var ABT_sched_basic_freq = { .idx = -4,
                                              .type = ABT_SCHED_CONFIG_INT };
 
int ABT_sched_config_create(ABT_sched_config *config, ...)
{
    ABTI_UB_ASSERT(ABTI_initialized());
 
    int abt_errno;
    int i = 0;
    ABTI_sched_config *p_config;
 
    abt_errno = ABTU_calloc(1, sizeof(ABTI_sched_config), (void **)&p_config);
    ABTI_CHECK_ERROR(abt_errno);
    /* Initialize index. */
 
    for (i = 0; i < ABTI_SCHED_CONFIG_HTABLE_SIZE; i++) {
        p_config->elements[i].idx = ABTI_SCHED_CONFIG_UNUSED_INDEX;
    }
 
    va_list varg_list;
    va_start(varg_list, config);
 
    /* We read (var, value) until we find ABT_sched_config_var_end */
    while (1) {
        ABT_sched_config_var var = va_arg(varg_list, ABT_sched_config_var);
        int idx = var.idx;
        if (idx == ABT_sched_config_var_end.idx)
            break;
        /* Add the argument */
        switch (var.type) {
            case ABT_SCHED_CONFIG_INT: {
                int int_val = va_arg(varg_list, int);
                abt_errno = sched_config_set(p_config, idx,
                                             ABT_SCHED_CONFIG_INT, &int_val);
                break;
            }
            case ABT_SCHED_CONFIG_DOUBLE: {
                double double_val = va_arg(varg_list, double);
                abt_errno =
                    sched_config_set(p_config, idx, ABT_SCHED_CONFIG_DOUBLE,
                                     &double_val);
                break;
            }
            case ABT_SCHED_CONFIG_PTR: {
                void *ptr_val = va_arg(varg_list, void *);
                abt_errno = sched_config_set(p_config, idx,
                                             ABT_SCHED_CONFIG_PTR, &ptr_val);
                break;
            }
            default:
                abt_errno = ABT_ERR_INV_ARG;
        }
        if (abt_errno != ABT_SUCCESS) {
            sched_config_free(p_config);
            va_end(varg_list);
            ABTI_HANDLE_ERROR(abt_errno);
        }
    }
    va_end(varg_list);
 
    *config = ABTI_sched_config_get_handle(p_config);
    return ABT_SUCCESS;
}
 
int ABT_sched_config_read(ABT_sched_config config, int num_vars, ...)
{
    ABTI_UB_ASSERT(ABTI_initialized());
 
    int idx;
    ABTI_sched_config *p_config = ABTI_sched_config_get_ptr(config);
    ABTI_CHECK_NULL_SCHED_CONFIG_PTR(p_config);
 
    va_list varg_list;
    va_start(varg_list, num_vars);
    for (idx = 0; idx < num_vars; idx++) {
        void *ptr = va_arg(varg_list, void *);
        if (ptr) {
            int abt_errno = sched_config_get(p_config, idx, NULL, ptr);
            /* It's okay even if there's no associated value. */
            (void)abt_errno;
        }
    }
    va_end(varg_list);
    return ABT_SUCCESS;
}
 
int ABT_sched_config_free(ABT_sched_config *config)
{
    ABTI_UB_ASSERT(ABTI_initialized());
 
    ABTI_sched_config *p_config = ABTI_sched_config_get_ptr(*config);
    ABTI_CHECK_NULL_SCHED_CONFIG_PTR(p_config);
 
    sched_config_free(p_config);
 
    *config = ABT_SCHED_CONFIG_NULL;
 
    return ABT_SUCCESS;
}
 
int ABT_sched_config_set(ABT_sched_config config, int idx,
                         ABT_sched_config_type type, const void *val)
{
    ABTI_UB_ASSERT(ABTI_initialized());
 
    ABTI_sched_config *p_config = ABTI_sched_config_get_ptr(config);
    ABTI_CHECK_NULL_SCHED_CONFIG_PTR(p_config);
    int abt_errno = sched_config_set(p_config, idx, type, val);
    ABTI_CHECK_ERROR(abt_errno);
    return ABT_SUCCESS;
}
 
int ABT_sched_config_get(ABT_sched_config config, int idx,
                         ABT_sched_config_type *type, void *val)
{
    ABTI_UB_ASSERT(ABTI_initialized());
 
    ABTI_sched_config *p_config = ABTI_sched_config_get_ptr(config);
    ABTI_CHECK_NULL_SCHED_CONFIG_PTR(p_config);
    int abt_errno = sched_config_get(p_config, idx, type, val);
    ABTI_CHECK_ERROR(abt_errno);
    return ABT_SUCCESS;
}
 
/*****************************************************************************/
/* Private APIs                                                              */
/*****************************************************************************/
 
ABTU_ret_err int ABTI_sched_config_read(const ABTI_sched_config *p_config,
                                        int idx, void *p_val)
{
    return sched_config_get(p_config, idx, NULL, p_val);
}
 
/*****************************************************************************/
/* Internal static functions                                                 */
/*****************************************************************************/
 
ABTU_ret_err static int sched_config_get(const ABTI_sched_config *p_config,
                                         int idx, ABT_sched_config_type *p_type,
                                         void *p_val)
{
    int table_index = ((idx % ABTI_SCHED_CONFIG_HTABLE_SIZE) +
                       ABTI_SCHED_CONFIG_HTABLE_SIZE) %
                      ABTI_SCHED_CONFIG_HTABLE_SIZE;
    if (p_config->elements[table_index].idx == ABTI_SCHED_CONFIG_UNUSED_INDEX) {
        return ABT_ERR_INV_ARG;
    } else {
        const ABTI_sched_config_element *p_element =
            &p_config->elements[table_index];
        while (p_element) {
            if (p_element->idx == idx) {
                if (p_val) {
                    memcpy(p_val, p_element->val,
                           sched_config_type_size(p_element->type));
                }
                if (p_type) {
                    *p_type = p_element->type;
                }
                return ABT_SUCCESS;
            } else {
                p_element = p_element->p_next;
            }
        }
        return ABT_ERR_INV_ARG;
    }
}
 
ABTU_ret_err static int sched_config_set(ABTI_sched_config *p_config, int idx,
                                         ABT_sched_config_type type,
                                         const void *p_val)
{
    int table_index = ((idx % ABTI_SCHED_CONFIG_HTABLE_SIZE) +
                       ABTI_SCHED_CONFIG_HTABLE_SIZE) %
                      ABTI_SCHED_CONFIG_HTABLE_SIZE;
    if (p_config->elements[table_index].idx == ABTI_SCHED_CONFIG_UNUSED_INDEX) {
        if (p_val) {
            /* Newly add. */
            p_config->elements[table_index].idx = idx;
            p_config->elements[table_index].type = type;
            memcpy(p_config->elements[table_index].val, p_val,
                   sched_config_type_size(type));
        }
    } else {
        ABTI_sched_config_element *p_element = &p_config->elements[table_index];
        ABTI_sched_config_element **pp_element = NULL;
        while (p_element) {
            if (p_element->idx == idx) {
                if (p_val) {
                    /* Update. */
                    p_element->type = type;
                    memcpy(p_element->val, p_val, sched_config_type_size(type));
                } else {
                    /* Remove the element. */
                    if (pp_element) {
                        *pp_element = p_element->p_next;
                        ABTU_free(p_element);
                    } else {
                        ABTI_sched_config_element *p_next = p_element->p_next;
                        if (p_next) {
                            memcpy(p_element, p_next,
                                   sizeof(ABTI_sched_config_element));
                            ABTU_free(p_next);
                        } else {
                            p_element->idx = ABTI_SCHED_CONFIG_UNUSED_INDEX;
                        }
                    }
                }
                break;
            } else if (!p_element->p_next) {
                if (p_val) {
                    /* Newly add. */
                    ABTI_sched_config_element *p_new_element;
                    int abt_errno =
                        ABTU_calloc(1, sizeof(ABTI_sched_config_element),
                                    (void **)&p_new_element);
                    ABTI_CHECK_ERROR(abt_errno);
                    p_new_element->idx = idx;
                    p_new_element->type = type;
                    memcpy(p_new_element->val, p_val,
                           sched_config_type_size(type));
                    p_element->p_next = p_new_element;
                }
                break;
            } else {
                pp_element = &p_element->p_next;
                p_element = *pp_element;
            }
        }
    }
    return ABT_SUCCESS;
}
 
static void sched_config_free(ABTI_sched_config *p_config)
{
    /* Check elements. */
    int i;
    for (i = 0; i < ABTI_SCHED_CONFIG_HTABLE_SIZE; i++) {
        ABTI_sched_config_element *p_element = p_config->elements[i].p_next;
        while (p_element) {
            ABTI_sched_config_element *p_next = p_element->p_next;
            ABTU_free(p_element);
            p_element = p_next;
        }
    }
    ABTU_free(p_config);
}
 
static inline size_t sched_config_type_size(ABT_sched_config_type type)
{
    switch (type) {
        case ABT_SCHED_CONFIG_INT:
            return sizeof(int);
        case ABT_SCHED_CONFIG_DOUBLE:
            return sizeof(double);
        case ABT_SCHED_CONFIG_PTR:
            return sizeof(void *);
        default:
            ABTI_ASSERT(0);
            ABTU_unreachable();
    }
}