Posix_Profile.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 "Posix_Profile.h"
#include "VMPI.h"

#include <stdlib.h>
#include <stdio.h>
#include <mpi.h>

#include "Timer.h"

#include "Posix_Wrapp.h"


struct Profile_Entry __POSIX_Profile_entries[T_POSIX_COUNT]; 


void Profile_Entry_init( struct Profile_Entry *ent, Wrapped_symbol id )
{
        //bzero( ent, sizeof(struct Profile_Entry) );
        ent->id = id;
}

void Profile_Entry_release( struct Profile_Entry *ent )
{
        bzero( ent, sizeof(struct Profile_Entry) );
}

void POSIX_profile_init()
{
        /* Fill Profile entries with Zeroes */
        int i;
        
        for( i = 0 ; i < T_POSIX_COUNT; i++ )
                Profile_Entry_init( &__POSIX_Profile_entries[i], i );
        
        TEST_LOAD_SYMBOL( qsort );
        TEST_LOAD_SYMBOL( malloc );
        TEST_LOAD_SYMBOL( free );
}

void POSIX_profile_release()
{
        int i;
        
        for( i = 0 ; i < T_POSIX_COUNT; i++ )
                Profile_Entry_release( &__POSIX_Profile_entries[i] );
}


void POSIX_profile_reduce()
{
        /* Allocate arrays to perform the reduction */
        uint64_t * hits = REAL(malloc)( sizeof( uint64_t ) * T_POSIX_COUNT );
        uint64_t * time = REAL(malloc)( sizeof( uint64_t ) * T_POSIX_COUNT );
        int64_t *  size = REAL(malloc)( sizeof( uint64_t ) * T_POSIX_COUNT );
        
        uint64_t * out_hits = REAL(malloc)( sizeof( uint64_t ) * T_POSIX_COUNT );
        uint64_t * out_time = REAL(malloc)( sizeof( uint64_t ) * T_POSIX_COUNT );
        int64_t *  out_size = REAL(malloc)( sizeof( uint64_t ) * T_POSIX_COUNT );
        
        if( !hits||!time||!size||!out_hits||!out_time||!out_size)
        {
                perror("malloc");
                printf("Failled to allocate array\n");
                abort();
        }
        
        
        /* Copy back datas */
        int i;
        
        for( i = 0 ; i < T_POSIX_COUNT; i++ )
        {
                hits[i] = __POSIX_Profile_entries[i].hits;
                time[i] = __POSIX_Profile_entries[i].time;
                size[i] = __POSIX_Profile_entries[i].size;
        }
        
        /* Perform the reduction to rank 0 */
        PMPI_Allreduce(hits, out_hits, T_POSIX_COUNT, MPI_UNSIGNED_LONG_LONG, MPI_SUM, VMPI_Get_partition_comm());
        PMPI_Allreduce(time, out_time, T_POSIX_COUNT, MPI_UNSIGNED_LONG_LONG, MPI_SUM, VMPI_Get_partition_comm());
        PMPI_Allreduce(size, out_size, T_POSIX_COUNT, MPI_LONG_LONG, MPI_SUM, VMPI_Get_partition_comm());


        /* Copy back */
        for( i = 0 ; i < T_POSIX_COUNT; i++ )
        {
                __POSIX_Profile_entries[i].hits = out_hits[i];
                __POSIX_Profile_entries[i].time = out_time[i];
                __POSIX_Profile_entries[i].size = out_size[i];
        }
        
        /* Free datas */
        REAL(free)( hits );
        REAL(free)( time );
        REAL(free)( size );
        REAL(free)( out_hits );
        REAL(free)( out_time );
        REAL(free)( out_size );
}

int Profile_Entry_sort(const void *a, const void *b)
{
        struct Profile_Entry  *sa = (struct Profile_Entry  *) a;
        struct Profile_Entry  *sb = (struct Profile_Entry  *) b;
        
        if( !sa || !sb )
                return 0;
        
        if( sb->time < sa->time )
                return -1;
        
        if( sa->time < sb->time )
                return 1;
                
        if( sb->time == sa->time )
                return 0;
}

void POSIX_profile_render()
{
        struct Profile_Entry *entries = REAL(malloc)( sizeof( struct Profile_Entry ) * T_POSIX_COUNT );
        
        if( !entries )
        {
                perror("malloc");
                return;
        }
        
        /* Fill the array to be sorted */
        memcpy( entries, __POSIX_Profile_entries , sizeof( struct Profile_Entry ) * T_POSIX_COUNT );
        
        /* Sort the array in terms of total time */
        REAL(qsort)(entries, T_POSIX_COUNT, sizeof( struct Profile_Entry ) , Profile_Entry_sort);
        
        /* Perform the output */
        int i;
        
        printf("POSIX profile ======================================\n");
        
        for( i = 0 ; i < T_POSIX_COUNT ; i++ )
        {
                if( !entries[i].hits )
                        continue;
                
                printf("\t%s hits: %llu time: %.2g sec (%llu ticks) ", Wrapped_symbol_names[entries[i].id], entries[i].hits, (double)entries[i].time/Timer_second(), entries[i].time );
                
                if( entries[i].size )
                        printf("size: %lld", entries[i].size );
                else
                        printf("\n");
        }
        
        printf("===================================================\n");
        
        /* Free the array */
        REAL(free)( entries );
}


void POSIX_profile_serialize()
{
        
        
}