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_add(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, ...)
{
    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_add(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_add(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_add(p_config, idx,
                                             ABT_SCHED_CONFIG_PTR, &ptr_val);
                break;
            }
            default:
                abt_errno = ABT_ERR_SCHED_CONFIG;
        }
        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, ...)
{
    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 = ABTI_sched_config_read(p_config, idx, 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_sched_config *p_config = ABTI_sched_config_get_ptr(*config);
    ABTI_CHECK_NULL_SCHED_CONFIG_PTR(p_config);
 
    ABTU_free(p_config);
 
    *config = ABT_SCHED_CONFIG_NULL;
 
    return ABT_SUCCESS;
}
 
/*****************************************************************************/
/* Private APIs                                                              */
/*****************************************************************************/
 
ABTU_ret_err int ABTI_sched_config_read(const ABTI_sched_config *p_config,
                                        int idx, 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_OTHER;
    } else {
        const ABTI_sched_config_element *p_element =
            &p_config->elements[table_index];
        while (p_element) {
            if (p_element->idx == idx) {
                memcpy(p_val, p_element->val,
                       sched_config_type_size(p_element->type));
                return ABT_SUCCESS;
            } else {
                p_element = p_element->p_next;
            }
        }
        return ABT_ERR_OTHER;
    }
}
 
/*****************************************************************************/
/* Internal static functions                                                 */
/*****************************************************************************/
 
ABTU_ret_err static int sched_config_add(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) {
        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];
        while (p_element) {
            if (p_element->idx == idx) {
                /* Update. */
                p_element->type = type;
                memcpy(p_element->val, p_val, sched_config_type_size(type));
                break;
            } else if (!p_element->p_next) {
                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 {
                p_element = p_element->p_next;
            }
        }
    }
    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();
    }
}