slog_impl.c

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

         && ( slog->frame_dir ).entries == NULL ) {
        fprintf( errfile, __FILE__":SLOG_WriteInitFrameDir() - malloc() calls "
                          "for ( slog->frame_dir ).entries[] fails\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }

    for ( ii = 0; ii < (int)slog->hdr->max_Ndirframe; ii ++ ){
        ( ( slog->frame_dir ).entries[ ii ] ).fptr2framehdr
        = SLOG_fptr_NULL;
        ( ( slog->frame_dir ).entries[ ii ] ).starttime
        = SLOG_time_NULL;
        ( ( slog->frame_dir ).entries[ ii ] ).endtime
        = SLOG_time_NULL;
    }

  /*
      Set the SLOG buffer's Frame Directory pointer to the
      beginning of Frame Directory
  */
    fflush( slog->fd );
    slog->file_dir_hdr = slog_ftell( slog->fd );

  /*
      Write the initialization section of the frame directory 
  */
    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 );

  /*
      Set the SLOG buffer's Frame Directory CURRENT Entry pointer to the
      1st entry of Frame Directory 
  */
    fflush( slog->fd );
    slog->file_dir_cur = slog_ftell( slog->fd );

#if defined( DEBUG )
    if (    slog->file_dir_cur - slog->file_dir_hdr
         != SLOG_typesz[ FrameDirHdr ] ) {
        fprintf( errfile, __FILE__":SLOG_WriteInitFrameDir() -  Inconsistency "
                          " between file pointers\n" );
        fprintf( errfile, "      ""slog->file_dir_cur("fmt_fptr") - "
                          "slog->file_dir_hdr("fmt_fptr") "
                          "!= SLOG_typesz[ FrameDirHdr ]("fmt_ui32")\n",
                          slog->file_dir_cur, slog->file_dir_hdr,
                          SLOG_typesz[ FrameDirHdr ] );
        fflush( errfile );
        return SLOG_FAIL;
    }
#endif

    for ( ii = 0; ii < (int)slog->hdr->max_Ndirframe; ii ++ ) {
        SLOG_WriteFrameDirEntryGiven( slog->fd, 
                                      &( ( slog->frame_dir ).entries[ ii ] )
                                    );
    }

  /*
      Save the location of the end of the Frame Directory
      For writing of the 1st Frame Header and Buffer.
  */
    fflush( slog->fd );
    slog->file_loc = slog_ftell( slog->fd );

#if defined( DEBUG )
    if (    slog->file_loc - slog->file_dir_cur 
         != slog->hdr->max_Ndirframe * SLOG_typesz[ FrameDirEntry ] ) {
        fprintf( errfile, __FILE__":SLOG_WriteInitFrameDir() -  Inconsistency "
                          " between file pointers\n" );
        fprintf( errfile, "      ""slog->file_loc("fmt_fptr") - "
                          "slog->file_dir_cur("fmt_fptr") "
                          "!= SLOG_typesz[ FrameDirEntries ]("fmt_ui32")\n",
                          slog->file_loc, slog->file_dir_cur,
                          slog->hdr->max_Ndirframe
                          * SLOG_typesz[ FrameDirEntry ] );
        fflush( errfile );
        return SLOG_FAIL;
    }
#endif

    return SLOG_SUCCESS;
}



