blob: 892c9ed73b8da64a64a60247ccf64f62025724e1 [file] [log] [blame]
Tom Rini83d290c2018-05-06 17:58:06 -04001/* SPDX-License-Identifier: GPL-2.0+ */
Simon Glassd1389402015-06-23 15:38:23 -06002/*
3 * (C) Copyright 2015 Google, Inc
4 *
Simon Glassd1389402015-06-23 15:38:23 -06005 * Dhrystone is widely available in the public domain. A GPL license is
6 * chosen for U-Boot.
7 */
8
9/*****************************************************************************
10 * The BYTE UNIX Benchmarks - Release 3
11 * Module: dhry.h SID: 3.4 5/15/91 19:30:21
12 *
13 *****************************************************************************
14 * Bug reports, patches, comments, suggestions should be sent to:
15 *
16 * Ben Smith, Rick Grehan or Tom Yager
17 * ben@bytepb.byte.com rick_g@bytepb.byte.com tyager@bytepb.byte.com
18 *
19 *****************************************************************************
20 * Modification Log:
21 * addapted from:
22 *
23 *
24 * "DHRYSTONE" Benchmark Program
25 * -----------------------------
26 *
27 * Version: C, Version 2.1
28 *
29 * File: dhry.h (part 1 of 3)
30 *
31 * Date: May 25, 1988
32 *
33 * Author: Reinhold P. Weicker
34 * Siemens AG, AUT E 51
35 * Postfach 3220
36 * 8520 Erlangen
37 * Germany (West)
38 * Phone: [+49]-9131-7-20330
39 * (8-17 Central European Time)
40 * Usenet: ..!mcvax!unido!estevax!weicker
41 *
42 * Original Version (in Ada) published in
43 * "Communications of the ACM" vol. 27., no. 10 (Oct. 1984),
44 * pp. 1013 - 1030, together with the statistics
45 * on which the distribution of statements etc. is based.
46 *
47 * In this C version, the following C library functions are used:
48 * - strcpy, strcmp (inside the measurement loop)
49 * - printf, scanf (outside the measurement loop)
50 * In addition, Berkeley UNIX system calls "times ()" or "time ()"
51 * are used for execution time measurement. For measurements
52 * on other systems, these calls have to be changed.
53 *
54 * Collection of Results:
55 * Reinhold Weicker (address see above) and
56 *
57 * Rick Richardson
58 * PC Research. Inc.
59 * 94 Apple Orchard Drive
60 * Tinton Falls, NJ 07724
61 * Phone: (201) 834-1378 (9-17 EST)
62 * Usenet: ...!seismo!uunet!pcrat!rick
63 *
64 * Please send results to Rick Richardson and/or Reinhold Weicker.
65 * Complete information should be given on hardware and software used.
66 * Hardware information includes: Machine type, CPU, type and size
67 * of caches; for microprocessors: clock frequency, memory speed
68 * (number of wait states).
69 * Software information includes: Compiler (and runtime library)
70 * manufacturer and version, compilation switches, OS version.
71 * The Operating System version may give an indication about the
72 * compiler; Dhrystone itself performs no OS calls in the measurement loop.
73 *
74 * The complete output generated by the program should be mailed
75 * such that at least some checks for correctness can be made.
76 *
77 ***************************************************************************
78 *
79 * History: This version C/2.1 has been made for two reasons:
80 *
81 * 1) There is an obvious need for a common C version of
82 * Dhrystone, since C is at present the most popular system
83 * programming language for the class of processors
84 * (microcomputers, minicomputers) where Dhrystone is used most.
85 * There should be, as far as possible, only one C version of
86 * Dhrystone such that results can be compared without
87 * restrictions. In the past, the C versions distributed
88 * by Rick Richardson (Version 1.1) and by Reinhold Weicker
89 * had small (though not significant) differences.
90 *
91 * 2) As far as it is possible without changes to the Dhrystone
92 * statistics, optimizing compilers should be prevented from
93 * removing significant statements.
94 *
95 * This C version has been developed in cooperation with
96 * Rick Richardson (Tinton Falls, NJ), it incorporates many
97 * ideas from the "Version 1.1" distributed previously by
98 * him over the UNIX network Usenet.
99 * I also thank Chaim Benedelac (National Semiconductor),
100 * David Ditzel (SUN), Earl Killian and John Mashey (MIPS),
101 * Alan Smith and Rafael Saavedra-Barrera (UC at Berkeley)
102 * for their help with comments on earlier versions of the
103 * benchmark.
104 *
105 * Changes: In the initialization part, this version follows mostly
106 * Rick Richardson's version distributed via Usenet, not the
107 * version distributed earlier via floppy disk by Reinhold Weicker.
108 * As a concession to older compilers, names have been made
109 * unique within the first 8 characters.
110 * Inside the measurement loop, this version follows the
111 * version previously distributed by Reinhold Weicker.
112 *
113 * At several places in the benchmark, code has been added,
114 * but within the measurement loop only in branches that
115 * are not executed. The intention is that optimizing compilers
116 * should be prevented from moving code out of the measurement
117 * loop, or from removing code altogether. Since the statements
118 * that are executed within the measurement loop have NOT been
119 * changed, the numbers defining the "Dhrystone distribution"
120 * (distribution of statements, operand types and locality)
121 * still hold. Except for sophisticated optimizing compilers,
122 * execution times for this version should be the same as
123 * for previous versions.
124 *
125 * Since it has proven difficult to subtract the time for the
126 * measurement loop overhead in a correct way, the loop check
127 * has been made a part of the benchmark. This does have
128 * an impact - though a very minor one - on the distribution
129 * statistics which have been updated for this version.
130 *
131 * All changes within the measurement loop are described
132 * and discussed in the companion paper "Rationale for
133 * Dhrystone version 2".
134 *
135 * Because of the self-imposed limitation that the order and
136 * distribution of the executed statements should not be
137 * changed, there are still cases where optimizing compilers
138 * may not generate code for some statements. To a certain
139 * degree, this is unavoidable for small synthetic benchmarks.
140 * Users of the benchmark are advised to check code listings
141 * whether code is generated for all statements of Dhrystone.
142 *
143 * Version 2.1 is identical to version 2.0 distributed via
144 * the UNIX network Usenet in March 1988 except that it corrects
145 * some minor deficiencies that were found by users of version 2.0.
146 * The only change within the measurement loop is that a
147 * non-executed "else" part was added to the "if" statement in
148 * Func_3, and a non-executed "else" part removed from Proc_3.
149 *
150 ***************************************************************************
151 *
152 * Defines: The following "Defines" are possible:
153 * -DREG=register (default: Not defined)
154 * As an approximation to what an average C programmer
155 * might do, the "register" storage class is applied
156 * (if enabled by -DREG=register)
157 * - for local variables, if they are used (dynamically)
158 * five or more times
159 * - for parameters if they are used (dynamically)
160 * six or more times
161 * Note that an optimal "register" strategy is
162 * compiler-dependent, and that "register" declarations
163 * do not necessarily lead to faster execution.
164 * -DNOSTRUCTASSIGN (default: Not defined)
165 * Define if the C compiler does not support
166 * assignment of structures.
167 * -DNOENUMS (default: Not defined)
168 * Define if the C compiler does not support
169 * enumeration types.
170 * -DTIMES (default)
171 * -DTIME
172 * The "times" function of UNIX (returning process times)
173 * or the "time" function (returning wallclock time)
174 * is used for measurement.
175 * For single user machines, "time ()" is adequate. For
176 * multi-user machines where you cannot get single-user
177 * access, use the "times ()" function. If you have
178 * neither, use a stopwatch in the dead of night.
179 * "printf"s are provided marking the points "Start Timer"
180 * and "Stop Timer". DO NOT use the UNIX "time(1)"
181 * command, as this will measure the total time to
182 * run this program, which will (erroneously) include
183 * the time to allocate storage (malloc) and to perform
184 * the initialization.
185 * -DHZ=nnn
186 * In Berkeley UNIX, the function "times" returns process
187 * time in 1/HZ seconds, with HZ = 60 for most systems.
188 * CHECK YOUR SYSTEM DESCRIPTION BEFORE YOU JUST APPLY
189 * A VALUE.
190 *
191 ***************************************************************************
192 *
193 * Compilation model and measurement (IMPORTANT):
194 *
195 * This C version of Dhrystone consists of three files:
196 * - dhry.h (this file, containing global definitions and comments)
197 * - dhry_1.c (containing the code corresponding to Ada package Pack_1)
198 * - dhry_2.c (containing the code corresponding to Ada package Pack_2)
199 *
200 * The following "ground rules" apply for measurements:
201 * - Separate compilation
202 * - No procedure merging
203 * - Otherwise, compiler optimizations are allowed but should be indicated
204 * - Default results are those without register declarations
205 * See the companion paper "Rationale for Dhrystone Version 2" for a more
206 * detailed discussion of these ground rules.
207 *
208 * For 16-Bit processors (e.g. 80186, 80286), times for all compilation
209 * models ("small", "medium", "large" etc.) should be given if possible,
210 * together with a definition of these models for the compiler system used.
211 *
212 **************************************************************************
213 *
214 * Dhrystone (C version) statistics:
215 *
216 * [Comment from the first distribution, updated for version 2.
217 * Note that because of language differences, the numbers are slightly
218 * different from the Ada version.]
219 *
220 * The following program contains statements of a high level programming
221 * language (here: C) in a distribution considered representative:
222 *
223 * assignments 52 (51.0 %)
224 * control statements 33 (32.4 %)
225 * procedure, function calls 17 (16.7 %)
226 *
227 * 103 statements are dynamically executed. The program is balanced with
228 * respect to the three aspects:
229 *
230 * - statement type
231 * - operand type
232 * - operand locality
233 * operand global, local, parameter, or constant.
234 *
235 * The combination of these three aspects is balanced only approximately.
236 *
237 * 1. Statement Type:
238 * ----------------- number
239 *
240 * V1 = V2 9
241 * (incl. V1 = F(..)
242 * V = Constant 12
243 * Assignment, 7
244 * with array element
245 * Assignment, 6
246 * with record component
247 * --
248 * 34 34
249 *
250 * X = Y +|-|"&&"|"|" Z 5
251 * X = Y +|-|"==" Constant 6
252 * X = X +|- 1 3
253 * X = Y *|/ Z 2
254 * X = Expression, 1
255 * two operators
256 * X = Expression, 1
257 * three operators
258 * --
259 * 18 18
260 *
261 * if .... 14
262 * with "else" 7
263 * without "else" 7
264 * executed 3
265 * not executed 4
266 * for ... 7 | counted every time
267 * while ... 4 | the loop condition
268 * do ... while 1 | is evaluated
269 * switch ... 1
270 * break 1
271 * declaration with 1
272 * initialization
273 * --
274 * 34 34
275 *
276 * P (...) procedure call 11
277 * user procedure 10
278 * library procedure 1
279 * X = F (...)
280 * function call 6
281 * user function 5
282 * library function 1
283 * --
284 * 17 17
285 * ---
286 * 103
287 *
288 * The average number of parameters in procedure or function calls
289 * is 1.82 (not counting the function values as implicit parameters).
290 *
291 *
292 * 2. Operators
293 * ------------
294 * number approximate
295 * percentage
296 *
297 * Arithmetic 32 50.8
298 *
299 * + 21 33.3
300 * - 7 11.1
301 * * 3 4.8
302 * / (int div) 1 1.6
303 *
304 * Comparison 27 42.8
305 *
306 * == 9 14.3
307 * /= 4 6.3
308 * > 1 1.6
309 * < 3 4.8
310 * >= 1 1.6
311 * <= 9 14.3
312 *
313 * Logic 4 6.3
314 *
315 * && (AND-THEN) 1 1.6
316 * | (OR) 1 1.6
317 * ! (NOT) 2 3.2
318 *
319 * -- -----
320 * 63 100.1
321 *
322 *
323 * 3. Operand Type (counted once per operand reference):
324 * ---------------
325 * number approximate
326 * percentage
327 *
328 * Integer 175 72.3 %
329 * Character 45 18.6 %
330 * Pointer 12 5.0 %
331 * String30 6 2.5 %
332 * Array 2 0.8 %
333 * Record 2 0.8 %
334 * --- -------
335 * 242 100.0 %
336 *
337 * When there is an access path leading to the final operand (e.g. a record
338 * component), only the final data type on the access path is counted.
339 *
340 *
341 * 4. Operand Locality:
342 * -------------------
343 * number approximate
344 * percentage
345 *
346 * local variable 114 47.1 %
347 * global variable 22 9.1 %
348 * parameter 45 18.6 %
349 * value 23 9.5 %
350 * reference 22 9.1 %
351 * function result 6 2.5 %
352 * constant 55 22.7 %
353 * --- -------
354 * 242 100.0 %
355 *
356 *
357 * The program does not compute anything meaningful, but it is syntactically
358 * and semantically correct. All variables have a value assigned to them
359 * before they are used as a source operand.
360 *
361 * There has been no explicit effort to account for the effects of a
362 * cache, or to balance the use of long or short displacements for code or
363 * data.
364 *
365 ***************************************************************************
366 */
367
368
369/* Compiler and system dependent definitions: */
370
371#ifndef TIME
372#define TIMES
373#endif
374 /* Use times(2) time function unless */
375 /* explicitly defined otherwise */
376
377#define Mic_secs_Per_Second 1000000.0
378 /* Berkeley UNIX C returns process times in seconds/HZ */
379
380#ifdef NOSTRUCTASSIGN
381#define structassign(d, s) memcpy(&(d), &(s), sizeof(d))
382#else
383#define structassign(d, s) d = s
384#endif
385
386#ifdef NOENUM
387#define Ident_1 0
388#define Ident_2 1
389#define Ident_3 2
390#define Ident_4 3
391#define Ident_5 4
392 typedef int Enumeration;
393#else
394 typedef enum {Ident_1, Ident_2, Ident_3, Ident_4, Ident_5}
395 Enumeration;
396#endif
397 /* for boolean and enumeration types in Ada, Pascal */
398
399/* General definitions: */
400
401#define Null 0
402 /* Value of a Null pointer */
403#define true 1
404#define false 0
405
406typedef int One_Thirty;
407typedef int One_Fifty;
408typedef char Capital_Letter;
409typedef int Boolean;
410typedef char Str_30 [31];
411typedef int Arr_1_Dim [50];
412typedef int Arr_2_Dim [50] [50];
413
414typedef struct record
415 {
416 struct record *Ptr_Comp;
417 Enumeration Discr;
418 union {
419 struct {
420 Enumeration Enum_Comp;
421 int Int_Comp;
422 char Str_Comp [31];
423 } var_1;
424 struct {
425 Enumeration E_Comp_2;
426 char Str_2_Comp [31];
427 } var_2;
428 struct {
429 char Ch_1_Comp;
430 char Ch_2_Comp;
431 } var_3;
432 } variant;
433 } Rec_Type, *Rec_Pointer;
434
435
436/*
437 * dhry() - run dhrystone for a given number of iterations
438 *
439 * @iterations: Number of iterations to run
440 */
441void dhry(int iterations);