slog_recdefs.c

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

.N SLOG_RETURN_STATUS
@*/
int SLOG_RDEF_AddExtraRecDef(       SLOG_STREAM          *slog,
                              const SLOG_intvltype_t      intvltype,
                              const SLOG_bebit_t          bebit_0,
                              const SLOG_bebit_t          bebit_1,
                              const SLOG_N_assocs_t       Nassocs,
                              const SLOG_N_args_t         Nargs )
{
    SLOG_recdefs_table_t   *recdefs;
    SLOG_fptr               file_loc_saved;
    SLOG_uint32             idx;
    int                     ierr;

    recdefs = slog->rec_defs;

#if defined( DEBUG )
    if ( recdefs == NULL ) {
        fprintf( errfile, __FILE__":SLOG_RDEF_AddExtraRecDef() - "
                          "the SLOG_recdefs_table_t pointer in slog "
                          "is NULL\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }
#endif

    if ( recdefs->Nentries + 1 > recdefs->capacity ) {
        fprintf( errfile, __FILE__":SLOG_RDEF_AddExtraRecDef() - \n"
                          "\t""All reserved space in the "
                          "Record Definition Table of the logfile "
                          "has been used up!\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }

    idx = recdefs->Nentries;
    SLOG_RecDef_Assign( &( recdefs->entries[ idx ] ),
                        intvltype, bebit_0, bebit_1, Nassocs, Nargs );
    SLOG_RecDef_SetUsed( &( recdefs->entries[ idx ] ), SLOG_FALSE );
    if ( SLOG_RDEF_IsDuplicated( recdefs, &(recdefs->entries[ idx ]) ) ) {
        fprintf( errfile, __FILE__":SLOG_RDEF_AddExtraRecDef() - "
                          "there is a copy of input record\n " );
        fprintf( errfile, "\t""definition with identical keys "
                          "in the SLOG record definition table\n" );
        fprintf( errfile, "\t""The input record definition = [ "fmt_itype_t
                          ", ("fmt_bebit_t", "fmt_bebit_t
                          "), "fmt_Nassocs_t", "fmt_Nargs_t" ] \n",
                          intvltype, bebit_0, bebit_1, Nassocs, Nargs );
        fflush( errfile );
        return SLOG_FAIL;
    }
    recdefs->Nentries += 1;

    /*  Save the current position in the logfile for later restoration  */
    file_loc_saved = slog_ftell( slog->fd );

    /*  Update the number of record definitions on the file/disk  */
    ierr = slog_fseek( slog->fd, slog->hdr->fptr2recdefs, SEEK_SET );
    if ( ierr != 0 ) {
        fprintf( errfile, __FILE__":SLOG_RDEF_AddExtraRecDef() - "
                          "slog_fseek( fptr2recdefs ) fails\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }
    ierr = bswp_fwrite( &( recdefs->Nentries ),
                        sizeof( SLOG_uint32 ), 1, slog->fd );
    if ( ierr < 1 ) {
        fprintf( errfile,  __FILE__":SLOG_RDEF_AddExtraRecDef() - \n"
                           "\t""Update the number of entries in the record "
                           "definition table on the file fails\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }

    /*  Insert the new record definition to the reserved space  */
    ierr = slog_fseek( slog->fd, recdefs->file_loc, SEEK_SET );
    if ( ierr != 0 ) {
        fprintf( errfile, __FILE__":SLOG_RDEF_AddExtraRecDef() - "
                          "slog_fseek( recdefs->file_loc ) fails\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }
    ierr = SLOG_RecDef_WriteToFile( &( recdefs->entries[idx] ), slog->fd );
    if ( ierr != SLOG_TRUE ) {
        fprintf( errfile,  __FILE__":SLOG_RDEF_AddExtraRecDef() - \n"
                           "\t""SLOG_RecDef_WriteToFile() fails at "
                           "%d-th addition of the record definition to "
                           "table section of logfile\n", idx );
        fflush( errfile );
        return SLOG_FAIL;
    }
    fflush( slog->fd );

    /*  Update the file pointer to the reserved space of RecDefs in file */
    recdefs->file_loc = slog_ftell( slog->fd );

    /*  Restore the original file position in the logfile  */
    ierr = slog_fseek( slog->fd, file_loc_saved, SEEK_SET );

    return SLOG_SUCCESS;
}



SLOG_recdef_t *SLOG_RDEF_GetRecDef( const SLOG_recdefs_table_t   *recdefs,
                                    const SLOG_intvltype_t        intvltype,
                                    const SLOG_bebit_t            bebit_0,
                                    const SLOG_bebit_t            bebit_1 )
{
    SLOG_recdef_t  *cur_def;
    int             ii;

    for ( ii = 0; ii < (int)recdefs->Nentries; ii++ ) {
        cur_def = &( recdefs->entries[ ii ] );
        if (    ( cur_def->intvltype == intvltype )
             && ( cur_def->bebits[0] == bebit_0 )
             && ( cur_def->bebits[1] == bebit_1 ) ) {
             return cur_def;
        }
    }

    fprintf( errfile, __FILE__":SLOG_RDEF_GetRecDef() - \n"
                      "\t""Cannot find [ intvltype = "fmt_itype_t", ("
                      fmt_bebit_t", "fmt_bebit_t") ] "
                      "in the Record Definition Table\n",
                      intvltype, bebit_0, bebit_1 );
    fflush( errfile );
    return NULL;
}



static int SLOG_RecDef_CompareKey( const SLOG_recdef_t *def1,
                                   const SLOG_recdef_t *def2 )
{
    int order1, order2;

    if ( def1->intvltype < def2->intvltype )
        return -1;
    else if ( def1->intvltype == def2->intvltype ) {
        order1 = SLOG_bebits_GetOrder( def1->bebits );
        order2 = SLOG_bebits_GetOrder( def2->bebits );
        if ( order1 < order2 )
            return -1;
        else if ( order1 == order2 )
            return 0;
        else
            return 1;
    }    
    else
        return 1;
}



static int SLOG_RecDef_CompareKeyFn( const void *def1, const void *def2 )
{
    return( SLOG_RecDef_CompareKey( (SLOG_recdef_t *) def1,
                                    (SLOG_recdef_t *) def2 ) );
}



void SLOG_RDEF_SortTable( SLOG_recdefs_table_t *recdefs )
{
    qsort( recdefs->entries, recdefs->Nentries, sizeof( SLOG_recdef_t ),
           &SLOG_RecDef_CompareKeyFn );
}



int SLOG_RDEF_IsBebitIntvlsConsistent( SLOG_recdefs_table_t *recdefs )
{
    SLOG_recdef_t          *recdef;
    SLOG_recdef_t           joined_def;
    SLOG_uint32             idx_begin, idx_end;
    SLOG_uint32             ii, jj;
    int                     DoPartIntvlsExist4itype;

#if defined( DEBUG )
    if ( recdefs == NULL ) {
        fprintf( errfile, __FILE__":SLOG_RDEF_IsBebitIntvlsConsistent() - \n"
                          "\t""the SLOG_recdefs_table_t pointer in slog "
                          "is NULL\n" );
        fflush( errfile );
        return SLOG_FALSE;
    }
#endif

    /*  Sort the table in increasing intvltype and bebits order  */
    SLOG_RDEF_SortTable( recdefs );

    /*
        The following statements assume intvltype will be changed when
        bebits are recycled
    */
    DoPartIntvlsExist4itype = SLOG_FALSE;
    idx_begin               = 0;
    for ( ii = 0; ii < recdefs->Nentries; ii++ ) {
        recdef = &( recdefs->entries[ ii ] );
        if ( ! SLOG_bebits_IsWholeIntvl( recdef->bebits ) ) {
            if ( ! DoPartIntvlsExist4itype ) {
                /*  The 1st bebit interval  */
                idx_begin = ii;
                SLOG_RecDef_Assign( &joined_def,
                                    recdef->intvltype, 1, 1,
                                    recdef->Nassocs, recdef->Nargs );
            }
            else {
                /*  The non-1st bebit interval, but NOT whole interval  */
                idx_end = ii;
                if (    recdef->intvltype != joined_def.intvltype
                     || recdef->Nassocs   != joined_def.Nassocs )
                {
                    fprintf( errfile, __FILE__
                                      ":SLOG_RDEF_IsBebitIntvlsConsistent() -\n"
                                      "\t""Inconsistency detected for "
                                      "intvltype = "fmt_itype_t"\n",
                                      recdef->intvltype );
                    for ( jj = idx_begin; jj <= idx_end; jj++ ) {
                        fprintf( errfile, "%d, ", jj );
                        SLOG_RecDef_Print( &( recdefs->entries[ jj ] ),
                                           errfile );
                        fprintf( errfile, "\n" );
                    }
                    fflush( errfile );
                    return SLOG_FALSE;
                }
                joined_def.Nargs   += recdef->Nargs;
            }
            DoPartIntvlsExist4itype  = SLOG_TRUE;
        }
        else {  /*  if ( SLOG_bebits_IsWholeIntvl( recdef->bebits ) )  */
            /*  The whole bebit interval  */
            idx_end = ii;
            if ( DoPartIntvlsExist4itype ) {
                if ( ! SLOG_RecDef_IsValueEqualTo( recdef, &joined_def ) ) {
                    fprintf( errfile, __FILE__
                                      ":SLOG_RDEF_IsBebitIntvlsConsistent() -\n"
                                      "\t""Inconsistency detected for "
                                      "intvltype = "fmt_itype_t"\n",
                                      recdef->intvltype );
                    for ( jj = idx_begin; jj <= idx_end; jj++ ) {
                        fprintf( errfile, "%d, ", jj );
                        SLOG_RecDef_Print( &( recdefs->entries[ jj ] ),
                                           errfile );
                        fprintf( errfile, "\n" );
                    }
                    fflush( errfile );
                    return SLOG_FALSE;
                }
            }
            DoPartIntvlsExist4itype = SLOG_FALSE;
        }
    }

    return SLOG_TRUE;
}



int SLOG_RDEF_CompressTable( SLOG_recdefs_table_t *recdefs )
{
    SLOG_recdef_t          *entries_used;
    SLOG_recdef_t          *recdef;
    SLOG_intvltype_t        prev_used_itype;
    SLOG_uint32             Nentries_used;
    SLOG_uint32             idx, ii;
    int                     itmp;

#if defined( DEBUG )
    if ( recdefs == NULL ) {
        fprintf( errfile, __FILE__":SLOG_RDEF_CompressTable() - "
                          "the SLOG_recdefs_table_t pointer in slog "
                          "is NULL\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }
#endif

    /*  Sort the table in increasing intvltype and bebits order  */
    SLOG_RDEF_SortTable( recdefs );

    /*  Set idx to first non scanned but used entry  */
    itmp = -1; 
    for ( idx = 0; idx < recdefs->Nentries && itmp != -1; idx++ ) {
        recdef = &( recdefs->entries[ idx ] );
        if ( recdef->used )
            itmp = recdef->intvltype;
    }
    
    /* 
        If any of partial bebit intervals is set,
        set the whole interval as used
    */
    for ( prev_used_itype = itmp; idx < recdefs->Nentries; idx++ ) {
        recdef = &( recdefs->entries[ idx ] );
        if ( recdef->used )
            prev_used_itype = recdef->intvltype;
        else {
            if (    SLOG_bebits_IsWholeIntvl( recdef->bebits ) 
                 && recdef->intvltype == prev_used_itype ) {
                 SLOG_RecDef_SetUsed( recdef, SLOG_TRUE );
            }
        }
    }

    /*  Compute the Number of __used__ entries in the record def table  */
    Nentries_used = 0;
    for ( ii = 0; ii < recdefs->Nentries; ii++ )
         if ( ( recdefs->entries[ ii ] ).used )
             Nentries_used++;

    if ( Nentries_used == recdefs->Nentries )
        return SLOG_SUCCESS;

    /*  Allocate the temporary storage for the used definition  */
    entries_used = ( SLOG_recdef_t * ) malloc(   Nentries_used
                                               * sizeof( SLOG_recdef_t ) );
    if ( Nentries_used > 0 && entries_used == NULL ) {
        fprintf( errfile, __FILE__":SLOG_RDEF_CompressTable() - \n"
                          "\t""malloc() for temporary storage, "
                          "entries_used, fails for Nentries_used = "
                          fmt_ui32" ! \n", Nentries_used );
        fflush( errfile );
        return SLOG_FAIL;
    }

    /*  Copy the used record definitions to the temporary storage  */
    idx = 0;
    for ( ii = 0; ii < recdefs->Nentries; ii++ ) {
        if ( ( recdefs->entries[ ii ] ).used ) {
            recdef = &( recdefs->entries[ ii ] );
            SLOG_RecDef_Assign( &( entries_used[ idx ] ),
                                recdef->intvltype,
                                recdef->bebits[0], recdef->bebits[1],
                                recdef->Nassocs, recdef->Nargs );
            idx++;
        }
    }

    /*  Throw away the original record definition table  */
    if ( recdefs->Nentries > 0 && recdefs->entries != NULL ) {
        free( recdefs->entries );
        recdefs->entries    = NULL;
        recdefs->capacity   = 0;
        recdefs->Nentries   = 0;
    }

    /*  
        Shrink the original table in memory to store the used definitions 
        by pointing the record definition table to the temporary storage.
    */
    recdefs->capacity   = Nentries_used;
    recdefs->Nentries   = Nentries_used;
    recdefs->entries    = entries_used;

    return SLOG_SUCCESS;
}



/*
    Update the disk content of record definition table to reflect
    the compression done on the table in memory
*/
int SLOG_RDEF_CompressedTableToFile( SLOG_STREAM  *slog )
{
    SLOG_recdefs_table_t   *recdefs;
    SLOG_fptr               file_loc_saved;
    SLOG_uint32             ii;
    int                     ierr;

    recdefs = slog->rec_defs;

#if defined( DEBUG )
    if ( recdefs == NULL ) {