clog_preamble.c

mpi并行计算的c++代码 可用vc或gcc编译通过 可以用来搭建并行计算试验环境

    buf_ptr = CLOG_Util_strbuf_put( buf_ptr, buf_tail,
                                    "known_eventID_start=",
                                    "CLOG_KNOWN_EVENTID_START Title" );
    snprintf( value_str, CLOG_PREAMBLE_STRLEN, "%d",
              preamble->known_eventID_start );
    /* 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_EVENTID_START Value" );

    /* Write the CLOG_USER_EVENTID_START */
    buf_ptr = CLOG_Util_strbuf_put( buf_ptr, buf_tail,
                                    "user_eventID_start=",
                                    "CLOG_USER_EVENTID_START Title" );
    snprintf( value_str, CLOG_PREAMBLE_STRLEN, "%d",
              preamble->user_eventID_start );
    /* 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_EVENTID_START Value" );

    /* Write the CLOG_USER_SOLO_EVENTID_START */
    buf_ptr = CLOG_Util_strbuf_put( buf_ptr, buf_tail,
                                    "user_eventID_start=",
                                    "CLOG_USER_SOLO_EVENTID_START Title" );
    snprintf( value_str, CLOG_PREAMBLE_STRLEN, "%d",
              preamble->user_solo_eventID_start );
    /* 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_START Value" );

    /* Write the CLOG known_stateID_count */
    buf_ptr = CLOG_Util_strbuf_put( buf_ptr, buf_tail,
                                    "known_stateID_count=",
                                    "CLOG known_stateID_count Title" );
    snprintf( value_str, CLOG_PREAMBLE_STRLEN, "%d",
              preamble->known_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 known_stateID_count Value" );

    /* Write the CLOG user_stateID_count */
    buf_ptr = CLOG_Util_strbuf_put( buf_ptr, buf_tail,
                                    "user_stateID_count=",
                                    "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 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" );

    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   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 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, "MPI_COMM_WORLD Size Title" );
    buf_ptr = CLOG_Util_strbuf_get( value_str,
                                    &(value_str[ CLOG_PREAMBLE_STRLEN-1 ]),
                                    buf_ptr, "MPI_COMM_WORLD Size Value" );
    preamble->comm_world_size     = (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 = (unsigned int) 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 = (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_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 = (unsigned int) 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 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 );
}

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" );

    fprintf( stream, "num_buffered_blocks = %d\n",
                     preamble->num_buffered_blocks );
    fprintf( stream, "block_size = %d\n",
                     preamble->block_size );
    fprintf( stream, "comm_world_size = %d\n",
                     preamble->comm_world_size );
    fprintf( stream, "known_eventID_start = %d\n",
                     preamble->known_eventID_start );
    fprintf( stream, "user_eventID_start = %d\n",
                     preamble->user_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, "user_solo_eventID_count = %d\n",
                     preamble->user_solo_eventID_count );
}