slog_irec_common.c

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

        return SLOG_TRUE;
    }
    else
        return SLOG_FAIL;
}



int SLOG_Irec_IsEqualTo( const SLOG_intvlrec_t *irec1, 
                         const SLOG_intvlrec_t *irec2 )
{
    return (    ( irec1->bytesize   == irec2->bytesize   )
             && ( irec1->rectype    == irec2->rectype    )
             && ( irec1->intvltype  == irec2->intvltype  )
             && ( irec1->bebits[0]  == irec2->bebits[0]  )
             && ( irec1->bebits[1]  == irec2->bebits[1]  )
             && ( irec1->starttime  == irec2->starttime  )
             && ( irec1->duration   == irec2->duration   )
             && SLOG_TaskID_IsEqualTo( &(irec1->origID), &(irec2->origID) )
             && ( SLOG_global_IsOffDiagRec( irec1->rectype )                      ?
                  SLOG_TaskID_IsEqualTo( &(irec1->destID), &(irec2->destID) ) :
                  1 )
             && ( irec1->instr_addr == irec2->instr_addr )
             && SLOG_Assoc_IsEqualTo( irec1->N_assocs, irec1->assocs, 
                                      irec2->N_assocs, irec2->assocs ) 
             && SLOG_Vargs_AreEqualTo( irec1->vhead, irec2->vhead ) );
}



        /*  Low level SLOG_Irec Methods  */

