OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [bootloaders/] [orpmon/] [coremark/] [core_state.c] - Diff between revs 355 and 406

Go to most recent revision | Show entire file | Details | Blame | View Log

Rev 355 Rev 406
Line 16... Line 16...
4354 Town Center Blvd. Suite 114-200
4354 Town Center Blvd. Suite 114-200
El Dorado Hills, CA, 95762
El Dorado Hills, CA, 95762
*/
*/
#include "coremark.h"
#include "coremark.h"
/* local functions */
/* local functions */
enum CORE_STATE core_state_transition( ee_u8 **instr , ee_u32 *transition_count);
enum CORE_STATE core_state_transition(ee_u8 ** instr,
 
                                      ee_u32 * transition_count);
 
 
/*
/*
Topic: Description
Topic: Description
        Simple state machines like this one are used in many embedded products.
        Simple state machines like this one are used in many embedded products.
 
 
Line 46... Line 47...
        ee_u32 final_counts[NUM_CORE_STATES];
        ee_u32 final_counts[NUM_CORE_STATES];
        ee_u32 track_counts[NUM_CORE_STATES];
        ee_u32 track_counts[NUM_CORE_STATES];
        ee_u8 *p=memblock;
        ee_u8 *p=memblock;
        ee_u32 i;
        ee_u32 i;
 
 
 
 
#if CORE_DEBUG
#if CORE_DEBUG
        ee_printf("State Bench: %d,%d,%d,%04x\n",seed1,seed2,step,crc);
        ee_printf("State Bench: %d,%d,%d,%04x\n",seed1,seed2,step,crc);
#endif
#endif
        for (i=0; i<NUM_CORE_STATES; i++) {
        for (i=0; i<NUM_CORE_STATES; i++) {
                final_counts[i]=track_counts[i]=0;
                final_counts[i]=track_counts[i]=0;
        }
        }
        /* run the state machine over the input */
        /* run the state machine over the input */
        while (*p!=0) {
        while (*p!=0) {
                enum CORE_STATE fstate=core_state_transition(&p,track_counts);
                enum CORE_STATE fstate =
 
                    core_state_transition(&p, track_counts);
                final_counts[fstate]++;
                final_counts[fstate]++;
#if CORE_DEBUG
#if CORE_DEBUG
        ee_printf("%d,",fstate);
        ee_printf("%d,",fstate);
        }
        }
        ee_printf("\n");
        ee_printf("\n");
Line 73... Line 74...
                p+=step;
                p+=step;
        }
        }
        p=memblock;
        p=memblock;
        /* run the state machine over the input again */
        /* run the state machine over the input again */
        while (*p!=0) {
        while (*p!=0) {
                enum CORE_STATE fstate=core_state_transition(&p,track_counts);
                enum CORE_STATE fstate =
 
                    core_state_transition(&p, track_counts);
                final_counts[fstate]++;
                final_counts[fstate]++;
#if CORE_DEBUG
#if CORE_DEBUG
        ee_printf("%d,",fstate);
        ee_printf("%d,",fstate);
        }
        }
        ee_printf("\n");
        ee_printf("\n");
Line 97... Line 99...
        }
        }
        return crc;
        return crc;
}
}
 
 
/* Default initialization patterns */
/* Default initialization patterns */
static ee_u8 *intpat[4]  ={(ee_u8 *)"5012",(ee_u8 *)"1234",(ee_u8 *)"-874",(ee_u8 *)"+122"};
static ee_u8 *intpat[4] =
static ee_u8 *floatpat[4]={(ee_u8 *)"35.54400",(ee_u8 *)".1234500",(ee_u8 *)"-110.700",(ee_u8 *)"+0.64400"};
    { (ee_u8 *) "5012", (ee_u8 *) "1234", (ee_u8 *) "-874", (ee_u8 *) "+122" };
static ee_u8 *scipat[4]  ={(ee_u8 *)"5.500e+3",(ee_u8 *)"-.123e-2",(ee_u8 *)"-87e+832",(ee_u8 *)"+0.6e-12"};
static ee_u8 *floatpat[4] =
static ee_u8 *errpat[4]  ={(ee_u8 *)"T0.3e-1F",(ee_u8 *)"-T.T++Tq",(ee_u8 *)"1T3.4e4z",(ee_u8 *)"34.0e-T^"};
    { (ee_u8 *) "35.54400", (ee_u8 *) ".1234500", (ee_u8 *) "-110.700",
 
(ee_u8 *) "+0.64400" };
 
