sched_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>
 
#define SCHED_CONFIG_HTABLE_SIZE 8
typedef struct {
    ABT_sched_config_type type; /* Element type. */
    union {
        int v_int;
        double v_double;
        void *v_ptr;
    } val;
} sched_config_element;
 
static void sched_config_create_element_int(sched_config_element *p_elem,
                                            int val);
static void sched_config_create_element_double(sched_config_element *p_elem,
                                               double val);
static void sched_config_create_element_ptr(sched_config_element *p_elem,
                                            void *ptr);
ABTU_ret_err static int
sched_config_create_element_typed(sched_config_element *p_elem,
                                  ABT_sched_config_type type,
                                  const void *p_val);
static void sched_config_read_element(const sched_config_element *p_elem,
                                      void *ptr);
 
/* 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;
    ABTI_sched_config *p_config;
 
    abt_errno = ABTU_calloc(1, sizeof(ABTI_sched_config), (void **)&p_config);
    ABTI_CHECK_ERROR(abt_errno);
 
    abt_errno =
        ABTU_hashtable_create(SCHED_CONFIG_HTABLE_SIZE,
                              sizeof(sched_config_element), &p_config->p_table);
    if (abt_errno != ABT_SUCCESS) {
        ABTU_free(p_config);
        ABTI_HANDLE_ERROR(abt_errno);
    }
 
    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 */
        sched_config_element data;
        switch (var.type) {
            case ABT_SCHED_CONFIG_INT: {
                sched_config_create_element_int(&data, va_arg(varg_list, int));
                break;
            }
            case ABT_SCHED_CONFIG_DOUBLE: {
                sched_config_create_element_double(&data,
                                                   va_arg(varg_list, double));
                break;
            }
            case ABT_SCHED_CONFIG_PTR: {
                sched_config_create_element_ptr(&data,
                                                va_arg(varg_list, void *));
                break;
            }
            default:
                abt_errno = ABT_ERR_INV_ARG;
        }
        if (abt_errno == ABT_SUCCESS) {
            abt_errno = ABTU_hashtable_set(p_config->p_table, idx, &data, NULL);
        }
        if (abt_errno != ABT_SUCCESS) {
            ABTU_hashtable_free(p_config->p_table);
            ABTU_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) {
            sched_config_element data;
            int found;
            ABTU_hashtable_get(p_config->p_table, idx, &data, &found);
            if (found) {
                sched_config_read_element(&data, ptr);
            }
        }
    }
    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);
 
    ABTU_hashtable_free(p_config->p_table);
    ABTU_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);
    if (val) {
        /* Add a value. */
        sched_config_element data;
        int abt_errno;
        abt_errno = sched_config_create_element_typed(&data, type, val);
        ABTI_CHECK_ERROR(abt_errno);
        abt_errno = ABTU_hashtable_set(p_config->p_table, idx, &data, NULL);
        ABTI_CHECK_ERROR(abt_errno);
    } else {
        /* Delete a value. */
        ABTU_hashtable_delete(p_config->p_table, idx, NULL);
    }
    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);
    sched_config_element data;
    int found;
    ABTU_hashtable_get(p_config->p_table, idx, &data, &found);
    if (found) {
        if (val) {
            sched_config_read_element(&data, val);
        }
        if (type) {
            *type = data.type;
        }
    } else {
        ABTI_HANDLE_ERROR(ABT_ERR_INV_ARG);
    }
    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 found;
    sched_config_element data;
    ABTU_hashtable_get(p_config->p_table, idx, &data, &found);
    if (found) {
        if (p_val) {
            sched_config_read_element(&data, p_val);
        }
        return ABT_SUCCESS;
    } else {
        return ABT_ERR_INV_ARG;
    }
}
 
/*****************************************************************************/
/* Internal static functions                                                 */
/*****************************************************************************/
 
static void sched_config_create_element_int(sched_config_element *p_elem,
                                            int val)
{
    memset(p_elem, 0, sizeof(sched_config_element));
    p_elem->type = ABT_SCHED_CONFIG_INT;
    p_elem->val.v_int = val;
}
 
static void sched_config_create_element_double(sched_config_element *p_elem,
                                               double val)
{
    memset(p_elem, 0, sizeof(sched_config_element));
    p_elem->type = ABT_SCHED_CONFIG_DOUBLE;
    p_elem->val.v_double = val;
}
 
static void sched_config_create_element_ptr(sched_config_element *p_elem,
                                            void *ptr)
{
    memset(p_elem, 0, sizeof(sched_config_element));
    p_elem->type = ABT_SCHED_CONFIG_PTR;
    p_elem->val.v_ptr = ptr;
}
 
ABTU_ret_err static int
sched_config_create_element_typed(sched_config_element *p_elem,
                                  ABT_sched_config_type type, const void *p_val)
{
    switch (type) {
        case ABT_SCHED_CONFIG_INT: {
            sched_config_create_element_int(p_elem, *(const int *)p_val);
            break;
        }
        case ABT_SCHED_CONFIG_DOUBLE: {
            sched_config_create_element_double(p_elem, *(const double *)p_val);
            break;
        }
        case ABT_SCHED_CONFIG_PTR: {
            sched_config_create_element_ptr(p_elem, *(void *const *)p_val);
            break;
        }
        default:
            return ABT_ERR_INV_ARG;
    }
    return ABT_SUCCESS;
}
 
static void sched_config_read_element(const sched_config_element *p_elem,
                                      void *ptr)
{
    switch (p_elem->type) {
        case ABT_SCHED_CONFIG_INT: {
            *((int *)ptr) = p_elem->val.v_int;
            break;
        }
        case ABT_SCHED_CONFIG_DOUBLE: {
            *((double *)ptr) = p_elem->val.v_double;
            break;
        }
        case ABT_SCHED_CONFIG_PTR: {
            *((void **)ptr) = p_elem->val.v_ptr;
            break;
        }
        default:
            ABTI_ASSERT(0);
    }
}