MALP_Config.c

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 "MALP_Config.h"
#include "Utils.h"

#include <stdlib.h>


struct TA_Conf_entry TA_Conf_entries[TA_CONF_KEY_COUNT];


//TA_Conf_entry

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

        if ( (TA_CONF_KEY_COUNT <= key ) ) {
                printf("Bad entry key \n");
                abort();
        }

        struct TA_Conf_entry *entry = &TA_Conf_entries[key];

        strncpy( entry->desc, desc, 499);
        entry->type = type;

        char empty[] = "";
        if( !value )
                value = empty;


        if ( !TA_Conf_entry_update( entry, value ) ) {
                printf("Wrong default config given \n");
                abort();
        }


}

int TA_Conf_entry_update( struct TA_Conf_entry *entry, char *value )
{
        if( (strlen(value) == 0) && entry->type != TA_CONF_STRING && entry->type != TA_CONF_NONE ) {
                printf("this options awaits a value\n");
                return 0;
        }

        snprintf(entry->c_value, 200, "%s", value);

        if ( entry->type != TA_CONF_STRING && entry->type != TA_CONF_NONE ) {
                if ( !MALP_Trace_is_numeric( value ) ) {
                        printf("Given entry ( %s ) is not numeric\n", value );
                        return 0;
                }

                switch ( entry->type ) {
                        case TA_CONF_INT :
                                entry->i_value = atoi(value);
                                break;
                        case TA_CONF_DOUBLE :
                                entry->d_value = atof(value);
                                break;
                        case TA_CONF_BOOL :
                                entry->i_value = atoi(value);
                                break;
                        default :
                                printf("Unknown type \n");
                                abort();
                }
        } else {
                entry->d_value = 0.0;
                entry->i_value = 0;
        }

        return 1;
}


//TA_Conf
static inline int TA_Conf_get_key_index( char *key_name )
{
        int i = 0;

        for ( i = 0 ; i < TA_CONF_KEY_COUNT ; i++ ) {
                if ( MALP_Trace_fast_strcmp( (char *)TA_Conf_key_lablel[i], key_name ) )
                        return i;

        }

        return -1;
}


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

        int index = TA_Conf_get_key_index( key_name );

        if ( index < 0 )
                return 0;

        struct TA_Conf_entry *entry = &TA_Conf_entries[index];

        return TA_Conf_entry_update( entry, val );

}


void TA_Conf_init_from_env()
{
        int i;
        for( i = 0 ; i < TA_CONF_KEY_COUNT ; i++ )
        {
                char * key = getenv( TA_Conf_key_lablel[i] );
                
                if( key )
                {
                        printf("Overriding %s to %s from env \n", TA_Conf_key_lablel[i], key);
                        if ( !TA_Conf_update( TA_Conf_key_lablel[i], key ) )
                        {
                                        printf("Warning env option for %s (%s) misformated \n", (char *)TA_Conf_key_lablel[i], key);
                        }
                }
                
        }
}