int SLOG_ReadFrameDir( SLOG_STREAM *slog )
{
    int ii;

  /*
      Set the SLOG buffer's Frame Directory pointer to the
      beginning of Frame Directory
  */
    slog->file_dir_hdr = slog_ftell( slog->fd );

  /*
      Read in the Frame Directory header
  */
    bswp_fread( &( ( slog->frame_dir ).prevdir ),
                SLOG_typesz[ fptr ], 1, slog->fd );
    bswp_fread( &( ( slog->frame_dir ).nextdir ),
                SLOG_typesz[ fptr ], 1, slog->fd );
    bswp_fread( &( ( slog->frame_dir ).Nframe ),
                SLOG_typesz[ ui32 ], 1, slog->fd );

  /*
      Allocate the memory for the Frame Directory
  */
    ( slog->frame_dir ).entries
    = ( SLOG_dir_entry_t * ) malloc( ( slog->frame_dir ).Nframe
                                   * sizeof( SLOG_dir_entry_t ) );
    if (    ( slog->frame_dir ).Nframe > 0
         && ( slog->frame_dir ).entries == NULL ) {
        fprintf( errfile, __FILE__":SLOG_ReadFrameDir() - malloc() calls "
                          "for ( slog->frame_dir ).entries[] fails\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }

  /*
      Set the SLOG buffer's Frame Directory CURRENT Entry pointer to the
      1st entry of Frame Directory 
  */
    slog->file_dir_cur = slog_ftell( slog->fd );

#if defined( DEBUG )
    if (    slog->file_dir_cur - slog->file_dir_hdr
         != SLOG_typesz[ FrameDirHdr ] ) {
        fprintf( errfile, __FILE__":SLOG_ReadFrameDir() -  Inconsistency "
                          " between file pointers\n" );
        fprintf( errfile, "      ""slog->file_dir_cur("fmt_fptr") - "
                          "slog->file_dir_hdr("fmt_fptr") "
                          "!= SLOG_typesz[ FrameDirHdr ]("fmt_ui32")\n", 
                          slog->file_dir_cur, slog->file_dir_hdr,
                          SLOG_typesz[ FrameDirHdr ] );
        fflush( errfile );
        return SLOG_FAIL;
    }
#endif

  /*
      Read in the Frame Directory records entries
  */
    for ( ii = 0; ii < (int)( slog->frame_dir ).Nframe; ii ++ )
        SLOG_ReadFrameDirEntry( slog->fd,
                                &( (slog->frame_dir).entries[ ii ] )
                              );
  
  /*
      Save the location of the end of the Frame Directory
      For writing of the 1st Frame Header and Buffer.
  */
    slog->file_loc = slog_ftell( slog->fd );

#if defined( DEBUG )
    if (    slog->file_loc - slog->file_dir_cur
         != ( slog->frame_dir ).Nframe * SLOG_typesz[ FrameDirEntry ] ) {
        fprintf( errfile, __FILE__":SLOG_ReadFrameDir() -  Inconsistency "
                          " between file pointers\n" );
        fprintf( errfile, "      ""slog->file_loc("fmt_fptr") - "
                          "slog->file_dir_cur("fmt_fptr") "
                          "!= SLOG_typesz[ FrameDirEntries ]("fmt_ui32")\n",
                          slog->file_loc, slog->file_dir_cur,
                          ( slog->frame_dir ).Nframe
                          * SLOG_typesz[ FrameDirEntry ] );
        fflush( errfile );
        return SLOG_FAIL;
    }
#endif

    return SLOG_SUCCESS;
}



/*  Simple update the Frame Directory Entry  */
int SLOG_WriteFrameDirEntryGiven(       FILE             *slog_fd,
                                  const SLOG_dir_entry_t *framedir_entry )
{
    bswp_fwrite( &( framedir_entry->fptr2framehdr ),
                 SLOG_typesz[ fptr ], 1, slog_fd );
    bswp_fwrite( &( framedir_entry->starttime )    ,
                 SLOG_typesz[  ts  ], 1, slog_fd );
    bswp_fwrite( &( framedir_entry->endtime )      ,
                 SLOG_typesz[  ts  ], 1, slog_fd );

    return SLOG_SUCCESS;
}



/*  Simple update the Frame Directory Entry  */
int SLOG_ReadFrameDirEntry( FILE             *slog_fd,
                            SLOG_dir_entry_t *framedir_entry )
{
    bswp_fread( &( framedir_entry->fptr2framehdr ),
                SLOG_typesz[ fptr ], 1, slog_fd );
    bswp_fread( &( framedir_entry->starttime )    ,
                SLOG_typesz[  ts  ], 1, slog_fd );
    bswp_fread( &( framedir_entry->endtime )      ,
                SLOG_typesz[  ts  ], 1, slog_fd );

    return SLOG_SUCCESS;
}



/*  Update the Frame Directory Entry by looking the SLOG_STREAM.file_dir_rec  */
int SLOG_WriteUpdatedFrameDirEntry( SLOG_STREAM  *slog )
{
    SLOG_fptr file_loc_saved;
    SLOG_fptr offset;
    SLOG_time starttime;
    SLOG_time endtime;
    int       ierr;


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

    offset    = ( slog->frame_dir_entry ).fptr2framehdr;
    starttime = ( slog->frame_dir_entry ).starttime;
    endtime   = ( slog->frame_dir_entry ).endtime;

    /*  Point to the current frame directory entry for writing  */
    ierr = slog_fseek( slog->fd, slog->file_dir_cur, SEEK_SET );
    if ( ierr != 0 ) {
        fprintf( errfile, __FILE__":SLOG_WriteUpdatedFrameDirEntry() - "
                          "slog_fseek("fmt_fptr") fails\n",
                          slog->file_dir_cur );
        fprintf( errfile, "\tCannot load the current frame directory entry\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }

    /*  Writing the current Directory Entry  */
    ierr = bswp_fwrite( &offset   , SLOG_typesz[ fptr ], 1, slog->fd );
    if ( ierr < 1 ) {
        fprintf( errfile, __FILE__":SLOG_WriteUpdatedFrameDirEntry() - "
                          "Cannot write the OFFSET to the SLOG file\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }
    ierr = bswp_fwrite( &starttime, SLOG_typesz[  ts  ], 1, slog->fd );
    if ( ierr < 1 ) {
        fprintf( errfile, __FILE__":SLOG_WriteUpdatedFrameDirEntry() - "
                          "Cannot write the STARTtime to the SLOG file\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }
    ierr = bswp_fwrite( &endtime  , SLOG_typesz[  ts  ], 1, slog->fd );
    if ( ierr < 1 ) {
        fprintf( errfile, __FILE__":SLOG_WriteUpdatedFrameDirEntry() - "
                          "Cannot write the ENDtime to the SLOG file\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }

  /*
      Update the SLOG buffer's Frame Directory CURRENT Entry pointer to the
      Next entry of Frame Directory 
  */
    fflush( slog->fd );
    slog->file_dir_cur = slog_ftell( 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_WriteUpdatedFrameDirEntry() - "
                          "\t""slog_fseek() fails, cannot restore the "
                          "original file position before the subroutine "
                          "call\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }

    return SLOG_SUCCESS;
}



/*  **************  LOWER Level API  **************  */


/*
    The index returned by SLOG_STM_IdxOfCurFrameDirEntry() starts from 0.
*/
int SLOG_STM_IdxOfCurFrameDirEntry( const SLOG_STREAM *slog )
{
    SLOG_fptr entry0;
    SLOG_fptr entry0_entryCUR;
    SLOG_fptr ifptr;

    entry0          = slog->file_dir_hdr + SLOG_typesz[ FrameDirHdr ];
    entry0_entryCUR = slog->file_dir_cur - entry0;

    if ( entry0_entryCUR % SLOG_typesz[ FrameDirEntry ] != 0 ) {
        fprintf( errfile, __FILE__":SLOG_STM_IdxOfCurFrameDirEntry() - "
                          "entry0_entryCUR("fmt_fptr") is indivisable by "
                          "SLOG_typesz[ FrameDirEntry ]("fmt_ui32")\n",
                          entry0_entryCUR, SLOG_typesz[ FrameDirEntry ] );
        fflush( errfile );
        return SLOG_FAIL;
    }

    ifptr = entry0_entryCUR / SLOG_typesz[ FrameDirEntry ];

    if ( ifptr >= slog->hdr->max_Ndirframe ) { 
        fprintf( errfile, __FILE__":SLOG_STM_IdxOfCurFrameDirEntry() - "
                          "ifptr("fmt_fptr") is bigger than the largest "
                          "value(%d)\n", ifptr, slog->hdr->max_Ndirframe );
        fflush( errfile );
        return SLOG_FAIL;
    }

    if ( ifptr >= (slog->frame_dir).Nframe ) {
        /*
        fprintf( errfile, __FILE__":SLOG_STM_IdxOfCurFrameDirEntry() - "
                          "ifptr("fmt_fptr") is bigger Number of Frame("
                          fmt_ui32") in File Frame Directory\n",
                          ifptr, (slog->frame_dir).Nframe );
        fflush( errfile );
        */
        return SLOG_EOF;
    }

    return (int) ifptr;
}



void SLOG_STM_Init( SLOG_STREAM *slog )
{
    const SLOG_uint32 zero = (SLOG_uint32) 0;

    /*  Initialize the Frame Direcrtory Header in the buffer  */
    /*  This is only done ONCE for SINGLE directory SLOG file */

    SLOG_STM_UpdateFrameDirHdrGiven( slog, SLOG_fptr_NULL,
                                     SLOG_fptr_NULL, zero );
    
    /*  Initialize the frame header in the buffer  */
    SLOG_STM_UpdateFrameHdrGiven( slog, zero, zero, zero, zero,
                                        zero, zero, zero, zero );

    /*  Initialize the bi-directional list buffers & related variables  */
    SLOG_Bbuf_Init( slog->cur_bbuf );
    SLOG_Bbuf_Init( slog->inc_bbuf );
    SLOG_Bbuf_Init( slog->pas_bbuf );
    SLOG_Bbuf_Init( slog->out_bbuf );
    SLOG_Bbuf_Init( slog->tmp_bbuf );
}



void SLOG_STM_UpdateFrameDirHdrGiven(       SLOG_STREAM       *slog,
                                      const SLOG_fptr          prevdir_i,
                                      const SLOG_fptr          nextdir_i,