ts_increqendtime_resfneqyes.c

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

                                       classtype, label, color, 0 );
        if ( ierr != SLOG_SUCCESS ) {
            fprintf( errfile, __FILE__":Main() - "
                              "SLOG_PROF_AddIntvlInfo( Variable ) fails!\n" );
            fflush( errfile );
            exit( 1 );
        }
    }

    /*  Create the Indexes for Fixed Interval Record's display profile  */
    for ( idx_type   = FixIrec_MinIdx;
          idx_type  <= FixIrec_MaxIdx;
          idx_type++ ) {
        for ( Nassocs = 0; Nassocs <= MaxAssocs; Nassocs++ ) {
            for ( Nargs = 0; Nargs <= MaxArgs; Nargs++ ) {
                count++;
                intvltype = GetIntvlType( idx_type, Nassocs, Nargs );
                /*
                printf( "PROF : idx_type = %d, Nargs = %d, intvltype = %d \n",
                        idx_type, Nargs, intvltype );
                */
                str_add_num_label( label, fix_label, count );
                /*  str_add_num_label( color, fix_color, count );  */
                strcpy( color, color_strs[ count ] );
#if 0
                switch ( Nargs ) {
                case 1 :
                    ierr = SLOG_PROF_AddIntvlInfo( slog,
                                                   intvltype, bebit_0, bebit_1,
                                                   classtype, label, color, 1,
                                                   "arg0" );
                    break;
                case 2 :
                    ierr = SLOG_PROF_AddIntvlInfo( slog,
                                                   intvltype, bebit_0, bebit_1,
                                                   classtype, label, color, 2,
                                                   "arg0", "arg1" );
                    break;
                default :
                    ierr = SLOG_PROF_AddIntvlInfo( slog,
                                                   intvltype, bebit_0, bebit_1,
                                                   classtype, label, color, 0 );
                }
                if ( ierr != SLOG_SUCCESS ) {
                    fprintf( errfile, __FILE__":Main() - "
                                      "SLOG_PROF_AddIntvlInfo( Fixed ) "
                                      "fails!\n" );
                    fflush( errfile );
                    exit( 1 );
                }
#else
                ierr = SLOG_PROF_AddIntvlInfoWithArray( slog, intvltype,
                                                        bebit_0, bebit_1,
                                                        classtype, label, color,
                                                        Nargs, arg_labels );
                if ( ierr != SLOG_SUCCESS ) {
                    fprintf( errfile, __FILE__":Main() - "
                                      "SLOG_PROF_AddIntvlInfoWithArray() "
                                      "fails!\n" );
                    fflush( errfile );
                    exit( 1 );
                }
#endif
            }
        }
    }

#if defined( USER_MARKER )
    ierr = SLOG_PROF_SetExtraNumOfIntvlInfos( slog, Nentries_extra_recdefs );
    if ( ierr != SLOG_SUCCESS ) {
        fprintf( errfile, __FILE__":Main() - "
                          "SLOG_PROF_SetExtraNumOfIntvlInfos(%d) fails!\n",
                          Nentries_extra_recdefs );
        fflush( errfile );
        exit( 1 );
    }
#else
    /*  Finalize the Display Profile Table in SLOG file  */
    ierr = SLOG_PROF_Close( slog );
    if ( ierr != SLOG_SUCCESS ) {
        fprintf( errfile, __FILE__":Main() - "
                          "SLOG_PROF_Close() fails!\n" );
        fflush( errfile );
        exit( 1 );
    }
#endif


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

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

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

    /*  Create the Indexes for Variable Interval Record Definition  */
    Nargs = 0;    /*  Initialization, does NOT mean anything  */
    for ( Nassocs = 0; Nassocs <= MaxAssocs; Nassocs++ ) {
        intvltype = GetIntvlType( VarIrec_MinIdx, Nassocs, Nargs );
        ierr = SLOG_RDEF_AddRecDef( slog,
                                    intvltype, bebit_0, bebit_1,
                                    Nassocs, Nargs );
        if ( ierr != SLOG_SUCCESS ) {
            fprintf( errfile, __FILE__":Main() - "
                              "SLOG_RDEF_AddRecDef( Variable ) fails!\n" ); 
            fflush( errfile );
            exit( 1 );
        }
    }

    /*  Create the Indexes for Fixed Interval Record Definition  */
    for ( idx_type   = FixIrec_MinIdx;
          idx_type  <= FixIrec_MaxIdx;
          idx_type++ ) {
        for ( Nassocs = 0; Nassocs <= MaxAssocs; Nassocs++ ) {
            for ( Nargs = 0; Nargs <= MaxArgs; Nargs++ ) {
                intvltype = GetIntvlType( idx_type, Nassocs, Nargs );
                ierr = SLOG_RDEF_AddRecDef( slog,
                                            intvltype, bebit_0, bebit_1,
                                            Nassocs, Nargs );
                if ( ierr != SLOG_SUCCESS ) {
                    fprintf( errfile, __FILE__":Main() - "
                                      "SLOG_RDEF_AddRecDef( Fixed ) fails!\n" );
                    fflush( errfile );
                    exit( 1 );
                }
            }
        }
    }
   
#if defined( USER_MARKER )
    ierr = SLOG_RDEF_SetExtraNumOfRecDefs( slog, Nentries_extra_recdefs );
    if ( ierr != SLOG_SUCCESS ) {
        fprintf( errfile, __FILE__":Main() - "
                          "SLOG_RDEF_SetExtraNumOfRecDefs(%d) fails!\n",
                          Nentries_extra_recdefs );
        fflush( errfile );
        exit( 1 );
    } 
