Basic_Events.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 BASIC_EVENT_TYPES
#define BASIC_EVENT_TYPES

#include <string.h>

typedef enum
{
        C_NONE,
        C_MPI,
        C_COUNT
}Event_category;


typedef enum
{
                T_NONE,
                T_MPI_COMMON,
                T_MPI_COLL,
                T_MPI_ONE_SIDED,
                T_MPI_P2P,
                T_MPI_KEY,
                T_MPI_OP,
                T_MPI_REQ_AND_STAT,
                T_MPI_INFO,
                T_MPI_ERROR,
                T_MPI_ASYNC,
                T_MPI_IO,
                T_MPI_COMM_AND_GROUPS,
                T_MPI_TOPO,
                T_MPI_TYPES_AND_PACKS,
        T_COUNT
} Event_type;


static const char *const Event_types_datas[T_COUNT][3] =
{ 
        { "Unknown" , "" , "T_NONE" },
        { "MPI Common" , "" , "T_MPI_COMMON" },
        { "MPI Collectives" , "" , "T_MPI_COLL" },
        { "MPI One sided" , "" , "T_MPI_ONE_SIDED" },
        { "MPI Point to point" , "" , "T_MPI_P2P" },
        { "MPI Key management" , "" , "T_MPI_KEY" },
        { "MPI Operations" , "" , "T_MPI_OP" },
        { "MPI Request and status management" , "" , "T_MPI_REQ_AND_STAT" },
        { "MPI Info" , "" , "T_MPI_INFO" },
        { "MPI Error handling" , "" , "T_MPI_ERROR" },
        { "MPI Asynchronous communications" , "" , "T_MPI_ASYNC" },
        { "MPI IO" , "" , "T_MPI_IO" },
        { "MPI Communicators and groups" , "" , "T_MPI_COMM_AND_GROUPS" },
        { "MPI Topology management" , "" , "T_MPI_TOPO" },
        { "MPI Type and pack handling" , "", "T_MPI_TYPES_AND_PACKS" }
};

static inline Event_type Event_types_parse( char *type )
{
        if( !type )
                return T_NONE;
        
        int i;
        
        for( i = 0 ; i < T_COUNT ; i++ )
        {
                if( !strcmp( type, Event_types_datas[i][2] ) )
                        return 1;

        }
        
        return T_NONE;
}


/* MPI Members */

static const char *const MPI_COMMON[] =
{
        "MPI_Finalize",
        "MPI_Finalized",
        "MPI_Abort",
        "MPI_Init",
        "MPI_Initialized",
        "MPI_Init_thread",
        "MPI_Get_count",
        "MPI_Get_elements",
        "MPI_Get_processor_name",
        "MPI_Get_version",
        "MPI_Is_thread_main",
        "MPI_Query_thread",
        "MPI_Pcontrol",
        "MPI_Wtick",
        "MPI_Wtime",
        NULL
};
static const char *const MPI_COLL[] =
{
        "MPI_Allgather",
        "MPI_Allgatherv",
        "MPI_Allreduce",
        "MPI_Alltoall",
        "MPI_Alltoallv",
        "MPI_Alltoallw",
        "MPI_Barrier",
        "MPI_Bcast",
        "MPI_Exscan",
        "MPI_Gather",
        "MPI_Gatherv",
        "MPI_Reduce",
        "MPI_Reduce_local",
        "MPI_Reduce_scatter",
        "MPI_Scan",
        "MPI_Scatter",
        "MPI_Scatterv",
        NULL
};

static const char *const MPI_ONE_SIDED[] =
{
        "MPI_Accumulate",
        "MPI_Address",
        "MPI_Alloc_mem",
        "MPI_Free_mem",
        "MPI_Get_address",
        "MPI_Get",
        "MPI_Put",
        "MPI_Win_call_errhandler",
        "MPI_Win_complete",
        "MPI_Win_create",
        "MPI_Win_create_errhandler",
        "MPI_Win_create_keyval",
        "MPI_Win_delete_attr",
        "MPI_Win_fence",
        "MPI_Win_free",
        "MPI_Win_free_keyval",
        "MPI_Win_get_attr",
        "MPI_Win_get_errhandler",
        "MPI_Win_get_group",
        "MPI_Win_get_name",
        "MPI_Win_lock",
        "MPI_Win_post",
        "MPI_Win_set_attr",
        "MPI_Win_set_errhandler",
        "MPI_Win_set_name",
        "MPI_Win_start",
        "MPI_Win_test",
        "MPI_Win_unlock",
        "MPI_Win_wait",
        NULL
};

