clog_preamble.c

fortran并行计算包

                                    "CLOG user_stateID_count Title" );
    snprintf( value_str, CLOG_PREAMBLE_STRLEN, "%d",
              preamble->user_stateID_count );
    /* just in case, there isn't \0 in value_str  */
    value_str[ CLOG_PREAMBLE_STRLEN-1 ] = '\0';
    buf_ptr = CLOG_Util_strbuf_put( buf_ptr, buf_tail, value_str,
                                    "CLOG user_stateID_count Value" );


    /* Write the CLOG known_solo_eventID_count */
    buf_ptr = CLOG_Util_strbuf_put( buf_ptr, buf_tail,
                                    "known_solo_eventID_count=",
                                    "CLOG known_solo_eventID_count Title" );
    snprintf( value_str, CLOG_PREAMBLE_STRLEN, "%d",
              preamble->known_solo_eventID_count );
    /* just in case, there isn't \0 in value_str  */
    value_str[ CLOG_PREAMBLE_STRLEN-1 ] = '\0';
    buf_ptr = CLOG_Util_strbuf_put( buf_ptr, buf_tail, value_str,
                                    "CLOG known_solo_eventID_count Value" );

    /* Write the CLOG user_solo_eventID_count */
    buf_ptr = CLOG_Util_strbuf_put( buf_ptr, buf_tail,
                                    "user_solo_eventID_count=",
                                    "CLOG user_solo_eventID_count Title" );
    snprintf( value_str, CLOG_PREAMBLE_STRLEN, "%d",
              preamble->user_solo_eventID_count );
    /* just in case, there isn't \0 in value_str  */
    value_str[ CLOG_PREAMBLE_STRLEN-1 ] = '\0';
    buf_ptr = CLOG_Util_strbuf_put( buf_ptr, buf_tail, value_str,
                                    "CLOG user_solo_eventID_count Value" );


    /* Write the file offset to the CLOG communicator IDs table */
    buf_ptr = CLOG_Util_strbuf_put( buf_ptr, buf_tail,
                                    "commtable_fptr=",
                                    "CLOG commIDs_table_file_offset Title" );
    /* Actual value = Main * Unit + Sub */
    fptr_giga = (int) (preamble->commtable_fptr / ONE_GIGA);
    snprintf( value_str, CLOG_PREAMBLE_STRLEN, "%d", fptr_giga );
    /* just in case, there isn't \0 in value_str  */
    value_str[ CLOG_PREAMBLE_STRLEN-1 ] = '\0';
    buf_ptr = CLOG_Util_strbuf_put( buf_ptr, buf_tail, value_str,
                                    "CLOG commIDs_table_file_offset Main" );
    fptr_unit = ONE_GIGA;
    snprintf( value_str, CLOG_PREAMBLE_STRLEN, "%d", fptr_unit );
    /* just in case, there isn't \0 in value_str  */
    value_str[ CLOG_PREAMBLE_STRLEN-1 ] = '\0';
    buf_ptr = CLOG_Util_strbuf_put( buf_ptr, buf_tail, value_str,
                                    "CLOG commIDs_table_file_offset Unit" );
    fptr_rmdr = (int) (preamble->commtable_fptr % ONE_GIGA);
    snprintf( value_str, CLOG_PREAMBLE_STRLEN, "%d", fptr_rmdr );
    /* just in case, there isn't \0 in value_str  */
    value_str[ CLOG_PREAMBLE_STRLEN-1 ] = '\0';
    buf_ptr = CLOG_Util_strbuf_put( buf_ptr, buf_tail, value_str,
                                    "CLOG commIDs_table_file_offset Sub" );

    if ( buf_ptr > buf_tail ) {
        fprintf( stderr, __FILE__":CLOG_Preamble_write() - Error \n"
                         "\t""Internal buffer overflows!.\n" );
        fflush( stderr );
        CLOG_Util_abort( 1 );
    }

    /* Initialize the rest of the buffer[] to zero to keep valgrind happy */
    while ( buf_ptr <= buf_tail ) {
        *buf_ptr = 0;
        buf_ptr++;
    }

    ierr = write( fd, buffer, CLOG_PREAMBLE_SIZE );
    if ( ierr != CLOG_PREAMBLE_SIZE ) {
        fprintf( stderr, __FILE__":CLOG_Preamble_write() - Error \n"
                         "\t""Write to the logfile fails.\n" );
        fflush( stderr );
        CLOG_Util_abort( 1 );
    }
}