#else
    /*  Finalize the Record Definition Table in SLOG file  */
    ierr = SLOG_RDEF_Close( slog );
    if ( ierr != SLOG_SUCCESS ) {
        fprintf( errfile, __FILE__":Main() - "
                          "SLOG_RDEF_Close() fails!\n" );
        fflush( errfile );
        exit( 1 );
    } 
#endif

    printf( "Start appending records :\n" );

    events = ( tagged_irec * ) malloc( 2*MaxIrec * sizeof( tagged_irec ) );

/*
    printf( "\t""Append variable records:\n" );
    for ( ii = 0; ii <= VarIrec_MaxAssocs; ii++ ) {
        irec_rectype     = ( SLOG_rectype_t ) SLOG_RECTYPE_DYNAMIC_DIAG;
        irec_bebits[0]   = ( SLOG_bebit_t ) 1;
        irec_bebits[1]   = ( SLOG_bebit_t ) 1;
        irec_starttime   = ( SLOG_starttime_t ) ii*0.1;
        irec_duration    = ( SLOG_duration_t ) 0.1;
        irec_orig_node   = ( SLOG_nodeID_t ) ii % MaxNumOfProc;
        irec_orig_cpu    = ( SLOG_cpuID_t ) 1;
        irec_orig_thread = ( SLOG_threadID_t ) ii / MaxNumOfProc;
        irec_instr_addr  = ( SLOG_iaddr_t ) 8888;

        irec_Nassocs     = ii % ( MaxIdx4VarIrec + 1 );
        irec_Nargs       = 2;
        irec_intvltype   = GetIntvlType( VarIrec_MinIdx,
                                         irec_Nassocs, irec_Nargs );

        irec = SLOG_Irec_Create();
        SLOG_Irec_SetMinRec( irec, irec_rectype, irec_intvltype, 
                             irec_bebits[0], irec_bebits[1],
                             irec_starttime, irec_duration,
                             irec_orig_node, irec_orig_cpu, irec_orig_thread,
                             irec_instr_addr );
        if ( irec_Nassocs > 0 )
            SLOG_Irec_SetAssocs( irec, slog, irec_Nassocs, irec_assocs );
        for ( jj = 0; jj < irec_Nvtrargs; jj++ ) {
            if ( irec_Nargs > 0 )
               SLOG_Irec_SetArgs( irec, slog, irec_Nargs, irec_args );
            irec_Nargs++;
        }

        printf( "MAIN: %d, irec = ( "
                fmt_itype_t", "fmt_stime_t", "fmt_dura_t", "
                fmt_Nassocs_t" )\n", 
                ii, irec_intvltype, irec_starttime, irec_duration,
                irec_Nassocs );
        SLOG_Irec_Print( irec, stdout ); fprintf( stdout, "\n" );

        SLOG_Irec_ToOutputStream( slog, irec );
        SLOG_Irec_Free( irec );
    }

    irec_endtime = irec_starttime + irec_duration;
*/

    printf( "\t""Creation of fixed records:\n" );

    idx2state = 0;
    ii        = 0;
    IsForwardArrow = 1;

    while ( ii < MaxIrec ) {

        /*
            Set up the default value of the irec's components
        */
        irec_rectype     = (SLOG_rectype_t) SLOG_RECTYPE_STATIC_DIAG;
        irec_bebits[0]   = (SLOG_bebit_t) 1;
        irec_bebits[1]   = (SLOG_bebit_t) 1;
        irec_endtime     = (SLOG_time) ( idx2state + 1 ) * 0.1;
        irec_duration    = (SLOG_duration_t) 0.08;
        irec_starttime   = (SLOG_starttime_t) ( irec_endtime - irec_duration );
        irec_orig_node   = (SLOG_nodeID_t) idx2state % MaxNumOfProc;
        irec_orig_cpu    = (SLOG_cpuID_t) 1;
        irec_orig_thread = (SLOG_threadID_t) idx2state / MaxNumOfProc;
        irec_instr_addr  = (SLOG_iaddr_t) 8888;

        /*
            Make up some starttime and endtime stamps of interval records
            to check various features of the SLOG WRITE API
        */
        if ( idx2state == 3 ) {
            irec_duration  = ( SLOG_duration_t ) 0.15;
            irec_starttime = irec_endtime - irec_duration;
        }
        if ( idx2state == 7 ) {
            irec_duration  = ( SLOG_duration_t ) 0.55;
            irec_starttime = irec_endtime - irec_duration;
        }
        if ( idx2state == 12 ) {
            irec_duration = ( SLOG_duration_t ) 0.75;
            irec_starttime = irec_endtime - irec_duration;
        }
        if ( idx2state == 17 ) {
            irec_duration = ( SLOG_duration_t ) 1.55;
            irec_starttime = irec_endtime - irec_duration;
        }

        /*
          - Check the support of variable length Association arguments is OK.
          - Check if the support of variable length MPI arguments is OK.
            Modify the irec_intvltype to reflect the number of
            association arguments attached in the interval records.
        */

        switch ( 0 ) {
        case 0 : 
            irec_Nassocs  = 0;
            irec_Nargs    = idx2state % ( MaxArgs + 1 );
            break;
        case 1 :
            irec_Nassocs  = 0;
            irec_Nargs    = idx2state % ( MaxIdx4VarIrec + 1 );
            break;
        case 2 :
            irec_Nassocs  = idx2state % ( MaxIdx4VarIrec + 1 );
            irec_Nargs    = 0;
            break;