static const char *const MPI_P2P[] =
{
        "MPI_Bsend",
        "MPI_Bsend_init",
        "MPI_Buffer_attach",
        "MPI_Buffer_detach",
        "MPI_Ibsend",
        "MPI_Recv_init",
        "MPI_Recv",
        "MPI_Rsend",
        "MPI_Rsend_init",
        "MPI_Send_init",
        "MPI_Send",
        "MPI_Sendrecv",
        "MPI_Sendrecv_replace",
        "MPI_Ssend_init",
        "MPI_Ssend",
        "MPI_Start",
        "MPI_Startall",
        NULL
};

static const char *const MPI_KEY[] =
{
        "MPI_Attr_delete",
        "MPI_Attr_get",
        "MPI_Attr_put",
        "MPI_Keyval_create",
        "MPI_Keyval_free",
        NULL
};

static const char *const MPI_OP[] =
{
        "MPI_Op_c2f",
        "MPI_Op_commutative",
        "MPI_Op_create",
        "MPI_Op MPI_Op_f2c",
        "MPI_Op_free",
        NULL
};

static const char *const MPI_REQ_AND_STAT[] =
{
        "MPI_Grequest_complete",
        "MPI_Grequest_start",
        "MPI_Request_free",
        "MPI_Request_get_status",
        "MPI_Status_set_cancelled",
        "MPI_Status_set_elements",
        NULL
};

static const char *const MPI_INFO[] =
{
        "MPI_Info_create",
        "MPI_Info_delete",
        "MPI_Info_dup",
        "MPI_Info_free",
        "MPI_Info_get",
        "MPI_Info_get_nkeys",
        "MPI_Info_get_nthkey",
        "MPI_Info_get_valuelen",
        "MPI_Info_set",
        NULL
};

static const char *const MPI_ERROR[] =
{
        "MPI_Add_error_class",
        "MPI_Add_error_code",
        "MPI_Add_error_string",
        "MPI_Dims_create",
        "MPI_Errhandler_create",
        "MPI_Errhandler_free",
        "MPI_Errhandler_get",
        "MPI_Errhandler_set",
        "MPI_Error_class",
        "MPI_Error_string",
        NULL
};

static const char *const MPI_ASYNC[] =
{
        "MPI_Cancel",
        "MPI_Ibsend",
        "MPI_Iprobe",
        "MPI_Irecv",
        "MPI_Irsend",
        "MPI_Isend",
        "MPI_Issend",
        "MPI_Probe",
        "MPI_Testall",
        "MPI_Testany",
        "MPI_Test",
        "MPI_Test_cancelled",
        "MPI_Testsome",
        "MPI_Waitall",
        "MPI_Waitany",
        "MPI_Wait",
        "MPI_Waitsome",
        NULL
};

static const char *const MPI_IO[] =
{
        "MPI_File_call_errhandler",
        "MPI_File_create_errhandler",
        "MPI_File_set_errhandler",
        "MPI_File_get_errhandler",
        "MPI_File_open",
        "MPI_File_close",
        "MPI_File_delete",
        "MPI_File_set_size",
        "MPI_File_preallocate",
        "MPI_File_get_size",
        "MPI_File_get_group",
        "MPI_File_get_amode",
        "MPI_File_set_info",
        "MPI_File_get_info",
        "MPI_File_set_view",
        "MPI_File_get_view",
        "MPI_File_read_at",
        "MPI_File_read_at_all",
        "MPI_File_write_at",
        "MPI_File_write_at_all",
        "MPI_File_iread_at",
        "MPI_File_iwrite_at",
        "MPI_File_read",
        "MPI_File_read_all",
        "MPI_File_write",
        "MPI_File_write_all",
        "MPI_File_iread",
        "MPI_File_iwrite",
        "MPI_File_seek",
        "MPI_File_get_position",
        "MPI_File_get_byte_offset",
        "MPI_File_read_shared",
        "MPI_File_write_shared",
        "MPI_File_iread_shared",
        "MPI_File_iwrite_shared",
        "MPI_File_read_ordered",
        "MPI_File_write_ordered",
        "MPI_File_seek_shared",
        "MPI_File_get_position_shared",
        "MPI_File_read_at_all_begin",
        "MPI_File_read_at_all_end",
        "MPI_File_write_at_all_begin",
        "MPI_File_write_at_all_end",
        "MPI_File_read_all_begin",
        "MPI_File_read_all_end",
        "MPI_File_write_all_begin",
        "MPI_File_write_all_end",
        "MPI_File_read_ordered_begin",
        "MPI_File_read_ordered_end",
        "MPI_File_write_ordered_begin",
        "MPI_File_write_ordered_end",
        "MPI_File_get_type_extent",
        "MPI_File_set_atomicity",
        "MPI_File_get_atomicity",
        "MPI_File_sync",
        NULL
};

