Skip to content

Commit a666741

Browse files
jservjserv
committed
Improve puzzle benchmark
The bench code is much shorter. It can be regarded as the starting point to extend future benchmarks.
1 parent 4d8ae01 commit a666741

File tree

2 files changed

+101
-143
lines changed

2 files changed

+101
-143
lines changed

‎build/puzzle.elf

100644100755
-3.01 KB
Binary file not shown.

‎tests/puzzle.c

Lines changed: 101 additions & 143 deletions
Original file line numberDiff line numberDiff line change
@@ -1,250 +1,204 @@
1-
/*
2-
* provide timing and utility functions.
3-
*
4-
* identifiers starting with bm_ are reserved
5-
*/
1+
/* puzzle benchmark */
62

73
#include <stdbool.h>
84
#include <stdint.h>
95
#include <stdio.h>
106

11-
/* return the last result of TIME_CYCLES. */
12-
#define GET_CYCLES 1 /* bm_get_cycles () */
7+
#define SIZE 511
8+
#define CLASS_MAX 3
9+
#define TYPE_MAX 12
1310

14-
/* output the result of type double, higher is better. Never returns. */
15-
#define RESULT(val) bm_set_result(val)
11+
static char piececount[CLASS_MAX + 1];
12+
static uint8_t class[TYPE_MAX + 1];
13+
static short piecemax[TYPE_MAX + 1];
14+
static bool puzzle[SIZE + 1];
15+
static bool p[TYPE_MAX + 1][SIZE + 1];
1616

17-
/* output an error and kill the program. Never returns. */
18-
#define ERROR(msg) bm_error(msg)
19-
20-
/* make sure this value is calculated and not optimized away. */
21-
#define USE(value) bm_eat((int) (value))
22-
23-
/* return a zero without the compiler knowing it. */
24-
#define ZERO bm_return_zero()
25-
26-
/* tag the next result with the given string. */
27-
#define TAG(s) bm_set_tag(s)
28-
29-
#define TIME_CYCLES
30-
31-
static int bm_return_zero(void)
32-
{
33-
return 0;
34-
}
35-
static void bm_eat(int val) {}
36-
static void bm_set_tag(const char *tag)
37-
{
38-
printf("TAG %s\n", tag);
39-
}
40-
static void bm_error(char *msg)
41-
{
42-
printf("ERROR %s\n", msg);
43-
}
44-
static void bm_set_result(float val)
45-
{
46-
;
47-
}
48-
static void bm_get_cycles()
49-
{
50-
;
51-
}
52-
53-
/*
54-
* declares the main function for you, use it like this:
55-
* BEGIN_MAIN
56-
* code;
57-
* more code;
58-
* END_MAIN
59-
*/
60-
#define BEGIN_MAIN \
61-
int main(int argc, char **argv) \
62-
{
63-
#define END_MAIN \
64-
return 0; \
65-
}
66-
67-
/*
68-
* can be used instead of coding your own main(), if you
69-
* only have a single, simple test
70-
*/
71-
#define SINGLE_BENCHMARK(code) \
72-
BEGIN_MAIN \
73-
code; \
74-
END_MAIN
75-
76-
#define size 511
77-
#define classmax 3
78-
#define typemax 12
79-
#define d 8
80-
81-
/*
82-
* The standard puzzle benchmark
83-
*/
84-
85-
char piececount[classmax + 1];
86-
char class[typemax + 1];
87-
short piecemax[typemax + 1];
88-
char puzzle[size + 1];
89-
char p[typemax + 1][size + 1];
90-
91-
short m, n;
92-
int kount;
17+
static short m, n;
18+
static int kount;
9319

9420
int fit(int i, int j)
9521
{
96-
short k;
22+
for (short k = 0; k <= piecemax[i]; k++) {
23+
if (p[i][k] && puzzle[j + k])
24+
return false;
25+
}
9726

98-
for (k = 0; k <= piecemax[i]; k++)
99-
if (p[i][k])
100-
if (puzzle[j + k])
101-
return false;
10227
return true;
10328
}
10429

10530
int place(int i, int j)
10631
{
107-
short k;
108-
for (k = 0; k <= piecemax[i]; k++)
32+
for (short k = 0; k <= piecemax[i]; k++) {
10933
if (p[i][k])
11034
puzzle[j + k] = true;
35+
}
11136
piececount[class[i]] = piececount[class[i]] - 1;
112-
for (k = j; k <= size; k++)
37+
for (short k = j; k <= SIZE; k++) {
11338
if (!puzzle[k])
11439
return k;
40+
}
11541

11642
return false;
11743
}
11844

