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

Subversion Repositories steelcore

[/] [coremark/] [core_state.c] - Blame information for rev 11

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 11 rafaelcalc
/*
2
Copyright 2018 Embedded Microprocessor Benchmark Consortium (EEMBC)
3
 
4
Licensed under the Apache License, Version 2.0 (the "License");
5
you may not use this file except in compliance with the License.
6
You may obtain a copy of the License at
7
 
8
    http://www.apache.org/licenses/LICENSE-2.0
9
 
10
Unless required by applicable law or agreed to in writing, software
11
distributed under the License is distributed on an "AS IS" BASIS,
12
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13
See the License for the specific language governing permissions and
14
limitations under the License.
15
 
16
Original Author: Shay Gal-on
17
*/
18
 
19
#include "coremark.h"
20
/* local functions */
21
enum CORE_STATE core_state_transition(ee_u8 **instr, ee_u32 *transition_count);
22
 
23
/*
24
Topic: Description
25
        Simple state machines like this one are used in many embedded products.
26
 
27
        For more complex state machines, sometimes a state transition table
28
implementation is used instead, trading speed of direct coding for ease of
29
maintenance.
30
 
31
        Since the main goal of using a state machine in CoreMark is to excercise
32
the switch/if behaviour, we are using a small moore machine.
33
 
34
        In particular, this machine tests type of string input,
35
        trying to determine whether the input is a number or something else.
36
        (see core_state.png).
37
*/
38
 
39
/* Function: core_bench_state
40
        Benchmark function
41
 
42
        Go over the input twice, once direct, and once after introducing some
43
   corruption.
44
*/
45
ee_u16
46
core_bench_state(ee_u32 blksize,
47
                 ee_u8 *memblock,
48
                 ee_s16 seed1,
49
                 ee_s16 seed2,
50
                 ee_s16 step,
51
                 ee_u16 crc)
52
{
53
    ee_u32 final_counts[NUM_CORE_STATES];
54
    ee_u32 track_counts[NUM_CORE_STATES];
55
    ee_u8 *p = memblock;
56
    ee_u32 i;
57
 
58
#if CORE_DEBUG
59
    ee_printf("State Bench: %d,%d,%d,%04x\n", seed1, seed2, step, crc);
60
#endif
61
    for (i = 0; i < NUM_CORE_STATES; i++)
62
    {
63
        final_counts[i] = track_counts[i] = 0;
64
    }
65
    /* run the state machine over the input */
66
    while (*p != 0)
67
    {
68
        enum CORE_STATE fstate = core_state_transition(&p, track_counts);
69
        final_counts[fstate]++;
70
#if CORE_DEBUG
71
        ee_printf("%d,", fstate);
72
    }
73
    ee_printf("\n");
74
#else
75
    }
76
#endif
77
    p = memblock;
78
    while (p < (memblock + blksize))
79
    { /* insert some corruption */
80
        if (*p != ',')
81
            *p ^= (ee_u8)seed1;
82
        p += step;
83
    }
84
    p = memblock;
85
    /* run the state machine over the input again */
86
    while (*p != 0)
87
    {
88
        enum CORE_STATE fstate = core_state_transition(&p, track_counts);
89
        final_counts[fstate]++;
90
#if CORE_DEBUG
91
        ee_printf("%d,", fstate);
92
    }
93
    ee_printf("\n");
94
#else
95
    }
96
#endif
97
    p = memblock;
98
    while (p < (memblock + blksize))
99
    { /* undo corruption is seed1 and seed2 are equal */
100
        if (*p != ',')
101
            *p ^= (ee_u8)seed2;
102
        p += step;
103
    }
104
    /* end timing */
105
    for (i = 0; i < NUM_CORE_STATES; i++)
106
    {
107
        crc = crcu32(final_counts[i], crc);
108
        crc = crcu32(track_counts[i], crc);
109
    }
110
    return crc;
111
}
112
 
113
/* Default initialization patterns */
114
static ee_u8 *intpat[4]
115
    = { (ee_u8 *)"5012", (ee_u8 *)"1234", (ee_u8 *)"-874", (ee_u8 *)"+122" };
116
static ee_u8 *floatpat[4] = { (ee_u8 *)"35.54400",
117
                              (ee_u8 *)".1234500",
118
                              (ee_u8 *)"-110.700",
119
                              (ee_u8 *)"+0.64400" };
120
static ee_u8 *scipat[4]   = { (ee_u8 *)"5.500e+3",
121
                            (ee_u8 *)"-.123e-2",
122
                            (ee_u8 *)"-87e+832",
123
                            (ee_u8 *)"+0.6e-12" };
124
static ee_u8 *errpat[4]   = { (ee_u8 *)"T0.3e-1F",
125
                            (ee_u8 *)"-T.T++Tq",
126
                            (ee_u8 *)"1T3.4e4z",
127
                            (ee_u8 *)"34.0e-T^" };
128
 
