MALP_Config.h

Go to the documentation of this file.

/* ############################ MALP License ############################## */
/* # Fri Jan 18 14:00:00 CET 2013                                         # */
/* # Copyright or (C) or Copr. Commissariat a l'Energie Atomique          # */
/* #                                                                      # */
/* # This software is governed by the CeCILL-C license under French law   # */
/* # and abiding by the rules of distribution of free software.  You can  # */
/* # use, modify and/ or redistribute the software under the terms of     # */
/* # the CeCILL-C license as circulated by CEA, CNRS and INRIA at the     # */
/* # following URL http://www.cecill.info.                                # */
/* #                                                                      # */
/* # The fact that you are presently reading this means that you have     # */
/* # had knowledge of the CeCILL-C license and that you accept its        # */
/* # terms.                                                               # */
/* #                                                                      # */
/* # Authors:                                                             # */
/* #   - BESNARD Jean-Baptiste jean-baptiste.besnard@cea.fr               # */
/* #                                                                      # */
/* ######################################################################## */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>


#ifndef MALP_CONFIG_H
#define MALP_CONFIG_H

typedef enum {
    //GLOBAL CONFIG
    TA_CONF_GLOBAL_HEADER,
    TA_CONF_THREAD_PER_TASK,


    //VERBOSITY
        TA_CONF_VERBOSITY_HEADER,
        TA_CONF_DISPLAY_BANNER,
    TA_CONF_DISPLAY_BB_LOAD,
        TA_CONF_VERBOSE_OUTPUT,

    //INSTRUMENTATION
    TA_CONF_INSTRUMENT_HEADER,
        TA_CONF_INSTRUMENT_MPI,
        TA_CONF_INSTRUMENT_POSIX,
        TA_CONF_INSTRUMENT_MPI_OTF,
        TA_CONF_INSTRUMENT_POSIX_OTF,
        TA_CONF_INSTRUMENT_POSIX_PROFILE,
        TA_CONF_INSTRUMENT_POSIX_PROFILE_DUMP,

        // SAMPLE ANALYSIS
    
    TA_CONF_SAMPLE_ANALYSIS_HEADER,
    TA_CONF_SAMPLE_ANALYSIS_ENABLED,
        
    // OTF2 ANALYSIS

    TA_CONF_OTF2_ANALYSIS_HEADER,
    TA_CONF_OTF2_ANALYSIS_ENABLED,
    TA_CONF_OTF2_TRACE_PATH,
    TA_CONF_OTF2_TRACE_NAME,

    //END
    TA_CONF_KEY_COUNT

} TA_Conf_key_t;


static const char * const TA_Conf_key_lablel[TA_CONF_KEY_COUNT] = {
        //GLOBAL CONFIG
        "TA_CONF_GLOBAL_HEADER",
        "TA_CONF_THREAD_PER_TASK",


    //VERBOSITY
        "TA_CONF_VERBOSITY_HEADER",
        "TA_CONF_DISPLAY_BANNER",
    "TA_CONF_DISPLAY_BB_LOAD",
        "TA_CONF_VERBOSE_OUTPUT",

    //INSTRUMENTATION
    "TA_CONF_INSTRUMENT_HEADER",
        "TA_CONF_INSTRUMENT_MPI",
        "TA_CONF_INSTRUMENT_POSIX",
        "TA_CONF_INSTRUMENT_MPI_OTF",
        "TA_CONF_INSTRUMENT_POSIX_OTF",
        "TA_CONF_INSTRUMENT_POSIX_PROFILE",
        "TA_CONF_INSTRUMENT_POSIX_PROFILE_DUMP",

        // SAMPLE ANALYSIS
        
        "TA_CONF_SAMPLE_ANALYSIS_HEADER",
    "TA_CONF_SAMPLE_ANALYSIS_ENABLED",

    // OTF2 ANALYSIS

    "TA_CONF_OTF2_ANALYSIS_HEADER",
    "TA_CONF_OTF2_ANALYSIS_ENABLED",
    "TA_CONF_OTF2_TRACE_PATH",
    "TA_CONF_OTF2_TRACE_NAME"
        
};

typedef enum {
    TA_CONF_NONE,   
    TA_CONF_INT,    
    TA_CONF_BOOL,   
    TA_CONF_DOUBLE, 
    TA_CONF_STRING  
} TA_Conf_type;


struct TA_Conf_entry {
    char desc[500];     
    TA_Conf_type type;  
        //Embeds all types for better efficiency
    char c_value[1000]; 
    float d_value;      
    int i_value;        
};

void TA_Conf_entry_init( TA_Conf_key_t key, char *desc, TA_Conf_type type, char *value );

int TA_Conf_entry_update( struct TA_Conf_entry *entry, char *value );

int TA_Conf_update( char *key_name, char *val );

void TA_Conf_init_default();

void TA_Conf_init_from_env();

void TA_Conf_dispatch();

void TA_Conf_dump( char *dest );

void TA_Conf_load( char *source );

extern struct TA_Conf_entry TA_Conf_entries[TA_CONF_KEY_COUNT];


static inline int TA_Conf_get_key_int( TA_Conf_key_t key )
{
        if( ( key < TA_CONF_KEY_COUNT )  ) {
                if( TA_Conf_entries[key].type == TA_CONF_INT ) {
                        return TA_Conf_entries[key].i_value;
                } else {
                        printf("Bad config type\n");
                        abort();
                }
        } else {
                printf("Bad config key\n");
                abort();
        }
}

static inline int TA_Conf_get_key_bool( TA_Conf_key_t key )
{
        if( ( key < TA_CONF_KEY_COUNT )  )
        {
                if( TA_Conf_entries[key].type == TA_CONF_BOOL )
                {
                        return TA_Conf_entries[key].i_value & 0x1;
                } else {
                        printf("Bad config type for key %s\n", TA_Conf_key_lablel[key]);
                        abort();
                }
        } else {
                printf("Bad config key\n");
                abort();
        }
}

static inline double TA_Conf_get_key_double( TA_Conf_key_t key )
{
        if( ( key < TA_CONF_KEY_COUNT )  ) {
                if( TA_Conf_entries[key].type == TA_CONF_DOUBLE ) {
                        return TA_Conf_entries[key].d_value;
                } else {
                        printf("Bad config type for key %s\n", TA_Conf_key_lablel[key]);
                        abort();
                }
        } else {
                printf("Bad config key\n");
                abort();
        }
}

static inline char * TA_Conf_get_key_string( TA_Conf_key_t key )
{
        if( ( key < TA_CONF_KEY_COUNT )  ) {
                if( TA_Conf_entries[key].type == TA_CONF_STRING ) {
                        return TA_Conf_entries[key].c_value;
                } else {
                        printf("Bad config type for key %s\n", TA_Conf_key_lablel[key]);
                        abort();
                }
        } else {
                printf("Bad config key\n");
                abort();
        }
}


#define TA_Conf_dispatch()      do{int ___ret = PMPI_Bcast( (char*)TA_Conf_entries,\
                                                        sizeof(struct TA_Conf_entry) * TA_CONF_KEY_COUNT,\
                                                        MPI_CHAR, 0, VMPI_Get_partition_comm());\
                                                        if( ___ret != MPI_SUCCESS ) {\
                                                                printf("Failled to dispatch configuration \n");\
                                                                abort();\
                                                        }}while(0)




#endif