void TA_Conf_init_default()
{
        //GLOBAL CONFIG
        TA_Conf_entry_init( TA_CONF_GLOBAL_HEADER,
                            "#############################################\n"
                            "#                                            #\n"
                            "#              GLOBAL CONFIGURATION          #\n"
                            "#                                            #\n"
                            "##############################################\n",
                            TA_CONF_NONE,
                            "" );
        TA_Conf_entry_init( TA_CONF_THREAD_PER_TASK,
                            "Number of concurent worker threads per task (0 for core count)",
                            TA_CONF_INT,
                            "1" );
        //VERBOSITY
        TA_Conf_entry_init( TA_CONF_VERBOSITY_HEADER,
                            "##############################################\n"
                            "#                                            #\n"
                            "#              ANALYZER VERBOSITY            #\n"
                            "#                                            #\n"
                            "##############################################\n",
                            TA_CONF_NONE,
                            "");
                TA_Conf_entry_init( TA_CONF_DISPLAY_BANNER,
                            "Display MALP banner at program startup",
                            TA_CONF_BOOL,
                            "1" );                  
        TA_Conf_entry_init( TA_CONF_DISPLAY_BB_LOAD,
                            "Display blackboard's load to diagnose heavy load (useful for C++)",
                            TA_CONF_BOOL,
                            "0" );
        TA_Conf_entry_init( TA_CONF_VERBOSE_OUTPUT,
                            "Activates debug messages during report generation",
                            TA_CONF_BOOL,
                            "0" );
    //INSTRUMENTATION
        
        TA_Conf_entry_init( TA_CONF_INSTRUMENT_HEADER,
                            "##############################################\n"
                            "#                                            #\n"
                            "#              INSTRUMENTATION               #\n"
                            "#                                            #\n"
                            "##############################################\n",
                            TA_CONF_NONE,
                            "");
                TA_Conf_entry_init( TA_CONF_INSTRUMENT_MPI,
                            "Enable MPI calls instrumentation",
                            TA_CONF_BOOL,
                            "1" );       
                TA_Conf_entry_init( TA_CONF_INSTRUMENT_POSIX,
                            "Enable POSIX calls instrumentation",
                            TA_CONF_BOOL,
                            "0" );
                TA_Conf_entry_init( TA_CONF_INSTRUMENT_MPI_OTF,
                            "Activate to send MPI calls to the OTF trace",
                            TA_CONF_BOOL,
                            "1" );   
                TA_Conf_entry_init( TA_CONF_INSTRUMENT_POSIX_OTF,
                            "Activate to send POSIX calls to the OTF trace",
                            TA_CONF_BOOL,
                            "0" );       
                TA_Conf_entry_init( TA_CONF_INSTRUMENT_POSIX_PROFILE,
                            "Generate a complete posix profile (including untracked streams)",
                            TA_CONF_BOOL,
                            "1" );
                TA_Conf_entry_init( TA_CONF_INSTRUMENT_POSIX_PROFILE_DUMP,
                            "Dump a posix profile at program termination (Works for non MPI programs)",
                            TA_CONF_BOOL,
                            "0" );
        //SAMPLE ANALYSIS
        TA_Conf_entry_init( TA_CONF_SAMPLE_ANALYSIS_HEADER,
                                        "#############################################\n"
                                        "#                                            #\n"
                                        "#             SAMPLE ANALYSIS                #\n"
                                        "#                                            #\n"
                                        "##############################################\n",
                                        TA_CONF_NONE,
                                        "" );
        TA_Conf_entry_init( TA_CONF_SAMPLE_ANALYSIS_ENABLED,
                            "Enable Sample Analysis (TEST MODULE ONLY)",
                            TA_CONF_BOOL,
                            "0" );
    //OTF2 ANALYSIS
    TA_Conf_entry_init( TA_CONF_OTF2_ANALYSIS_HEADER,
                    "#############################################\n"
                    "#                                            #\n"
                    "#             OTF2 ANALYSIS                  #\n"
                    "#                                            #\n"
                    "##############################################\n",
                    TA_CONF_NONE,
                    "" );
    TA_Conf_entry_init( TA_CONF_OTF2_ANALYSIS_ENABLED,
                        "Enable OTF2 Analysis",
                        TA_CONF_BOOL,
                        "0" );
    TA_Conf_entry_init( TA_CONF_OTF2_TRACE_PATH,
                        "Path to otf2 trace",
                        TA_CONF_STRING,
                        "./otf2/" );
    TA_Conf_entry_init( TA_CONF_OTF2_TRACE_NAME,
                        "Name of otf2 trace file",
                        TA_CONF_STRING,
                        "malp_output" );

}




void TA_Conf_dump( char *dest )
{
        FILE *conf = fopen( dest, "w" );

        if ( !conf ) {
                printf("Failed to open config file for write (%s)\n", dest);
                return;
        }

        int i = 0;

        for (i = 0; i < TA_CONF_KEY_COUNT; i++) {
                fprintf(conf, "\n#%s\n", TA_Conf_entries[i].desc );
                if ( TA_Conf_entries[i].type != TA_CONF_NONE ) {
                        fprintf(conf, "%s %s\n", TA_Conf_key_lablel[i],  TA_Conf_entries[i].c_value );
                }

        }

        fclose(conf);
}


void TA_Conf_load( char *source )
{
        FILE *file = fopen( source , "r" );

        if (!file) {
                //printf("INFO : Could NOT open config file, ignoring\n");
                return;
        }


        char linebuff[1500];
        char name_buff[500];
        char val_buff[1000];

        int line_count = 1;


        while ( fgets( linebuff, 500, file) ) {
                int ret = 0;
                linebuff[strlen(linebuff) - 1] = '\0'; //strip the \n

                if ( !MALP_Trace_line_begins_with_sharp(linebuff) ) {
                        if ( (ret =sscanf( linebuff, "%s %1000[^\n]s", name_buff, val_buff)) == 2 ) {
                                if ( !TA_Conf_update( name_buff, val_buff ) ) {
                                        printf("Warning @ line %d : %s \n", line_count, linebuff);
                                }
                        }

                        if( ret == 1 ) {
                                //Allows empty update ( for strings )
                                if ( (sscanf( linebuff, "%s", name_buff) == 1 ) ) {
                                        if ( !TA_Conf_update( name_buff, "" ) ) {
                                                printf("Warning @ line %d : %s \n", line_count, linebuff);
                                        }
                                }

                        }


                        if ( ret == 0 )
                                perror("Error parsing line");


                }
                line_count++;
        }

        fclose( file );
}