VMPI.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               # */
/* #                                                                      # */
/* ######################################################################## */

#ifndef VMPI
#define VMPI


#include <mpi.h>

#ifdef __cplusplus
extern "C" {
#endif

#include <limits.h>
#include <string.h>
#include <stdio.h>

#define VMPI_NG_ARBITRARY_VALUE 0x1234567llu

#define VMPI_NG_MAXIMUM_TAGS 1000000

#define MPI_COMM_UNIVERSE ((MPI_Comm)VMPI_NG_ARBITRARY_VALUE)

enum VMPI_Return_Status
{
        VMPI_EAGAIN=-3,         
        VMPI_ERROR=-2,          
        VMPI_MEM=-1,            
        VMPI_SUCCESS=0          
};

int VMPI_Enabled();

int VMPI_Init(int * argc, char ***argv);

int VMPI_Release();

#define VMPI_PNAME_LEN 200

#define VMPI_COMMAND_LEN 1024

typedef struct 
{
        int id;                                                                 
        int root_id;                                                    
        int size;                                                               
        char name[200];                                                 
        char program_name[VMPI_PNAME_LEN];              
        char command_line[VMPI_COMMAND_LEN];    
        MPI_Comm partition_comm;                
}VMPI_Partition_desc;


struct VMPI_Status
{
        int mypartition;                            
        int numpartitions;                          
        int (*vmpi_trampoline)( int argc, char **argv );
        char trampoline_partition_name[200];
        char partition_name[200];                   
        int current_tag;                                                        
        int vmpi_enabled;                           
        MPI_Comm vmpi_communicator;                 
        VMPI_Partition_desc *partition_descs;       
};

extern struct VMPI_Status __vmpi_status;

static inline int VMPI_Get_partition_id()
{
        return __vmpi_status.mypartition;
}


static inline VMPI_Partition_desc *VMPI_Get_desc()
{
        int id = VMPI_Get_partition_id();
        return &__vmpi_status.partition_descs[id];
}


static inline int VMPI_Get_partition_count()
{
        return __vmpi_status.numpartitions;
}

static inline MPI_Comm VMPI_Get_partition_comm()
{
        return VMPI_Get_desc()->partition_comm;
}

static inline int VMPI_Set_partition_name( char *name )
{
        snprintf(__vmpi_status.partition_name, 200, "%s" , name );
        return VMPI_SUCCESS;
}


static inline int VMPI_Set_trace_trampoline( char *trampoline_partition,
                                                                                     int (*vmpi_trampoline)( int argc, char **argv ) )
{
        if( !vmpi_trampoline || !trampoline_partition )
                return 1;
                
        
        strncpy( __vmpi_status.trampoline_partition_name, trampoline_partition, 200 );
        __vmpi_status.vmpi_trampoline = vmpi_trampoline;
        
        return 0;
}

static inline int VMPI_In_trampoline()
{
        if( __vmpi_status.vmpi_trampoline != NULL )
        {
                if( VMPI_Get_partition_id() == 1 )
                        return 1;
        }
        
        return 0;
}
                                                                                    


static inline VMPI_Partition_desc *VMPI_Get_desc_by_name(char *name)
{
        int i;

        for( i = 0 ; i < VMPI_Get_partition_count() ; i++ )
        {
                if( !strcmp( __vmpi_status.partition_descs[i].name, name ) )
                        return &__vmpi_status.partition_descs[i];
        }

        return NULL;
}

static inline VMPI_Partition_desc *VMPI_Get_desc_by_id(int id)
{
        if( VMPI_Get_partition_count() <= id )
                return NULL;

        return &__vmpi_status.partition_descs[id];

}



void VMPI_Display_desc(VMPI_Partition_desc *desc);

void VMPI_Display_descs();

typedef enum
{
        VMPI_MAP_FIXED,                 
        VMPI_MAP_RANDOM,                
        VMPI_MAP_ROUND_ROBIN    
}VMPI_Map_mode;


typedef struct
{
        int count;              
        int *ranks;             
}VMPI_Map;

static inline void VMPI_Map_clear( VMPI_Map *map )
{
        map->count = 0;
        map->ranks = NULL;
}

int VMPI_Map_partitions( int target_partition, VMPI_Map_mode mode, VMPI_Map *map );
void VMPI_Print_map( VMPI_Map *map );
static inline MPI_Comm VMPI_Get_vmpi_comm()
{
        if( !VMPI_Enabled())
                return MPI_COMM_WORLD;

        return __vmpi_status.vmpi_communicator;
}


int VMPI_get_new_tag();

#include "VMPI_stream.h"

#ifdef __cplusplus
}
#endif

#endif /*VMPI*/