slog_impl.c

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

                                      const SLOG_uint32        Nframe_i )
{
    ( slog->frame_dir ).prevdir     = prevdir_i;
    ( slog->frame_dir ).nextdir     = nextdir_i;
    ( slog->frame_dir ).Nframe      = Nframe_i;
    ( slog->frame_dir ).entries     = NULL;
}



int SLOG_STM_IncrementFrameDirHdr( SLOG_STREAM       *slog )
{
    /*  Increment the Number of Frame in the Frame Buffer  */
    if ( ( slog->frame_dir ).Nframe < slog->hdr->max_Ndirframe )
       ( slog->frame_dir ).Nframe ++;
    else {
        fprintf( errfile, __FILE__":SLOG_STM_IncrementFrameDirHdr() - "
                          "( slog->frame_dir ).Nframe = "fmt_ui32" >= Maximum "
                          "Allowed Record Numbers per Frame Directory\n",
                          ( slog->frame_dir ).Nframe );
        fflush( errfile );
        exit( 1 );
        return SLOG_FAIL;
    }

    return SLOG_SUCCESS;
}



int SLOG_STM_WriteFrameDirHdr( SLOG_STREAM       *slog )
{
    SLOG_fptr file_loc_saved;
    int       ierr;

    /*  Save the current file pointer position  */
    file_loc_saved = slog_ftell( slog->fd );

    ierr = slog_fseek( slog->fd, slog->file_dir_hdr, SEEK_SET );
    if ( ierr != 0 ) {
        fprintf( errfile, __FILE__":SLOG_STM_WriteFrameDirHdr() - slog_fseek() "
                          "cannot load the current frame directory entry\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }

  /*
      Write the initialization section of the frame directory
      Could be done in bswp_fwrite statement to improve speed
  */
    bswp_fwrite( &( ( slog->frame_dir ).prevdir ),
                 SLOG_typesz[ fptr ], 1, slog->fd );
    bswp_fwrite( &( ( slog->frame_dir ).nextdir ),
                 SLOG_typesz[ fptr ], 1, slog->fd );
    bswp_fwrite( &( ( slog->frame_dir ).Nframe ),
                 SLOG_typesz[ ui32 ], 1, slog->fd );
    
    /*  Restore the saved file pointer position  */
    ierr = slog_fseek( slog->fd, file_loc_saved, SEEK_SET );
    if ( ierr != 0 ) {
        fprintf( errfile, __FILE__":SLOG_STM_WriteFrameDirHdr() - slog_fseek() "
                          "fails, cannot restore the orginal file position "
                          "before the subroutine call\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }

    return SLOG_SUCCESS;
}



/*
    This routine assume that 
    NEITHER ( slog->cur_bbuf )->lhead == NULL
    NOR     ( slog->cur_bbuf )->ltail == NULL
    i.e.  This routine is meant to be used WHEN the cur_bbuf is FILLED
*/
int SLOG_STM_UpdateFrameDirEntry_Forward(       SLOG_STREAM  *slog,
                                          const int           IsLastFrame )
{
    SLOG_time           endtime_tmp;
    SLOG_uint32         idx_of_cur_frame;

    /*  Update the Buffer's Frame Directory Entry  */

    ( slog->frame_dir_entry ).fptr2framehdr = slog->file_loc;
    if ( ( slog->frame_dir_entry ).fptr2framehdr == SLOG_fptr_NULL ) {
        fprintf( errfile, __FILE__":SLOG_STM_UpdateFrameDirEntry_Forward() - "
                          "the current frame buffer's Fptr2FrameHdr "
                          "is assigned NULL!\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }

    if ( SLOG_Bbuf_IsEmpty( slog->cur_bbuf ) ) {
        fprintf( errfile, __FILE__":SLOG_STM_UpdateFrameDirEntry_Forward() - "
                          "slog->cur_bbuf contains NO elements!\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }

    idx_of_cur_frame = ( slog->frame_dir ).Nframe;

    /*  Set the frame's starttime  */
    if ( idx_of_cur_frame == 0 ) 
        ( slog->frame_dir_entry ).starttime
        = SLOG_Bbuf_EarliestStarttime( slog->cur_bbuf ); 
    else
        ( slog->frame_dir_entry ).starttime
        = ( (slog->frame_dir).entries[idx_of_cur_frame-1] ).endtime;

    /*  Set the frame's endtime  */
    if ( ( slog->cur_bbuf )->ltail != NULL ) {
        if ( slog->hdr->IsIncreasingEndtime == SLOG_TRUE )
            ( slog->frame_dir_entry ).endtime
            = ( ( ( slog->cur_bbuf )->ltail )->irec )->starttime
            + ( ( ( slog->cur_bbuf )->ltail )->irec )->duration;
        else if ( slog->hdr->IsIncreasingStarttime == SLOG_TRUE )
            ( slog->frame_dir_entry ).endtime
            = ( ( ( slog->cur_bbuf )->ltail )->irec )->starttime;
        else
            ( slog->frame_dir_entry ).endtime = SLOG_time_NULL;
    }
    else
        ( slog->frame_dir_entry ).endtime = SLOG_time_NULL;

    if ( IsLastFrame == SLOG_TRUE ) {
        ( slog->frame_dir_entry ).endtime
        = SLOG_Bbuf_LatestEndtime( slog->cur_bbuf );

        if ( ! SLOG_Bbuf_IsEmpty( slog->tmp_bbuf ) ) {
            endtime_tmp = SLOG_Bbuf_LatestEndtime( slog->tmp_bbuf );
            if ( endtime_tmp > ( slog->frame_dir_entry ).endtime ) 
                ( slog->frame_dir_entry ).endtime = endtime_tmp;
        }
    }

    if ( idx_of_cur_frame >= slog->hdr->max_Ndirframe ) {
        fprintf( errfile, __FILE__
                          ":SLOG_STM_UpdateFrameDirEntry_Forward() - "
                          "the current frame index ("fmt_ui32") >= maximum "
                          "number of frames per directory ("fmt_ui32") !!!\n",
                          idx_of_cur_frame, slog->hdr->max_Ndirframe );
        fflush( errfile );
        return SLOG_FAIL;
    }

    /*  Update the (slog->frame_dir).entries[ idx_of_current_frame ]  */
    ( slog->frame_dir ).entries[ idx_of_cur_frame ].fptr2framehdr
    = ( slog->frame_dir_entry ).fptr2framehdr;
    ( slog->frame_dir ).entries[ idx_of_cur_frame ].starttime
    = ( slog->frame_dir_entry ).starttime;
    ( slog->frame_dir ).entries[ idx_of_cur_frame ].endtime
    = ( slog->frame_dir_entry ).endtime;


    /*  Inconsistency Check  */
    if (    ( slog->frame_dir_entry ).starttime
         == ( slog->frame_dir_entry ).endtime   ) {
        if ( ( slog->cur_bbuf )->lhead != NULL ) {
            if ( ( ( ( slog->cur_bbuf )->lhead )->irec )->duration > 0.0 ) {
                fprintf( errfile, __FILE__
                                  ":SLOG_STM_UpdateFrameDirEntry_Forward() - "
                                  "the current frame buffer's STARTtime ("
                                  fmt_time") == ENDtime ("fmt_time") !!!\n",
                                  ( slog->frame_dir_entry ).starttime,
                                  ( slog->frame_dir_entry ).endtime );
                fflush( errfile );
                return SLOG_FAIL;
            }
        }
    }

    /*  Inconsistency Check  */
    if (    ( slog->frame_dir_entry ).starttime
         >  ( slog->frame_dir_entry ).endtime   ) {
        if ( ( slog->cur_bbuf )->count_irec > 0 ) { 
            fprintf( errfile, __FILE__
                              ":SLOG_STM_UpdateFrameDirEntry_Forward() - "
                              "the current frame buffer's STARTtime ("
                              fmt_time") >  ENDtime ("fmt_time") !!!\n",
                              ( slog->frame_dir_entry ).starttime,
                              ( slog->frame_dir_entry ).endtime );
            fflush( errfile );
            return SLOG_FAIL;
        }
    }

    return SLOG_SUCCESS;
}



int SLOG_STM_UpdateFrameDirEntry_Backward(       SLOG_STREAM *slog,
                                           const SLOG_uint32  idx_of_cur_frame )
{
    SLOG_time   starttime_tmp;

    
    if ( idx_of_cur_frame >= (slog->frame_dir).Nframe ) {
        fprintf( errfile, __FILE__
                          ":SLOG_STM_UpdateFrameDirEntry_Backward() - \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_EOF;
    }

    /* 
        Update the SLOG_STREAM's internal data structure, frame_dir_entry,
        which is used in SLOG_STM_UpdateFRAME_Backward(),
    */
    ( slog->frame_dir_entry ).fptr2framehdr
    = ( slog->frame_dir ).entries[ idx_of_cur_frame ].fptr2framehdr;
    ( slog->frame_dir_entry ).starttime
    = ( slog->frame_dir ).entries[ idx_of_cur_frame ].starttime;
    ( slog->frame_dir_entry ).endtime
    = ( slog->frame_dir ).entries[ idx_of_cur_frame ].endtime;

    slog->file_dir_cur = slog->file_dir_hdr + SLOG_typesz[ FrameDirHdr ]
                       + idx_of_cur_frame * SLOG_typesz[ FrameDirEntry ];
    
    if ( idx_of_cur_frame > 0 ) return SLOG_SUCCESS;

    /* 
        The following statements are for the very 1st frame,
        with frame_idx = 0
    */

    /*  Update the Buffer's Frame Directory Entry  */

    if ( ( slog->frame_dir_entry ).fptr2framehdr == SLOG_fptr_NULL ) {
        fprintf( errfile, __FILE__":SLOG_STM_UpdateFrameDirEntry_Backward() - "
                          "the current frame buffer's Fptr2FrameHdr "
                          "is assigned NULL!\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }

    if ( SLOG_Bbuf_IsEmpty( slog->cur_bbuf ) ) {
        fprintf( errfile, __FILE__":SLOG_STM_UpdateFrameDirEntry_Backward() - "
                          "slog->cur_bbuf contains NO elements!\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }

    if ( ! SLOG_Bbuf_IsEmpty( slog->tmp_bbuf ) ) {
        starttime_tmp = SLOG_Bbuf_EarliestStarttime( slog->tmp_bbuf );
        if ( starttime_tmp < ( slog->frame_dir_entry ).starttime )
            ( slog->frame_dir_entry ).starttime = starttime_tmp;
    }

    /*  Update the (slog->frame_dir).entries[ idx_of_current_frame ]  */
    ( slog->frame_dir ).entries[ idx_of_cur_frame ].fptr2framehdr
    = ( slog->frame_dir_entry ).fptr2framehdr;
    ( slog->frame_dir ).entries[ idx_of_cur_frame ].starttime
    = ( slog->frame_dir_entry ).starttime;
    ( slog->frame_dir ).entries[ idx_of_cur_frame ].endtime
    = ( slog->frame_dir_entry ).endtime;

    return SLOG_SUCCESS;
}



void SLOG_STM_UpdateFrameHdrGiven(       SLOG_STREAM  *slog,
                                   const SLOG_uint32   Nbytes_cur_i,
                                   const SLOG_uint32   Nrec_cur_i,
                                   const SLOG_uint32   Nbytes_inc_i,
                                   const SLOG_uint32   Nrec_inc_i,
                                   const SLOG_uint32   Nbytes_pas_i,
                                   const SLOG_uint32   Nrec_pas_i,
                                   const SLOG_uint32   Nbytes_out_i, 
                                   const SLOG_uint32   Nrec_out_i )
{
    ( slog->frame_hdr ).Nbytes_cur = Nbytes_cur_i;
    ( slog->frame_hdr ).Nrec_cur   = Nrec_cur_i;
    ( slog->frame_hdr ).Nbytes_inc = Nbytes_inc_i;
    ( slog->frame_hdr ).Nrec_inc   = Nrec_inc_i;
    ( slog->frame_hdr ).Nbytes_pas = Nbytes_pas_i;
    ( slog->frame_hdr ).Nrec_pas   = Nrec_pas_i;
    ( slog->frame_hdr ).Nbytes_out = Nbytes_out_i;
    ( slog->frame_hdr ).Nrec_out   = Nrec_out_i;
}



/*
    This routine automatically updates the Frame Header,
    slog->frame_hdr, everytime when the frame is filled.  It is
    meant to be used right BEFORE Writing of the Frame Header
    to the disk or disk buffer.

    Currently, it is used in SLOG_STM_UpdateFRAME_Forward().
*/
void SLOG_STM_UpdateFrameHdr( SLOG_STREAM  *slog )
{
    ( slog->frame_hdr ).Nbytes_cur = ( slog->cur_bbuf )->Nbytes_in_file;
    ( slog->frame_hdr ).Nrec_cur   = ( slog->cur_bbuf )->count_irec;
    ( slog->frame_hdr ).Nbytes_inc = ( slog->inc_bbuf )->Nbytes_in_file;
    ( slog->frame_hdr ).Nrec_inc   = ( slog->inc_bbuf )->count_irec;
    ( slog->frame_hdr ).Nbytes_pas = ( slog->pas_bbuf )->Nbytes_in_file;
    ( slog->frame_hdr ).Nrec_pas   = ( slog->pas_bbuf )->count_irec;
    ( slog->frame_hdr ).Nbytes_out = ( slog->out_bbuf )->Nbytes_in_file;
    ( slog->frame_hdr ).Nrec_out   = ( slog->out_bbuf )->count_irec;
}



int SLOG_STM_DepositFrameHdr( const SLOG_framehdr_t *frame_hdr,
                                    filebuf_t       *fbuf )
{
    SLOG_uint32 Nbytes_written;
    int         ierr;

    Nbytes_written = 0;

    ierr = fbuf_deposit( &( frame_hdr->Nbytes_cur ),
                         SLOG_typesz[ ui32 ], 1, fbuf );
    if ( ierr < 1 ) {
        fprintf( errfile, __FILE__":SLOG_STM_DepositFrameHdr() - Cannot write "
                          "the Nbytes_cur to the SLOG filebuffer\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }
    Nbytes_written += ierr * SLOG_typesz[ ui32 ];

    ierr = fbuf_deposit( &( frame_hdr->Nrec_cur ),
                         SLOG_typesz[ ui32 ], 1, fbuf );
    if ( ierr < 1 ) {
        fprintf( errfile, __FILE__":SLOG_STM_DepositFrameHdr() - Cannot write "
                          "the Nrec_cur to the SLOG filebuffer\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }
    Nbytes_written += ierr * SLOG_typesz[ ui32 ];

    ierr = fbuf_deposit( &( frame_hdr->Nbytes_inc ),
                         SLOG_typesz[ ui32 ], 1, fbuf );
    if ( ierr < 1 ) {
        fprintf( errfile, __FILE__":SLOG_STM_DepositFrameHdr() - Cannot write "
                          "the Nbytes_inc to the SLOG filebuffer\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }
    Nbytes_written += ierr * SLOG_typesz[ ui32 ];

    ierr = fbuf_deposit( &( frame_hdr->Nrec_inc ),
                         SLOG_typesz[ ui32 ], 1, fbuf );
    if ( ierr < 1 ) {
        fprintf( errfile, __FILE__":SLOG_STM_DepositFrameHdr() - Cannot write "
                          "the Nrec_inc to the SLOG filebuffer\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }
    Nbytes_written += ierr * SLOG_typesz[ ui32 ];

    ierr = fbuf_deposit( &( frame_hdr->Nbytes_pas ),
                         SLOG_typesz[ ui32 ], 1, fbuf );