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>

/* 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 };

int ABT_sched_config_create(ABT_sched_config *config, ...)
{
    int abt_errno = ABT_SUCCESS;
    ABTI_sched_config *p_config;

    char *buffer = NULL;
    size_t alloc_size = 8 * sizeof(size_t);

    int num_params = 0;
    size_t offset = sizeof(num_params);

    size_t buffer_size = alloc_size;
    buffer = (char *)ABTU_malloc(buffer_size);

    va_list varg_list;
    va_start(varg_list, config);

    /* We read each couple (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);
        if (var.idx == ABT_sched_config_var_end.idx)
            break;

        int param = var.idx;
        ABT_sched_config_type type = var.type;
        num_params++;

        size_t size = ABTI_sched_config_type_size(type);
        if (offset + sizeof(param) + sizeof(type) + size > buffer_size) {
            size_t cur_buffer_size = buffer_size;
            buffer_size += alloc_size;
            buffer = ABTU_realloc(buffer, cur_buffer_size, buffer_size);
        }
        /* Copy the parameter index */
        memcpy(buffer + offset, (void *)&param, sizeof(param));
        offset += sizeof(param);

        /* Copy the size of the argument */
        memcpy(buffer + offset, (void *)&size, sizeof(size));
        offset += sizeof(size);

        /* Copy the argument */
        void *ptr;
        int i;
        double d;
        void *p;
        switch (type) {
            case ABT_SCHED_CONFIG_INT:
                i = va_arg(varg_list, int);
                ptr = (void *)&i;
                break;
            case ABT_SCHED_CONFIG_DOUBLE:
                d = va_arg(varg_list, double);
                ptr = (void *)&d;
                break;
            case ABT_SCHED_CONFIG_PTR:
                p = va_arg(varg_list, void *);
                ptr = (void *)&p;
                break;
            default:
                abt_errno = ABT_ERR_SCHED_CONFIG;
                goto fn_fail;
        }

        memcpy(buffer + offset, ptr, size);
        offset += size;
    }
    va_end(varg_list);

    if (num_params) {
        memcpy(buffer, (int *)&num_params, sizeof(num_params));
    } else {
        ABTU_free(buffer);
        buffer = NULL;
    }

    p_config = (ABTI_sched_config *)buffer;
    *config = ABTI_sched_config_get_handle(p_config);

fn_exit:
    return abt_errno;

fn_fail:
    HANDLE_ERROR_FUNC_WITH_CODE(abt_errno);
    goto fn_exit;
}

int ABT_sched_config_read(ABT_sched_config config, int num_vars, ...)
{
    int abt_errno = ABT_SUCCESS;
    int v;

    /* We read all the variables and save the addresses */
    void **variables = (void *)ABTU_malloc(num_vars * sizeof(void *));
    va_list varg_list;
    va_start(varg_list, num_vars);
    for (v = 0; v < num_vars; v++) {
        variables[v] = va_arg(varg_list, void *);
    }
    va_end(varg_list);

    abt_errno = ABTI_sched_config_read(config, 1, num_vars, variables);
    ABTI_CHECK_ERROR(abt_errno);

    ABTU_free(variables);

fn_exit:
    return abt_errno;

fn_fail:
    HANDLE_ERROR_FUNC_WITH_CODE(abt_errno);
    goto fn_exit;
}

int ABT_sched_config_free(ABT_sched_config *config)
{
    ABTI_sched_config *p_config = ABTI_sched_config_get_ptr(*config);
    ABTU_free(p_config);

    *config = ABT_SCHED_CONFIG_NULL;

    return ABT_SUCCESS;
}

size_t ABTI_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);
            return 0;
    }
}

int ABTI_sched_config_read_global(ABT_sched_config config,
                                  ABT_pool_access *access, ABT_bool *automatic)
{
    int abt_errno = ABT_SUCCESS;
    int num_vars = 2;
    /* We use XXX_i variables because va_list converts these types into int */
    int access_i = -1;
    int automatic_i = -1;

    void **variables = (void **)ABTU_malloc(num_vars * sizeof(void *));
    variables[(ABT_sched_config_access.idx + 2) * (-1)] = &access_i;
    variables[(ABT_sched_config_automatic.idx + 2) * (-1)] = &automatic_i;

    abt_errno = ABTI_sched_config_read(config, 0, num_vars, variables);
    ABTU_free(variables);
    ABTI_CHECK_ERROR(abt_errno);

    if (access_i != -1)
        *access = (ABT_pool_access)access_i;
    if (automatic_i != -1)
        *automatic = (ABT_bool)automatic_i;

fn_exit:
    return abt_errno;

fn_fail:
    HANDLE_ERROR_FUNC_WITH_CODE(abt_errno);
    goto fn_exit;
}

/* type is 0 if we read the private parameters, else 1 */
int ABTI_sched_config_read(ABT_sched_config config, int type, int num_vars,
                           void **variables)
{
    size_t offset = 0;
    int num_params;

    if (config == ABT_SCHED_CONFIG_NULL) {
        return ABT_SUCCESS;
    }

    ABTI_sched_config *p_config = ABTI_sched_config_get_ptr(config);

    char *buffer = (char *)p_config;

    /* Number of parameters in buffer */
    memcpy(&num_params, buffer, sizeof(num_params));
    offset += sizeof(num_params);

    /* Copy the data from buffer to the right variables */
    int p;
    for (p = 0; p < num_params; p++) {
        int var_idx;
        size_t size;

        /* Get the variable index of the next parameter */
        memcpy(&var_idx, buffer + offset, sizeof(var_idx));
        offset += sizeof(var_idx);
        /* Get the size of the next parameter */
        memcpy(&size, buffer + offset, sizeof(size));
        offset += sizeof(size);
        /* Get the next argument */
        /* We save it only if
         *   - the index is < 0  when type == 0
         *   - the index is >= 0 when type == 1
         */
        if (type == 0) {
            if (var_idx < 0) {
                var_idx = (var_idx + 2) * -1;
                if (var_idx >= num_vars)
                    return ABT_ERR_INV_SCHED_CONFIG;
                memcpy(variables[var_idx], buffer + offset, size);
            }
        } else {
            if (var_idx >= 0) {
                if (var_idx >= num_vars)
                    return ABT_ERR_INV_SCHED_CONFIG;
                memcpy(variables[var_idx], buffer + offset, size);
            }
        }
        offset += size;
    }
    return ABT_SUCCESS;
}