int SLOG_Irec_DepositToFbuf( const SLOG_intvlrec_t *irec,
                                   filebuf_t       *fbuf )
{
    SLOG_vtrarg_lptr_t *vptr;
    SLOG_bebits_t       bebits;
    SLOG_uint32         count;
    SLOG_uint32         Nbytes_written;
    int                 ierr;

    Nbytes_written = 0;

    ierr = fbuf_deposit( &( irec->bytesize ), SLOG_typesz[ sz_t ], 1, fbuf );
    if ( ierr < 1 ) {
        fprintf( errfile, __FILE__":SLOG_Irec_DepositToFbuf() - Cannot "
                          "deposit the ByteSize to the SLOG filebuffer, "
                          fmt_ui32" bytes written so far\n", Nbytes_written );
        fprintf( errfile, "      ""irec = " );
        SLOG_Irec_Print( irec, errfile ); fprintf( errfile, "\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }
    Nbytes_written += ierr * SLOG_typesz[ sz_t ];

    ierr = fbuf_deposit( &( irec->rectype ), SLOG_typesz[ rtype_t ], 1, fbuf );
    if ( ierr < 1 ) {
        fprintf( errfile, __FILE__":SLOG_Irec_DepositToFbuf() - Cannot "
                          "deposit the EVENT_TYPE to the SLOG filebuffer, "
                          fmt_ui32" bytes written so far\n", Nbytes_written );
        fprintf( errfile, "      ""irec = " );
        SLOG_Irec_Print( irec, errfile ); fprintf( errfile, "\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }
    Nbytes_written += ierr * SLOG_typesz[ rtype_t ];

    ierr = fbuf_deposit( &( irec->intvltype ), SLOG_typesz[ itype_t ],
                         1, fbuf );
    if ( ierr < 1 ) {
        fprintf( errfile, __FILE__":SLOG_Irec_DepositToFbuf() - Cannot "
                          "deposit the RECORD_TYPE to the SLOG filebuffer, "
                          fmt_ui32" bytes written so far\n", Nbytes_written );
        fprintf( errfile, "      ""irec = " );
        SLOG_Irec_Print( irec, errfile ); fprintf( errfile, "\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }
    Nbytes_written += ierr * SLOG_typesz[ itype_t ];

    bebits = SLOG_bebits_encode( irec->bebits[0], irec->bebits[1] );
    ierr = fbuf_deposit( &bebits, SLOG_typesz[ bebits_t ], 1, fbuf );
    if ( ierr < 1 ) {
        fprintf( errfile, __FILE__":SLOG_Irec_DepositToFbuf() - Cannot "
                          "deposit the BEBITS to the SLOG filebuffer, "
                          fmt_ui32" bytes written so far\n", Nbytes_written );
        fprintf( errfile, "      ""irec = " );
        SLOG_Irec_Print( irec, errfile ); fprintf( errfile, "\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }
    Nbytes_written += ierr * SLOG_typesz[ bebits_t ];

    ierr = fbuf_deposit( &( irec->starttime ),
                         SLOG_typesz[ stime_t ], 1, fbuf );
    if ( ierr < 1 ) {
        fprintf( errfile, __FILE__":SLOG_Irec_DepositToFbuf() - Cannot "
                          "deposit the STARTtime to the SLOG filebuffer, "
                          fmt_ui32" bytes written so far\n", Nbytes_written );
        fprintf( errfile, "      ""irec = " );
        SLOG_Irec_Print( irec, errfile ); fprintf( errfile, "\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }
    Nbytes_written += ierr * SLOG_typesz[ stime_t ];

    ierr = fbuf_deposit( &( irec->duration ), SLOG_typesz[ dura_t ], 1, fbuf );
    if ( ierr < 1 ) {
        fprintf( errfile, __FILE__":SLOG_Irec_DepositToFbuf() - Cannot "
                          "deposit the DURATION to the SLOG filebuffer, "
                          fmt_ui32" bytes written so far\n", Nbytes_written );
        fprintf( errfile, "      ""irec = " );
        SLOG_Irec_Print( irec, errfile ); fprintf( errfile, "\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }
    Nbytes_written += ierr * SLOG_typesz[ dura_t ];

    ierr = SLOG_TaskID_DepositToFbuf( &( irec->origID ), fbuf );
    if ( ierr < (int)SLOG_typesz[ taskID_t ] ) {
        fprintf( errfile, __FILE__":SLOG_Irec_DepositToFbuf() - Cannot "
                          "deposit the Origin TASK IDs to the SLOG "
                          "filebuffer, "fmt_ui32" bytes written so far\n",
                          Nbytes_written );
        fprintf( errfile, "      ""irec = " );
        SLOG_Irec_Print( irec, errfile ); fprintf( errfile, "\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }
    Nbytes_written += ierr;

    if ( SLOG_global_IsOffDiagRec( irec->rectype ) ) {
        ierr = SLOG_TaskID_DepositToFbuf( &( irec->destID ), fbuf );
        if ( ierr < (int)SLOG_typesz[ taskID_t ] ) {
            fprintf( errfile, __FILE__":SLOG_Irec_DepositToFbuf() - Cannot "
                              "deposit the Destination TASK IDs to the SLOG "
                              "filebuffer, "fmt_ui32" bytes written so far\n",
                              Nbytes_written );
            fprintf( errfile, "      ""irec = " );
            SLOG_Irec_Print( irec, errfile ); fprintf( errfile, "\n" );
            fflush( errfile );
            return SLOG_FAIL;
        }
        Nbytes_written += ierr;
    }

#if ! defined( NOINSTRUCTION )
    ierr = fbuf_deposit( &( irec->instr_addr ),
		         SLOG_typesz[ iaddr_t ], 1, fbuf );
    if ( ierr < 1 ) {
        fprintf( errfile, __FILE__":SLOG_Irec_DepositToFbuf() - Cannot "
                          "deposit the Instruction Address to the SLOG "
			  "filebuffer, " fmt_ui32" bytes written so far\n",
			  Nbytes_written );
        fprintf( errfile, "      ""irec = " );
        SLOG_Irec_Print( irec, errfile ); fprintf( errfile, "\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }
    Nbytes_written += ierr * SLOG_typesz[ iaddr_t ];
#endif

    ierr = fbuf_deposit( irec->assocs, 
                         SLOG_typesz[ assoc_t ], irec->N_assocs, fbuf );
    if ( ierr < irec->N_assocs ) {
        fprintf( errfile, __FILE__":SLOG_Irec_DepositToFbuf() - Cannot "
                          "deposit the ASSOCIATIONs to the SLOG filebuffer, "
                          fmt_ui32" bytes written so far\n", Nbytes_written );
        fprintf( errfile, "      ""irec = " );
        SLOG_Irec_Print( irec, errfile ); fprintf( errfile, "\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }
    Nbytes_written += ierr * SLOG_typesz[ assoc_t ];

    if ( SLOG_global_IsVarRec( irec->rectype ) ) {
        count = 0;
        for ( vptr = irec->vhead; vptr != NULL; vptr = vptr->next, count++ ) {
            if ( vptr->vtr == NULL ) {
                fprintf( errfile, __FILE__":SLOG_Irec_DepositToFbuf() - "
                                  "the %d-th node of vector arguments has "
                                  "NULL vector\n", count );
                fprintf( errfile, "      ""irec = " );
                SLOG_Irec_Print( irec, errfile ); fprintf( errfile, "\n" );
                fflush( errfile );
                return SLOG_FAIL;
            }

            ierr = fbuf_deposit( &( vptr->vtr->size ),
                                 SLOG_typesz[ Nargs_t ], 1, fbuf );
            if ( ierr < 1 ) {
                fprintf( errfile, __FILE__":SLOG_Irec_DepositToFbuf() - "
                                  "Cannot deposit %d-th ARGS's size, "
                                  fmt_Nargs_t ", to the SLOG filebuffer\n",
                                  count, vptr->vtr->size );
                fprintf( errfile, "      ""irec = " );
                SLOG_Irec_Print( irec, errfile ); fprintf( errfile, "\n" );
                fflush( errfile );
                return SLOG_FAIL;
            }
            Nbytes_written += ierr * SLOG_typesz[ Nargs_t ];

            ierr = fbuf_deposit( vptr->vtr->values,
                                 SLOG_typesz[ arg_t ], vptr->vtr->size, fbuf );
            if ( ierr < vptr->vtr->size ) {
                fprintf( errfile, __FILE__":SLOG_Irec_DepositToFbuf() - "
                                  "Cannot deposit %d-th "
                                  "ARGS[0:"fmt_Nargs_t"-1] to the SLOG "
                                  "filebuffer\n", count, vptr->vtr->size );
                fprintf( errfile, "       "fmt_ui32" bytes written so far\n",
                                  Nbytes_written );
                fprintf( errfile, "      ""irec = " );
                SLOG_Irec_Print( irec, errfile ); fprintf( errfile, "\n" );
                fflush( errfile );
                return SLOG_FAIL;
            }
            Nbytes_written += ierr * SLOG_typesz[ arg_t ];
        }   /*  Endof { for ( vptr = ... ) }  */
    }
    else {   /*  if ( SLOG_global_IsVarRec( irec->rectype ) )  */
        vptr = irec->vhead;
        if ( vptr != NULL ) {
            if ( vptr->vtr == NULL ) {
                fprintf( errfile, __FILE__":SLOG_Irec_DepositToFbuf() - "
                                  "the vector argument has NULL vector\n" );
                fprintf( errfile, "      ""irec = " );
                SLOG_Irec_Print( irec, errfile ); fprintf( errfile, "\n" );
                fflush( errfile );
                return SLOG_FAIL;
            }

            ierr = fbuf_deposit( vptr->vtr->values,
                                 SLOG_typesz[ arg_t ], vptr->vtr->size, fbuf );
            if ( ierr < vptr->vtr->size ) {
                fprintf( errfile, __FILE__":SLOG_Irec_DepositToFbuf() - "
                                  "Cannot deposit "
                                  "ARGS[0:"fmt_Nargs_t"-1] to the SLOG "
                                  "filebuffer\n", vptr->vtr->size );
                fprintf( errfile, "       "fmt_ui32" bytes written so far\n",
                                  Nbytes_written );
                fprintf( errfile, "      ""irec = " );
                SLOG_Irec_Print( irec, errfile ); fprintf( errfile, "\n" );
                fflush( errfile );
                return SLOG_FAIL;
            }
            Nbytes_written += ierr * SLOG_typesz[ arg_t ];
        }   /*  Endof    if ( vptr != NULL )  */
    }   /*  Endof   if ( SLOG_global_IsVarRec( irec->rectype ) )  */

#if defined (DEBUG)
    /*   Consistency check if deposited number of bytes is as expected   */
    if ( Nbytes_written != irec->bytesize ) {
        fprintf( errfile, __FILE__":SLOG_Irec_DepositToFbuf() - "
                          "Nbytes_written = "fmt_ui32", but irec->bytesize = "
                          fmt_sz_t"\n", Nbytes_written, irec->bytesize );
        fprintf( errfile, "      ""irec = " );
        SLOG_Irec_Print( irec, errfile ); fprintf( errfile, "\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }
#endif

    return Nbytes_written;
}



SLOG_intvlrec_t *
SLOG_Irec_WithdrawFromFbuf( const SLOG_recdefs_table_t  *slog_recdefs,
                                  filebuf_t             *fbuf )
{
    SLOG_intvlrec_t *irec;
    SLOG_vtrarg_t   *vtr_args;
    SLOG_N_args_t    N_args;
    SLOG_bebits_t    bebits;
    SLOG_uint32      count;
    SLOG_uint32      Nbytes_read;
    int              ierr;


    irec = SLOG_Irec_Create();
    if ( irec == NULL ) {
        fprintf( errfile, __FILE__":SLOG_Irec_WithdrawFromFbuf() - "
                          "SLOG_Irec_Create() fails\n" );
        fflush( errfile );
        return NULL;
    }

    Nbytes_read = 0;

    ierr = fbuf_withdraw( &( irec->bytesize ),
                          SLOG_typesz[ sz_t ], 1, fbuf );
    if ( ierr < 1 ) {
        fprintf( errfile, __FILE__":SLOG_Irec_WithdrawFromFbuf() - Cannot "
                          "withdraw the ByteSize from the SLOG filebuffer, "
                          fmt_ui32" bytes read so far\n", Nbytes_read );
        fflush( errfile );
        free( irec );
        return NULL;
    }
    Nbytes_read += ierr * SLOG_typesz[ sz_t ];

    ierr = fbuf_withdraw( &( irec->rectype ), SLOG_typesz[ rtype_t ], 1, fbuf );
    if ( ierr < 1 ) {
        fprintf( errfile, __FILE__":SLOG_Irec_WithdrawFromFbuf() - Cannot "
                          "withdraw the EVENT_TYPE from the SLOG filebuffer, "
                          fmt_ui32" bytes read so far\n", Nbytes_read );
        fprintf( errfile, "      ""irec = " );
        SLOG_Irec_Print( irec, errfile ); fprintf( errfile, "\n" );
        fflush( errfile );
        free( irec );
        return NULL;
    }
    Nbytes_read += ierr * SLOG_typesz[ rtype_t ];

    ierr = fbuf_withdraw( &( irec->intvltype ),
                          SLOG_typesz[ itype_t ], 1, fbuf );
    if ( ierr < 1 ) {
        fprintf( errfile, __FILE__":SLOG_Irec_WithdrawFromFbuf() - Cannot "
                          "withdraw the RECORD_TYPE from the SLOG filebuffer, "
                          fmt_ui32" bytes read so far\n", Nbytes_read );
        fprintf( errfile, "      ""irec = " );
        SLOG_Irec_Print( irec, errfile ); fprintf( errfile, "\n" );
        fflush( errfile );
        free( irec );
        return NULL;
    }
    Nbytes_read += ierr * SLOG_typesz[ itype_t ];

    ierr = fbuf_withdraw( &bebits, SLOG_typesz[ bebits_t ], 1, fbuf );
    if ( ierr < 1 ) {
        fprintf( errfile, __FILE__":SLOG_Irec_WithdrawFromFbuf() - Cannot "
                          "withdraw the BEBITS from the SLOG filebuffer, "
                          fmt_ui32" bytes read so far\n", Nbytes_read );
        fprintf( errfile, "      ""irec = " );
        SLOG_Irec_Print( irec, errfile ); fprintf( errfile, "\n" );
        fflush( errfile );
        free( irec );
        return NULL;
    }
    Nbytes_read += ierr * SLOG_typesz[ bebits_t ];
    SLOG_bebits_decode( bebits, irec->bebits );

    ierr = fbuf_withdraw( &( irec->starttime ),