static ee_u8 *scipat[4] =
 
    { (ee_u8 *) "5.500e+3", (ee_u8 *) "-.123e-2", (ee_u8 *) "-87e+832",
 
(ee_u8 *) "+0.6e-12" };
 
static ee_u8 *errpat[4] =
 
    { (ee_u8 *) "T0.3e-1F", (ee_u8 *) "-T.T++Tq", (ee_u8 *) "1T3.4e4z",
 
(ee_u8 *) "34.0e-T^" };
 
 
/* Function: core_init_state
/* Function: core_init_state
        Initialize the input data for the state machine.
        Initialize the input data for the state machine.
 
 
        Populate the input with several predetermined strings, interspersed.
        Populate the input with several predetermined strings, interspersed.
        Actual patterns chosen depend on the seed parameter.
        Actual patterns chosen depend on the seed parameter.
 
 
        Note:
        Note:
        The seed parameter MUST be supplied from a source that cannot be determined at compile time
        The seed parameter MUST be supplied from a source that cannot be determined at compile time
*/
*/
void core_init_state(ee_u32 size, ee_s16 seed, ee_u8 *p) {
void core_init_state(ee_u32 size, ee_s16 seed, ee_u8 * p)
 
{
        ee_u32 total=0,next=0,i;
        ee_u32 total=0,next=0,i;
        ee_u8 *buf=0;
        ee_u8 *buf=0;
#if CORE_DEBUG
#if CORE_DEBUG
        ee_u8 *start=p;
        ee_u8 *start=p;
        ee_printf("State: %d,%d\n",size,seed);
        ee_printf("State: %d,%d\n",size,seed);
Line 163... Line 173...
#if CORE_DEBUG
#if CORE_DEBUG
        ee_printf("State Input: %s\n",start);
        ee_printf("State Input: %s\n",start);
#endif
#endif
}
}
 
 
static ee_u8 ee_isdigit(ee_u8 c) {
static ee_u8 ee_isdigit(ee_u8 c)
 
{
        ee_u8 retval;
        ee_u8 retval;
        retval = ((c>='0') & (c<='9')) ? 1 : 0;
        retval = ((c>='0') & (c<='9')) ? 1 : 0;
        return retval;
        return retval;
}
}
 
 
Line 179... Line 190...
        2 - a valid number has been detected.
        2 - a valid number has been detected.
 
 
        The input pointer is updated to point to the end of the token, and the end state is returned (either specific format determined or invalid).
        The input pointer is updated to point to the end of the token, and the end state is returned (either specific format determined or invalid).
