slog_impl.c

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

                                  "fails\n" );
                fflush( errfile );
                return SLOG_FAIL;
            }
        }
        else {   /*  if ( irec_endtime > frame_endtime )  */
            ierr = SLOG_Bbufs_MoveIntvlRec( slog->tmp_bbuf,
                                            slog->pas_bbuf );
            if ( ierr != SLOG_SUCCESS ) {
                fprintf( errfile, __FILE__":SLOG_STM_UpdateFRAME_Forward() - "
                                  "SLOG_Bbufs_MoveIntvlRec( _tmp_ -> _pas_ ) "
                                  "fails\n" );
                fflush( errfile );
                return SLOG_FAIL;
            }
        }

    }   /*  Endof while ( lptr != NULL ) for tmp_bbuf  */


    /*
        Split the interval records in CURRENT Bbuf into the all the other
        Bbufs, INCOMING, OUTGOING and PASSING THROUGH Bbufs according
        to the timestamp limits set for each sectors
    */
    lptr = SLOG_Bbuf_GetPointerAtHead( slog->cur_bbuf );
    while ( lptr != NULL ) {

        irec_starttime = ( lptr->irec )->starttime;
        irec_endtime   = ( lptr->irec )->starttime + ( lptr->irec )->duration;
        ierr = SLOG_Bbuf_SetPointerAt( slog->cur_bbuf, lptr );
        if ( ierr != SLOG_SUCCESS ) {
            fprintf( errfile, __FILE__":SLOG_STM_UpdateFRAME_Forward() - "
                              "SLOG_Bbuf_SetPointerAt( _cur_, lptr ) fails\n" );
            fflush( errfile );
            return SLOG_FAIL;
        }
        lptr = lptr->next;

        if ( irec_endtime <= frame_endtime ) {
            if ( irec_starttime < frame_starttime ) {
                ierr = SLOG_Bbufs_MoveIntvlRec( slog->cur_bbuf,
                                                slog->inc_bbuf );
                if ( ierr != SLOG_SUCCESS ) {
                    fprintf( errfile, __FILE__
                                      ":SLOG_STM_UpdateFRAME_Forward() - "
                                      "SLOG_Bbufs_MoveIntvlRec( _cur_ "
                                      "-> _inc_ ) fails\n" );
                    fflush( errfile );
                    return SLOG_FAIL;
                }
            }
            else {  /*  if ( irec_starttime >= frame_starttime )  */
                /*  Leave the irec in slog->cur_bbuf  */
            }
        }
        else {  /*  if ( irec_endtime > frame_endtime )  */
            if ( irec_starttime < frame_starttime ) {
                ierr = SLOG_Bbufs_MoveIntvlRec( slog->cur_bbuf,
                                                slog->pas_bbuf );
                if ( ierr != SLOG_SUCCESS ) {
                    fprintf( errfile, __FILE__
                                      ":SLOG_STM_UpdateFRAME_Forward() - "
                                      "SLOG_Bbufs_MoveIntvlRec( _cur_ "
                                      "-> _pas_ ) fails\n" );
                    fflush( errfile );
                    return SLOG_FAIL;
                }
            }
            else {  /*  if ( irec_starttime >= frame_starttime )  */
                ierr = SLOG_Bbufs_MoveIntvlRec( slog->cur_bbuf,
                                                slog->out_bbuf );
                if ( ierr != SLOG_SUCCESS ) {
                    fprintf( errfile, __FILE__
                                      ":SLOG_STM_UpdateFRAME_Forward() - "
                                      "SLOG_Bbufs_MoveIntvlRec( _cur_ "
                                      "-> _out_ ) fails\n" );
                    fflush( errfile );
                    return SLOG_FAIL;
                }
            }
        }  
        
    }   /*  Endof while ( lptr != NULL ) for cur_bbuf  */

