ts_increqendtime_resfneqyes.c

MPICH是MPI的重要研究,提供了一系列的接口函数,为并行计算的实现提供了编程环境.

#include <stdio.h>

#ifdef HAVE_SLOGCONF_H
#include "slog_config.h"
#endif
#ifdef HAVE_SLOG_WINCONFIG_H
#include "slog_winconfig.h"
#endif
#if defined( STDC_HEADERS ) || defined( HAVE_STDLIB_H )
#include <stdlib.h>
#endif
#if defined( STDC_HEADERS ) || defined( HAVE_STRING_H )
#include <string.h>
#endif
#if defined( STDC_HEADERS ) || defined( HAVE_CTYPE_H )
#include <ctype.h>
#endif

#include "slog.h"

#define  MaxNdirFrames    64
#define  FrameByteSize    320
#define  SLOG_PREVIEWNAME  "SLOG_Preview.txt"
#define  SLOG_PROFILENAME  "SLOG_Profile.txt"    /*  Not used  */
#define  USER_MARKER 

#define  MaxIdx4VarIrec   4
#define  MaxNumOfProc     4

#if 0 
#define  MaxAssocs  10
#define  MaxArgs    10
#else
#define  MaxAssocs  0
#define  MaxArgs    2
#endif

typedef struct {
    int               IsStartEvent;
    SLOG_Irec         irec;
} tagged_irec;

int event_cmp_fn( const void *event1, const void *event2 );

int event_cmp( const tagged_irec *event1, const tagged_irec *event2 );

SLOG_intvltype_t GetIntvlType( const SLOG_uint32 IdxType,
                               const SLOG_uint32 IdxAssocs,
                               const SLOG_uint32 IdxArgs );

int str_add_num_label( char *str, const char *fix_str, int num );