static const char *const MPI_COMM_AND_GROUPS[] =
{
        "MPI_Intercomm_create",
        "MPI_Intercomm_merge",
        "MPI_Lookup_name",
        "MPI_Open_port",
        "MPI_Close_port",
        "MPI_Comm_accept",
        "MPI_Comm_call_errhandler",
        "MPI_Comm_compare",
        "MPI_Comm_connect",
        "MPI_Comm_create_errhandler",
        "MPI_Comm_create_keyval",
        "MPI_Comm_create",
        "MPI_Comm_delete_attr",
        "MPI_Comm_disconnect",
        "MPI_Comm_dup",
        "MPI_Comm_free_keyval",
        "MPI_Comm_free",
        "MPI_Comm_get_attr",
        "MPI_Comm_get_errhandler",
        "MPI_Comm_get_name",
        "MPI_Comm_get_parent",
        "MPI_Comm_group",
        "MPI_Comm_join",
        "MPI_Comm_rank",
        "MPI_Comm_remote_group",
        "MPI_Comm_remote_size",
        "MPI_Comm_set_attr",
        "MPI_Comm_set_errhandler",
        "MPI_Comm_set_name",
        "MPI_Comm_size",
        "MPI_Comm_spawn",
        "MPI_Comm_spawn_multiple",
        "MPI_Comm_split",
        "MPI_Comm_test_inter",
        "MPI_Group_compare",
        "MPI_Group_difference",
        "MPI_Group_excl",
        "MPI_Group_free",
        "MPI_Group_incl",
        "MPI_Group_intersection",
        "MPI_Group_range_excl",
        "MPI_Group_range_incl",
        "MPI_Group_rank",
        "MPI_Group_size",
        "MPI_Group_translate_ranks",
        "MPI_Group_union",
        "MPI_Publish_name",
        "MPI_Unpublish_name",
        NULL
};

static const char *const MPI_TOPO[] =
{
        "MPI_Graph_create",
        "MPI_Graph_get",
        "MPI_Graph_map",
        "MPI_Graph_neighbors_count",
        "MPI_Graph_neighbors",
        "MPI_Graphdims_get",
        "MPI_Cart_coords",
        "MPI_Cart_create",
        "MPI_Cart_get",
        "MPI_Cart_map",
        "MPI_Cart_rank",
        "MPI_Cart_shift",
        "MPI_Cart_sub",
        "MPI_Cartdim_get",
        "MPI_Topo_test",
        NULL
};

static const char *const MPI_TYPES_AND_PACKS[] =
{
        "MPI_Pack_external",
        "MPI_Pack_external_size",
        "MPI_Pack",
        "MPI_Pack_size",
        "MPI_Register_datarep",
        "MPI_Type_commit",
        "MPI_Type_contiguous",
        "MPI_Type_create_darray",
        "MPI_Type_create_f90_complex",
        "MPI_Type_create_f90_integer",
        "MPI_Type_create_f90_real",
        "MPI_Type_create_hindexed",
        "MPI_Type_create_hvector",
        "MPI_Type_create_keyval",
        "MPI_Type_create_indexed_block",
        "MPI_Type_create_struct",
        "MPI_Type_create_subarray",
        "MPI_Type_create_resized",
        "MPI_Type_delete_attr",
        "MPI_Type_dup",
        "MPI_Type_extent",
        "MPI_Type_free",
        "MPI_Type_free_keyval",
        "MPI_Type_get_attr",
        "MPI_Type_get_contents",
        "MPI_Type_get_envelope",
        "MPI_Type_get_extent",
        "MPI_Type_get_name",
        "MPI_Type_get_true_extent",
        "MPI_Type_hindexed",
        "MPI_Type_hvector",
        "MPI_Type_indexed",
        "MPI_Type_lb",
        "MPI_Type_match_size",
        "MPI_Type_set_attr",
        "MPI_Type_set_name",
        "MPI_Type_size",
        "MPI_Type_struct",
        "MPI_Type_ub",
        "MPI_Type_vector",
        "MPI_Unpack",
        "MPI_Unpack_external",
        NULL
};


static const char * const * const Event_types_members[T_COUNT] =
{ 
        NULL,
        MPI_COMMON,
        MPI_COLL,
        MPI_ONE_SIDED,
        MPI_P2P,
        MPI_KEY,
        MPI_OP,
        MPI_REQ_AND_STAT,
        MPI_INFO,
        MPI_ERROR,
        MPI_ASYNC,
        MPI_IO,
        MPI_COMM_AND_GROUPS,
        MPI_TOPO,
        MPI_TYPES_AND_PACKS
};


static const Event_category Event_types_cat[T_COUNT] =
{
        C_NONE,
        C_MPI,
        C_MPI,
        C_MPI,
        C_MPI,
        C_MPI,
        C_MPI,
        C_MPI,
        C_MPI,
        C_MPI,
        C_MPI,
        C_MPI,
        C_MPI,
        C_MPI,
        C_MPI
};












#endif /* BASIC_EVENT_TYPES */