main.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 "MPI_Events.h"
#include <stdio.h>
#include <mpi.h>
#include <pthread.h>
#include "VMPI.h"
#include "Timer.h"
#include "Trace_Comm.h"
#include "Sync_Time_MPI.h"
#include "Stream_MGR.h"
#include "Event_Pack.h"
#include "Posix_Wrapp.h"
#include "MALP_Config.h"
#include "config.h"
#include "Posix_Profile.h"


#include "Debug.h"

#include <execinfo.h>
#include <signal.h>
#include <stdlib.h>


#include <signal.h>
#include <execinfo.h>



void Config_Setup(int rank)
{       
        if( !rank )
        {
                char * conf_path = getenv("MALP_CONF");
                
                if( !conf_path )
                {
                        TA_Conf_load("./malp_an.conf");
                }
                else
                {
                        TA_Conf_load(conf_path);
                }

                /* We now overrride defaults from ENV */
                TA_Conf_init_from_env();
        }
        
        TA_Conf_dispatch();
}



void Instrumentation_Constructor()  __attribute__ ((constructor));

void Instrumentation_Constructor()
{
        TA_Conf_init_default();
        Posix_Wrapp_init();
        TEST_LOAD_SYMBOL(sleep);
        Timer_Init_scale( REAL(sleep) );
        Wrapp_enable();
}


static int is_an_mpi_program = 0;

void Instrumentation_Destructor()  __attribute__ ((destructor));

void Instrumentation_Destructor()
{
        Wrapp_disable();
        if( ! is_an_mpi_program && TA_Conf_get_key_bool( TA_CONF_INSTRUMENT_POSIX_PROFILE_DUMP) )
        {
                POSIX_profile_render();
        }
}





int  MPI_Init(int * argc, char *** argv)
{
        int d;
        return MPI_Init_thread(argc , argv ,MPI_THREAD_SINGLE ,&d);
}


static const char * MALP_VERSION = "2.1";

#if MPMD_SUPPORTED==0
//In this case we are linked with the analyzer
extern int analyzer_main( int argc, char **argv );
#endif


int MPI_Init_thread(int *argc ,char ***argv ,int required ,int * provided)
{
        int ret;
        
        is_an_mpi_program = 1;

        Stream_Infos_enter_mpi();
        if( (ret = PMPI_Init_thread(argc, argv, required, provided)) != MPI_SUCCESS )
                return ret;
        Stream_Infos_leave_mpi();

#if MPMD_SUPPORTED==0
        VMPI_Set_trace_trampoline( "Analyzer", analyzer_main );
        
        /* Rebuild ARGV for fortran programs */
        int new_argc = 1;
        
        char *prog_name = NULL;
        
        if( argv && *argv )
        {
                prog_name = (*argv)[0];
        }
        else
        {
                /* If no name give one =) */
                prog_name = "Program";
        }
        
        char ** new_argv = malloc( 2 * sizeof( char * ) );
        
        if( ! new_argv )
        {
                abort();
        }
        
        new_argv[0] = strdup( prog_name );
        new_argv[1] = NULL;
        
        
        VMPI_Init(&new_argc, &new_argv);
#else
        VMPI_Init(argc, argv);
#endif

        /* Init trace communicator */
        Trace_Comm_init();
        /* Sync Timestamps */
        sync_mpi();

        
        int rank = 0;

        Stream_Infos_enter_mpi();
        PMPI_Comm_rank(VMPI_Get_partition_comm(), &rank);
        Stream_Infos_leave_mpi();
        
        Config_Setup(rank);

        VMPI_Partition_desc *desc = VMPI_Get_desc_by_id(0);
        VMPI_Partition_desc *current_dest = VMPI_Get_desc();
        
        int displays_banner = 0;

        if(!strcmp(desc->name, "Analyzer"))
        {
                displays_banner = 1;
        }


        if( (rank == current_dest->root_id) 
        && (VMPI_Get_partition_id() == displays_banner) 
        && (TA_Conf_get_key_bool( TA_CONF_DISPLAY_BANNER) || TA_Conf_get_key_bool(TA_CONF_VERBOSE_OUTPUT)) )
        {
                fprintf(stderr,"\033[1;31m=====================================================\033[0m\n");
                fprintf(stderr,"\033[1;31m#       #     ########     #          #######\033[0m\n");
                fprintf(stderr,"\033[1;31m# #   # #     #      #     #          #     #\033[0m\n");
                fprintf(stderr,"\033[1;31m#   #   #     #      #     #          #     #\033[0m\n");
                fprintf(stderr,"\033[1;31m#       #     ########     #          #######\033[0m\n");
                fprintf(stderr,"\033[1;31m#       #     #      #     #          #\033[0m\n");
                fprintf(stderr,"\033[1;31m#       #     #      #     #          #\033[0m\n");
                fprintf(stderr,"\033[1;31m#       #     #      #     #######    #\033[0m\n");
                fprintf(stderr,"\033[1;31m=============================================== \033[36m%s\033[0m \033[1;31m=\033[0m\n", MALP_VERSION);
        }

        /* Initialize event stream */
        Event_Packer_init();
        
        /* Initialize Stream Manager */
        Stream_Manager_init();
        
        /* Fill in root infos */
        struct Stream_Infos *sd = Stream_MGR_new_stream( NULL, MALP_PROCESS );
        
        if( !sd )
        {
                printf("Failed to initialize stream infos\n");
                PMPI_Abort(VMPI_Get_partition_comm(), 1);
        }

        Stream_infos_set(sd);

        return ret;
}


void Render_POSIX_profile()
{
        if( !TA_Conf_get_key_bool( TA_CONF_INSTRUMENT_POSIX_PROFILE_DUMP) )
                return;
        
        /* Reduce POSIX profile */
        POSIX_profile_reduce();
        int rank = 0;

        Stream_Infos_enter_mpi();
        PMPI_Comm_rank(VMPI_Get_partition_comm(), &rank);
        Stream_Infos_leave_mpi();       
        
        if( !rank )
                POSIX_profile_render();
}


int MPI_Finalize()
{
        int ret;

        /* Disable Event notification */
        Wrapp_disable();
        
        /* Render POSIX profile (if needed ) */
        Render_POSIX_profile();
        
        /* Signal end */
        Stream_MGR_end_stream();

        /* Release Stream Manager */
        Stream_Manager_release();

        /* Release event stream */
        Event_Packer_release();

        /* Release trace communicator */
        Trace_Comm_release();

        Stream_Infos_enter_mpi();

        Stream_Infos_leave_mpi();

        /* Release VMPI */
        VMPI_Release();

        ret = PMPI_Finalize();

        return ret;
}