int main( int argc, char **argv )
{
    const char slog_name[] = "slogfile.data";

    const SLOG_intvltype_t     VarIrec_MinIdx    = 0;
    const SLOG_intvltype_t     FixIrec_MinIdx    = 1;
    const SLOG_intvltype_t     FixIrec_MaxIdx    = 5;
    const SLOG_intvltype_t     FixIrecIdxRange   = FixIrec_MaxIdx
                                                 - FixIrec_MinIdx + 1;
    /*  const SLOG_intvltype_t     VarIrec_MaxAssocs = 2 * MaxIdx4VarIrec;  */
    const SLOG_rectype_t       SLOG_RecType4OffDiagRec
                               = SLOG_RECTYPE_STATIC_OFFDIAG;
    const SLOG_intvltype_t     SLOG_IntvlType4ForwardArrow   = 998;
    const SLOG_intvltype_t     SLOG_IntvlType4BackwardArrow  = 999;
    const SLOG_bebit_t         SLOG_Bebit4OffDiagRec     = 1;
          SLOG                 slog;
          SLOG_Irec            irec;
          SLOG_Irec            prev_irec;

          int                  MaxIrec = 8;
          int                  ii, jj, idx2state, count, idx_type, ierr;
          char                 IsForwardArrow;

          /*  Variables for SLOG Thread Table  */
          SLOG_nodeID_t        node_id;
          SLOG_threadID_t      thread_id;
          SLOG_OSprocessID_t   OSprocess_id;
          SLOG_OSthreadID_t    OSthread_id;
          SLOG_appID_t         app_id;

          /*  Variables for SLOG Display Profile  */
    /*  const char                 fix_classtype[20] = "state";  */
    const char                 fix_label[20]     = "label";
    /*  const char                 fix_color[20]     = "color";  */
          char                 classtype[20]     = "state";
          char                 label[20]         = "label";
          char                 color[20]         = "color";
          char                *color_strs[20]    = { "red", "green",
                                                     "blue", "yellow",
                                                     "orange", "gold",
                                                     "RoyalBlue", "navy",
                                                     "pink", "grey",
                                                     "purple", "LimeGreen",
                                                     "brown", "NavyBlue",
                                                     "ivory", "AliceBlue",
                                                     "MistyRose", "linen",
                                                     "PeachPuff", "azure" };
          char                *arg_labels[20]    = { "arg_0", "arg_1",
                                                     "arg_2" };

          /*  Variables for SLOG Record Definition Table  */
          SLOG_intvltype_t     intvltype;
          SLOG_bebit_t         bebit_0 = 1;
          SLOG_bebit_t         bebit_1 = 1;
          SLOG_N_assocs_t      Nassocs;
          SLOG_N_args_t        Nargs;

          /*  Variables for SLOG Interval Record  */
          SLOG_rectype_t       irec_rectype;
          SLOG_intvltype_t     irec_intvltype;
          SLOG_starttime_t     irec_starttime;
          SLOG_duration_t      irec_duration;
          SLOG_time            irec_endtime;
          SLOG_bebit_t         irec_bebits[2];
          SLOG_nodeID_t        irec_orig_node;
          SLOG_cpuID_t         irec_orig_cpu;
          SLOG_threadID_t      irec_orig_thread;
          SLOG_iaddr_t         irec_instr_addr;
          SLOG_nodeID_t        irec_dest_node;
          SLOG_cpuID_t         irec_dest_cpu;
          SLOG_threadID_t      irec_dest_thread;

          SLOG_N_assocs_t      irec_Nassocs;
          SLOG_assoc_t         irec_assocs[ 100 ];
          SLOG_N_args_t        irec_Nargs;
          SLOG_arg_t           irec_args[ 100 ];
          /*  SLOG_uint32          irec_Nvtrargs = 2;  */


          /*
              Generate an array of events from a set of interval records.
          */
          tagged_irec         *events;
          SLOG_uint32          Nentries_extra_recdefs;
          SLOG_recdef_t       *recdefs_reserved;
          SLOG_recdef_t       *recdef;
          SLOG_intvlinfo_t    *intvlinfos_reserved;
          SLOG_intvlinfo_t    *intvlinfo;

    /*
        Change the Number of Interval Records created in slogfile based on
        command line argument
    */
    if ( argc > 1 ) {
        printf( "argv[1] = _%s_\n", argv[1] );
        if ( isdigit( (int) argv[1][0] ) )  MaxIrec = atoi( argv[1] );
    }

    /*  MaxIrec = 15;  */

    /*  Initialization  */
    for ( jj = 0; jj < MaxAssocs; jj++ ) irec_assocs[ jj ] = jj+1;
    for ( jj = 0; jj < MaxArgs; jj++ )   irec_args[ jj ] = jj+1;
    irec_starttime = 0.0;
    irec_duration  = 0.0;

    /*  Get a handle to the SLOG_STREAM data structure  */
    slog = SLOG_OpenOutputStream( slog_name );

    /*
        Tell the API the properties of the slog file by using SLOG_SetXXXX()
    */

    /*  Set the maimum number of frames per directory in slog file  */
    SLOG_SetMaxNumOfFramesPerDir( slog, MaxNdirFrames );

    /*  Set the byte size per frame  */
    SLOG_SetFrameByteSize( slog, FrameByteSize );

    /*  Set the reserved space in each frame  */
    /*  SLOG_SetFrameReservedSpace( slog, SLOG_typesz[ min_IntvlRec ] );  */
    /*  Here SLOG_Irec_ReserveSpace() will be used, so set 0 reserve space  */
    SLOG_SetFrameReservedSpace( slog, 0 );

    /*  Set the flag for the time order arrangement of the interval record  */
    /*  SLOG_SetIncreasingStarttimeOrder( slog );  */
    SLOG_SetIncreasingEndtimeOrder( slog ); 

    /*
        Set the SLOG Preview to be read from a given file, filename,
        and then init SLOG's Preview section
    */ 
    /*  SLOG_SetPreviewName( slog, SLOG_PREVIEWNAME );  */
    SLOG_SetPreviewName( slog, "/dev/null" );

    /*
        This is an optional call to set the Preview Statistics's array
        size, if this function is NOT called, the default size
        SLOG_PSTAT_STATSIZE_MAX will be used.
    */
    SLOG_SetPreviewStatisticsSize( slog, 20 );

#if defined( USER_MARKER )
    Nentries_extra_recdefs = 2;
    recdefs_reserved    = ( SLOG_recdef_t * )
                          malloc( Nentries_extra_recdefs
                                * sizeof ( SLOG_recdef_t ) );
    intvlinfos_reserved = ( SLOG_intvlinfo_t * )
                          malloc( Nentries_extra_recdefs
                                * sizeof ( SLOG_intvlinfo_t ) );
#else
    Nentries_extra_recdefs = 0;
    recdefs_reserved = NULL;
    intvlinfos_reserved = NULL;
#endif


    /*  Initialize the SLOG Thread Table  */
    if ( SLOG_TTAB_Open( slog ) != SLOG_SUCCESS ) {
        fprintf( errfile, __FILE__":Main() - SLOG_TTAB_Open() fails!\n" );
        fflush( errfile );
        exit( 1 );
    }

    /*  Add the entries of SLOG Thread Table  */
    for ( ii = 0; ii < MaxIrec; ii++ ) {
        node_id      = ii % MaxNumOfProc;
        thread_id    = ii / MaxNumOfProc;
        OSprocess_id = ii % ( MaxNumOfProc / 2 );
        OSthread_id  = ii % ( MaxNumOfProc * 2 );
        app_id       = node_id;
        ierr = SLOG_TTAB_AddThreadInfo( slog, node_id, thread_id,
                                        OSprocess_id, OSthread_id, app_id );
        if ( ierr != SLOG_SUCCESS ) {
            fprintf( errfile, __FILE__"Main() - "
                              "SLOG_TTAB_AddTheadInfo() fails!\n" ); 
            fflush( errfile );
            /*  exit( 1 );  */
        }
    }

    /*  Finalize the Record Definition Table in SLOG file  */
    ierr = SLOG_TTAB_Close( slog );
    if ( ierr != SLOG_SUCCESS ) {
        fprintf( errfile, __FILE__"Main() - "
                          "SLOG_TTAB_Close() fails!\n" ); 
        fflush( errfile );
        exit( 1 );
    } 
    
    /*  Set the SLOG Display Profile with a given filename and init SLOG  */
    /*  SLOG_SetProfileName( slog, SLOG_PROFILENAME );  */

    /*  Initialize the SLOG Display Profile Table  */
    if ( SLOG_PROF_Open( slog ) != SLOG_SUCCESS ) {
        fprintf( errfile, __FILE__":Main() - SLOG_PROF_Open() fails\n " );
        fflush( errfile );
        exit( 1 );
    }

    /*  Create the Indexes for Message Record's display profile  */
    ierr = SLOG_PROF_AddIntvlInfo( slog, SLOG_IntvlType4ForwardArrow,
                                   SLOG_Bebit4OffDiagRec, SLOG_Bebit4OffDiagRec,
                                   "Message", "Forward Arrow", "white", 0 );
    if ( ierr != SLOG_SUCCESS ) {
        fprintf( errfile, __FILE__":Main() - "
                          "SLOG_PROF_AddIntvlInfo( ForwardArrow ) fails!\n" );
        fflush( errfile );
        exit( 1 );
    }

    ierr = SLOG_PROF_AddIntvlInfo( slog, SLOG_IntvlType4BackwardArrow,
                                   SLOG_Bebit4OffDiagRec, SLOG_Bebit4OffDiagRec,
                                   "Message", "Backward Arrow", "grey", 0 );
    if ( ierr != SLOG_SUCCESS ) {
        fprintf( errfile, __FILE__":Main() - "
                          "SLOG_PROF_AddIntvlInfo( BackwardArrow ) fails!\n" );
        fflush( errfile );
        exit( 1 );
    }


    count = -1;
    /*  Create the Indexes for Variable Interval's display profile  */
    Nargs = 0;    /*  Initialization, does NOT mean anything  */
    for ( Nassocs = 0; Nassocs <= MaxAssocs; Nassocs++ ) {
        count++;
        intvltype = GetIntvlType( VarIrec_MinIdx, Nassocs, Nargs );
        str_add_num_label( label, fix_label, count );
        /*  str_add_num_label( color, fix_color, count );  */
        strcpy( color, color_strs[ count ] );
        ierr = SLOG_PROF_AddIntvlInfo( slog, intvltype, bebit_0, bebit_1,