*/
*/
 
 
enum CORE_STATE core_state_transition( ee_u8 **instr , ee_u32 *transition_count) {
enum CORE_STATE core_state_transition(ee_u8 ** instr, ee_u32 * transition_count)
        ee_u8 *str=*instr;
{
 
        ee_u8 *str = *instr;
        ee_u8 NEXT_SYMBOL;
        ee_u8 NEXT_SYMBOL;
        enum CORE_STATE state=CORE_START;
        enum CORE_STATE state=CORE_START;
        for( ; *str && state != CORE_INVALID; str++ ) {
        for( ; *str && state != CORE_INVALID; str++ ) {
                NEXT_SYMBOL = *str;
                NEXT_SYMBOL = *str;
                if (NEXT_SYMBOL==',') /* end of this input */ {
                if (NEXT_SYMBOL == ',') {       /* end of this input */
                        str++;
                        str++;
                        break;
                        break;
                }
                }
                switch(state) {
                switch(state) {
                case CORE_START:
                case CORE_START:
                        if(ee_isdigit(NEXT_SYMBOL)) {
                        if(ee_isdigit(NEXT_SYMBOL)) {
                                state = CORE_INT;
                                state = CORE_INT;
                        }
                        } else if (NEXT_SYMBOL == '+' || NEXT_SYMBOL == '-') {
                        else if( NEXT_SYMBOL == '+' || NEXT_SYMBOL == '-' ) {
 
                                state = CORE_S1;
                                state = CORE_S1;
                        }
                        } else if (NEXT_SYMBOL == '.') {
                        else if( NEXT_SYMBOL == '.' ) {
 
                                state = CORE_FLOAT;
                                state = CORE_FLOAT;
                        }
                        } else {
                        else {
 
                                state = CORE_INVALID;
                                state = CORE_INVALID;
                                transition_count[CORE_INVALID]++;
                                transition_count[CORE_INVALID]++;
                        }
                        }
                        transition_count[CORE_START]++;
                        transition_count[CORE_START]++;
                        break;
                        break;
                case CORE_S1:
                case CORE_S1:
                        if(ee_isdigit(NEXT_SYMBOL)) {
                        if(ee_isdigit(NEXT_SYMBOL)) {
                                state = CORE_INT;
                                state = CORE_INT;
                                transition_count[CORE_S1]++;
                                transition_count[CORE_S1]++;
                        }
                        } else if (NEXT_SYMBOL == '.') {
                        else if( NEXT_SYMBOL == '.' ) {
 
                                state = CORE_FLOAT;
                                state = CORE_FLOAT;
                                transition_count[CORE_S1]++;
                                transition_count[CORE_S1]++;
                        }
                        } else {
                        else {
 
                                state = CORE_INVALID;
                                state = CORE_INVALID;
                                transition_count[CORE_S1]++;
                                transition_count[CORE_S1]++;
                        }
                        }
                        break;
                        break;
                case CORE_INT:
                case CORE_INT:
                        if( NEXT_SYMBOL == '.' ) {
                        if( NEXT_SYMBOL == '.' ) {
                                state = CORE_FLOAT;
                                state = CORE_FLOAT;
                                transition_count[CORE_INT]++;
                                transition_count[CORE_INT]++;
                        }
                        } else if (!ee_isdigit(NEXT_SYMBOL)) {
                        else if(!ee_isdigit(NEXT_SYMBOL)) {
 
                                state = CORE_INVALID;
                                state = CORE_INVALID;
                                transition_count[CORE_INT]++;
                                transition_count[CORE_INT]++;
                        }
                        }
                        break;
                        break;
                case CORE_FLOAT:
                case CORE_FLOAT:
                        if( NEXT_SYMBOL == 'E' || NEXT_SYMBOL == 'e' ) {
                        if( NEXT_SYMBOL == 'E' || NEXT_SYMBOL == 'e' ) {
                                state = CORE_S2;
                                state = CORE_S2;
                                transition_count[CORE_FLOAT]++;
                                transition_count[CORE_FLOAT]++;
                        }
                        } else if (!ee_isdigit(NEXT_SYMBOL)) {
                        else if(!ee_isdigit(NEXT_SYMBOL)) {
 
                                state = CORE_INVALID;
                                state = CORE_INVALID;
                                transition_count[CORE_FLOAT]++;
                                transition_count[CORE_FLOAT]++;
                        }
                        }
                        break;
                        break;
                case CORE_S2:
                case CORE_S2:
                        if( NEXT_SYMBOL == '+' || NEXT_SYMBOL == '-' ) {
                        if( NEXT_SYMBOL == '+' || NEXT_SYMBOL == '-' ) {
                                state = CORE_EXPONENT;
                                state = CORE_EXPONENT;
                                transition_count[CORE_S2]++;
                                transition_count[CORE_S2]++;
                        }
                        } else {
                        else {
 
                                state = CORE_INVALID;
                                state = CORE_INVALID;
                                transition_count[CORE_S2]++;
                                transition_count[CORE_S2]++;
                        }
                        }
                        break;
                        break;
                case CORE_EXPONENT:
                case CORE_EXPONENT:
                        if(ee_isdigit(NEXT_SYMBOL)) {
                        if(ee_isdigit(NEXT_SYMBOL)) {
                                state = CORE_SCIENTIFIC;
                                state = CORE_SCIENTIFIC;
                                transition_count[CORE_EXPONENT]++;
                                transition_count[CORE_EXPONENT]++;
                        }
                        } else {
                        else {
 
                                state = CORE_INVALID;
                                state = CORE_INVALID;
                                transition_count[CORE_EXPONENT]++;
                                transition_count[CORE_EXPONENT]++;
                        }
                        }
                        break;
                        break;
                case CORE_SCIENTIFIC:
                case CORE_SCIENTIFIC:

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.