11945
void remove_(int i, int j)
12046
{
121-
for (short k = 0; k <= piecemax[i]; k++)
47+
for (short k = 0; k <= piecemax[i]; k++) {
12248
if (p[i][k])
12349
puzzle[j + k] = false;
50+
}
12451
piececount[class[i]] = piececount[class[i]] + 1;
12552
}
12653

12754
int trial(int j)
12855
{
129-
int i, k;
130-
char trialval;
131-
132-
for (i = 0; i <= typemax; i++) {
133-
if (piececount[class[i]])
134-
if (fit(i, j)) {
135-
k = place(i, j);
136-
if (trial(k) || (k == 0)) {
137-
/*printf("piece %d at %d\n", i + 1, k + 1);*/;
138-
kount = kount + 1;
139-
return (true);
140-
} else
141-
remove_(i, j);
56+
for (int i = 0; i <= TYPE_MAX; i++) {
57+
if (piececount[class[i]] && fit(i, j)) {
58+
int k = place(i, j);
59+
if (trial(k) || (k == 0)) {
60+
kount++;
61+
return true;
14262
}
63+
remove_(i, j);
64+
}
14365
}
144-
kount = kount + 1;
145-
return (false);
66+
67+
kount++;
68+
return false;
14669
}
14770

148-
void puzzle_(void)
71+
void run_puzzle(void)
14972
{
15073
int i, j, k;
15174

152-
for (m = 0; m <= size; m++)
75+
for (m = 0; m <= SIZE; m++)
15376
puzzle[m] = 1;
154-
for (i = 1; i <= 5; i++)
77+
78+
for (i = 1; i <= 5; i++) {
15579
for (j = 1; j <= 5; j++)
15680
for (k = 1; k <= 5; k++)
15781
puzzle[i + 8 * (j + 8 * k)] = 0;
158-
for (i = 0; i <= 12; i++)
82+
}
83+
for (i = 0; i <= 12; i++) {
15984
for (m = 0; m <= 511; m++)
160-
p[i][m] = 0;
161-
for (i = 0; i <= 3; i++)
85+
p[i][m] = false;
86+
}
87+
for (i = 0; i <= 3; i++) {
16288
for (j = 0; j <= 1; j++)
16389
for (k = 0; k <= 0; k++)
164-
p[0][i + 8 * (j + 8 * k)] = 1;
90+
p[0][i + 8 * (j + 8 * k)] = true;
91+
}
92+
16593
class[0] = 0;
16694
piecemax[0] = 3 + 8 * 1 + 8 * 8 * 0;
167-
for (i = 0; i <= 1; i++)
95+
for (i = 0; i <= 1; i++) {
16896
for (j = 0; j <= 0; j++)
16997
for (k = 0; k <= 3; k++)
170-
p[1][i + 8 * (j + 8 * k)] = 1;
98+
p[1][i + 8 * (j + 8 * k)] = true;
99+
}
100+
171101
class[1] = 0;
172102
piecemax[1] = 1 + 8 * 0 + 8 * 8 * 3;
173-
for (i = 0; i <= 0; i++)
103+
for (i = 0; i <= 0; i++) {
174104
for (j = 0; j <= 3; j++)
175105
for (k = 0; k <= 1; k++)
176-
p[2][i + 8 * (j + 8 * k)] = 1;
106+
p[2][i + 8 * (j + 8 * k)] = true;
107+
}
108+
177109
class[2] = 0;
178110
piecemax[2] = 0 + 8 * 3 + 8 * 8 * 1;
179-
for (i = 0; i <= 1; i++)
111+
for (i = 0; i <= 1; i++) {
180112
for (j = 0; j <= 3; j++)
181113
for (k = 0; k <= 0; k++)
182-
p[3][i + 8 * (j + 8 * k)] = 1;
114+
p[3][i + 8 * (j + 8 * k)] = true;
115+
}
116+
183117
class[3] = 0;
184118
piecemax[3] = 1 + 8 * 3 + 8 * 8 * 0;
185-
for (i = 0; i <= 3; i++)
119+
for (i = 0; i <= 3; i++) {
186120
for (j = 0; j <= 0; j++)
187121
for (k = 0; k <= 1; k++)
188-
p[4][i + 8 * (j + 8 * k)] = 1;
122+
p[4][i + 8 * (j + 8 * k)] = true;
123+
}
124+
189125
class[4] = 0;
190126
piecemax[4] = 3 + 8 * 0 + 8 * 8 * 1;
191-
for (i = 0; i <= 0; i++)
127+
for (i = 0; i <= 0; i++) {
192128
for (j = 0; j <= 1; j++)
193129
for (k = 0; k <= 3; k++)
194-
p[5][i + 8 * (j + 8 * k)] = 1;
130+
p[5][i + 8 * (j + 8 * k)] = true;
131+
}
132+
195133
class[5] = 0;
196134
piecemax[5] = 0 + 8 * 1 + 8 * 8 * 3;
197-
for (i = 0; i <= 2; i++)
135+
for (i = 0; i <= 2; i++) {
198136
for (j = 0; j <= 0; j++)
199137
for (k = 0; k <= 0; k++)
200-
p[6][i + 8 * (j + 8 * k)] = 1;
138+
p[6][i + 8 * (j + 8 * k)] = true;
139+
}
140+
201141
class[6] = 1;
202142
piecemax[6] = 2 + 8 * 0 + 8 * 8 * 0;
203-
for (i = 0; i <= 0; i++)
143+
for (i = 0; i <= 0; i++) {
204144
for (j = 0; j <= 2; j++)
205145
for (k = 0; k <= 0; k++)
206-
p[7][i + 8 * (j + 8 * k)] = 1;
146+
p[7][i + 8 * (j + 8 * k)] = true;
147+
}
148+
207149
class[7] = 1;
208150
piecemax[7] = 0 + 8 * 2 + 8 * 8 * 0;
209-
for (i = 0; i <= 0; i++)
151+
for (i = 0; i <= 0; i++) {
210152
for (j = 0; j <= 0; j++)
211153
for (k = 0; k <= 2; k++)
212-
p[8][i + 8 * (j + 8 * k)] = 1;
154+
p[8][i + 8 * (j + 8 * k)] = true;
155+
}
156+
213157
class[8] = 1;
214158
piecemax[8] = 0 + 8 * 0 + 8 * 8 * 2;
215-
for (i = 0; i <= 1; i++)
159+
for (i = 0; i <= 1; i++) {
216160
for (j = 0; j <= 1; j++)
217161
for (k = 0; k <= 0; k++)
218-
p[9][i + 8 * (j + 8 * k)] = 1;
162+
p[9][i + 8 * (j + 8 * k)] = true;
163+
}
164+
219165
class[9] = 2;
220166
piecemax[9] = 1 + 8 * 1 + 8 * 8 * 0;
221-
for (i = 0; i <= 1; i++)
167+
for (i = 0; i <= 1; i++) {
222168
for (j = 0; j <= 0; j++)
223169
for (k = 0; k <= 1; k++)
224-
p[10][i + 8 * (j + 8 * k)] = 1;
170+
p[10][i + 8 * (j + 8 * k)] = true;
171+
}
172+
225173
class[10] = 2;
226174
piecemax[10] = 1 + 8 * 0 + 8 * 8 * 1;
227-
for (i = 0; i <= 0; i++)
175+
for (i = 0; i <= 0; i++) {
228176
for (j = 0; j <= 1; j++)
229177
for (k = 0; k <= 1; k++)
230-
p[11][i + 8 * (j + 8 * k)] = 1;
178+
p[11][i + 8 * (j + 8 * k)] = true;
179+
}
180+
231181
class[11] = 2;
232182
piecemax[11] = 0 + 8 * 1 + 8 * 8 * 1;
233-
for (i = 0; i <= 1; i++)
183+
for (i = 0; i <= 1; i++) {
234184
for (j = 0; j <= 1; j++)
235185
for (k = 0; k <= 1; k++)
236-
p[12][i + 8 * (j + 8 * k)] = 1;
186+
p[12][i + 8 * (j + 8 * k)] = true;
187+
}
188+
237189
class[12] = 3;
238190
piecemax[12] = 1 + 8 * 1 + 8 * 8 * 1;
239191
piececount[0] = 13;
240192
piececount[1] = 3;
241193
piececount[2] = 1;
242194
piececount[3] = 1;
195+
243196
m = 1 + 8 * (1 + 8 * 1);
244197
kount = 0;
245-
if (fit(0, m))
198+
199+
if (fit(0, m)) {
246200
n = place(0, m);
247-
else {
201+
} else {
248202
printf("error 1\n");
249203
}
250204
if (trial(n)) {
@@ -254,4 +208,8 @@ void puzzle_(void)
254208
}
255209
}
256210

257-
SINGLE_BENCHMARK(puzzle_())
211+
int main(int argc, char **argv)
212+
{
213+
run_puzzle();
214+
return 0;
215+
}

0 commit comments

Comments
 (0)