129
/* Function: core_init_state
130
        Initialize the input data for the state machine.
131
 
132
        Populate the input with several predetermined strings, interspersed.
133
        Actual patterns chosen depend on the seed parameter.
134
 
135
        Note:
136
        The seed parameter MUST be supplied from a source that cannot be
137
   determined at compile time
138
*/
139
void
140
core_init_state(ee_u32 size, ee_s16 seed, ee_u8 *p)
141
{
142
    ee_u32 total = 0, next = 0, i;
143
    ee_u8 *buf = 0;
144
#if CORE_DEBUG
145
    ee_u8 *start = p;
146
    ee_printf("State: %d,%d\n", size, seed);
147
#endif
148
    size--;
149
    next = 0;
150
    while ((total + next + 1) < size)
151
    {
152
        if (next > 0)
153
        {
154
            for (i = 0; i < next; i++)
155
                *(p + total + i) = buf[i];
156
            *(p + total + i) = ',';
157
            total += next + 1;
158
        }
159
        seed++;
160
        switch (seed & 0x7)
161
        {
162
            case 0: /* int */
163
            case 1: /* int */
164
            case 2: /* int */
165
                buf  = intpat[(seed >> 3) & 0x3];
166
                next = 4;
167
                break;
168
            case 3: /* float */
169
            case 4: /* float */
170
                buf  = floatpat[(seed >> 3) & 0x3];
171
                next = 8;
172
                break;
173
            case 5: /* scientific */
174
            case 6: /* scientific */
175
                buf  = scipat[(seed >> 3) & 0x3];
176
                next = 8;
177
                break;
178
            case 7: /* invalid */
179
                buf  = errpat[(seed >> 3) & 0x3];
180
                next = 8;
181
                break;
182
            default: /* Never happen, just to make some compilers happy */
183
                break;
184
        }
185
    }
186
    size++;
187
    while (total < size)
188
    { /* fill the rest with 0 */
189
        *(p + total) = 0;
190
        total++;
191
    }
192
#if CORE_DEBUG
193
    ee_printf("State Input: %s\n", start);
194
#endif
195
}
196
 
197
static ee_u8
198
ee_isdigit(ee_u8 c)
199
{
200
    ee_u8 retval;
201
    retval = ((c >= '0') & (c <= '9')) ? 1 : 0;
202
    return retval;
203
}
204
 
205
/* Function: core_state_transition
206
        Actual state machine.
207
 
208
        The state machine will continue scanning until either:
209
        1 - an invalid input is detcted.
210
        2 - a valid number has been detected.
211
 
212
        The input pointer is updated to point to the end of the token, and the
213
   end state is returned (either specific format determined or invalid).
214
*/
215
 
216
enum CORE_STATE
217
core_state_transition(ee_u8 **instr, ee_u32 *transition_count)
218
{
219
    ee_u8 *         str = *instr;
220
    ee_u8           NEXT_SYMBOL;
221
    enum CORE_STATE state = CORE_START;
222
    for (; *str && state != CORE_INVALID; str++)
223
    {
224
        NEXT_SYMBOL = *str;
225
        if (NEXT_SYMBOL == ',') /* end of this input */
226
        {
227
            str++;
228
            break;
229
        }
230
        switch (state)
231
        {
232
            case CORE_START:
233
                if (ee_isdigit(NEXT_SYMBOL))
234
                {
235
                    state = CORE_INT;
236
                }
237
                else if (NEXT_SYMBOL == '+' || NEXT_SYMBOL == '-')
238
                {
239
                    state = CORE_S1;
240
                }
241
                else if (NEXT_SYMBOL == '.')
242
                {
243
                    state = CORE_FLOAT;
244
                }
245
                else
246
                {
247
                    state = CORE_INVALID;
248
                    transition_count[CORE_INVALID]++;
249
                }
250
                transition_count[CORE_START]++;
251
                break;
252
            case CORE_S1:
253
                if (ee_isdigit(NEXT_SYMBOL))
254
                {
255
                    state = CORE_INT;
256
                    transition_count[CORE_S1]++;
257
                }
258
                else if (NEXT_SYMBOL == '.')
259
                {
260
                    state = CORE_FLOAT;
261
                    transition_count[CORE_S1]++;
262
                }
263
                else
264
                {
265
                    state = CORE_INVALID;
266
                    transition_count[CORE_S1]++;
267
                }
268
                break;
269
            case CORE_INT:
270
                if (NEXT_SYMBOL == '.')
271
                {
272
                    state = CORE_FLOAT;
273
                    transition_count[CORE_INT]++;
274
                }
275
                else if (!ee_isdigit(NEXT_SYMBOL))
276
                {
277
                    state = CORE_INVALID;
278
                    transition_count[CORE_INT]++;
279
                }
280
                break;
281
            case CORE_FLOAT:
282
                if (NEXT_SYMBOL == 'E' || NEXT_SYMBOL == 'e')
283
                {
284
                    state = CORE_S2;
285
                    transition_count[CORE_FLOAT]++;
286
                }
287
                else if (!ee_isdigit(NEXT_SYMBOL))
288
                {
289
                    state = CORE_INVALID;
290
                    transition_count[CORE_FLOAT]++;
291
                }
292
                break;
293
            case CORE_S2:
294
                if (NEXT_SYMBOL == '+' || NEXT_SYMBOL == '-')
295
                {
296
                    state = CORE_EXPONENT;
297
                    transition_count[CORE_S2]++;
298
                }
299
                else
300
                {
301
                    state = CORE_INVALID;
302
                    transition_count[CORE_S2]++;
303
                }
304
                break;
305
            case CORE_EXPONENT:
306
                if (ee_isdigit(NEXT_SYMBOL))
307
                {
308
                    state = CORE_SCIENTIFIC;
309
                    transition_count[CORE_EXPONENT]++;
310
                }
311
                else
312
                {
313
                    state = CORE_INVALID;
314
                    transition_count[CORE_EXPONENT]++;
315
                }
316
                break;
317
            case CORE_SCIENTIFIC:
318
                if (!ee_isdigit(NEXT_SYMBOL))
319
                {
320
                    state = CORE_INVALID;
321
                    transition_count[CORE_INVALID]++;
322
                }
323
                break;
324
            default:
325
                break;
326
        }
327
    }
328
    *instr = str;
329
    return state;
330
}

powered by: WebSVN 2.1.0

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