void CLOG_Preamble_read( CLOG_Preamble_t *preamble, int fd )
{
    char  buffer[ CLOG_PREAMBLE_SIZE ];
    char  value_str[ CLOG_PREAMBLE_STRLEN ];
    char *buf_ptr, *buf_tail;
    int   fptr_giga, fptr_rmdr, fptr_unit;
    int   ierr;

    ierr = read( fd, buffer, CLOG_PREAMBLE_SIZE );
    if ( ierr != CLOG_PREAMBLE_SIZE ) {
        fprintf( stderr, __FILE__":CLOG_Preamble_read() - \n"
                         "\t""read(%d) fails to read CLOG Preamble buffer.\n ",
                         CLOG_PREAMBLE_SIZE );
        fflush( stderr );
        CLOG_Util_abort( 1 );
    }

    buf_ptr  = (char *) buffer;
    buf_tail = buf_ptr + CLOG_PREAMBLE_SIZE - 1;

    /* Read the CLOG version ID */
    buf_ptr = CLOG_Util_strbuf_get( preamble->version,
                                    &(preamble->version[CLOG_VERSION_STRLEN-1]),
                                    buf_ptr, "CLOG Version ID" );

    if ( strncmp( preamble->version, CLOG_VERSION, CLOG_VERSION_STRLEN ) != 0 )
    {
        fprintf( stderr, __FILE__":CLOG_Preamble_read() - ERROR:\n"
                         "\t""The input version ID %s is not %s expected!\n",
                         preamble->version, CLOG_VERSION );
        fflush( stderr );
        CLOG_Util_abort( 1 );
    }
    /*  Need to be checking to make sure this is the same CLOG version */

    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr, "CLOG Endianess Title" );
    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr, "CLOG Endianess Value" );
    if ( strcmp( value_str, "TRUE " ) == 0 )
        preamble->is_big_endian = CLOG_BOOL_TRUE;
    else
        preamble->is_big_endian = CLOG_BOOL_FALSE;

    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr, "CLOG Finalized State Title" );
    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr, "CLOG Finalized State Value" );
    if ( strcmp( value_str, "TRUE " ) == 0 )
        preamble->is_finalized = CLOG_BOOL_TRUE;
    else
        preamble->is_finalized = CLOG_BOOL_FALSE;

    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr, "CLOG Block Size Title" );
    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr, "CLOG Block Size Value" );
    preamble->block_size = (unsigned int) atoi( value_str );

    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr, "CLOG Buffered Blocks Title" );
    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr, "CLOG Buffered Blocks Value" );
    preamble->num_buffered_blocks = (unsigned int) atoi( value_str );

    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr, "Max MPI_COMM_WORLD Size Title" );
    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr, "Max MPI_COMM_WORLD Size Value" );
    preamble->max_comm_world_size = (unsigned int) atoi( value_str );

    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr, "Max Thread Count Title" );
    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr, "Max Thread Count Value" );
    preamble->max_thread_count    = (unsigned int) atoi( value_str );

    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr, "CLOG_KNOWN_EVENTID_START Title" );
    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr, "CLOG_KNOWN_EVENTID_START Value" );
    preamble->known_eventID_start = atoi( value_str );

    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr, "CLOG_USER_EVENTID_START Title" );
    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr, "CLOG_USER_EVENTID_START Value" );
    preamble->user_eventID_start = atoi( value_str );

    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr,
                                    "CLOG_KNOWN_SOLO_EVENTID_START Title" );
    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr,
                                    "CLOG_KNOWN_SOLO_EVENTID_START Value" );
    preamble->known_solo_eventID_start = atoi( value_str );

    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr,
                                    "CLOG_USER_SOLO_EVENTID_START Title" );
    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr,
                                    "CLOG_USER_SOLO_EVENTID_START Value" );
    preamble->user_solo_eventID_start = atoi( value_str );

    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr, "CLOG known_stateID_count Title" );
    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr, "CLOG known_stateID_count Value" );
    preamble->known_stateID_count = (unsigned int) atoi( value_str );

    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr, "CLOG user_stateID_count Title" );
    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr, "CLOG user_stateID_count Value" );
    preamble->user_stateID_count = (unsigned int) atoi( value_str );

    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr,
                                    "CLOG known_solo_eventID_count Title" );
    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr,
                                    "CLOG known_solo_eventID_count Value" );
    preamble->known_solo_eventID_count = (unsigned int) atoi( value_str );

    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr,
                                    "CLOG user_solo_eventID_count Title" );
    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr,
                                    "CLOG user_solo_eventID_count Value" );
    preamble->user_solo_eventID_count = (unsigned int) atoi( value_str );

    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr,
                                    "CLOG commIDs_table_file_offset Title" );
    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr,
                                    "CLOG commIDs_table_file_offset Main" );
    fptr_giga = (unsigned int) atoi( value_str );
    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr,
                                    "CLOG commIDs_table_file_offset Unit" );
    fptr_unit = (unsigned int) atoi( value_str );
    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr,
                                    "CLOG commIDs_table_file_offset Sub" );
    fptr_rmdr = (unsigned int) atoi( value_str );
    preamble->commtable_fptr = fptr_rmdr;
    if ( fptr_giga > 0 ) {
        preamble->commtable_fptr += (CLOG_int64_t) fptr_unit * fptr_giga;
    }
}

