OTF_Event_forge.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 "OTF_Event_forge.h"
#include <stdio.h>
#include <stdlib.h>

char * OTF_Str_ids[OTF_EVENT_COUNT];

uint64_t OTF_Event_resolve_str_id( MALP_Trace_event_type type, uint64_t subtype )
{
        uint64_t base_index = 0;
        
    switch( type )
    {
                case MALP_EVENT_OTF:
                        base_index = 0;
                break;
                case MALP_EVENT_MPI:
                        base_index = MALP_OTF_ANALYSER_INFO_COUNT;
                        break;
                case MALP_EVENT_WRAPPED:
                        base_index = MALP_OTF_ANALYSER_INFO_COUNT + T_MPI_COUNT;
                        break;
                default:
                        return -1;
    }
        
        return base_index + subtype;
}



char * OTF_Event_resolve( uint64_t str_id )
{
        if( (MALP_OTF_ANALYSER_INFO_COUNT < str_id) && ( str_id < OTF_EVENT_COUNT ) )
                return OTF_Str_ids[ str_id ];
        
        return NULL;
}

int OTF_Event_set( uint64_t str_id , char * data )
{

        if( (str_id <= MALP_OTF_ANALYSER_INFO_COUNT) || ( OTF_EVENT_COUNT <= str_id ) )
                return 1;

        
        if( data )
        {
                OTF_Str_ids[ str_id ] = strdup(data);
        }
        else
        {
                free( OTF_Str_ids[ str_id ] );
                OTF_Str_ids[ str_id ] = NULL;
        }
}


void OTF_Event_forge_init()
{
        int i;

        /* Fill in OTF related Events */
        for( i = 0 ; i < MALP_OTF_ANALYSER_INFO_COUNT; i++ )
        {
                OTF_Event_set( OTF_Event_resolve_str_id( MALP_EVENT_MPI, i ) , (char *)OTF_Event_names[i] );
        }

        /* Fill in MPI events */        
        for( i = 0 ; i < T_MPI_COUNT; i++ )
        {
                OTF_Event_set( OTF_Event_resolve_str_id( MALP_EVENT_MPI, i ) , (char *)MPI_Event_names[i] );
        }
        
        /* Fill in POSIX events */
        for( i = 0 ; i < T_POSIX_COUNT; i++ )
        {
                OTF_Event_set( OTF_Event_resolve_str_id( MALP_EVENT_WRAPPED, i ) , (char *)Wrapped_symbol_names[i] );
        }

}



void OTF_Event_forge_release()
{
        int i;

        /* Clear event names */ 
        for( i = 0 ; i < OTF_EVENT_COUNT; i++ )
        {
                OTF_Event_set( i , NULL );
        }

        
}


int OTF_Event_forge( struct MALP_Trace_Event *event, OTF_Event_type enterleave,
                      MALP_Trace_event_type type, uint64_t subtype )
{
        /* First make sure this is an OTF event */
        event->type = MALP_EVENT_OTF;
        
        struct OTF_Event *otf_event = &event->event.otf;
        
        otf_event->type = enterleave;

        if( type ==  MALP_EVENT_MPI )
        {
                otf_event->category = OTF_EVENT_MPI;
        }
        else if(  type ==  MALP_EVENT_WRAPPED )
        {
                otf_event->category = OTF_EVENT_POSIX;
        }
        else
        {
                otf_event->category = OTF_EVENT_OTHER;
        }
        
        otf_event->str_id = OTF_Event_resolve_str_id( type, subtype );
        
        if( otf_event->str_id < 0 )
        {
                printf("Failed to resolve an event in %s\n", __FUNCTION__);
                return 1;
        }
        
        otf_event->src_tid = 0;
        otf_event->dest_tid = 0;
        otf_event->comm_id = 0;
        
        return 0;
}

void  OTF_Event_print( struct MALP_Trace_Event *event)
{
        if( event->type != MALP_EVENT_OTF )
        {
                printf("Not an OTF event\n");
                return;
        }
        
        struct OTF_Event *otf_event = &event->event.otf;
        
        printf("================\n");
        printf("TYPE : %s\n", (otf_event->type==OTF_EVENT_ENTER)?"ENTER":"LEAVE" );
        printf("FCT : %s(%d)\n", OTF_Event_resolve( otf_event->str_id ), otf_event->str_id );
        printf("TID : %ld\n", event->tid );
        printf("TS : %ld\n", event->timestamp );
        
        printf("================\n");
        
        
}