1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
|
/*
* Sample code for the DIS Field Stressmark
*
* This source code is the completely correct source code based on
* the example codes provided by Atlantic Aerospace Division, Titan
* Systems Corporation, 2000.
*
* If you just compile and generate the executables from this source
* code, this code would be enough. However, if you wish to get a complete
* understanding of this stressmark, it is strongly suggested that you
* read the Benchmark Analysis and Specifications Document Version 1.0
* before going on since the detailed comments are given in this documents.
* the comments are not repeated here.
*/
#include "DISstressmarkRNG.h"
#include "extra.h"
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define MIN_FIELD_SIZE 16
#define MAX_FIELD_SIZE (16777216 * 4) // This has been quadrupled from original
#define MIN_SEED -2147483647
#define MAX_SEED -1
#define MIN_MOD_OFFSET 0
#define MAX_MOD_OFFSET 65535
#define MIN_TOKENS 1
#define MAX_TOKENS 256
#define MIN_TOKEN_LENGTH 1
#define MAX_TOKEN_LENGTH 8
#define MIN_TOKEN_VALUE 0
#define MAX_TOKEN_VALUE 255
#define MAX_SUBFIELDS 256
/*
* main()
*/
int main(int argc, char **argv) {
SET_UP
unsigned char *field;
unsigned int f;
int seed;
int mod_offset;
unsigned int n;
time_t startTime, endTime;
struct tokenS {
unsigned char delimiter[MAX_TOKEN_LENGTH];
unsigned char length;
struct statisticS {
unsigned int count;
unsigned char min;
unsigned char sum;
} stat[MAX_SUBFIELDS];
unsigned char subfields;
} token[MAX_TOKENS];
unsigned int l;
assert(fscanf(stdin, "%d %d %d %d", &f, &seed, &mod_offset, &n) == 4);
assert((f >= MIN_FIELD_SIZE) && (f <= MAX_FIELD_SIZE));
assert((seed >= MIN_SEED) && (seed <= MAX_SEED));
assert((mod_offset >= MIN_MOD_OFFSET) && (mod_offset <= MAX_MOD_OFFSET));
assert((n >= MIN_TOKENS) && (n <= MAX_TOKENS));
for (l = 0; l < n; l++) {
int x;
int index;
index = 0;
assert(fscanf(stdin, "%x", &x) == 1);
while (x != 0) {
assert((x >= MIN_TOKEN_VALUE) && (x <= MAX_TOKEN_VALUE));
token[l].delimiter[index] = (unsigned char)x;
index++;
assert(fscanf(stdin, "%x", &x) == 1);
}
assert((index >= MIN_TOKEN_LENGTH) && (index <= MAX_TOKEN_LENGTH));
token[l].length = index;
}
if ((field = (unsigned char *)malloc(f * sizeof(unsigned char))) == NULL)
return (-1);
randInit(seed);
for_each_job {
for (l = 0; l < f; l++) {
field[l] = randInt(MIN_TOKEN_VALUE, MAX_TOKEN_VALUE);
}
startTime = time(NULL);
for (l = 0; l < n; l++) {
unsigned int index;
token[l].subfields = 0;
token[l].stat[0].count = 0;
token[l].stat[0].sum = 0;
token[l].stat[0].min = MAX_TOKEN_VALUE;
index = 0;
while ((index < f) && (token[l].subfields < MAX_SUBFIELDS)) {
unsigned char offset;
offset = 0;
while ((field[index + offset] == token[l].delimiter[offset]) &&
(offset < token[l].length)) {
offset++;
}
if (offset == token[l].length) {
for (offset = 0; offset < token[l].length; offset++) {
field[index + offset] = (field[index + offset] +
field[(index + offset + mod_offset) % f]) %
(MAX_TOKEN_VALUE + 1);
}
index += token[l].length - 1;
token[l].subfields++;
token[l].stat[token[l].subfields].count = 0;
token[l].stat[token[l].subfields].sum = 0;
token[l].stat[token[l].subfields].min = MAX_TOKEN_VALUE;
}
else {
token[l].stat[token[l].subfields].count++;
token[l].stat[token[l].subfields].sum += field[index];
if (token[l].stat[token[l].subfields].min > field[index])
token[l].stat[token[l].subfields].min = field[index];
}
index++;
}
token[l].subfields++;
}
}
endTime = time(NULL);
volatile int _stop_optimizer = 0;
for (l = 0; l < n; l++) {
unsigned int ll;
//fprintf(stdout, "%d subfields for token %d \n", token[l].subfields, l);
_stop_optimizer += token[l].subfields + l;
for (ll = 0; ll < token[l].subfields; ll++) {
_stop_optimizer += ll + token[l].stat[ll].count + token[l].stat[ll].min +
token[l].stat[ll].sum;
//fprintf(stdout, "subfields %d:\tcount = %d\tmin= %x\tsum= %x\n",
// ll, token[l].stat[ll].count,
// token[l].stat[ll].min, token[l].stat[ll].sum);*/
}
}
fprintf(stderr, "time for field stressmark = %f seconds.\n",
difftime(endTime, startTime));
free(field);
WRITE_TO_FILE
return (0);
}
|