void CLOG_Preamble_print( const CLOG_Preamble_t *preamble, FILE *stream )
{
    fprintf( stream, "%s\n", preamble->version );

    if ( preamble->is_big_endian == CLOG_BOOL_TRUE )
        fprintf( stream, "is_big_endian = TRUE\n" );
    else
        fprintf( stream, "is_big_endian = FALSE\n" );

    if ( preamble->is_finalized == CLOG_BOOL_TRUE )
        fprintf( stream, "is_finalized = TRUE\n" );
    else
        fprintf( stream, "is_finalized = FALSE\n" );

    fprintf( stream, "num_buffered_blocks = %d\n",
                     preamble->num_buffered_blocks );
    fprintf( stream, "block_size = %d\n",
                     preamble->block_size );
    fprintf( stream, "max_comm_world_size = %d\n",
                     preamble->max_comm_world_size );
    fprintf( stream, "max_thread_count = %d\n",
                     preamble->max_thread_count );
    fprintf( stream, "known_eventID_start = %d\n",
                     preamble->known_eventID_start );
    fprintf( stream, "user_eventID_start = %d\n",
                     preamble->user_eventID_start );
    fprintf( stream, "known_solo_eventID_start = %d\n",
                     preamble->known_solo_eventID_start );
    fprintf( stream, "user_solo_eventID_start = %d\n",
                     preamble->user_solo_eventID_start );
    fprintf( stream, "known_stateID_count = %d\n",
                     preamble->known_stateID_count );
    fprintf( stream, "user_stateID_count = %d\n",
                     preamble->user_stateID_count );
    fprintf( stream, "known_solo_eventID_count = %d\n",
                     preamble->known_solo_eventID_count );
    fprintf( stream, "user_solo_eventID_count = %d\n",
                     preamble->user_solo_eventID_count );
    fprintf( stream, "commIDs_table_file_offset = %lld\n",
                     (long long) preamble->commtable_fptr );
}

void CLOG_Preamble_copy( const CLOG_Preamble_t *src, CLOG_Preamble_t *dest )
{
    strcpy( dest->version, src->version );
    dest->is_big_endian             = src->is_big_endian;
    dest->is_finalized              = src->is_finalized;
    dest->num_buffered_blocks       = src->num_buffered_blocks;
    dest->block_size                = src->block_size;
    dest->max_comm_world_size       = src->max_comm_world_size;
    dest->max_thread_count          = src->max_thread_count;
    dest->known_eventID_start       = src->known_eventID_start;
    dest->user_eventID_start        = src->user_eventID_start;
    dest->known_solo_eventID_start  = src->known_solo_eventID_start;
    dest->user_solo_eventID_start   = src->user_solo_eventID_start;
    dest->known_stateID_count       = src->known_stateID_count;
    dest->user_stateID_count        = src->user_stateID_count;
    dest->known_solo_eventID_count  = src->known_solo_eventID_count;
    dest->user_solo_eventID_count   = src->user_solo_eventID_count;
    dest->commtable_fptr            = src->commtable_fptr;
}

void CLOG_Preamble_sync(       CLOG_Preamble_t *parent,
                         const CLOG_Preamble_t *child )
{
     /* Determine max_comm_world_size for out_cache's preamble */
     if ( child->max_comm_world_size > parent->max_comm_world_size )
         parent->max_comm_world_size = child->max_comm_world_size;
     /* Determine max_thread_count for out_cache's preamble */
     if ( child->max_thread_count > parent->max_thread_count )
         parent->max_thread_count = child->max_thread_count;
     /* Determine maximum block_size */
     if ( child->block_size > parent->block_size )
         parent->block_size  = child->block_size;
}