slog_profile.c

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

    int                     ierr;

    slog->prof = ( SLOG_prof_t * ) malloc( sizeof( SLOG_prof_t ) );
    if ( slog->prof == NULL ) {
        fprintf( errfile, __FILE__":SLOG_PROF_ReadIntvlInfos() - "
                          "malloc() fails, Cannot allocate memory for "
                          "SLOG_prof_t\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }

    /*  Initialize the Record Definition table data structure  */
    slog->prof->increment  = 10;
    slog->prof->capacity   = slog->prof->increment;
    slog->prof->Nentries   = 0;
    slog->prof->entries    = NULL;
    
    /*  Seek to the beginning of the Record Def'n Table in the SLOG file  */
    if ( slog->hdr->fptr2profile == SLOG_fptr_NULL ) {
        fprintf( errfile, __FILE__":SLOG_PROF_ReadIntvlInfos() - "
                          "slog->hdr->fptr2profile == SLOG_fptr_NULL\n" );
        fprintf( errfile, "\t""SLOG_PROF_Close() may NOT be called\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }
    ierr = slog_fseek( slog->fd, slog->hdr->fptr2profile, SEEK_SET );
    if ( ierr != 0 ) {
        fprintf( errfile, __FILE__":SLOG_PROF_ReadIntvlInfos() - "
                          "slog_fseek( fptr2profile ) fails\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }

    /*  Read in the data structure  */
    profile = slog->prof;
    
    ierr = bswp_fread( &( profile->Nentries ),
                       sizeof( SLOG_uint32 ), 1, slog->fd );
    if ( ierr < 1 ) {
        fprintf( errfile, __FILE__":SLOG_PROF_ReadIntvlInfos() - \n"
                          "\t""Fails at reading the number of entries "
                          "of the display profile table\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }
    profile->capacity = profile->Nentries;
    profile->entries  = ( SLOG_intvlinfo_t * )
                        malloc( profile->capacity
                              * sizeof( SLOG_intvlinfo_t ) );
    if ( profile->Nentries > 0 && profile->entries == NULL ) {
        fprintf( errfile, __FILE__":SLOG_PROF_ReadIntvlInfos() - "
                          "malloc() fails for profile->entries[]\n" );
        fflush( errfile );
        return SLOG_FAIL;
    }
    
    for ( ii = 0; ii < (int)profile->Nentries; ii++ ) {
        ierr = SLOG_IntvlInfo_ReadFromFile( &( profile->entries[ ii ] ), 
                                            slog->fd );
        if ( ierr != SLOG_TRUE ) {
            fprintf( errfile, __FILE__":SLOG_PROF_ReadIntvlInfos() - \n"
                              "\t""SLOG_IntvlInfo_ReadFromFile() fails at "
                              "%d-th reading of interval decriptor from "
                              "the table section of logfile\n", ii );
            fflush( errfile ); 
            return SLOG_FAIL;
        }
    }

#if defined( DEBUG )
    fprintf( outfile, __FILE__":SLOG_PROF_ReadIntvlInfos() - Read\n" );
    SLOG_PROF_Print( outfile, profile );
    fflush( outfile );
#endif
  
    return SLOG_SUCCESS;
}



void SLOG_PROF_Print( FILE* fd, const SLOG_prof_t *profile )
{
    int ii;

    for ( ii = 0; ii < (int)profile->Nentries; ii++ ) {
        fprintf( fd, " def[%i] = ", ii );
        SLOG_IntvlInfo_Print( &( profile->entries[ ii ] ), fd );
        fprintf( fd, "\n" );
    }
    fflush( fd );
}



/*  -- Component level supporting subroutines  -- */

        /* SLOG_IntvlInfo_xxxx methods */

void SLOG_IntvlInfo_Assign(       SLOG_intvlinfo_t        *intvlinfo,
                            const SLOG_intvltype_t         in_intvltype,
                            const SLOG_bebit_t             in_bebit_0,
                            const SLOG_bebit_t             in_bebit_1,
                            const char *                   in_classtype,
                            const char *                   in_label,
                            const char *                   in_color )
{
    intvlinfo->intvltype = in_intvltype;
    intvlinfo->bebits[0] = in_bebit_0;
    intvlinfo->bebits[1] = in_bebit_1;
    SLOG_str_ncopy_set( intvlinfo->classtype, in_classtype, SLOG_STRING_LEN );
    SLOG_str_ncopy_set( intvlinfo->label,     in_label,     SLOG_STRING_LEN );
    SLOG_str_ncopy_set( intvlinfo->color,     in_color,     SLOG_STRING_LEN );
}



void SLOG_IntvlInfo_Print( const SLOG_intvlinfo_t *info, FILE *fd )
{
    fprintf( fd, "[ "fmt_itype_t", ("fmt_bebit_t", "fmt_bebit_t"), %s, %s, %s",
                 info->intvltype, info->bebits[0], info->bebits[1],
                 info->classtype, info->label, info->color );
  
    if ( info->arg_labels != NULL ) {
        fprintf( fd, " : " );
        SLOG_StrList_Print( info->arg_labels, fd );
    }

    fprintf( fd, " ]" );
}



int SLOG_IntvlInfo_WriteToFile( SLOG_intvlinfo_t *info, FILE *fd )
{
    const char          delimiter = '\t';
    const char          newline   = '\n';
          char          intvltype_str[ SLOG_STRING_LEN ]    = SLOG_STRING_INIT;
          char          bebits_str[ SLOG_STRING_LEN ]       = SLOG_STRING_INIT;
          char          N_arg_labels_str[ SLOG_STRING_LEN ] = SLOG_STRING_INIT;
          SLOG_bebits_t bebits;
          SLOG_uint32   N_arg_labels;
          int           lgth;
          int           ierr;

    /*  snprintf() counts '\0' in the copied char length parameter  */
    /*
    ierr = bswp_fwrite( &( info->intvltype ),
                        sizeof( SLOG_intvltype_t ), 1, fd );
    if ( ierr < 1 ) return SLOG_FALSE;
    ierr = snprintf( intvltype_str,
                     lgth, "%u", info->intvltype );
    */

    lgth = SLOG_STRING_LEN - 2;

    sprintf( intvltype_str, fmt_itype_t, info->intvltype );
    if ( intvltype_str[ lgth+1 ] != ' ' ) {
        fprintf( errfile, __FILE__":SLOG_IntvlInfo_WriteToFile() - \n"
                          "\t""intvltype of input SLOG_intvlinfo_t is "
                          "too large to fit into %d characters, intvltype "
                          "= "fmt_itype_t"\n", lgth, info->intvltype );
        fflush( errfile ); 
        return SLOG_FALSE;
    }
    intvltype_str[ lgth+1 ] = delimiter;
    ierr = bswp_fwrite( intvltype_str,
                        sizeof( char ), SLOG_STRING_LEN, fd );
    if ( ierr < SLOG_STRING_LEN ) return SLOG_FALSE;

    bebits = SLOG_bebits_encode( info->bebits[0], info->bebits[1] );
    sprintf( bebits_str, fmt_bebits_t, bebits );
    if ( bebits_str[ lgth+1 ] != ' ' ) {
        fprintf( errfile, __FILE__":SLOG_IntvlInfo_WriteToFile() - \n"
                          "\t""encoded bebits of input SLOG_intvlinfo_t is "
                          "too large to fit into %d characters, encoded_bebits "
                          "= "fmt_bebits_t"\n", lgth, bebits );
        fflush( errfile ); 
        return SLOG_FALSE;
    }
    bebits_str[ lgth+1 ] = delimiter;
    ierr = bswp_fwrite( bebits_str,
                        sizeof( char ), SLOG_STRING_LEN, fd );
    if ( ierr < SLOG_STRING_LEN ) return SLOG_FALSE;

    info->classtype[ lgth+1 ] = delimiter;
    ierr = bswp_fwrite( &( info->classtype ),
                        sizeof( char ), SLOG_STRING_LEN, fd );
    if ( ierr < SLOG_STRING_LEN ) return SLOG_FALSE;

    info->label[ lgth+1 ] = delimiter;
    ierr = bswp_fwrite( &( info->label ),
                        sizeof( char ), SLOG_STRING_LEN, fd );
    if ( ierr < SLOG_STRING_LEN ) return SLOG_FALSE;

    info->color[ lgth+1 ] = delimiter;
    ierr = bswp_fwrite( &( info->color ),
                        sizeof( char ), SLOG_STRING_LEN, fd );
    if ( ierr < SLOG_STRING_LEN ) return SLOG_FALSE;

    if ( info->arg_labels != NULL )
        N_arg_labels = 1;
    else 
        N_arg_labels = 0;

    sprintf( N_arg_labels_str, fmt_ui32, N_arg_labels );
    if ( N_arg_labels_str[ lgth+1 ] != ' ' ) {
        fprintf( errfile, __FILE__":SLOG_IntvlInfo_WriteToFile() - \n"
                          "\t""N_arg_labels of input SLOG_intvlinfo_t is "
                          "too large to fit into %d characters, N_arg_labels "
                          "= "fmt_ui32"\n", lgth, N_arg_labels );
        fflush( errfile ); 
        return SLOG_FALSE;
    }
    N_arg_labels_str[ lgth+1 ] = delimiter;
    ierr = bswp_fwrite( N_arg_labels_str,
                        sizeof( char ), SLOG_STRING_LEN, fd );
    if ( ierr < SLOG_STRING_LEN ) return SLOG_FALSE;

    switch ( N_arg_labels ) {
    case 0 :
        break;
    case 1 :
        ierr = SLOG_StrList_WriteToFileAsStrs( info->arg_labels, fd );
        if ( ierr != SLOG_SUCCESS ) {
            fprintf( errfile, __FILE__":SLOG_IntvlInfo_WriteToFile() - \n"
                              "\t""SLOG_StrList_WriteToFileAsStrs() fails "
                              "for the arg_labels :\n\t" );
            SLOG_StrList_Print( info->arg_labels, errfile );
            fprintf( errfile, "\n" ); 
            fflush( errfile ); 
            return SLOG_FALSE;
        }
        break;
    default :
        fprintf( errfile, __FILE__":SLOG_IntvlInfo_WriteToFile() - \n"
                          "\t""The invalid N_arg_labels is "fmt_ui32"\n",
                          N_arg_labels );
        fflush( errfile ); 
        return SLOG_FALSE;
    }

    ierr = bswp_fwrite( &newline, sizeof( char ), 1, fd );
    if ( ierr < 1 ) return SLOG_FALSE;

    return SLOG_TRUE;
}



int SLOG_IntvlInfo_ReadFromFile( SLOG_intvlinfo_t *info, FILE *fd )
{
          char          newline = '\n';
          char          intvltype_str[ SLOG_STRING_LEN ];
          char          bebits_str[ SLOG_STRING_LEN ];
          char          N_arg_labels_str[ SLOG_STRING_LEN ];
          SLOG_bebits_t bebits;
          SLOG_uint32   N_arg_labels;
          int           ierr;

    /*
    ierr = bswp_fread( &( info->intvltype ),
                       sizeof( SLOG_intvltype_t ), 1, fd );
    if ( ierr < 1 ) return SLOG_FALSE;
    */
    ierr = bswp_fread( intvltype_str,
                       sizeof( char ), SLOG_STRING_LEN, fd );
    if ( ierr < SLOG_STRING_LEN ) return SLOG_FALSE;
    info->intvltype = atoi( intvltype_str );

    ierr = bswp_fread( bebits_str,
                       sizeof( char ), SLOG_STRING_LEN, fd );
    if ( ierr < SLOG_STRING_LEN ) return SLOG_FALSE;
    bebits = atoi( bebits_str );
    SLOG_bebits_decode( bebits, info->bebits );
    
    ierr = bswp_fread( &( info->classtype ),
                       sizeof( char ), SLOG_STRING_LEN, fd );
    if ( ierr < SLOG_STRING_LEN ) return SLOG_FALSE;

    ierr = bswp_fread( &( info->label ),
                       sizeof( char ), SLOG_STRING_LEN, fd );
    if ( ierr < SLOG_STRING_LEN ) return SLOG_FALSE;

    ierr = bswp_fread( &( info->color ),
                       sizeof( char ), SLOG_STRING_LEN, fd );
    if ( ierr < SLOG_STRING_LEN ) return SLOG_FALSE;

    ierr = bswp_fread( N_arg_labels_str,
                       sizeof( char ), SLOG_STRING_LEN, fd );
    if ( ierr < SLOG_STRING_LEN ) return SLOG_FALSE;
    N_arg_labels = atoi( N_arg_labels_str );

    switch ( N_arg_labels ) {
    case 0 :
        info->arg_labels = NULL;
        break;
    case 1 :
        info->arg_labels = SLOG_StrList_ReadFromFileAsStrs( fd );
        if ( info->arg_labels == NULL ) {
            fprintf( errfile, __FILE__":SLOG_IntvlInfo_ReadFromFile() - \n"
                              "\t""SLOG_StrList_ReadFromFileAsStrs() fails "
                              "for the SLOG_strlist_t.\n" );
            fflush( errfile ); 
            return SLOG_FALSE;
        }
        break;
    default :
        fprintf( errfile, __FILE__":SLOG_IntvlInfo_ReadFromFile() - \n"
                          "\t""The invalid N_arg_labels read is "fmt_ui32"\n",
                          N_arg_labels );
        fflush( errfile ); 
        return SLOG_FALSE;
    }

    ierr = bswp_fread( &newline, sizeof( char ), 1, fd );
    if ( ierr < 1 ) return SLOG_FALSE;

    return SLOG_TRUE;
}



int SLOG_IntvlInfo_IsKeyEqualTo( const SLOG_intvlinfo_t *info1,
                                 const SLOG_intvlinfo_t *info2 )
{
    return (    ( info1->intvltype == info2->intvltype )
             && ( info1->bebits[0] == info2->bebits[0] )
             && ( info1->bebits[1] == info2->bebits[1] ) );
}

int SLOG_IntvlInfo_IsValueEqualTo( const SLOG_intvlinfo_t *info1,
                                   const SLOG_intvlinfo_t *info2 )
{
    if (    strcmp( info1->classtype, info2->classtype ) != 0
         || strcmp( info1->label,     info2->label )     != 0
         || strcmp( info1->color,     info2->color )     != 0 )
        return SLOG_FALSE;

    if ( ! SLOG_StrList_IsEqualTo( info1->arg_labels, info2->arg_labels ) )
        return SLOG_FALSE;

    return SLOG_TRUE;
}

int SLOG_IntvlInfo_IsEqualTo( const SLOG_intvlinfo_t *info1,
                              const SLOG_intvlinfo_t *info2 )
{
    return (    SLOG_IntvlInfo_IsKeyEqualTo( info1, info2 )
             && SLOG_IntvlInfo_IsValueEqualTo( info1, info2 ) );
}


int SLOG_IntvlInfo_IsKeyWholeIntvl( const SLOG_intvlinfo_t *info )
{
    return ( SLOG_bebits_IsWholeIntvl( info->bebits ) );
}


void SLOG_IntvlInfo_SetUsed(       SLOG_intvlinfo_t *info,
                             const int               boolean_flag )
{
    if ( info != NULL )
        info->used = boolean_flag;
}