#if defined( DEBUG )
    if ( ! SLOG_Bbuf_IsEmpty( slog->tmp_bbuf ) ) {
        fprintf( errfile, __FILE__":SLOG_STM_UpdateFRAME_Forward() - "
                          "slog->tmp_bbuf is NON-empty\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }
#endif

    /*
        After the distribution of irec in slog->tmp_bbuf and
        slog->cur_bbuf in all the other bbufs.  Update the
        Frame Header data structure before Writing the Frame
        and Reinitialization of the Frame data.  i.e. Number 
        of Interval records and Number of bytes in each sectors.
    */
    SLOG_STM_UpdateFrameHdr( slog );

    return SLOG_SUCCESS;
}



/*
    SLOG_STM_UpdateFrameDirEntry_Backward() = Update the buffer's Frame 
    Directory Record's Fptr2FrameHdr, StartTime & EndTime 

    So, for the 1st frame, (slog->frame_dir).entries[ 0 ],
    SLOG_STM_UpdateFrameDirEntry_Backward( slog ) HAS To Be Called
    BEFORE any operations on the various sectors of the frame, i.e. xxx_bbuf
    because the starttime and endtime of the frame determines where
    where each interval record should go.
*/
int SLOG_STM_UpdateFRAME_Backward( SLOG_STREAM *slog )
{
    /* const SLOG_intvlrec_lptr_t  *lptr;  */
          SLOG_intvlrec_lptr_t  *lptr;
          SLOG_intvlrec_t       *irec;
          SLOG_time              frame_starttime;
    /*    SLOG_time              frame_endtime;  */
          SLOG_time              irec_starttime;
          SLOG_uint32            Nbytes_changed;
          int                    ierr;


    frame_starttime = ( slog->frame_dir_entry ).starttime;
    /*  frame_endtime   = ( slog->frame_dir_entry ).endtime;  */
    Nbytes_changed  = 0;

    /*
        Split interval records in TEMPORARY Bbuf into PASSING THROUGH
        and OUTGOING Bbufs according to the criterion
        ( exceeds the Frame's starttime )
    */
    lptr = SLOG_Bbuf_GetPointerAtHead( slog->tmp_bbuf );
    while ( lptr != NULL ) {

        /*
            Save a handle to irec in lptr for later use 
            before lptr is updated below
        */
        irec           = lptr->irec;
        irec_starttime = irec->starttime;

        /*  Set slog->tmp_bbuf->lptr = lptr  */
        ierr = SLOG_Bbuf_SetPointerAt( slog->tmp_bbuf, lptr );
        if ( ierr != SLOG_SUCCESS ) {
            fprintf( errfile, __FILE__":SLOG_STM_UpdateFRAME_Backward() - "
                              "SLOG_Bbuf_SetPointerAt( _tmp_, lptr ) fails\n" );
            fflush( errfile );
            return SLOG_FAIL;
        }
        lptr = lptr->next;

        if ( irec_starttime >= frame_starttime ) {
            if (    SLOG_Bbuf_LocateIntvlRec( slog->out_bbuf, irec )
                 == NULL ) {  /*  _tmp_'s irec is NOT in _out_  */
                ierr = SLOG_Bbufs_MoveIntvlRec( slog->tmp_bbuf,
                                                slog->out_bbuf );
                if ( ierr != SLOG_SUCCESS ) {
                    fprintf( errfile, __FILE__
                                      ":SLOG_STM_UpdateFRAME_Backward() - "
                                      "SLOG_Bbufs_MoveIntvlRec( _tmp_ "
                                      "-> _out_ ) fails\n" );
                    fflush( errfile );
                    return SLOG_FAIL;
                }
                Nbytes_changed += irec->bytesize;
            }
            else {  /*  _tmp_'s irec is in _out_  */
                ierr = SLOG_Bbuf_RemoveNodeLinks( slog->tmp_bbuf );
                if ( ierr != SLOG_SUCCESS ) {
                    fprintf( errfile, __FILE__
                                      ":SLOG_STM_UpdateFRAME_Backward() - "
                                      "SLOG_Bbuf_RemoveNodeLinks() fails "
                                      "when irec is in slog->out_bbuf\n" );
                    fflush( errfile );
                    return SLOG_FAIL;
                }
                SLOG_Bbuf_FreeNode( slog->tmp_bbuf );
            }
        }
        else {   /*  if ( irec_endtime < frame_endtime )  */
            if (    SLOG_Bbuf_LocateIntvlRec( slog->pas_bbuf, irec )
                 == NULL ) {   /*  _tmp_'s irec is NOT in _pas_  */
                ierr = SLOG_Bbufs_MoveIntvlRec( slog->tmp_bbuf,
                                                slog->pas_bbuf );
                if ( ierr != SLOG_SUCCESS ) {
                    fprintf( errfile, __FILE__
                                      ":SLOG_STM_UpdateFRAME_Backward() - "
                                      "SLOG_Bbufs_MoveIntvlRec( _tmp_ "
                                      "-> _pas_ ) fails\n" );
                    fflush( errfile );
                    return SLOG_FAIL;
                }
                Nbytes_changed += irec->bytesize;
            }
            else {   /*  _tmp_'s irec is in _pas_  */
                ierr = SLOG_Bbuf_RemoveNodeLinks( slog->tmp_bbuf );
                if ( ierr != SLOG_SUCCESS ) {
                    fprintf( errfile, __FILE__
                                      ":SLOG_STM_UpdateFRAME_Backward() - "
                                      "SLOG_Bbuf_RemoveNodeLinks() fails "
                                      "when irec is in slog->pas_bbuf\n" );
                    fflush( errfile );
                    return SLOG_FAIL;
                }
                SLOG_Bbuf_FreeNode( slog->tmp_bbuf );
            }
        }

    }   /*  Endof while ( lptr != NULL ) for tmp_bbuf  */

#if defined( DEBUG )
    if ( ! SLOG_Bbuf_IsEmpty( slog->tmp_bbuf ) ) {
        fprintf( errfile, __FILE__":SLOG_STM_UpdateFRAME_Backward() - "
                          "slog->tmp_bbuf is NON-empty\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }
#endif

    /*
        After the distribution of irec in slog->tmp_bbuf and
        into slog->out_bbuf and slog->pas_bbuf.  Update the
        Frame Header data structure before Writing the Frame
        and Reinitialization of the Frame data.  i.e. Number 
        of Interval records and Number of bytes in each sectors.
    */
    SLOG_STM_UpdateFrameHdr( slog );

    return Nbytes_changed;
}



int SLOG_STM_WriteFRAMEatIdx(       SLOG_STREAM *slog,
                              const SLOG_uint32  idx_of_cur_frame )
{
    SLOG_fptr   ifptr2framehdr;
    int         ierr;

    if ( idx_of_cur_frame >= (slog->frame_dir).Nframe ) {
        fprintf( errfile, __FILE__":SLOG_STM_WriteFRAMEatIdx() - \n" );
        fprintf( errfile, "\t""the input index("fmt_ui32") is bigger "
                          "the Number of Frames("fmt_ui32") in "
                          "File Frame Directory\n",
                          idx_of_cur_frame, (slog->frame_dir).Nframe );
        fflush( errfile );
        return SLOG_FAIL;
    }

    ifptr2framehdr
        = ( (slog->frame_dir).entries[ idx_of_cur_frame ] ).fptr2framehdr;
#if defined( DEBUG )
    fprintf( errfile, __FILE__":SLOG_STM_WriteFRAMEatIdx("fmt_ui32") - "
                      "ifptr2framehdr = "fmt_fptr"\n", idx_of_cur_frame,
                      ifptr2framehdr );
    fflush( errfile );
#endif

    ierr = slog_fseek( slog->fd, ifptr2framehdr, SEEK_SET );
    if ( ierr != 0 ) {
        fprintf( errfile, __FILE__":SLOG_STM_WriteFRAMEatIdx() - "
                          "slog_fseek("fmt_fptr") fails\n", ifptr2framehdr );
        fflush( errfile );
        return SLOG_EOF;
    }
    ierr = SLOG_STM_WriteFRAME( slog );
    if ( ierr == SLOG_FAIL ) {
        fprintf( errfile, __FILE__":SLOG_STM_WriteFRAMEatIdx("fmt_ui32") - "
                          "SLOG_STM_WriteFRAME() fails\n", idx_of_cur_frame );
        fflush( errfile );
        return SLOG_FAIL;
    }

    return ierr;
}



int SLOG_STM_WriteFRAME( SLOG_STREAM *slog )
{
    SLOG_uint32 Nbytes_written;
    int         ierr;

#if defined( DEBUG )
    SLOG_fptr  slogfile_loc_cur;
#endif 


    Nbytes_written = 0;

  /*  Output buffer's frame header to the filebuffer  */
    ierr = SLOG_STM_DepositFrameHdr( &( slog->frame_hdr ), slog->fbuf );
    if ( ierr == SLOG_FAIL ) {
        fprintf( errfile, __FILE__":SLOG_STM_WriteFRAME() - "
                          "SLOG_STM_DepositFrameHdr( slog->Frame_Hdr ) "
                          "fails!!\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }
    Nbytes_written += ierr;

  /*  Output all buffers' interval records to the filebuffer  */
    ierr = SLOG_STM_DepositBBuf( slog->cur_bbuf, slog->fbuf );
    if ( ierr == SLOG_FAIL ) {
        fprintf( errfile, __FILE__":SLOG_STM_WriteFRAME() - "
                          "SLOG_STM_DepositBBuf( slog->CURRENT_Bbuf ) "
                          "fails!!\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }
    Nbytes_written += ierr;

    ierr = SLOG_STM_DepositBBuf( slog->inc_bbuf, slog->fbuf );
    if ( ierr == SLOG_FAIL ) {
        fprintf( errfile, __FILE__":SLOG_STM_WriteFRAME() - "
                          "SLOG_STM_DepositBBuf( slog->INCOMING_Bbuf ) "
                          "fails!!\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }
    Nbytes_written += ierr;

    ierr = SLOG_STM_DepositBBuf( slog->pas_bbuf, slog->fbuf );
    if ( ierr == SLOG_FAIL ) {
        fprintf( errfile, __FILE__":SLOG_STM_WriteFRAME() - "
                          "SLOG_STM_DepositBBuf( slog->PASSING_THROUGH_Bbuf ) "
                          "fails!!\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }
    Nbytes_written += ierr;

    ierr = SLOG_STM_DepositBBuf( slog->out_bbuf, slog->fbuf );
    if ( ierr == SLOG_FAIL ) {
        fprintf( errfile, __FILE__":SLOG_STM_WriteFRAME() - "
                          "SLOG_STM_DepositBBuf( slog->OUTGOING_Bbuf ) "
                          "fails!!\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }
    Nbytes_written += ierr;

#if defined( DEBUG )
        fprintf( errfile, __FILE__":SLOG_STM_WriteFRAME() - A\n" );
        slogfile_loc_cur = slog_ftell( slog->fd );
        if ( slogfile_loc_cur != ( slog->frame_dir_entry ).fptr2framehdr ) {
            fprintf( errfile, __FILE__":SLOG_STM_WriteFRAME() - "
                              "Inconsistency in File Pointers BEFORE calling "
                              "fbuf_empty( frame buffer ) at line %d\n",
                              __LINE__ );
            fprintf( errfile, "       ""- slogfile_loc_cur = "fmt_fptr", but "