source: soft/giet_vm/applications/coremark/core_util.c @ 753

Last change on this file since 753 was 753, checked in by cfuguet, 8 years ago

Introducing the coremark benchmark
File size: 5.0 KB
Line 
1/*
2Author : Shay Gal-On, EEMBC
3
4This file is part of  EEMBC(R) and CoreMark(TM), which are Copyright (C) 2009
5All rights reserved.                           
6
7EEMBC CoreMark Software is a product of EEMBC and is provided under the terms of the
8CoreMark License that is distributed with the official EEMBC COREMARK Software release.
9If you received this EEMBC CoreMark Software without the accompanying CoreMark License,
10you must discontinue use and download the official release from www.coremark.org. 
11
12Also, if you are publicly displaying scores generated from the EEMBC CoreMark software,
13make sure that you are in compliance with Run and Reporting rules specified in the accompanying readme.txt file.
14
15EEMBC
164354 Town Center Blvd. Suite 114-200
17El Dorado Hills, CA, 95762
18*/ 
19#include "coremark.h"
20/* Function: get_seed
21        Get a values that cannot be determined at compile time.
22
23        Since different embedded systems and compilers are used, 3 different methods are provided:
24        1 - Using a volatile variable. This method is only valid if the compiler is forced to generate code that
25        reads the value of a volatile variable from memory at run time.
26        Please note, if using this method, you would need to modify core_portme.c to generate training profile.
27        2 - Command line arguments. This is the preferred method if command line arguments are supported.
28        3 - System function. If none of the first 2 methods is available on the platform,
29        a system function which is not a stub can be used.
30       
31        e.g. read the value on GPIO pins connected to switches, or invoke special simulator functions.
32*/
33#if (SEED_METHOD==SEED_VOLATILE)
34        extern volatile ee_s32 seed1_volatile;
35        extern volatile ee_s32 seed2_volatile;
36        extern volatile ee_s32 seed3_volatile;
37        extern volatile ee_s32 seed4_volatile;
38        extern volatile ee_s32 seed5_volatile;
39        ee_s32 get_seed_32(int i) {
40                ee_s32 retval;
41                switch (i) {
42                        case 1:
43                                retval=seed1_volatile;
44                                break;
45                        case 2:
46                                retval=seed2_volatile;
47                                break;
48                        case 3:
49                                retval=seed3_volatile;
50                                break;
51                        case 4:
52                                retval=seed4_volatile;
53                                break;
54                        case 5:
55                                retval=seed5_volatile;
56                                break;
57                        default:
58                                retval=0;
59                                break;
60                }
61                return retval;
62        }
63#elif (SEED_METHOD==SEED_ARG)
64ee_s32 parseval(char *valstring) {
65        ee_s32 retval=0;
66        ee_s32 neg=1;
67        int hexmode=0;
68        if (*valstring == '-') {
69                neg=-1;
70                valstring++;
71        }
72        if ((valstring[0] == '0') && (valstring[1] == 'x')) {
73                hexmode=1;
74                valstring+=2;
75        }
76                /* first look for digits */
77        if (hexmode) {
78                while (((*valstring >= '0') && (*valstring <= '9')) || ((*valstring >= 'a') && (*valstring <= 'f'))) {
79                        ee_s32 digit=*valstring-'0';
80                        if (digit>9)
81                                digit=10+*valstring-'a';
82                        retval*=16;
83                        retval+=digit;
84                        valstring++;
85                }
86        } else {
87                while ((*valstring >= '0') && (*valstring <= '9')) {
88                        ee_s32 digit=*valstring-'0';
89                        retval*=10;
90                        retval+=digit;
91                        valstring++;
92                }
93        }
94        /* now add qualifiers */
95        if (*valstring=='K')
96                retval*=1024;
97        if (*valstring=='M')
98                retval*=1024*1024;
99
100        retval*=neg;
101        return retval;
102}
103
104ee_s32 get_seed_args(int i, int argc, char *argv[]) {
105        if (argc>i)
106                return parseval(argv[i]);
107        return 0;
108}
109
110#elif (SEED_METHOD==SEED_FUNC)
111/* If using OS based function, you must define and implement the functions below in core_portme.h and core_portme.c ! */
112ee_s32 get_seed_32(int i) {
113        ee_s32 retval;
114        switch (i) {
115                case 1:
116                        retval=portme_sys1();
117                        break;
118                case 2:
119                        retval=portme_sys2();
120                        break;
121                case 3:
122                        retval=portme_sys3();
123                        break;
124                case 4:
125                        retval=portme_sys4();
126                        break;
127                case 5:
128                        retval=portme_sys5();
129                        break;
130                default:
131                        retval=0;
132                        break;
133        }
134        return retval;
135}
136#endif
137
138/* Function: crc*
139        Service functions to calculate 16b CRC code.
140
141*/
142ee_u16 crcu8(ee_u8 data, ee_u16 crc )
143{
144        ee_u8 i=0,x16=0,carry=0;
145
146        for (i = 0; i < 8; i++)
147    {
148                x16 = (ee_u8)((data & 1) ^ ((ee_u8)crc & 1));
149                data >>= 1;
150
151                if (x16 == 1)
152                {
153                   crc ^= 0x4002;
154                   carry = 1;
155                }
156                else 
157                        carry = 0;
158                crc >>= 1;
159                if (carry)
160                   crc |= 0x8000;
161                else
162                   crc &= 0x7fff;
163    }
164        return crc;
165} 
166ee_u16 crcu16(ee_u16 newval, ee_u16 crc) {
167        crc=crcu8( (ee_u8) (newval)                             ,crc);
168        crc=crcu8( (ee_u8) ((newval)>>8)        ,crc);
169        return crc;
170}
171ee_u16 crcu32(ee_u32 newval, ee_u16 crc) {
172        crc=crc16((ee_s16) newval               ,crc);
173        crc=crc16((ee_s16) (newval>>16) ,crc);
174        return crc;
175}
176ee_u16 crc16(ee_s16 newval, ee_u16 crc) {
177        return crcu16((ee_u16)newval, crc);
178}
179
180ee_u8 check_data_types() {
181        ee_u8 retval=0;
182        if (sizeof(ee_u8) != 1) {
183                ee_printf("ERROR: ee_u8 is not an 8b datatype!\n");
184                retval++;
185        }
186        if (sizeof(ee_u16) != 2) {
187                ee_printf("ERROR: ee_u16 is not a 16b datatype!\n");
188                retval++;
189        }
190        if (sizeof(ee_s16) != 2) {
191                ee_printf("ERROR: ee_s16 is not a 16b datatype!\n");
192                retval++;
193        }
194        if (sizeof(ee_s32) != 4) {
195                ee_printf("ERROR: ee_s32 is not a 32b datatype!\n");
196                retval++;
197        }
198        if (sizeof(ee_u32) != 4) {
199                ee_printf("ERROR: ee_u32 is not a 32b datatype!\n");
200                retval++;
201        }
202        if (sizeof(ee_ptr_int) != sizeof(int *)) {
203                ee_printf("ERROR: ee_ptr_int is not a datatype that holds an int pointer!\n");
204                retval++;
205        }
206        if (retval>0) {
207                ee_printf("ERROR: Please modify the datatypes in core_portme.h!\n");
208        }
209        return retval;
210}
Note: See TracBrowser for help on using the repository browser.